waw 0.2.2

data/lib/waw/tools/mail/template.rb

@@ -0,0 +1,38 @@
+module Waw
+  module Tools
+    class MailAgent
+      # Allows creating WLang templates for mails easily
+      class Template < Mail
+        
+        # The wlang dialect
+        attr_writer :dialect
+        
+        # Returns the wlang dialect to use
+        def dialect
+          return @dialect if @dialect
+          case content_type
+            when 'text/html'
+              'wlang/xhtml'
+            when 'text/plain'
+              'wlang/active-string'
+            else
+              Waw.logger.warn("Unable to get wlang dialect from content-type #{content_type}")
+              Waw.logger.warn("Using wlang/active-string by default")
+          end
+        end
+        
+        # Instantiates this template using a given wlang context.
+        # The date of the resulting mail is set to Time.now
+        def instantiate(context = {})
+          mail, args = self.dup, context.unsymbolize_keys
+          mail.subject = mail.subject.wlang(args, dialect)
+          mail.body = mail.body.wlang(args, dialect)
+          mail.date = Time.now
+          mail
+        end
+        alias :to_mail :instantiate
+        
+      end
+    end # class MailAgent
+  end # module Tools
+end # module Waw

data/lib/waw/utils/dsl_helper.rb

@@ -0,0 +1,116 @@
+#
+# This file is extracted from the CRUC library (http://code.chefbe.net)
+# which is distributed under the licence below. Please keep this header
+# when using this class. Send an email to blambeau at gmail dot com if
+# you need special usage rights.
+#
+# The MIT License
+# Copyright (c) 2009 Bernard Lambeau and the University of Louvain 
+# (Universite Catholique de Louvain, Louvain-la-Neuve, Belgium)
+# 
+
+#
+# Provides a simple but powerful way to create non intrusive DSLs.
+# Typical use cases are described below.
+#
+# === Punctual DSL usage
+# A given user block uses your DSL punctually. As the later installs 
+# potentially intrusive methods in some Ruby core classes, you would
+# like your DSL to be installed, user block executed and Ruby methods
+# restored immediately after.
+#
+#    DSLHelper.new(String => [:upcase], Symbol => [:/, :&, :|]) do
+#      load 'mydsl.rb'           # install your DSL first 
+#      yield if block_given?     # yield user block
+#    end
+#
+# After the DSLHelper new invocation, all Ruby methods are correctly 
+# restored. 
+#
+# === Middle-case DSL usage
+# Your DSL must be installed punctually but you cannot encapsulate its
+# usage in a single DSLHelper.new invocation. Calling save and restore 
+# methods is the alternative. However, their invocation MUST respect 
+# (save restore)* invocation regexp otherwise a RuntimeError is raised.
+#
+#   helper = DSLHelper.new(String => [:upcase], Symbol => [:/, :&, :|])
+#   helper.save      # save Ruby methods that you plan to override
+#   load 'mydsl.rb'  # install your DSL 
+#   [...]            # do anything you want, here of somewhere
+#   helper.restore   # restore Ruby methods when finished
+#
+# === Long-term DSL usage
+# Your DSL (or more generically, ruby extensions you've written) is used during 
+# the whole execution of the program. You hope that it is not intrusive (you only 
+# add methods that doesn't already exist to some Ruby classes). You would like to 
+# check this hypothesis (because Ruby evolves, your code may be used in conjunction 
+# with third party libraries that install their own methods, etc.)
+#
+#   if DSLHelper.is_intrusive?(String => [:upcase], Symbol => [:/, :&, :|])
+#     STDERR << "WARNING: this library seems to override Ruby existing methods"
+#   end
+#   load 'ruby_extensions.rb'
+#
+class DSLHelper
+  
+  # Creates a DSLHelper instance. _hash_ must be a Hash instance
+  # mapping modules to array of symbols. If a block is given, the
+  # Ruby state is immediately saved, block is yield and state is
+  # restored after that.
+  def initialize(hash)
+    @definition = hash
+    @saved = nil
+    if block_given?
+      save
+      yield
+      restore
+    end
+  end
+
+  # Checks if a set of methods that your DSL is planning to install
+  # makes it an intrusive DSL (overriding existing Ruby or third
+  # party methods)
+  def self.is_intrusive?(hash)
+    hash.each_pair do |mod, methods|
+      methods.each do |method|
+        return true if mod.method_defined?(method)
+      end
+    end
+    false
+  end
+  
+  # Finds a method inside a Module, or returns nil.
+  def self.find_instance_method(mod, method)
+    mod.instance_method(method)
+  rescue NameError
+    nil
+  end
+
+  # Saves all methods of the definition hash in an internal data
+  # structure. This method raises an error is a save is already
+  # pending.
+  def save
+    raise "save already pending" unless @saved.nil?
+    @saved = {}
+    @definition.each_pair do |mod, methods|
+      @saved[mod] = methods.collect {|m| DSLHelper.find_instance_method(mod,m)}
+    end
+  end
+  
+  # Restores all methods previously saved. This method raises an
+  # error if no save call has been made before.
+  def restore
+    raise "save has not been called previously." if @saved.nil?
+    @definition.each_pair do |mod, methods|
+      methods.zip(@saved[mod]).each do |name, saved|
+        if saved.nil?
+          mod.send(:remove_method, name) if mod.method_defined?(name)
+        elsif
+          mod.send(:define_method, name, saved)
+        end
+      end
+    end
+    @saved = nil
+  end
+
+end

data/lib/waw/validation.rb

@@ -0,0 +1,175 @@
+require 'waw/validation/errors'
+require 'waw/validation/helpers'
+require 'waw/validation/validator'
+require 'waw/validation/not_validator'
+require 'waw/validation/and_validator'
+require 'waw/validation/or_validator'
+
+require 'waw/validation/missing_validator'
+require 'waw/validation/mandatory_validator'
+require 'waw/validation/default_validator'
+require 'waw/validation/same_validator'
+require 'waw/validation/isin_validator'
+
+require 'date'
+require 'waw/validation/boolean_validator'
+require 'waw/validation/string_validator'
+require 'waw/validation/integer_validator'
+require 'waw/validation/float_validator'
+require 'waw/validation/date_validator'
+require 'waw/validation/regexp_validator'
+
+require 'waw/validation/comparison_validations'
+require 'waw/validation/size_validations'
+require 'waw/validation/array_validations'
+require 'waw/validation/file_validator'
+require 'waw/validation/ext'
+require 'waw/validation/signature'
+module Waw
+  #
+  # Provides a reusable architecture for parameter validation 
+  #
+  module Validation
+    extend ::Waw::Validation::Helpers
+    
+    # Validators, by name
+    @@validators = {}
+    
+    # Ruby classes => validators
+    @@ruby_classes_to_validators = {}
+    
+    # Other modules that include me
+    @@who_includes_me = []
+    
+    # Allows this module to be included as a normal one, hiding
+    # introspection mechanisms to install validators
+    class << self
+      
+      # When this module is included in _who_ we install all validation
+      # methods dynamically
+      def included(who)
+        @@who_includes_me << who unless @@who_includes_me.include?(who)
+        @@validators.each_pair do |name, validator|
+          who.module_eval <<-EOF
+            def #{name}(*args, &block)
+              ::Waw::Validation.send(:#{name}, *args, &block)
+            end
+          EOF
+        end
+      end
+      
+    end # Metaprogramming hack for module inclusion
+    
+    
+    # Helpers for extensions
+    class << self
+      
+      # Builds a signature with a given block as definition
+      def signature(&block)
+        Signature.new(&block)
+      end
+      
+      # Adds a ruby class => validator mapping
+      def ruby_class_to_validator(ruby_class, validator)
+        @@ruby_classes_to_validators[ruby_class] = validator
+      end
+      
+      # Returns a validator to use for a given ruby class
+      def validator_for_ruby_class(ruby_class, raise_if_not_found=true)
+        val = @@ruby_classes_to_validators[ruby_class]
+        return val unless val.nil?
+        raise "Unable to find a validator for #{ruby_class}" if raise_if_not_found
+      end
+
+      # Automatically builds the validator and installs a method returning
+      # it.
+      def validator(name = nil, *args, &block)
+        # Build the validator
+        validator = args[0]
+        if validator.nil? and block
+          # first case, block creation
+          validator = Validator.new(&block)
+        elsif ::Waw::Validation::Validator===validator and block.nil?
+          # first case: explicit validator, nothing to do
+        elsif validator.is_a?(::Class) and block.nil?
+          # second case: class, for defered creation
+          validator = to_validator(validator) unless validator.ancestors.include?(::Waw::Validation::Validator)
+        elsif ::Module===validator and block.nil?
+          # third case: module of validation rules, nothing to do
+        elsif block.nil?
+          # fifth case: auto conversion
+          validator = to_validator(validator)
+        else
+          raise WawError, "Invalid Waw::Validation.validator call with #{name}, #{args.inspect}, #{block.inspect}"
+        end
+        
+        # Install it if a name is provided
+        return validator if name.nil?
+        @@validators[name] = validator
+
+        # Installs the class method that returns the validator
+        instance_eval <<-EOF
+          class << self
+            def #{name}(*args, &block)
+              val = @@validators[:#{name}]
+              val.is_a?(::Class) ? val.new(*args, &block) : val
+            end
+          end
+        EOF
+        
+        # Install the class methods on all modules that include me
+        @@who_includes_me.each do |mod|
+          mod.module_eval <<-EOF
+            def #{name}(*args, &block)
+              ::Waw::Validation.send(:#{name}, *args, &block)
+            end
+          EOF
+        end
+        
+        validator
+      end
+      
+      # User-friendly message for missing validators
+      def method_missing(name, *args, &block)
+        raise WawError, "Unknown validator #{name}", caller
+      end
+      
+    end # Helpers for extensions
+  
+    # General validators typically used for parameter validation
+    validator :always_accept, validator{|*args| true}
+    validator :missing,   ::Waw::Validation::MissingValidator.new
+    validator :mandatory, ::Waw::Validation::MandatoryValidator.new
+    validator :default,   ::Waw::Validation::DefaultValidator
+    validator :same,      ::Waw::Validation::SameValidator.new
+    validator :equal,     ::Waw::Validation::SameValidator.new
+    validator :isin,      ::Waw::Validation::IsInValidator
+    
+    # Type-based validators
+    validator :boolean,   ::Waw::Validation::BooleanValidator.new    
+    validator :string,    ::Waw::Validation::StringValidator.new
+    validator :integer,   ::Waw::Validation::IntegerValidator.new
+    validator :float,     ::Waw::Validation::FloatValidator.new
+    validator :date,      ::Waw::Validation::DateValidator.new
+    ruby_class_to_validator(::Boolean, boolean)
+    ruby_class_to_validator(::String, string)
+    ruby_class_to_validator(::Integer, integer)
+    ruby_class_to_validator(::Float, float)
+    ruby_class_to_validator(::Date, date)
+    
+    # Regexp-based validators
+    validator :mail,      /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]?@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/
+    validator :weburl,    /^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
+    
+    # Validators from other modules
+    Array              =  ::Waw::Validation::ArrayValidations
+    validator :array,     ::Waw::Validation::ArrayValidations
+    validator :size,      ::Waw::Validation::SizeValidations
+    validator :is,        ::Waw::Validation::ComparisonValidations
+    
+    # Validators about files and directories
+    validator :directory, validator{|*args| args.all?{|a| ::File.directory?(a)}}
+    validator :file,      ::Waw::Validation::FileValidator
+
+  end # module Validation
+end # module Waw

data/lib/waw/validation/and_validator.rb

@@ -0,0 +1,27 @@
+module Waw
+  module Validation
+    class AndValidator < Validator
+    
+      # Empty constructor that overrides the top one
+      def initialize(*validators)
+        @validators = validators
+      end
+    
+      # Calls the block installed at initialization time    
+      def validate(*values)
+        @validators.all?{|validator| validator.validate(*values)}
+      end
+    
+      # Converts and validate
+      def convert_and_validate(*values)
+        initials = values
+        @validators.each do |validator|
+          ok, values = validator.convert_and_validate(*values)
+          return [ok, initials] unless ok
+        end
+        [true, values]
+      end
+    
+    end # class AndValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/array_validations.rb

@@ -0,0 +1,38 @@
+module Waw
+  module Validation
+    module ArrayValidations
+      class ArrayValidator < Validator
+        
+        # Creates a validator instance with a delegator
+        def initialize(subvalidator)
+          @subvalidator = Waw::Validation.to_validator(subvalidator)
+        end
+        
+        # Validation method
+        def validate(*values)
+          values.all?{|val| val.is_a?(::Array) and @subvalidator.validate(*val) }
+        end
+        
+        # Convert and validate method
+        def convert_and_validate(*values)
+          my_converted = []
+          values.each do |val|
+            return [false, values] unless ::Array===val
+            ok, converted = @subvalidator.convert_and_validate(*val)
+            return [false, values] unless ok
+            my_converted << converted.compact
+          end
+          [true, my_converted]
+        end
+        
+      end
+      module Methods
+        # Checks that all values of the array are validated by a subvalidator
+        def [](subvalidator)
+          ArrayValidator.new(subvalidator)
+        end
+      end
+      extend Methods
+    end # module ArrayValidations
+  end # module Validation
+end # module Waw

data/lib/waw/validation/boolean_validator.rb

@@ -0,0 +1,32 @@
+module Waw
+  module Validation
+    class BooleanValidator < Validator
+    
+      def is_boolean?(value)
+        (value==true) || (value==false)
+      end
+    
+      def to_boolean(value)
+        return value if validate(value)
+        case value.to_s.strip
+          when 'true'
+            true
+          when 'false'
+            false
+          else 
+            nil
+        end 
+      end
+    
+      def validate(*values)
+        values.all?{|val| is_boolean?(val)}
+      end
+    
+      def convert_and_validate(*values)
+        converted = values.collect{|v| to_boolean(v)}
+        validate(*converted) ? [true, converted] : [false, values]
+      end
+    
+    end # class BooleanValidator
+  end # module Validation
+end # module Waw

data/lib/waw/validation/comparison_validations.rb

@@ -0,0 +1,45 @@
+module Waw
+  module Validation
+    module ComparisonValidations
+      module Methods
+        
+        # Builds a validator that verifies that the length is greater than
+        # a specified value
+        def >(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| val.respond_to?(:>) and val > value} }}
+        end
+    
+        # Builds a validator that verifies that the length is greater-or-equal to
+        # a specified value
+        def >=(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| val.respond_to?(:>=) and val >= value} }}
+        end
+    
+        # Builds a validator that verifies that the length is less than
+        # a specified value
+        def <(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| val.respond_to?(:<) and val < value} }}
+        end
+    
+        # Builds a validator that verifies that the length is less-or-equal to
+        # a specified value
+        def <=(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| val.respond_to?(:<=) and val <= value} }}
+        end
+    
+        # Builds a validator that verifies that the length is equal to a
+        # specified value
+        def ==(value)
+          Validator.new {|*vals| Validation.argument_safe{ vals.all?{|val| val.respond_to?(:==) and val == value} }}
+        end
+        
+        # Same as Waw::Validation.isin
+        def in(*values)
+          Waw::Validation.isin(*values)
+        end
+        
+      end
+      extend Methods
+    end # module ComparisonValidations
+  end # module Validation
+end # module Waw