must 0.2.2 → 0.2.3

data/README

@@ -10,9 +10,14 @@ add Object#must method to constrain its origin and conversions
     num = params[:num].to_i
     num = 10 unless (1..300) === num
 
+and has duck features
 
-Testing Methods
-===============
+    1.must.duck?(:to_s)  # => true
+    io.must.duck(:write) { io.extend Writable }
+
+
+Asking Methods
+==============
 
 be      : check whether object equals to the argument
 kind_of : check whether object is a kind of the arguments
@@ -36,6 +41,15 @@ an : return self
 These effect nothing but exist only for English grammar.
 
 
+Duck Methods
+============
+duck("foo")  : check whether object responds to "foo" method.
+duck(:foo)   : same above
+duck(".foo") : same above
+duck("#foo") : check whether object has "foo" instance method. (tested only in class/module)
+duck?(...)   : acts same as "duck", but this returns a just boolean
+
+
 Basic Examples
 ==============
 
@@ -114,8 +128,7 @@ Actual Examples
 Install
 =======
 
-gem install maiha-must
-# add source http://gems.github.com
+gem install must
 
 % irb -r rubygems -r must
 irb(main):001:0> 1.must.be 1

data/lib/must/rule.rb

@@ -48,6 +48,7 @@ module Must
     def one_of(target, &block)
       valid?(target === @object, &block)
     end
+    alias :match :one_of
 
     def valid?(condition, &block)
       if condition ^ @not
@@ -81,6 +82,31 @@ module Must
       retry
     end
 
-    alias :match :one_of
+    def duck(method_name, &block)
+      valid?(duck?(method_name), &block)
+    end
+
+    def duck?(method_name)
+      case method_name.to_s
+      when /^\./ then method_defined?($')
+      when /^#/  then instance_method_defined?($')
+      else       ;    method_defined?(method_name)
+      end
+    end
+
+    private
+      def instance?
+        @object.class.to_s !~ /\A(Class|Module)\Z/o
+      end
+
+      def instance_method_defined?(method_name)
+        return false if instance?
+        !! @object.instance_methods.find { |m| m.to_s == method_name.to_s}
+      end
+
+      def method_defined?(method_name)
+        @object.respond_to?(method_name)
+      end
+
   end
 end

data/lib/must/version.rb

@@ -0,0 +1,3 @@
+module Must
+  VERSION = "0.2.3"
+end

data/lib/must.rb

@@ -1,3 +1,5 @@
+require "must/version"
+
 # Must
 module Must
   class Invalid < StandardError; end
@@ -12,5 +14,5 @@ module Must
   end
 end
 
-require File.dirname(__FILE__) + '/must/rule'
+require "must/rule"
 Object.__send__ :include, Must

data/must.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "must/version"
+
+Gem::Specification.new do |s|
+  s.name        = "must"
+  s.version     = Must::VERSION
+  s.authors     = ["maiha"]
+  s.email       = ["maiha@wota.jp"]
+  s.homepage    = "http://github.com/maiha/must"
+  s.summary     = %q{a runtime specification tool}
+  s.description = %q{add Object#must method to constrain its origin and conversions}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/test/coerced_test.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'rubygems'
+require File.join(File.dirname(__FILE__), '../init')
+
+class CoercedTest < Test::Unit::TestCase
+  def test_is_a_feature
+    assert_equal 1, 1.must.be.coerced(Integer)
+    assert_equal 1, 1.must.be.coerced(Integer, String)
+    assert_equal 1, 1.must.be.coerced(String, Numeric)
+
+    assert_raises(Invalid)     { "1".must.be.coerced(Integer) }
+    assert_raises(Invalid)     { "1".must.be.coerced(Integer, Range) }
+    assert_raises(NotImplementedError) { "1".must.be.coerced(Integer){raise NotImplementedError} }
+  end
+
+  def test_coecing_succeeded
+    assert_equal 1,   1.must.be.coerced(Integer, String=>proc{|i|i.to_i})
+    assert_equal 1, "1".must.be.coerced(Integer, String=>proc{|i|i.to_i})
+    assert_equal 1, "1".must.be.coerced(Integer, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
+    assert_equal 1, "1".must.be.coerced(Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
+    assert_equal 1, "1".must.be.coerced(File, Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
+  end
+
+  def test_coecing_failed
+    assert_raises(Invalid)     { "1".must.be.coerced(Integer, String=>proc{|i| /a/}) }
+    assert_raises(NotImplementedError) { "1".must.be.coerced(Integer, String=>proc{|i| /a/}){raise NotImplementedError} }
+  end
+
+  def test_cascaded_coecing_succeeded
+    assert_equal 1,    1.must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
+    assert_equal 1,  "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
+    assert_equal 1, :"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
+  end
+
+  def test_detect_livelock
+    assert_raises(Invalid){ "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}
+    assert_raises(Invalid){:"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}
+  end
+end

data/test/duck_test.rb

@@ -0,0 +1,83 @@
+require 'test/unit'
+require 'rubygems'
+require File.join(File.dirname(__FILE__), '../init')
+
+class DuckTest < Test::Unit::TestCase
+  class ClassFoo
+    def foo; 1; end
+  end
+
+  module ModuleFoo
+    def foo; 1; end
+  end
+
+  def test_itself_duck_type
+    # succeeded
+    assert_equal 1, 1.must.duck(:to_s)
+    assert_equal 1, 1.must.duck("to_s")
+    assert_equal 1, 1.must.duck(".to_s")
+    assert_equal ClassFoo, ClassFoo.must.duck(:to_s)
+    assert_equal ClassFoo, ClassFoo.must.duck("to_s")
+    assert_equal ClassFoo, ClassFoo.must.duck(".to_s")
+    assert_equal ModuleFoo, ModuleFoo.must.duck(:to_s)
+    assert_equal ModuleFoo, ModuleFoo.must.duck("to_s")
+    assert_equal ModuleFoo, ModuleFoo.must.duck(".to_s")
+
+    # failed
+    assert_raises(Invalid) { 1.must.duck(:foo) }
+    assert_raises(Invalid) { 1.must.duck("foo") }
+    assert_raises(Invalid) { 1.must.duck(".foo") }
+    assert_raises(Invalid) { ClassFoo.must.duck(:foo) }
+    assert_raises(Invalid) { ClassFoo.must.duck("foo") }
+    assert_raises(Invalid) { ClassFoo.must.duck(".foo") }
+    assert_raises(Invalid) { ModuleFoo.must.duck(:foo) }
+    assert_raises(Invalid) { ModuleFoo.must.duck("foo") }
+    assert_raises(Invalid) { ModuleFoo.must.duck(".foo") }
+  end
+
+  def test_instance_duck_type
+    # succeeded
+    assert_equal ClassFoo, ClassFoo.must.duck("#foo")
+    assert_equal ModuleFoo, ModuleFoo.must.duck("#foo")
+
+    # failed
+    assert_raises(Invalid) { 1.must.duck("#bar") } # instance object
+    assert_raises(Invalid) { ClassFoo.must.duck("#bar") }
+    assert_raises(Invalid) { ModuleFoo.must.duck("#bar") }
+  end
+
+  def test_itself_duck_test
+    # succeeded
+    assert_equal true, 1.must.duck?(:to_s)
+    assert_equal true, 1.must.duck?("to_s")
+    assert_equal true, 1.must.duck?(".to_s")
+    assert_equal true, ClassFoo.must.duck?(:to_s)
+    assert_equal true, ClassFoo.must.duck?("to_s")
+    assert_equal true, ClassFoo.must.duck?(".to_s")
+    assert_equal true, ModuleFoo.must.duck?(:to_s)
+    assert_equal true, ModuleFoo.must.duck?("to_s")
+    assert_equal true, ModuleFoo.must.duck?(".to_s")
+
+    # failed
+    assert_equal false, 1.must.duck?(:foo)
+    assert_equal false, 1.must.duck?("foo")
+    assert_equal false, 1.must.duck?(".foo")
+    assert_equal false, ClassFoo.must.duck?(:foo)
+    assert_equal false, ClassFoo.must.duck?("foo")
+    assert_equal false, ClassFoo.must.duck?(".foo")
+    assert_equal false, ModuleFoo.must.duck?(:foo)
+    assert_equal false, ModuleFoo.must.duck?("foo")
+    assert_equal false, ModuleFoo.must.duck?(".foo")
+  end
+
+  def test_instance_duck_test
+    # succeeded
+    assert_equal true, ClassFoo.must.duck?("#foo")
+    assert_equal true, ModuleFoo.must.duck?("#foo")
+
+    # failed
+    assert_equal false, 1.must.duck?("#bar") # instance object
+    assert_equal false, ClassFoo.must.duck?("#bar")
+    assert_equal false, ModuleFoo.must.duck?("#bar")
+  end
+end

data/test/match_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'rubygems'
+require File.join(File.dirname(__FILE__), '../init')
+
+class MatchTest < Test::Unit::TestCase
+  def test_match_range
+    # succeeded
+    assert_equal 1, 1.must.match(0..3)
+    assert_equal 'b', 'b'.must.match('a'..'c')
+
+    # failed
+    assert_raises(Invalid) { 1.must.match(2..3) }
+    assert_raises(Invalid) { 'a'.must.match('y'..'z') }
+  end
+end

data/test/must_test.rb

@@ -35,53 +35,3 @@ class MustTest < Test::Unit::TestCase
   end
 end
 
-
-class CoercedTest < Test::Unit::TestCase
-  def test_is_a_feature
-    assert_equal 1, 1.must.be.coerced(Integer)
-    assert_equal 1, 1.must.be.coerced(Integer, String)
-    assert_equal 1, 1.must.be.coerced(String, Numeric)
-
-    assert_raises(Invalid)     { "1".must.be.coerced(Integer) }
-    assert_raises(Invalid)     { "1".must.be.coerced(Integer, Range) }
-    assert_raises(NotImplementedError) { "1".must.be.coerced(Integer){raise NotImplementedError} }
-  end
-
-  def test_coecing_succeeded
-    assert_equal 1,   1.must.be.coerced(Integer, String=>proc{|i|i.to_i})
-    assert_equal 1, "1".must.be.coerced(Integer, String=>proc{|i|i.to_i})
-    assert_equal 1, "1".must.be.coerced(Integer, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
-    assert_equal 1, "1".must.be.coerced(Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
-    assert_equal 1, "1".must.be.coerced(File, Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
-  end
-
-  def test_coecing_failed
-    assert_raises(Invalid)     { "1".must.be.coerced(Integer, String=>proc{|i| /a/}) }
-    assert_raises(NotImplementedError) { "1".must.be.coerced(Integer, String=>proc{|i| /a/}){raise NotImplementedError} }
-  end
-
-  def test_cascaded_coecing_succeeded
-    assert_equal 1,    1.must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
-    assert_equal 1,  "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
-    assert_equal 1, :"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
-  end
-
-  def test_detect_livelock
-    assert_raises(Invalid){ "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}
-    assert_raises(Invalid){:"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}
-  end
-
-end
-
-
-class MatchTest < Test::Unit::TestCase
-  def test_match_range
-    # succeeded
-    assert_equal 1, 1.must.match(0..3)
-    assert_equal 'b', 'b'.must.match('a'..'c')
-
-    # failed
-    assert_raises(Invalid) { 1.must.match(2..3) }
-    assert_raises(Invalid) { 'a'.must.match('y'..'z') }
-  end
-end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: must
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - maiha
@@ -15,12 +15,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-25 00:00:00 +09:00
+date: 2012-01-26 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
-description: ""
-email: maiha@wota.jp
+description: add Object#must method to constrain its origin and conversions
+email: 
+- maiha@wota.jp
 executables: []
 
 extensions: []
@@ -34,7 +35,11 @@ files:
 - install.rb
 - lib/must.rb
 - lib/must/rule.rb
-- tasks/expectation_tasks.rake
+- lib/must/version.rb
+- must.gemspec
+- test/coerced_test.rb
+- test/duck_test.rb
+- test/match_test.rb
 - test/must_test.rb
 has_rdoc: true
 homepage: http://github.com/maiha/must
@@ -69,6 +74,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: ""
+summary: a runtime specification tool
 test_files: []
 

data/tasks/expectation_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :must do
-#   # Task goes here
-# end