ducktypechecker 0.1.0

data/README

@@ -0,0 +1,58 @@
+Duck Type Checker is copyrighted free software by Brian Takita <brian.takita@gmail.com>.
+You can redistribute it and/or modify it under either the terms of the GPL, or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+    modifications to Usenet or an equivalent medium, or by allowing
+    the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+    together with instructions (in the manual page or equivalent)
+    on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+    the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+
+

data/lib/duck_type_checker.rb

@@ -0,0 +1,35 @@
+module DuckType
+  # Checks the given object if is responds to the given
+  # method signatures.
+  # ==Arguments
+  # :obj      = The object being tested
+  # :methods  = A method name or enumerable of the method names.
+  # :var_name = The name of the variable begin tested.
+  #             This is useful for the default messages.
+  # ==Block
+  # Optionally a block may be passed to respond to a method that
+  # is not implemented by the object.
+  def self.check(obj, methods, var_name = nil, &block)
+    methods = [methods] unless methods.respond_to?(:each)
+    methods.each do |s|
+      s = s.intern if s.respond_to?(:intern)
+      unless obj.respond_to?(s)
+        return yield(s) if block_given?
+        
+        if var_name.to_s == ''
+          message = "Object '#{obj.to_s}' needs to implement '#{s.to_s}'."
+        else
+          message = "Variable '#{var_name}' needs to implement '#{s.to_s}'."
+        end
+        fail TypeError.new(message)
+      end
+      
+      true
+    end
+  end
+  
+  # Instance implementation of the static method DuckTypeChecker.check
+  def duck_type_check(obj, methods, var_name = nil, &block)
+    DuckType.check(obj, methods, var_name, &block)
+  end
+end

data/lib/ducktypechecker.rb

@@ -0,0 +1,2 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/duck_type_checker"

data/test/tc_duck_type_checker.rb

@@ -0,0 +1,83 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../lib/duck_type_checker"
+require "test/unit"
+
+class DuckTypeCheckerTest < Test::Unit::TestCase
+  public
+  
+  def test_check_pass
+    do_test_pass(class_method)
+  end
+  
+  def test_check_fail_default
+    do_test_fail_default(class_method)
+  end
+    
+  def test_check_fail_block
+    do_fail_block(class_method)
+  end
+  
+  def test_duck_type_check_pass
+    do_test_pass(instance_method)
+  end
+  
+  def test_duck_type_check_fail_default
+    do_test_fail_default(instance_method)
+  end
+  
+  def test_duck_type_check_fail_block
+    do_fail_block(instance_method)
+  end
+  
+  private
+  
+  include DuckType
+  
+  def class_method
+    DuckType.method(:check)
+  end
+  
+  def instance_method
+    method(:duck_type_check)
+  end
+  
+  def do_test_pass(proc)
+    n = 1
+    assert(proc.call(n, :to_s))
+    assert(proc.call(n, :to_s, 'n'))
+    assert(proc.call(n, [:to_s]))
+    assert(proc.call(n, [:to_s], 'n'))
+  end
+  
+  def do_test_fail_default(proc)
+    n = 1
+    test_sym = :blah
+    
+    assert_raise(TypeError) do
+      begin
+        proc.call(n, [test_sym])
+      rescue Exception=>e
+        e_m = "Object '#{n.to_s}' needs to implement '#{test_sym.to_s}'."
+        assert_equal(e_m, e.message)
+        raise e
+      end
+    end
+    
+    var_name = 'test'
+    assert_raise(TypeError) do
+      begin
+        proc.call(n, [test_sym], var_name)
+      rescue Exception=>e
+        e_m = "Variable '#{var_name.to_s}' needs to implement '#{test_sym.to_s}'."
+        assert_equal(e_m, e.message)
+        raise e
+      end
+    end
+  end
+  
+  def do_fail_block(proc)
+    n = 1
+    v = proc.call(n, [:blah]) {|s| "#{s} test"}
+    assert_equal("blah test", v)
+  end
+end

data/test/ts_ducktypechecker.rb

@@ -0,0 +1,2 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/tc_duck_type_checker"

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: ducktypechecker
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2005-09-01 00:00:00 -07:00
+summary: Check to see if an object contains the required method signatures.
+require_paths: 
+  - lib
+email: brian.takita@gmail.com
+homepage: http://DuckTypeChecker.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: 
+authors: 
+  - Brian Takita
+files: 
+  - test/tc_duck_type_checker.rb
+  - test/ts_ducktypechecker.rb
+  - lib/ducktypechecker.rb
+  - lib/duck_type_checker.rb
+  - README
+test_files: 
+  - test/ts_ducktypechecker.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+executables: []
+extensions: []
+requirements: []
+dependencies: []