ducktator 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2006 Ola Bini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

data/README

@@ -0,0 +1,88 @@
+= Ducktator - the Duck Type Validator
+
+Ducktator is a small library to enable Ruby systems to generically
+validate objects introspectively. In plain speak, check certain common
+methods of objects, and see if they match what your schema expects the
+values to be. This capability is not necessary for most applications,
+but sometimes it's highly useful. For example, validating objects that
+have been serialized or marshallad. Validating what you get when
+loading YAML files, so that the object graph matches what your code
+does. Write test cases that expect a complicated object back. The
+possibilities are many.
+
+Ducktator can be configured either with YAML or directly using simple
+Hashes. The syntax is very recursive, extensible and easy. I will use
+YAML for the examples in this document, but for easier validations it
+may be better just creating the +Hash+ directly.
+
+
+== Validator usage
+
+The main way into the Ducktator validator framework are a couple of
+factory methods in the Ducktator namespace. To create a new +Validator+
+from a YAML file you could do it like this: (in this case, there must
+be a root key inside the YAML document)
+
+ Ducktator::from_file('validations.yml') # => #<Ducktator::Validator ...>
+
+You can also create a +Validator+ from a +String+ directly.
+
+ Ducktator::from('class: String') # => #<Ducktator::Validator ...>
+
+If you just want to do a one time validation, this can be done like
+this:
+
+ Ducktator::valid?('class: String', 123) # => false
+
+or like this:
+
+ Ducktator::valid?('class' => String, 'abc') # => true
+
+Using the +Validator+ object is mostly as simple as calling the method
++valid?+ and send it the objects you want to validate. +valid?+ will
+return +true+ only if all its arguments are valid ackording to its
+validation rules:
+
+ p v # => #<Ducktator::Validator ...>
+ v.valid?("str1")
+ v.valid?("str1","str2","str3")
+
+Validators can be combined with & and |, like this:
+
+vx = v1 & (v2 | v3) & v4 
+
+
+== Validation specification
+
+The validation specification will contain one or more validations to
+check against. A validation always has a value. It can be scalar, a
+sequence or a mapping. If it's a mapping, it will be interpolated as a
+new specification. A simple YAML file that validates a +Hash+, that
+should have +String+ keys and values that are +Array+'s with index 0
+being a +Symbol+ and index 1 an +Integer+ which is maximum 256: (note
+that the +root:+ is necessary, unless loading the YAML directly from a
++String+)
+
+ ---
+ root:
+  class: Hash
+  each_key: {class: String}
+  each_value:
+    class: Array
+    value:
+    - - 0
+      - class: Symbol
+    - - 1
+      - class: Integer
+      - max: 256
+
+More than one validation can exist in the same file, just use
++Ducktator#from_file+'s second, optional argument, which defaults to
+"root".
+
+
+== Author
+Ola Bini <ola@ologix.com>
+
+== License
+Ducktator is distributed with a MIT license, which can be found in the file LICENSE.

data/lib/ducktator.rb

@@ -0,0 +1,598 @@
+#!/usr/bin/env ruby
+
+require 'stringio'
+require 'yaml'
+
+=begin
+= Ducktator, duck type validation for Ruby
+
+== IntroDUCKtion
+Uses different constructs to make sure a Ruby object matches a specified instruction.
+Could be used to validate YAML documents.
+
+== Usage
+
+Create a new Validator from a file:
+
+Ducktator.from(stream) => #<Ducktator::Validator>
+or
+Ducktator.define(spec) => #<Ducktator::Validator>
+
+A spec in YAML should look like this:
+ ---
+ root:
+  class: Hash
+  respond_to:
+  - to_s
+  - each_with_key
+  each_value:
+  - class: Array
+    each: {class: [Numeric, Symbol]}
+
+This defines a validator for every object that should be a Hash ===,
+it should +respond_to?+ +:to_s+ and +:each_with_key+ and +each_value+
+should yield an +Array+ object where each value is either a +Numeric+
+or a +Symbol+. +===+ is always used for matching, and actually class
+works the same way as match which does the same thing. The available
+validations right now can be found in the different modules in
+Ducktator ending with Validation. For example, there is a module
+called +Ducktator::ScalarValidation+, which defines the methods
++check_class+, +check_is+ and +check_match+. These are available as
+the validations +class+, +is+ and +match+. To add new validations,
+just add methods following thise naming scheme to the validator in
+question. The method should take an object and a spec as argument.All
+of these take either a scalar value, or it's own sub validation
+definition.  The name root is used as the default name for validator,
+but you can define how many validators you want with different names,
+mix and match with yaml, etc.
+
+Author: Ola Metodius Bini <ola@ologix.com>
+License: MIT
+=end
+module Ducktator
+  # The default key to load the specification from in a YAML document
+  DEFAULT_ROOT='root'
+
+  # Defines a new Ducktator validator. +spec+ should be a valid
+  # +Ducktator::Specification+ instance
+  def self.define(spec)
+    Validator.new(spec)
+  end
+  
+  # Creates a new Ducktator validator. +str+ can either be a String
+  # containing YAML or an IO object to YAML. +root+ is the name in the
+  # YAML to load as root validation object
+  def self.from(str, root=DEFAULT_ROOT)
+    if str.is_a? String
+      from_string(str)
+    else
+      define(Specification.from_yaml(str,root))
+    end
+  end
+
+  # Reads YAML specification and creates Ducktator validator from the
+  # filename specified in +str+. +root+ is the name in the YAML file
+  # to load as validation object.
+  def self.from_file(str, root=DEFAULT_ROOT)
+    define(Specification.from_file(str,root))
+  end
+
+  # Loads the YAML in the provided string and creates a specifiction
+  # directly from the hash ensuing. (Note, no root objects needed. The
+  # hash will be the root).
+  def self.from_string(str)
+    define(Specification.from_hash(YAML.load(str)))
+  end
+  
+  # Checks to see if +objs+ are valid ackording to +validator+, which
+  # can be a +String+ with YAML data, a +Hash+ with the specification
+  # or a +Validator+. Returns +true+ only if all +objs+ are valid.
+  def self.valid?(validator, *objs)
+    validator = YAML.load(validator) if validator.is_a? String
+    validator = define(Specification.from_hash(validator)) if validator.is_a? Hash
+    validator.valid? *objs
+  end
+
+  # A Specifcation is a data container for all validation
+  # properties. The meat of it is in the factory methods. Any
+  # accessors called on a specification object will succeed, meaning
+  # it can handle new validation names. When parsing a YAML file or a
+  # +Hash+ into a +Specification+, it will recurse. Every +Hash+ it
+  # encounters will be transformed into a new +Specification+ object.
+  class Specification
+    # Creates a specification from the YAML +stream+ provided, with
+    # the +root+ provided.
+    def self.from_yaml(stream, root=DEFAULT_ROOT)
+      from_hash(YAML.load(stream)[root])
+    end
+
+    # Reads YAML from file with name +filename+, loading the YAML
+    # inside and uses the +root+ provided.
+    def self.from_file(filename, root=DEFAULT_ROOT)
+      open(filename, 'r') {|f| from_yaml(f,root) }
+    end
+    
+    # Recurses through the hash +h+ and creates all specification
+    # information from this.
+    def self.from_hash(h)
+      sp = Specification.new
+      h.each_key do |nm|
+        v = recurse_value(h[nm])
+        nm = 'clazz' if nm == 'class'
+        sp.send "#{nm}=",v
+      end
+      sp
+    end
+ 
+    # Special setter to avoid using the name +class+. This setter will
+    # transform the object provided into an array if it isn't already,
+    # and transform all array entries to +Module+
+    def clazz=(v)
+      v = [v] unless v.is_a? Array
+      @clazz = v.collect {|nm| Module === nm ? nm : to_class(nm) }
+    end
+    
+    def of=(v)
+      @of = Module === v ? v : to_class(v)
+    end
+
+    # Sets or gets all properties
+    def method_missing(name, *args)
+      name = name.to_s
+      if name =~ /^(.*)=$/
+        instance_variable_set "@#$1",args[0]
+      else
+        instance_variable_get "@#{name}"
+      end
+    end
+    
+    private
+    # Recurses down +v+, transforming +Hash+ objects into
+    # +Specification+.
+    def self.recurse_value(v)
+      case v
+      when Hash: from_hash(v)
+      when Array: v.collect {|i| recurse_value(i) }
+      else v
+      end
+    end
+
+    # The +String+ +v+ will be transformed into a +Module+.
+    def to_class(v)
+      obj_class = Object
+      v.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if v
+      obj_class
+    end
+  end
+
+  #
+  # Boolean validations will take a list of validations and report
+  # differently depending on which operation asked. The available
+  # validations are +or+,+xor+,+and+,+not_all+ and +not_any+. A
+  # typical usage of +and+ could look like this:
+  #
+  #   and:
+  #   - class: String
+  #   - class: Enumerable
+  #
+  # which requires that the object in question is both a String and an
+  # Enumerable.
+  #
+  module BooleanValidation
+    def check_or(obj, spec)
+      if spec.or
+        spec.or.any? do |real|
+          check_valid(obj,real)
+        end
+      else
+        true
+      end
+    end
+
+    def check_xor(obj, spec)
+      if spec.xor
+        spec.xor.partition do |real|
+          check_valid(obj,real)
+        end.first.length == 1
+      else
+        true
+      end
+    end
+    
+    def check_and(obj, spec)
+      if spec.and
+        spec.and.all? do |real|
+          check_valid(obj,real)
+        end
+      else
+        true
+      end
+    end
+
+    def check_not_all(obj, spec)
+      if spec.not_all
+        !spec.not_all.all? do |real|
+          check_valid(obj,real)
+        end
+      else
+        true
+      end
+    end
+
+    def check_not_any(obj, spec)
+      if spec.not_any
+        !spec.not_any.any? do |real|
+          check_valid(obj,real)
+        end
+      else
+        true
+      end
+    end
+  end
+
+  #
+  # The comparison validations contain the validations +max+ and +min+
+  # which will make sure the object under question is either <=
+  # max-value or >= min-value.
+  #
+  # If specifying max or min for an object, make sure that object
+  # actually can handle the <= and >= operations.
+  #
+  # Example:
+  #
+  #   max: 1.1
+  #   min: 0.2
+  #
+  module ComparisonValidation
+    def check_max(obj, spec)
+      if spec.max
+        return false unless obj.respond_to? :<=
+        obj <= spec.max
+      else
+        true
+      end
+    end
+    def check_min(obj, spec)
+      if spec.min
+        return false unless obj.respond_to? :>=
+        obj >= spec.min
+      else
+        true
+      end
+    end    
+  end
+  
+  # 
+  # Scalar validation is one of the more common structures that other
+  # code will be based on. The available matches are +class+, +match+
+  # and +is+. Class checks if the object in question is +===+ the
+  # Class (or Module) in question. +match+ does the same thing, but
+  # will probably be used for Regexps and such. +is+ will match
+  # against a specific value. An example could look like this:
+  #
+  #   class: String
+  #   or:
+  #   - match: !ruby/regexp /foo/
+  #   - is: baz
+  #
+  module ScalarValidation
+    def check_class(obj, spec)
+      if spec.clazz
+        spec.clazz.any? {|v| v === obj } 
+      else
+        true
+      end
+    end
+
+    def check_match(obj, spec)
+      if spec.match
+        spec.match === obj
+      else
+        true
+      end
+    end
+    
+    def check_is(obj, spec)
+      if spec.is
+        spec.is == obj
+      else
+        true
+      end
+    end
+  end
+
+  #
+  # +EnumerableValidation+ provides common validations for objects
+  # that implement +each+ and friends. The available tests are +each+,
+  # +each_key+, +each_value+, +all+, +any+, +of+ and +none+. Most of
+  # these do exactly what they appear to. They walk through the
+  # objects, check if each object matches the specified rule and
+  # returns the result. +all+ and +each+ are the same thing. +none+ is
+  # a combination of +not+ and +any+. +of+ is a combination of each
+  # and class, making it easy to specify that an Array should only
+  # contain objects of a specific type. An example:
+  #
+  #   class: Hash
+  #   each_key: {class: String}
+  #   each_value: 
+  #           class: Array
+  #           each: {class: Numeric, max: 100}
+  #
+  # This validator will only succeed for Hashes where all keys are
+  # Strings, all values are Arrays and each element of the Array are
+  # Numeric and maximum 100.
+  #
+  module EnumerableValidation
+    def check_of(obj, spec)
+      if spec.of
+        obj.all? do |v|
+          spec.of === v
+        end
+      else
+        true
+      end
+    end
+
+    def check_each(obj, spec)
+      if spec.each
+        return false unless obj.respond_to? :each
+        xe = spec.each
+        obj.each do |val|
+          return false unless recurse_check(xe,val)
+        end
+      end
+      true
+    end
+
+    def check_each_key(obj, spec)
+      if spec.each_key
+        return false unless obj.respond_to? :each_key
+        xe = spec.each_key
+        obj.each_key do |val|
+          return false unless recurse_check(xe,val)
+        end
+      end
+      true
+    end
+
+    def check_each_value(obj, spec)
+      if spec.each_value
+        return false unless obj.respond_to? :each_value
+        xe = spec.each_value
+        obj.each_value do |val|
+          return false unless recurse_check(xe,val)
+        end
+      end
+      true
+    end
+    
+    def check_all(obj, spec)
+      if spec.all
+        return false unless obj.respond_to? :all?
+        xe = spec.all
+        obj.all? do |val|
+          recurse_check(xe,val)
+        end
+      else
+        true
+      end
+    end
+
+    def check_any(obj, spec)
+      if spec.any
+        return false unless obj.respond_to? :any?
+        xe = spec.any
+        xe = [xe] unless xe.is_a? Array
+        obj.any? do |val|
+          xe.any? do |chk|
+            if chk.is_a? Specification
+              check_valid(val,chk)
+            else
+              chk == val
+            end
+          end
+        end
+      else
+        true
+      end
+    end
+    
+    def check_none(obj, spec)
+      if spec.none
+        return false unless obj.respond_to? :any?
+        xe = spec.none
+        xe = [xe] unless xe.is_a? Array
+        !obj.any? do |val|
+          xe.any? do |chk|
+            if chk.is_a? Specification
+              check_valid(val,chk)
+            else
+              chk == val
+            end
+          end
+        end
+      else
+        true
+      end
+    end
+
+    private
+    def recurse_check(xe, val)
+      xe = [xe] unless xe.is_a? Array
+      xe.all? do |chk|
+        if chk.is_a? Specification
+          check_valid(val,chk)
+        else
+          chk == val
+        end
+      end
+    end
+  end
+
+  #
+  # Validates that the object in question +respond_to?+ one or more
+  # methods. This validation takes either a scalar or an array. If an
+  # array is provided, the object must +respond_to?+ all method names
+  # specified. Example:
+  #
+  #   or:
+  #   - respond_to: read
+  #   - respond_to: [to_s, to_sym]
+  #
+  # This example will match all objects that either +respond_to?+
+  # +read+ or +respond_to?+ +to_s+ and +to_sym+.
+  #
+  module DuckValidation
+    def check_respond_to(obj, spec)
+      if spec.respond_to
+        rs = spec.respond_to
+        rs = [rs] unless rs.is_a? Array
+        rs.all? do |m|
+          obj.respond_to? m
+        end
+      else
+        true
+      end
+    end
+  end
+
+  #
+  # +ValueValidation+ will check specific values on objects. It
+  # provides +value+, +method_value+ and +instance_value+. +value+ is
+  # for check objects that +respond_to?+ [], +method_value+ will call
+  # the accessor with the name specified and +instance_value+ will
+  # check the +instance_variable+ with the specified name. An example
+  # for value could look like this:
+  #
+  #   value:
+  #   - - version
+  #     - class: Float
+  #       min: 0.1
+  #       max: 9.9
+  #   - - foo
+  #     - each:
+  #         class: Hash
+  #         each_key: {class: Class}
+  #         each_value: {class: String}
+  #
+  # This checks the values returned by obj['version'] and obj['foo']
+  #
+  module ValueValidation
+    def check_value(obj, spec)
+      if spec.value
+        return false unless obj.respond_to? :[]
+        spec.value.all? do |key,spec|
+          if spec.is_a? Specification
+            check_valid(obj[key],spec)
+          else
+            spec == obj[key]
+          end
+        end
+      else
+        true
+      end
+    end
+    
+    def check_method_value(obj, spec)
+      if spec.method_value
+        spec.method_value.all? do |key,spec|
+          if spec.is_a? Specification
+            check_valid(obj.send(key),spec)
+          else
+            spec == obj.send(key)
+          end
+        end
+      else
+        true
+      end
+    end
+
+    def check_instance_value(obj, spec)
+      if spec.instance_value
+        spec.instance_value.all? do |key,spec|
+          if spec.is_a? Specification
+            check_valid(obj.instance_variable_get("@#{key}"),spec)
+          else
+            spec == obj.instance_variable_get("@#{key}")
+          end
+        end
+      else
+        true
+      end
+    end
+  end
+
+  # Makes it possible to compose Validators with & and |, just like that.
+  module ValidatorComposable
+    def &(other)
+      AndValidator.new(self,other)
+    end
+    def |(other)
+      OrValidator.new(self,other)
+    end
+  end
+
+  # The base validator class. The frame which everything is built
+  # around. When adding new validation, make this class Mix-in
+  # them. There isn't really much to this class. Almost all
+  # functionality is mixed-in.
+  class Validator
+    include ValidatorComposable
+    include ComparisonValidation, 
+            ScalarValidation, 
+            EnumerableValidation,
+            DuckValidation,
+            ValueValidation,
+            BooleanValidation
+    
+    def initialize(spec)
+      @spec = spec
+    end
+
+    # Checks that all submitted objects are valid ackording to this
+    # validator
+    def valid?(*objs)
+      objs.all? do |obj|
+        check_valid obj
+      end
+    end
+    
+    private
+    # The method that does the real work of finding out which methods
+    # to call and calling them. Also the focal point of most Validator
+    # recursion.
+    def check_valid(obj, spec=@spec)
+      (methods + protected_methods + private_methods).grep(/^check_/) do |name|
+        next if name == 'check_valid'
+        return false unless self.send name, obj, spec
+      end
+      true
+    end
+  end
+  
+  # Combines two validators into one that only succeeds if both succeeds separately
+  class AndValidator
+    include ValidatorComposable
+    
+    def initialize(one, two)
+      @one, @two = one, two
+    end
+    
+    def valid?(*objs)
+      @one.valid?(*objs) && @two.valid?(*objs)
+    end
+  end
+
+  # Combines two validators into one that succeeds if either of them succeeds
+  class OrValidator
+    include ValidatorComposable
+    
+    def initialize(one, two)
+      @one, @two = one, two
+    end
+    
+    def valid?(*objs)
+      @one.valid?(*objs) || @two.valid?(*objs)
+    end
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,75 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'ducktator'
+require 'test/unit'
+
+class TestBasicDuctator < Test::Unit::TestCase
+  def test_clazz_hash
+    assert Ducktator.valid?('class: Hash', {})
+    assert Ducktator.valid?('class: [Hash, Array]', [])
+    assert Ducktator.valid?('class: [Hash, Array]', {})
+    assert !Ducktator.valid?('class: Hash', [])
+  end
+
+  def test_each_clazz
+    assert Ducktator.valid?('each: {class: String}',[])
+    assert Ducktator.valid?('each: {class: String}','a'..'z')
+    assert !Ducktator.valid?('each: {class: String}',[123])
+    assert !Ducktator.valid?('each: {class: String}',['abc',123])
+  end
+
+  def test_all_clazz
+    assert Ducktator.valid?('all: {class: String}',[])
+    assert Ducktator.valid?('all: {class: String}','a'..'z')
+    assert !Ducktator.valid?('all: {class: String}',[123])
+    assert !Ducktator.valid?('all: {class: String}',['abc',123])
+  end
+
+  def test_any_clazz
+    assert Ducktator.valid?('any: {class: String}','a'..'z')
+    assert Ducktator.valid?('any: {class: String}',['abc',123])
+    assert !Ducktator.valid?('any: {class: String}',[])
+    assert !Ducktator.valid?('any: {class: String}',[123])
+  end
+  
+  def test_none_clazz
+    assert !Ducktator.valid?('none: {class: String}','a'..'z')
+    assert Ducktator.valid?('none: {class: String}',[])
+    assert Ducktator.valid?('none: {class: String}',[123])
+    assert !Ducktator.valid?('none: {class: String}',['abc',123])
+  end
+  
+  def test_match
+    assert Ducktator.valid?({'match' => /abc/},'aabcd')
+    assert !Ducktator.valid?({'match' => /abc/},'aadcd')
+    assert Ducktator.valid?('match: abc','abc')
+    assert !Ducktator.valid?('match: abc','adbc')
+  end
+
+  def test_each_value_clazz
+    assert Ducktator.valid?('each_value: {class: String}',{})
+    assert Ducktator.valid?('each_value: {class: String}',{123 => 'hello'})
+    assert Ducktator.valid?('each_value: {class: String}',{123 => 'hello', 321 => 'goodbye'})
+    assert !Ducktator.valid?('each_value: {class: String}',{'hello' => 123, 321 => 'goodbye'})
+  end
+
+  def test_each_key_clazz
+    assert Ducktator.valid?('each_key: {class: String}',{})
+    assert Ducktator.valid?('each_key: {class: String}',{'hello' => 123})
+    assert Ducktator.valid?('each_key: {class: String}',{'hello' => 123, 'goodbye' => 321})
+    assert !Ducktator.valid?('each_key: {class: String}',{'hello' => 123, 321 => 'goodbye'})
+  end
+  
+  def test_is
+    assert Ducktator.valid?('is: abc', 'abc')
+    assert !Ducktator.valid?('is: abcd', 'abc')
+  end
+  
+  def test_respond_to
+    assert Ducktator.valid?('respond_to: to_s', 'abc')
+    assert Ducktator.valid?('respond_to: [to_s]', 'abc')
+    assert Ducktator.valid?('respond_to: [to_s, hash]', 'abc')
+    assert !Ducktator.valid?('respond_to: try1', 'abc')
+    assert !Ducktator.valid?('respond_to: [try1]', 'abc')
+  end
+end

data/test/test_complex.rb

@@ -0,0 +1,48 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'ducktator'
+require 'test/unit'
+
+class TestComplexDuctator < Test::Unit::TestCase
+  TESTOBJ1 = { 
+    'abc' => [
+              {Class => 'Clazz',
+               Module => 'Mod'},
+              {Regexp => 'Reggie',
+               Numeric => 'Num'}
+             ],
+    'version' => 0.1
+  }
+  
+  VALIDATOR1 = {
+    'each_key' => { 'class' => String },
+    'value' => [['version',{ 'class' => Float,
+                                 'min' => 0.1,
+                                 'max' => 9.9 }],
+                ['abc',{ 'each' => { 'class' => Hash,
+                                         'each_key' => {'class' => Class},
+                                         'each_value' => ['class' => String]}}]    
+               ]}
+  
+  VALIDATOR2 = <<VAL;
+---
+each_key: {class: String}
+value:
+- - version
+  - class: Float
+    min: 0.1
+    max: 9.9
+- - abc
+  - each:
+      class: Hash
+      each_key: {class: Class}
+      each_value: {class: String}
+VAL
+
+  def test_validation1
+    assert Ducktator.valid?(VALIDATOR1,TESTOBJ1)
+    assert Ducktator.valid?(VALIDATOR2,TESTOBJ1)
+    assert !Ducktator.valid?(VALIDATOR1,{ })
+    assert !Ducktator.valid?(VALIDATOR2,{ })
+  end
+end

data/test/test_ducktator.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require 'test/test_basic'
+require 'test/test_complex'

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ducktator
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-09-19 00:00:00 +02:00
+summary: Duck Type Validator - your own Ruby type dictator
+require_paths: 
+- lib
+email: ola@ologix.com
+homepage: http://ducktator.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ola Bini
+files: 
+- lib/ducktator.rb
+- test/test_ducktator.rb
+- test/test_basic.rb
+- test/test_complex.rb
+- LICENSE
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+