Source for file Setting.class.php

Documentation is available at Setting.class.php

  1. <?php
  2. /**
  3.  * Gumbo Library Framework
  4.  *
  5.  * LICENSE
  6.  * This library is being released under the terms of the New BSD License.  A
  7.  * copy of the license is packaged with the software (LICENSE.txt).  If no
  8.  * copy is found, a copy of the license template can be found at:
  9.  * http://www.opensource.org/licenses/bsd-license.php
  10.  * 
  11.  * @category Gumbo
  12.  * @package Load
  13.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  14.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  15.  * @author Michael Luster <mluster79@yahoo.com>
  16.  * @link http://sourceforge.net/projects/phpgumbo
  17.  * @version 0.0.1
  18.  */
  19.  
  20. /**
  21.  * Load Setting Class
  22.  *
  23.  * @category Gumbo
  24.  * @package Load
  25.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  26.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  27.  * @author Michael Luster <mluster79@yahoo.com>
  28.  * @link http://sourceforge.net/projects/phpgumbo
  29.  * @desc Load Setting Class
  30.  * @version 0.0.1
  31.  */
  32.  
  33. gumbo_load ("Interface_Load_Setting");
  34. gumbo_load ("Setting");
  35.  
  36. class Gumbo_Load_Setting extends Gumbo_Setting implements Gumbo_Interface_Load_Setting {
  37.     
  38.     /**
  39.      * Constructor
  40.      * 
  41.      * The settings parameter will construct a new object from the array, overriding
  42.      * the default settings.  If the value is not set, the default will be used.  The
  43.      * array should contain key=>value pairs, where the key references a property of
  44.      * the object.  The key should exclude the underscore of the property name.  For
  45.      * example: <code>array ("ext"=>"html")</code> will set the $_ext value.
  46.      * 
  47.      * @param array $settings list of settings in key=>val pairs
  48.      * @throws Gumbo_Exception
  49.      */
  50.     public function __construct ($settings=array ()) {
  51.         
  52.         // set the defaults
  53.         parent::add ("class", false);
  54.         parent::add ("dirs");
  55.         parent::add ("ext", "php");
  56.         parent::add ("stretch", false);
  57.         parent::add ("separator", "_");
  58.         parent::add ("path", "include");
  59.         parent::add ("once", false);
  60.         parent::add ("include", false);
  61.         parent::add ("remove", null);
  62.         
  63.         try {
  64.             // verify precondition
  65.             if (!is_array ($settings)) {
  66.                 throw new Gumbo_Exception ("Invalid Argument 'settings:arr' => {$settings}:" . gettype ($settings));
  67.             }
  68.             
  69.             foreach ($settings as $key=>$val) {
  70.                 switch ($key) {
  71.                     case "class" : $this->setClass ($val); break;
  72.                     case "dirs" : $this->setDirs ($val); break;
  73.                     case "extension" : $this->setExtension ($val); break;
  74.                     case "ext" : $this->setExtension ($val); break;
  75.                     case "once" : $this->setOnce ($val); break;
  76.                     case "include" : $this->setInclude ($val); break;
  77.                     case "stretch" : $this->setStretch ($val); break;
  78.                     case "separator" : $this->setSeparator ($val); break;
  79.                     case "path" : $this->setPath ($val); break;
  80.                     case "remove" : $this->setRemove ($val); break;
  81.                 }
  82.             }
  83.         } catch (Gumbo_Exception $e) {
  84.             $e->setFunction (__METHOD__);
  85.             gumbo_trigger ($e);
  86.         }
  87.     }
  88.     
  89.     
  90.     
  91.     /** ACTION METHODS **/
  92.     /**
  93.      * Adds a key=>value pair to the setting
  94.      * @param string $key 
  95.      * @param mixed $val 
  96.      * @throws Gumbo_Exception
  97.      */
  98.     public function add ($key, $val=null) {
  99.         try {
  100.             // verify precondition
  101.             if (!is_string ($key)) {
  102.                 throw new Gumbo_Exception ("Invalid Argument 'key:str' => {$key}:" . gettype ($key));
  103.             }
  104.             
  105.             switch ($key) {
  106.                 case "class" : $this->setClass ($val); break;
  107.                 case "dirs" : $this->setDirs ($val); break;
  108.                 case "extension" : $this->setExtension ($val); break;
  109.                 case "ext" : $this->setExtension ($val); break;
  110.                 case "once" : $this->setOnce ($val); break;
  111.                 case "include" : $this->setInclude ($val); break;
  112.                 case "stretch" : $this->setStretch ($val); break;
  113.                 case "separator" : $this->setSeparator ($val); break;
  114.                 case "path" : $this->setPath ($val); break;
  115.                 case "remove" : $this->setRemove ($val); break;
  116.             }
  117.         } catch (Gumbo_Exception $e) {
  118.             $e->setFunction (__METHOD__);
  119.             gumbo_trigger ($e);
  120.         }
  121.     }
  122.     
  123.     /**
  124.      * Removes the setting
  125.      * @param string $key 
  126.      * @throws Gumbo_Exception
  127.      */
  128.     public function remove ($key) {
  129.         try {
  130.             // verify precondition
  131.             if (!is_string ($key)) {
  132.                 throw new Gumbo_Exception ("Invalid Argument 'key:str' => {$key}:" . gettype ($key));
  133.             }
  134.             if (!$this->exists ($key)) {
  135.                 throw new Gumbo_Exception ("Invalid Setting Key: {$key}");
  136.             }
  137.             
  138.             switch ($key) {
  139.                 case "class" : parent::add ("class", false); break;
  140.                 case "dirs" : parent::add ("dirs", null); break;
  141.                 case "extension" : parent::add ("extension", "php"); break;
  142.                 case "ext" : parent::add ("extension", "php"); break;
  143.                 case "once" : parent::add ("once", false); break;
  144.                 case "include" : parent::add ("include", false); break;
  145.                 case "stretch" : parent::add ("stretch", false); break;
  146.                 case "separator" : parent::add ("separator", "_"); break;
  147.                 case "path" : parent::add ("path", "include"); break;
  148.                 case "remove" : parent::add ("remove", null); break;
  149.             }
  150.             
  151.         } catch (Gumbo_Exception $e) {
  152.             $e->setFunction (__METHOD__);
  153.             gumbo_trigger ($e);
  154.         }
  155.     }
  156.     
  157.     
  158.     
  159.     /**
  160.      * Adds a directory path to the list (additional arguments may be accepted)
  161.      * @param string $dir 
  162.      * @throws Gumbo_Exception
  163.      */
  164.     public function addDir ($dir) {
  165.         try {
  166.             // verify precondition
  167.             if (!is_string ($dir)) {
  168.                 throw new Gumbo_Exception ("Invalid Argument 'dir:str' => {$dir}:" . gettype ($dir));
  169.             }
  170.             
  171.             if (func_num_args () > 1) {
  172.                 foreach (func_get_args () as $val) {
  173.                     $this->addDir ($val);
  174.                 }
  175.                 return;
  176.             }
  177.             
  178.             // check if location was previously set
  179.             $tmp = array ();
  180.             $tmp [] = $dir;
  181.             foreach ($this->getDirs () as $val) {
  182.                 if ($val == $dir) {
  183.                     return;
  184.                 }
  185.                 $tmp [] = $val;
  186.             }
  187.             
  188.             parent::add ("dirs", $tmp);
  189.         } catch (Gumbo_Exception $e) {
  190.             $e->setFunction (__METHOD__);
  191.             gumbo_trigger ($e);
  192.         }
  193.     }
  194.     
  195.     
  196.     
  197.     /** MUTATOR METHODS **/
  198.     /**
  199.      * Sets the setting to load a class file
  200.      * @param bool $val 
  201.      * @throws Gumbo_Exception
  202.      */
  203.     public function setClass ($val) {
  204.         try {
  205.             // verify precondition
  206.             if (!is_bool ($val)) {
  207.                 throw new Gumbo_Exception ("Invalid Argument 'val:bool' => {$val}:" . gettype ($val));
  208.             }
  209.             
  210.             parent::add ("class", $val);
  211.         } catch (Gumbo_Exception $e) {
  212.             $e->setFunction (__METHOD__);
  213.             gumbo_trigger ($e);
  214.         }
  215.     }
  216.     
  217.     /**
  218.      * Adds a list of directories to the list
  219.      * 
  220.      * There are three ways to set the Directory paths.  The first method passes
  221.      * a string, with either a single directory or list of directories separated
  222.      * by the PATH_SEPARATOR constant.  The second passes an array, with each
  223.      * element value a different directory.  The third involves either of the first
  224.      * two methods, but multiple arguments.
  225.      * 
  226.      * 1. $this->setDirs ("path1:path2:path3/path4");
  227.      * 2. $this->setDirs (array ("path1", "path2", "path3/path4"));
  228.      * 3. $this->setDirs ("path1", array ("path2"), "path3/path4:path5");
  229.      * 
  230.      * @param array|string$dirs ...[]
  231.      * @throws Gumbo_Exception
  232.      */
  233.     public function setDirs ($dirs) {
  234.         try {
  235.             // verify precondition
  236.             if (!is_array ($dirs) && !is_string ($dirs)) {
  237.                 throw new Gumbo_Exception ("Invalid Argument 'dirs:str|arr' => {$dirs}:" . gettype ($dirs));
  238.             }
  239.             
  240.             // check for multiple arguments
  241.             if (func_num_args () > 1) {
  242.                 foreach (func_get_args () as $val) {
  243.                     $this->setDirs ($val);
  244.                 }
  245.                 return;
  246.             }
  247.             
  248.             // check for an array
  249.             if (is_array ($dirs)) {
  250.                 foreach ($dirs as $dir) {
  251.                     $this->setDirs ($dir);
  252.                 }
  253.                 return;
  254.             }
  255.             
  256.             // check the path separator
  257.             if (strstr ($dirs, PATH_SEPARATOR)) {
  258.                 $dirs = explode (PATH_SEPARATOR, $dirs);
  259.                 foreach ($dirs as $dir) {
  260.                     $this->setDirs ($dir);
  261.                 }
  262.                 return;
  263.             }
  264.             
  265.             // add the new Directory
  266.             $this->addDir ($dir);
  267.         } catch (Gumbo_Exception $e) {
  268.             $e->setFunction (__METHOD__);
  269.             gumbo_trigger ($e);
  270.         }
  271.     }
  272.     
  273.     /**
  274.      * Sets the file extension (leading "." not necessary)
  275.      * @param string $ext 
  276.      * @throws Gumbo_Exception
  277.      */
  278.     public function setExtension ($ext) {
  279.         try {
  280.             // verify precondition
  281.             if (!is_null ($ext) && !is_string ($ext)) {
  282.                 throw new Gumbo_Exception ("Invalid Argument 'ext:str' => {$ext}:" . gettype ($ext));
  283.             }
  284.             
  285.             parent::add ("ext", $ext);
  286.         } catch (Gumbo_Exception $e) {
  287.             $e->setFunction (__METHOD__);
  288.             gumbo_trigger ($e);
  289.         }
  290.     }
  291.     
  292.     /**
  293.      * Sets the load only once setting
  294.      * @param bool $once 
  295.      * @throws Gumbo_Exception
  296.      */
  297.     public function setOnce ($once) {
  298.         try {
  299.             // verify precondition
  300.             if (!is_bool ($once)) {
  301.                 throw new Gumbo_Exception ("Invalid Argument 'once:bool' => {$once}:" . gettype ($once));
  302.             }
  303.             
  304.             parent::add ("once", $once);
  305.         } catch (Gumbo_Exception $e) {
  306.             $e->setFunction (__METHOD__);
  307.             gumbo_trigger ($e);
  308.         }
  309.     }
  310.     
  311.     /**
  312.      * Sets to use include instead of require
  313.      * @param bool $include 
  314.      * @throws Gumbo_Exception
  315.      */
  316.     public function setInclude ($include) {
  317.         try {
  318.             // verify precondition
  319.             if (!is_bool ($include)) {
  320.                 throw new Gumbo_Exception ("Invalid Argument 'include:bool' => {$include}:" . gettype ($include));
  321.             }
  322.             
  323.             parent::add ("include", $include);
  324.         } catch (Gumbo_Exception $e) {
  325.             $e->setFunction (__METHOD__);
  326.             gumbo_trigger ($e);
  327.         }
  328.     }
  329.     
  330.     /**
  331.      * Sets to stretch the file name as additional directory paths
  332.      * @param bool $stretch 
  333.      * @throws Gumbo_Exception
  334.      */
  335.     public function setStretch ($stretch) {
  336.         try {
  337.             // verify precondition
  338.             if (!is_bool ($stretch)) {
  339.                 throw new Gumbo_Exception ("Invalid Argument 'stretch:bool' => {$stretch}:" . gettype ($stretch));
  340.             }
  341.             
  342.             parent::add ("stretch", $stretch);
  343.         } catch (Gumbo_Exception $e) {
  344.             $e->setFunction (__METHOD__);
  345.             gumbo_trigger ($e);
  346.         }
  347.     }
  348.     
  349.     /**
  350.      * Sets the stretch separator character
  351.      * @param string $sep 
  352.      * @throws Gumbo_Exception
  353.      */
  354.     public function setSeparator ($sep) {
  355.         try {
  356.             // verify precondition
  357.             if (!is_null ($sep) && !is_string ($sep)) {
  358.                 throw new Gumbo_Exception ("Invalid Argument 'sep:str' => {$sep}:" . gettype ($sep));
  359.             }
  360.             
  361.             parent::add ("separator", $sep);
  362.         } catch (Gumbo_Exception $e) {
  363.             $e->setFunction (__METHOD__);
  364.             gumbo_trigger ($e);
  365.         }
  366.     }
  367.     
  368.     /**
  369.      * Sets the path to start searching from.
  370.      * Possible values:
  371.      * - include: search the include path (default)
  372.      * - home: start from Gumbo home directory
  373.      * - absolute: ignores starting point and uses dirs as absolute paths
  374.      * 
  375.      * @param string $path 
  376.      * @throws Gumbo_Exception
  377.      */
  378.     public function setPath ($path) {
  379.         try {
  380.             // verify precondition
  381.             if (!is_string ($path)) {
  382.                 throw new Gumbo_Exception ("Invalid Argument 'path:str' => {$path}:" . gettype ($path));
  383.             }
  384.             
  385.             switch ($path) {
  386.                 case "home" : break;
  387.                 case "absolute" : break;
  388.                 case "include" : break;
  389.                 default : throw new Gumbo_Exception ("Invalid Path: {$path}");
  390.             }
  391.             
  392.             parent::add ("path", $path);
  393.         } catch (Gumbo_Exception $e) {
  394.             $e->setFunction (__METHOD__);
  395.             gumbo_trigger ($e);
  396.         }
  397.     }
  398.     
  399.     /**
  400.      * Sets a string pattern to remove from the file name before search
  401.      * @param string $remove 
  402.      * @throws Gumbo_Exception
  403.      */
  404.     public function setRemove ($remove) {
  405.         try {
  406.             // verify precondition
  407.             if (!is_string ($remove)) {
  408.                 throw new Gumbo_Exception ("Invalid Argument 'remove:str' => {$remove}:" . gettype ($remove));
  409.             }
  410.             
  411.             parent::add ("remove", $remove);
  412.         } catch (Gumbo_Exception $e) {
  413.             $e->setFunction (__METHOD__);
  414.             gumbo_trigger ($e);
  415.         }
  416.     }
  417.     
  418.     
  419.     
  420.     /** ACCESSOR METHODS **/
  421.     /**
  422.      * Returns if the setting is for a class load
  423.      * @return bool 
  424.      */
  425.     public function getClass () {
  426.         return $this->get ("class");
  427.     }
  428.     
  429.     /**
  430.      * Returns the list of directory paths
  431.      * @return array 
  432.      */
  433.     public function getDirs () {
  434.         return $this->get ("dirs");
  435.     }
  436.     
  437.     /**
  438.      * Returns the file extension
  439.      * @return string 
  440.      */
  441.     public function getExtension () {
  442.         return $this->get ("ext");
  443.     }
  444.     
  445.     /**
  446.      * Returns if the file should be loaded once
  447.      * @return bool 
  448.      */
  449.     public function getOnce () {
  450.         return $this->get ("once");
  451.     }
  452.     
  453.     /**
  454.      * Returns if the include function should be used instead of require
  455.      * @return bool 
  456.      */
  457.     public function getInclude () {
  458.         return $this->get ("include");
  459.     }
  460.     
  461.     /**
  462.      * Returns if the file name should stretch
  463.      * @return bool 
  464.      */
  465.     public function getStretch () {
  466.         return $this->get ("stretch");
  467.     }
  468.     
  469.     /**
  470.      * Returns the stretch separator character
  471.      * @return string 
  472.      */
  473.     public function getSeparator () {
  474.         return $this->get ("separator");
  475.     }
  476.     
  477.     /**
  478.      * Returns the path to start searching from
  479.      * @return string 
  480.      */
  481.     public function getPath () {
  482.         return $this->get ("path");
  483.     }
  484.     
  485.     /**
  486.      * Returns the remove string pattern
  487.      * @return string 
  488.      */
  489.     public function getRemove () {
  490.         return $this->get ("remove");
  491.     }
  492.     
  493. }
  494.  
  495. ?>