Changeset 1334

Show
Ignore:
Timestamp:
02/06/08 18:18:33 (7 months ago)
Author:
mikey
Message:

moved creation of simple filters to a filter provider
allowed registration of user-defined base filters to be used in forType()
added support for length
fix: pass strategy to decorating filters

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/experiments/people/mikey/filterAPI/filterAPI.php

    r1332 r1334  
    1313$filter = stubFilterFactory::forType('string')->length(2, 5)->validatedBy(new stubRegexValidator($regex))->defaultsTo('foo'); 
    1414 
    15 $password = stubFilterFactory::forType('password')->minLength(5)->minDiffChars(3)->nonAllowedValues(array(1, 2, 3))->encodedWith(new stubMd5Encoder()); 
     15$password = stubFilterFactory::forType('password', array($rveFactory))->minLength(5)->minDiffChars(3)->nonAllowedValues(array(1, 2, 3))->encodedWith(new stubMd5Encoder()); 
    1616 
    17 $http = stubFilterFactory::forType('http')->checkDNS(true); 
     17$http = stubFilterFactory::forType('http', array($rveFactory))->checkDNS(true); 
    1818 
    19 $mail = stubFilterFactory::forType('mail'); 
     19$mail = stubFilterFactory::forType('mail', array($rveFactory)); 
    2020 
    2121 

  • trunk/experiments/people/mikey/filterAPI/stubFilterFactory.php

    r1332 r1334  
    77 * @subpackage  ipo_request_filters 
    88 */ 
    9 stubClassLoader::load('net::stubbles::ipo::request::stubAbstractFilterDecorator' 
    10                       'net::stubbles::ipo::request::stubRequestErrorValueFactory', 
     9stubClassLoader::load('net::stubbles::ipo::request::stubRequestErrorValueFactory', 
     10                      'net::stubbles::ipo::request::stubRequestValueErrorXJConfFactory', 
     11                      'net::stubbles::ipo::request::filters::stubAbstractFilterDecorator', 
     12                      'net::stubbles::ipo::request::filters::stubEncodingFilterDecorator', 
     13                      'net::stubbles::ipo::request::filters::stubDefaultValueFilterDecorator', 
     14                      'net::stubbles::ipo::request::filters::stubLengthFilterDecorator', 
     15                      'net::stubbles::ipo::request::filters::stubRangeFilterDecorator', 
     16                      'net::stubbles::ipo::request::filters::stubRequiredFilterDecorator', 
     17                      'net::stubbles::ipo::request::filters::stubStrategyFilterDecorator', 
     18                      'net::stubbles::ipo::request::filters::stubValidatorFilterDecorator', 
     19                      'net::stubbles::ipo::request::filters::provider::stubFilterProvider', 
     20                      'net::stubbles::ipo::request::filters::provider::stubMailFilterProvider', 
     21                      'net::stubbles::ipo::request::filters::provider::stubSimpleFilterProvider', 
    1122                      'net::stubbles::lang::exceptions::stubIllegalArgumentException' 
    1223); 
    …… 
    2132{ 
    2233    /** 
     34     * list of provider to use 
     35     * 
     36     * @var  array<stubFilterProvider> 
     37     */ 
     38    protected static $provider = array(); 
     39    /** 
    2340     * the request error value factory to be used by the filter 
    2441     * 
    …… 
    2845 
    2946    /** 
     47     * static initializer 
     48     */ 
     49    public static function __static() 
     50    { 
     51        self::$provider[] = new stubSimpleFilterProvider(array('int', 'integer'), 'net::stubbles::ipo::request::filters::stubIntegerFilter'); 
     52        self::$provider[] = new stubSimpleFilterProvider(array('double', 'float'), 'net::stubbles::ipo::request::filters::stubFloatFilter'); 
     53        self::$provider[] = new stubSimpleFilterProvider(array('string'), 'net::stubbles::ipo::request::filters::stubStringFilter'); 
     54        self::$provider[] = new stubSimpleFilterProvider(array('text'), 'net::stubbles::ipo::request::filters::stubTextFilter'); 
     55        self::$provider[] = new stubSimpleFilterProvider(array('password'), 'net::stubbles::ipo::request::filters::stubPasswordFilter'); 
     56        self::$provider[] = new stubSimpleFilterProvider(array('http'), 'net::stubbles::ipo::request::filters::stubHTTPURLFilter'); 
     57        self::$provider[] = new stubMailFilterProvider(); 
     58    } 
     59 
     60    /** 
     61     * adds a user-defined filter provider 
     62     * 
     63     * @param  stubFilterProvider  $filterProvider 
     64     */ 
     65    public static function addFilterProvider(stubFilterProvider $filterProvider) 
     66    { 
     67        self::$provider[] = $filterProvider; 
     68    } 
     69 
     70    /** 
    3071     * constructor 
    3172     * 
    …… 
    4081     * creates a filter for the given type 
    4182     * 
    42      * @param   string  $type 
    43      * @return  stubFilterFactory 
    44      * @todo    refactor to get rid of the large switch statement 
    45      */ 
    46     public static function forType($type, stubRequestErrorValueFactory $rveFactory = null) 
    47     { 
    48         switch ($type) { 
    49             case 'int': 
    50             case 'integer': 
    51                 $filter = new stubIntegerFilter(); 
    52                 break; 
    53              
    54             case 'double': 
    55             case 'float': 
    56                 $filter = new stubFloatFilter(); 
    57                 break; 
    58              
    59             case 'string': 
    60                 $filter = new stubStringFilter(); 
    61                 break; 
    62              
    63             case 'text': 
    64                 $filter = new stubTextFilter(); 
    65                 break; 
    66              
    67             case 'http': 
    68                 if (null === $rveFactory) { 
    69                     throw new stubIllegalArgumentException('Requested filter requires a stubRequestErrorValueFactory.'); 
    70                 } 
    71                  
    72                 $filter = new stubHTTPURLFilter($rveFactory); 
    73                 break; 
    74              
    75             case 'mail': 
    76                 if (null === $rveFactory) { 
    77                     throw new stubIllegalArgumentException('Requested filter requires a stubRequestErrorValueFactory.'); 
    78                 } 
    79                  
    80                 $filter = new stubMailFilter($rveFactory, new stubMailValidator()); 
    81                 break; 
    82              
    83             case 'password': 
    84                 if (null === $rveFactory) { 
    85                     throw new stubIllegalArgumentException('Requested filter requires a stubRequestErrorValueFactory.'); 
    86                 } 
    87                  
    88                 $filter = new stubPasswordFilter($rveFactory); 
    89              
    90             default: 
    91                 throw new stubIllegalArgumentException('No filter known for given type.'); 
    92         } 
    93          
    94         $me = new self($filter) 
     83     * @param   string             $type  type of filter to create 
     84     * @param   array              $args  optional  constructor arguments for filter 
     85     * @return  stubFilterFactory 
     86     */ 
     87    public static function forType($type, array $args = null) 
     88    { 
     89        $filter = null; 
     90        foreach (self::$provider as $filterProvider) { 
     91            if ($filterProvider->isResponsible($type) === true) { 
     92                $filter = $filterProvider->getFilter($args); 
     93            } 
     94        } 
     95         
     96        if (null === $filter) { 
     97            throw new stubIllegalArgumentException('No filter known for given type.'); 
     98        } 
     99         
     100        $me = new self($filter); 
    95101        if (null !== $rveFactory) { 
    96102            $me->using($rveFactory); 
    …… 
    150156            } 
    151157             
     158            $filter->setStrategy($strategy); 
    152159            $this->setDecoratedFilter($filter); 
    153160        } 
    …… 
    157164 
    158165    /** 
     166     * decorates the filter with a length filter 
     167     * 
     168     * To create a lower border only use NULL for $maxLength, to create an upper 
     169     * border only use NULL for $minLength. 
     170     * 
     171     * @param   numeric            $minLength 
     172     * @param   numeric            $maxLength 
     173     * @param   int                $strategy   optional  strategy to be used: before or after decorated filter 
     174     * @return  stubFilterFactory 
     175     */ 
     176    public function length($minLength, $maxLength, $strategy = stubStrategyFilterDecorator::STRATEGY_AFTER) 
     177    { 
     178        if (null !== $minLength && null !== $maxLength) { 
     179            $filter = new stubLengthFilterDecorator($this->getDecoratedFilter(), $this->getRVEFactory()); 
     180            if (null !== $minLength) { 
     181                $filter->setMinLengthValidator(new stubMinLengthValidator($minLength)); 
     182            } 
     183             
     184            if (null !== $maxLength) { 
     185                $filter->setMaxLengthValidator(new stubMaxLengthValidator($maxLength)); 
     186            } 
     187             
     188            $filter->setStrategy($strategy); 
     189            $this->setDecoratedFilter($filter); 
     190        } 
     191         
     192        return $this; 
     193    } 
     194 
     195    /** 
    159196     * decorates the filter as required 
    160197     * 
    …… 
    164201    public function asRequired($strategy = stubStrategyFilterDecorator::STRATEGY_BEFORE) 
    165202    { 
    166         $this->setDecoratedFilter(new stubRequiredFilterDecorator($this->getDecoratedFilter(), $this->getRVEFactory())); 
     203        $filter = new stubRequiredFilterDecorator($this->getDecoratedFilter(), $this->getRVEFactory()); 
     204        $filter->setStrategy($strategy); 
     205        $this->setDecoratedFilter($filter); 
    167206        return $this; 
    168207    } 
    …… 
    177216    public function defaultsTo($defaultValue, $strategy = stubStrategyFilterDecorator::STRATEGY_AFTER) 
    178217    { 
    179         $this->setDecoratedFilter(new stubDefaultValueFilterDecorator($this->getDecoratedFilter(), $defaultValue)); 
     218        $filter = new stubDefaultValueFilterDecorator($this->getDecoratedFilter(), $defaultValue); 
     219        $filter->setStrategy($strategy); 
     220        $this->setDecoratedFilter($filter); 
    180221        return $this; 
    181222    } 
    …… 
    196237        } 
    197238         
     239        $filter->setStrategy($strategy); 
    198240        $this->setDecoratedFilter($filter); 
    199241        return $this; 
    …… 
    210252    public function encodedWith(stubStringEncoder $encoder, $encoderMode = stubStringEncoder::MODE_DECODE, $strategy = stubStrategyFilterDecorator::STRATEGY_AFTER) 
    211253    { 
    212         $this->setDecoratedFilter(new stubEncodingFilterDecorator($this->getDecoratedFilter(), $encoder, $encoderMode)); 
     254        $filter = new stubEncodingFilterDecorator($this->getDecoratedFilter(), $encoder, $encoderMode); 
     255        $filter->setStrategy($strategy); 
     256        $this->setDecoratedFilter($filter); 
    213257        return $this; 
    214258    } 
    …… 
    255299     * execute the filter 
    256300     * 
    257      * @param   mixed                $value  value to filter 
    258      * @return  mixed                filtered value 
    259      * @throws  stubFilterException  in case $value has errors 
     301     * @param   mixed  $value  value to filter 
     302     * @return  mixed 
    260303     */ 
    261304    public function execute($value)