waw 0.2.2

data/lib/waw/validation/date_validator.rb

@@ -0,0 +1,31 @@
+require 'date'
+module Waw
+  module Validation
+    class DateValidator < Validator
+    
+      # Returns a Date object if value seems a date,
+      # nil otherwise
+      def seems_a_date?(value)
+        if /^\d{4}\/\d{2}\/\d{2}$/ =~ value.to_s
+          Date.strptime(value.to_s, "%Y/%m/%d")
+        elsif /^\d{2}\/\d{2}\/\d{4}$/ =~ value.to_s
+          Date.strptime(value.to_s, "%d/%m/%Y")
+        else
+          nil
+        end
+      rescue ArgumentError => ex
+        nil
+      end
+    
+      def validate(*values)
+        values.all?{|val| seems_a_date?(val)}
+      end
+    
+      def convert_and_validate(*values)
+        dates = values.collect{|v| seems_a_date?(v)}
+        dates.include?(nil) ? [false, values] : [true, dates]
+      end
+    
+    end # class IntegerValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/default_validator.rb

@@ -0,0 +1,30 @@
+module Waw
+  module Validation
+    class DefaultValidator < Validator
+    
+      # Creates a validator instance
+      def initialize(*args, &block)
+        error("Validator default expects one argument or a block: default(19) or default{Time.now} for example", caller)\
+          unless (args.size==1 and block.nil?) or (args.empty? and not(block.nil?))
+        @which = args.empty? ? :block : :arg
+        @default_value = args.empty? ? block : args[0]
+      end
+    
+      # Always returns true
+      def validate(*values)
+        all_missing?(values)
+      end
+      
+      # Computes the default value from a missing one
+      def compute_default(value)
+        @which == :block ? @default_value.call(value) : @default_value
+      end
+    
+      # Converts missing values by the default one
+      def convert_and_validate(*values)
+        validate(*values) ? [true, values.collect{|v| compute_default(v)}] : [false, values]
+      end
+    
+    end # class DefaultValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/dsl_ruby_extensions.rb

@@ -0,0 +1,11 @@
+class Class
+  def |(validator)
+    ::Waw::Validation.to_validator(self) | validator
+  end
+  def &(validator)
+    ::Waw::Validation.to_validator(self) & validator
+  end
+  def not()
+    ::Waw::Validation.to_validator(self).not
+  end
+end

data/lib/waw/validation/errors.rb

@@ -0,0 +1,17 @@
+module Waw
+  module Validation
+    class Error < StandardError
+      
+      # The list of failures
+      attr_accessor :failed 
+      
+      # Creates a validation error instance
+      def initialize(failed, msg = "Validation has failed #{failed.inspect}")
+        super(msg)
+        @failed = failed
+      end 
+      
+    end
+    class KO < Error; end
+  end
+end # module Waw

data/lib/waw/validation/ext.rb

@@ -0,0 +1,3 @@
+# A boolean class (used as namespace only)
+class Boolean
+end

data/lib/waw/validation/file_validator.rb

@@ -0,0 +1,30 @@
+module Waw
+  module Validation
+    class FileValidator < Validator
+    
+      def initialize(opts = {})
+        @options = opts
+      end
+      
+      # Seems a valid file
+      def seems_a_file?(f)
+        return false unless File.file?(f)
+        return true unless @options
+        @options.each_pair do |key, value|
+          case key
+            when :extension
+              return false unless value==File.extname(f)
+            else
+              raise Waw::Error, "Unexpected FileValidator option #{key} : #{value}"
+          end
+        end
+        true
+      end
+    
+      def validate(*values)
+        values.all?{|f| seems_a_file?(f)}
+      end
+    
+    end # class NotValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/float_validator.rb

@@ -0,0 +1,19 @@
+module Waw
+  module Validation
+    class FloatValidator < ::Waw::Validation::Validator
+      
+      # Regular expression we use
+      FLOAT_REGEXP = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/
+      
+      def validate(*values)
+        values.all?{|v| ::Float===v}
+      end
+      
+      def convert_and_validate(*values)
+        ok = values.all?{|v| FLOAT_REGEXP =~ v.to_s}
+        ok ? [true, values.collect{|v| v.to_s.to_f}] : [false, values]
+      end
+      
+    end
+  end # module Validation
+end # module Waw

data/lib/waw/validation/helpers.rb

@@ -0,0 +1,67 @@
+module Waw
+  module Validation
+    module Helpers
+      
+      # Sends a friendly error message if something is wrong
+      def error(msg, the_caller)
+        raise ::Waw::WawError, msg, the_caller
+      end
+      
+      # Checks if a given value is considered missing. In a web environment,
+      # we consider a value being missing when it is nil or an empty string
+      # (when stripped). All validators should use this method to share a 
+      # common definition for 'missing'. It may be overriden, at your own 
+      # risks however. This method always returns false when invoked on 
+      # any value other than nil or a String.
+      def is_missing?(value)
+        value.nil? or (String===value and value.strip.empty?)
+      end
+      
+      # Converts missing values to nil
+      def missings_to_nil(values)
+        values.collect{|v| is_missing?(v) ? nil : v}
+      end
+      
+      # Checks if all values are missing
+      def all_missing?(values)
+        values.all?{|v| is_missing?(v)}
+      end
+      
+      # Checks if any value is missing
+      def any_missing?(values)
+        values.any?{|v| is_missing?(v)}
+      end
+      
+      # Checks if no value is considered missing
+      def no_missing?(values)
+        not(any_missing?(values))
+      end
+      
+      # Yields the block inside a rescue on ArgumentError. Returns false
+      # if such an error has been raised
+      def argument_safe
+        yield
+      rescue ArgumentError
+        false
+      end
+      
+      # Automatically converts specials guys as validators (regular 
+      # expressions, some ruby classes, etc.)
+      def to_validator(who)
+        if who.is_a?(Class)
+          Waw::Validation.validator_for_ruby_class(who, true)
+        else
+          case who
+            when ::Waw::Validation::Validator
+              who
+            when Regexp
+              RegexpValidator.new(who, true)
+            else
+              raise "Unable to convert #{who}:#{who.class} to a validator"
+          end
+        end
+      end
+
+    end # module Helpers
+  end # module Validation
+end # module Waw

data/lib/waw/validation/integer_validator.rb

@@ -0,0 +1,16 @@
+module Waw
+  module Validation
+    class IntegerValidator < Validator
+    
+      def validate(*values)
+        values.all?{|val| ::Integer===val}
+      end
+    
+      def convert_and_validate(*values)
+        ok = values.all?{|v| Integer===v or (/^[+-]?\d+$/ =~ v.to_s.strip)}
+        ok ? [true, values.collect{|v| v.to_s.strip.to_i}] : [false, values]
+      end
+    
+    end # class IntegerValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/isin_validator.rb

@@ -0,0 +1,24 @@
+module Waw
+  module Validation
+    # Checks that arguments belongs to an array of allowed values provided 
+    # at construction time.
+    class IsInValidator < Validator
+      
+      # Creates the validator instance
+      def initialize(*allowed)
+        @allowed = (allowed.size==1 and Range===allowed[0]) ? allowed[0] : allowed
+      end
+      
+      # Validation method
+      def validate(*values)
+        values.all?{|v| @allowed.include?(v)}
+      end
+      
+      # Convert and validate method
+      def convert_and_validate(*values)
+        [validate(*values), values]
+      end
+      
+    end # class IsInValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/mandatory_validator.rb

@@ -0,0 +1,17 @@
+module Waw
+  module Validation
+    class MandatoryValidator < Validator
+    
+      # Calls the block installed at initialization time    
+      def validate(*values)
+        no_missing?(values)
+      end
+    
+      # Converts and validate
+      def convert_and_validate(*values)
+        validate(*values) ? [true, values] : [false, values]
+      end
+    
+    end # class MissingValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/missing_validator.rb

@@ -0,0 +1,17 @@
+module Waw
+  module Validation
+    class MissingValidator < Validator
+    
+      # Calls the block installed at initialization time    
+      def validate(*values)
+        values.all?{|value| is_missing?(value)}
+      end
+    
+      # Converts and validate
+      def convert_and_validate(*values)
+        validate(*values) ? [true, missings_to_nil(values)] : [false, values]
+      end
+    
+    end # class MissingValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/not_validator.rb

@@ -0,0 +1,20 @@
+module Waw
+  module Validation
+    class NotValidator < Validator
+    
+      def initialize(negated)
+        @negated = negated
+      end
+    
+      def validate(*values)
+        not(@negated.validate(*values))
+      end
+    
+      def convert_and_validate(*values)
+        ok, converted = @negated.convert_and_validate(*values)
+        ok ? [false, values] : [true, converted]
+      end
+    
+    end # class NotValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/or_validator.rb

@@ -0,0 +1,34 @@
+module Waw
+  module Validation
+    class OrValidator < Validator
+    
+      # Empty constructor that overrides the top one
+      def initialize(*validators)
+        @validators = validators
+      end
+    
+      # Calls the block installed at initialization time    
+      def validate(*values)
+        values.all?{|val| @validators.any?{|validator| validator.validate(val)}}
+      end
+    
+      # Converts and validate
+      def convert_and_validate(*values)
+        converted = []
+        values.each do |value|
+          found = false
+          @validators.each do |validator|
+            found, val_converted = validator.convert_and_validate(value)
+            if found
+              converted << val_converted[0]
+              break
+            end
+          end
+          return [false, values] unless found
+        end
+        [true, converted]
+      end
+    
+    end # class OrValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/regexp_validator.rb

@@ -0,0 +1,29 @@
+module Waw
+  module Validation
+    # Validator that checks that values match a given regular expression
+    class RegexpValidator < ::Waw::Validation::Validator
+      
+      #
+      # Creates a validator instance.
+      #
+      # If strip is set to true, the regexp is checked against a stripped
+      # version of value.to_s. In this case, the conversion strips the string 
+      # as well.
+      #
+      def initialize(regexp, strip = true)
+        @regexp, @strip = regexp, strip
+      end
+      
+      # Validation method
+      def validate(*values)
+        values.all?{|v| @regexp =~ (@strip ? v.to_s.strip : v.to_s)}
+      end
+      
+      # Converts and validate method
+      def convert_and_validate(*values)
+        validate(*values) ? [true, values.collect{|v| @strip ? v.to_s.strip : v}] : [false, values]
+      end
+      
+    end
+  end # module Validation
+end # module Waw

data/lib/waw/validation/same_validator.rb

@@ -0,0 +1,16 @@
+module Waw
+  module Validation
+    # Checks that arguments are all non missing and equal
+    class SameValidator < Validator
+    
+      def validate(*values)
+        any_missing?(values) ? false : values.uniq.size==1
+      end
+    
+      def convert_and_validate(*values)
+        [validate(*values), values]
+      end
+    
+    end # class IntegerValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/signature.rb

@@ -0,0 +1,157 @@
+module Waw
+  module Validation
+    #
+    # A service or data signature, as a list of validations to be respected.
+    #
+    class Signature
+    
+      # The DSL attached to signature
+      class DSL
+      
+        # Creates a DSL instance
+        def initialize(signature)
+          @signature = signature
+        end
+        
+        # Executes a block as this DSL
+        def execute(&block)
+          DSLHelper.new(Class => [:&, :|, :not]) do
+            Kernel.load(File.join(File.dirname(__FILE__), 'dsl_ruby_extensions.rb'))
+            self.instance_eval(&block)
+          end
+        end
+      
+        # Adds a validation
+        def validation(args, validator, onfailure)
+          @signature.add_validation(args, ::Waw::Validation.to_validator(validator), onfailure)
+        end
+      
+        # When a methos is missing
+        def method_missing(name, *args, &block)
+          Waw::Validation.send(name, *args, &block)
+        rescue Exception => ex
+          raise ex.class, ex.message, caller
+        end
+      
+      end # class DSL
+    
+      # A validation rule
+      class ValidationRule
+      
+        # Creates a Validation instance
+        def initialize(args, validator, onfailure)
+          @args = args
+          @validator = validator
+          @onfailure = onfailure
+        end
+        
+        # Collects the interesting parameters on a hash
+        def collect_on_hash(hash)
+          @args.collect{|arg| hash[arg]}
+        end
+      
+        # Validates argument values given through a hash. Returns nil
+        # if everything is ok, the on_failure installed parameters otherwise.
+        def validate(hash)
+          @validator.validate(*collect_on_hash(hash)) ? nil : @onfailure
+        end
+      
+        # Validates and convert a hash. Values of the hash are replaced
+        # by their convertions if the validation passes. In this case, a
+        # nil value is returned. Otherwise, the on_failure is returned 
+        # and the hash is not changed.
+        def convert_and_validate(hash)
+          ok, values = @validator.convert_and_validate(*collect_on_hash(hash))
+          @args.each_with_index {|arg, i| hash[arg] = values[i]} if ok
+          ok ? nil : @onfailure
+        end
+        
+        # Applies the validation and conversion rule on a hash. Returns the
+        # first converted (or non converted if validation fails) value.
+        def first_converted(hash)
+          ok, values = @validator.convert_and_validate(*collect_on_hash(hash))
+          values[0]
+        end
+        
+        # Completes a hash of default values
+        def complete_defaults(hash)
+          ok, values = @validator.convert_and_validate(*collect_on_hash(hash))
+          @args.each_with_index {|arg, i| hash[arg] = values[i]}
+        end
+      
+      end # class Validation
+    
+      # Rules
+      attr_accessor :rules
+    
+      # Creates an empty signature
+      def initialize(&block)
+        @rules = []
+        DSL.new(self).execute(&block) unless block.nil?
+      end
+    
+      # Merges this signature with additional definition
+      def merge(&block)
+        signature = self.dup
+        DSL.new(signature).execute(&block) unless block.nil?
+        signature
+      end
+    
+      # Adds a validation rule
+      def add_validation(args, validator, onfailure)
+        args = [args] if Symbol===args
+        @rules << ValidationRule.new(args, validator, onfailure)
+      end
+    
+      # Validates argument values given through a hash and returns a series
+      # of onfailure flags.
+      def validate(hash)
+        converted, failures = hash.dup, []
+        failures = @rules.collect{|rule| rule.validate(converted)}.compact
+        failures.empty? ? [true, converted] : [false, failures]
+      end
+    
+      # Validates argument values given through a hash and returns a series
+      # of onfailure flags.
+      def apply(hash)
+        raise ArgumentError, "Hash expected (did you invoked an action without a Hash?)" unless Hash===hash
+        converted, failures = hash.dup, []
+        failures = @rules.collect{|rule| rule.convert_and_validate(converted)}.compact
+        failures.empty? ? [true, converted] : [false, failures]
+      end
+      
+      # Calls first_converted(hash) on the first rule. Returns nil if no rule
+      # has been installed. The hash is never modified by this method.
+      def first_converted(hash = {})
+        return nil if @rules.nil? or @rules.empty?
+        @rules[0].first_converted(hash)
+      end
+      
+      # Checks if the signature allows passing with some values 
+      def allows?(hash={})
+        apply(hash)[0]
+      end
+      
+      # Checks if the signature blocks with some values 
+      def blocks?(hash={})
+        not(allows?(hash))
+      end
+      
+      # Computed default data for this signature
+      def default
+        defaults = {}
+        @rules.each {|rule| rule.complete_defaults(defaults)}
+        defaults
+      end
+    
+      # Duplicates this validation
+      def dup
+        copy = Signature.new
+        copy.rules = self.rules.dup
+        copy
+      end
+    
+      protected :rules=
+    end # class Signature
+  end # module Validation
+end # module Waw