functional-ruby 0.7.1 → 0.7.2

data/LICENSE

@@ -1,21 +1,21 @@
-Copyright (c) Jerry D'Antonio -- released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-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. 
+Copyright (c) Jerry D'Antonio -- released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+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.md

@@ -1,193 +1,193 @@
-# Functional Ruby [![Build Status](https://secure.travis-ci.org/jdantonio/functional-ruby.png)](https://travis-ci.org/jdantonio/functional-ruby?branch=master) [![Dependency Status](https://gemnasium.com/jdantonio/functional-ruby.png)](https://gemnasium.com/jdantonio/functional-ruby)
-
-A gem for adding Erlang, Clojure, and Go inspired functional programming tools to Ruby.
-
-*NOTE: As of version 0.7.0 the concurrency tools from this gem have been moved to the
-[concurrent-ruby](https://github.com/jdantonio/concurrent-ruby) gem.*
-
-The project is hosted on the following sites:
-
-* [RubyGems project page](https://rubygems.org/gems/functional-ruby)
-* [Source code on GitHub](https://github.com/jdantonio/functional-ruby)
-* [YARD documentation on RubyDoc.info](http://rubydoc.info/github/jdantonio/functional-ruby/frames)
-* [Continuous integration on Travis-CI](https://travis-ci.org/jdantonio/functional-ruby)
-* [Dependency tracking on Gemnasium](https://gemnasium.com/jdantonio/functional-ruby)
-* [Follow me on Twitter](https://twitter.com/jerrydantonio)
-
-## Introduction
-
-Three things I love are [Ruby](http://www.ruby-lang.org/en/),
-[functional](https://en.wikipedia.org/wiki/Functional_programming)
-[programming](http://c2.com/cgi/wiki?FunctionalProgramming) and
-[concurrency](http://www.amazon.com/s/ref=nb_sb_noss_1?url=search-alias%3Dstripbooks&field-keywords=concurrent%20programming).
-Sadly, the first is generally not associated with the other two. First, I reject the
-assertion that Ruby is an object-oriented language. It's certainly object-based, since
-everything is an object, but entire large-scale programs can be built without ever
-defining a single class. Ruby is a true multi-paradigm language and easily supports
-many advanced functional techniques. As to concurrency, Ruby's bad reputation is
-well earned, but recent versions of Ruby have made significan improvements in that
-area. Ruby 2.0 is now a [relevant](https://blog.heroku.com/archives/2013/6/17/ruby-2-default-new-aps)
-platform for concurrent applications.
-
-This gem is my small and humble attempt to help Ruby reach its full potential as
-a highly performant, functional programming language.
-
-### Goals
-
-My goal is to implement various functional programming patterns in Ruby. Specifically:
-
-* Stay true to the spirit of the languages providing inspiration
-* But implement in a way that makes sense for Ruby
-* Keep the semantics as idiomatic Ruby as possible
-* Support features that make sense in Ruby
-* Exclude features that don't make sense in Ruby
-* Keep everything small
-* Be as fast as reasonably possible
-
-## Features (and Documentation)
-
-Several features from Erlang, Go, and Clojure have been implemented thus far:
-
-* Function overloading with Erlang-style [Pattern Matching](https://github.com/jdantonio/functional-ruby/blob/master/md/pattern_matching.md)
-* Interface specifications with Erlang-style [Behavior](https://github.com/jdantonio/functional-ruby/blob/master/md/behavior.md)
-* Several useful functional [Utilities](https://github.com/jdantonio/functional-ruby/blob/master/md/utilities.md)
-
-### Is it any good?
-
-[Yes](http://news.ycombinator.com/item?id=3067434)
-
-### Supported Ruby versions
-
-MRI 1.9.2, 1.9.3, and 2.0. This library is pure Ruby and has no gem dependencies. It should be
-fully compatible with any Ruby interpreter that is 1.9.x compliant. I simply don't know enough
-about JRuby, Rubinius, or the others to fully support them. I can promise good karma and
-attribution on this page to anyone wishing to take responsibility for verifying compaitibility
-with any Ruby other than MRI.
-
-### Install
-
-```shell
-gem install functional-ruby
-```
-
-or add the following line to Gemfile:
-
-```ruby
-gem 'functional-ruby'
-```
-
-and run `bundle install` from your shell.
-
-Once you've installed the gem you must `require` it in your project:
-
-```ruby
-require 'functional'
-```
-
-### Examples
-
-For complete examples, see the specific documentation linked above. Below are a
-few examples to whet your appetite.
-
-#### Pattern Matching (Erlang)
-
-Documentation: [Pattern Matching](https://github.com/jdantonio/functional-ruby/blob/master/md/pattern_matching.md)
-
-```ruby
-require 'functional/pattern_matching'
-
-class Foo
-  include PatternMatching
-
-  defn(:greet, :male) {
-    puts "Hello, sir!"
-  }
-
-  defn(:greet, :female) {
-    puts "Hello, ma'am!"
-  }
-end
-
-foo = Foo.new
-foo.greet(:male)   #=> "Hello, sir!"
-foo.greet(:female) #=> "Hello, ma'am!"
-```
-
-#### Behavior (Erlang)
-
-Documentation: [Behavior](https://github.com/jdantonio/functional-ruby/blob/master/md/behavior.md)
-
-```ruby
-require 'functional/behavior'
-
-behaviour_info(:gen_foo, foo: 0, self_bar: 1)
-
-class Foo
-  behavior(:gen_foo)
-
-  def foo
-    return 'foo/0'
-  end
-
-  def self.bar(one, &block)
-    return 'bar/1'
-  end
-end
-
-foo = Foo.new
-
-Foo.behaves_as? :gen_foo    #=> true
-foo.behaves_as?(:gen_foo)   #=> true
-foo.behaves_as?(:bogus)     #=> false
-'foo'.behaves_as? :gen_foo  #=> false
-```
-
-#### Utilities
-
-Documentation: [Utilities](https://github.com/jdantonio/functional-ruby/blob/master/md/utilities.md)
-
-```ruby
-Infinity #=> Infinity
-NaN #=> NaN
-
-repl? #=> true when called under irb, pry, bundle console, or rails console
-
-safe(1, 2){|a, b| a + b} #=> 3
-safe{ eval 'puts "Hello World!"' } #=> SecurityError: Insecure operation
-
-pp_s [1,2,3,4] #=> "[1, 2, 3, 4]\n" props to Rha7
-
-delta(-1, 1) #=> 2
-delta({count: -1}, {count: 1}){|item| item[:count]} #=> 2
-
-# And many more!
-```
-
-## Copyright
-
-*Functional Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> 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.  
+# Functional Ruby [![Build Status](https://secure.travis-ci.org/jdantonio/functional-ruby.png)](https://travis-ci.org/jdantonio/functional-ruby?branch=master) [![Dependency Status](https://gemnasium.com/jdantonio/functional-ruby.png)](https://gemnasium.com/jdantonio/functional-ruby)
+
+A gem for adding Erlang, Clojure, and Go inspired functional programming tools to Ruby.
+
+*NOTE: As of version 0.7.0 the concurrency tools from this gem have been moved to the
+[concurrent-ruby](https://github.com/jdantonio/concurrent-ruby) gem.*
+
+The project is hosted on the following sites:
+
+* [RubyGems project page](https://rubygems.org/gems/functional-ruby)
+* [Source code on GitHub](https://github.com/jdantonio/functional-ruby)
+* [YARD documentation on RubyDoc.info](http://rubydoc.info/github/jdantonio/functional-ruby/frames)
+* [Continuous integration on Travis-CI](https://travis-ci.org/jdantonio/functional-ruby)
+* [Dependency tracking on Gemnasium](https://gemnasium.com/jdantonio/functional-ruby)
+* [Follow me on Twitter](https://twitter.com/jerrydantonio)
+
+## Introduction
+
+Three things I love are [Ruby](http://www.ruby-lang.org/en/),
+[functional](https://en.wikipedia.org/wiki/Functional_programming)
+[programming](http://c2.com/cgi/wiki?FunctionalProgramming) and
+[concurrency](http://www.amazon.com/s/ref=nb_sb_noss_1?url=search-alias%3Dstripbooks&field-keywords=concurrent%20programming).
+Sadly, the first is generally not associated with the other two. First, I reject the
+assertion that Ruby is an object-oriented language. It's certainly object-based, since
+everything is an object, but entire large-scale programs can be built without ever
+defining a single class. Ruby is a true multi-paradigm language and easily supports
+many advanced functional techniques. As to concurrency, Ruby's bad reputation is
+well earned, but recent versions of Ruby have made significan improvements in that
+area. Ruby 2.0 is now a [relevant](https://blog.heroku.com/archives/2013/6/17/ruby-2-default-new-aps)
+platform for concurrent applications.
+
+This gem is my small and humble attempt to help Ruby reach its full potential as
+a highly performant, functional programming language.
+
+### Goals
+
+My goal is to implement various functional programming patterns in Ruby. Specifically:
+
+* Stay true to the spirit of the languages providing inspiration
+* But implement in a way that makes sense for Ruby
+* Keep the semantics as idiomatic Ruby as possible
+* Support features that make sense in Ruby
+* Exclude features that don't make sense in Ruby
+* Keep everything small
+* Be as fast as reasonably possible
+
+## Features (and Documentation)
+
+Several features from Erlang, Go, and Clojure have been implemented thus far:
+
+* Function overloading with Erlang-style [Pattern Matching](https://github.com/jdantonio/functional-ruby/blob/master/md/pattern_matching.md)
+* Interface specifications with Erlang-style [Behavior](https://github.com/jdantonio/functional-ruby/blob/master/md/behavior.md)
+* Several useful functional [Utilities](https://github.com/jdantonio/functional-ruby/blob/master/md/utilities.md)
+
+### Is it any good?
+
+[Yes](http://news.ycombinator.com/item?id=3067434)
+
+### Supported Ruby versions
+
+MRI 1.9.2, 1.9.3, and 2.0. This library is pure Ruby and has no gem dependencies. It should be
+fully compatible with any Ruby interpreter that is 1.9.x compliant. I simply don't know enough
+about JRuby, Rubinius, or the others to fully support them. I can promise good karma and
+attribution on this page to anyone wishing to take responsibility for verifying compaitibility
+with any Ruby other than MRI.
+
+### Install
+
+```shell
+gem install functional-ruby
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'functional-ruby'
+```
+
+and run `bundle install` from your shell.
+
+Once you've installed the gem you must `require` it in your project:
+
+```ruby
+require 'functional'
+```
+
+### Examples
+
+For complete examples, see the specific documentation linked above. Below are a
+few examples to whet your appetite.
+
+#### Pattern Matching (Erlang)
+
+Documentation: [Pattern Matching](https://github.com/jdantonio/functional-ruby/blob/master/md/pattern_matching.md)
+
+```ruby
+require 'functional/pattern_matching'
+
+class Foo
+  include PatternMatching
+
+  defn(:greet, :male) {
+    puts "Hello, sir!"
+  }
+
+  defn(:greet, :female) {
+    puts "Hello, ma'am!"
+  }
+end
+
+foo = Foo.new
+foo.greet(:male)   #=> "Hello, sir!"
+foo.greet(:female) #=> "Hello, ma'am!"
+```
+
+#### Behavior (Erlang)
+
+Documentation: [Behavior](https://github.com/jdantonio/functional-ruby/blob/master/md/behavior.md)
+
+```ruby
+require 'functional/behavior'
+
+behaviour_info(:gen_foo, foo: 0, self_bar: 1)
+
+class Foo
+  behavior(:gen_foo)
+
+  def foo
+    return 'foo/0'
+  end
+
+  def self.bar(one, &block)
+    return 'bar/1'
+  end
+end
+
+foo = Foo.new
+
+Foo.behaves_as? :gen_foo    #=> true
+foo.behaves_as?(:gen_foo)   #=> true
+foo.behaves_as?(:bogus)     #=> false
+'foo'.behaves_as? :gen_foo  #=> false
+```
+
+#### Utilities
+
+Documentation: [Utilities](https://github.com/jdantonio/functional-ruby/blob/master/md/utilities.md)
+
+```ruby
+Infinity #=> Infinity
+NaN #=> NaN
+
+repl? #=> true when called under irb, pry, bundle console, or rails console
+
+safe(1, 2){|a, b| a + b} #=> 3
+safe{ eval 'puts "Hello World!"' } #=> SecurityError: Insecure operation
+
+pp_s [1,2,3,4] #=> "[1, 2, 3, 4]\n" props to Rha7
+
+delta(-1, 1) #=> 2
+delta({count: -1}, {count: 1}){|item| item[:count]} #=> 2
+
+# And many more!
+```
+
+## Copyright
+
+*Functional Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
+It is free software and may be redistributed under the terms specified in the LICENSE file.
+
+## License
+
+Released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+> 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/lib/functional.rb

@@ -1,4 +1,4 @@
-require 'functional/behavior'
-require 'functional/pattern_matching'
-require 'functional/utilities'
-require 'functional/version'
+require 'functional/behavior'
+require 'functional/pattern_matching'
+require 'functional/utilities'
+require 'functional/version'

data/lib/functional/behavior.rb

@@ -1,124 +1,132 @@
-module Kernel
-
-  BehaviorError = Class.new(StandardError)
-
-  # Define a behavioral specification (interface).
-  #
-  # @param name [Symbol] the name of the behavior
-  # @param functions [Hash] function names and their arity as key/value pairs
-  def behavior_info(name, functions = {})
-    $__behavior_info__ ||= {}
-    $__behavior_info__[name.to_sym] = functions.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-  end
-
-  alias :behaviour_info :behavior_info
-  alias :interface :behavior_info
-
-  module_function :behavior_info
-  module_function :behaviour_info
-  module_function :interface
-
-  # Specify a #behavior_info to enforce on the enclosing class
-  #
-  # @param name [Symbol] name of the #behavior_info being implemented
-  def behavior(name)
-
-    name = name.to_sym
-    raise BehaviorError.new("undefined behavior '#{name}'") if $__behavior_info__[name].nil?
-
-    clazz = self.method(:behavior).receiver
-
-    unless clazz.instance_methods(false).include?(:behaviors)
-      class << clazz
-        def behaviors
-          @behaviors ||= []
-        end
-      end
-    end
-
-    clazz.behaviors << name
-
-    if self.class == Module
-      (class << self; self; end).class_eval do
-        define_method(:included) do |base|
-          base.class_eval do
-            behavior(name)
-          end
-        end
-      end
-    end
-
-    class << clazz
-      def new(*args, &block)
-        obj = super
-        self.ancestors.each do |clazz|
-          if clazz.respond_to?(:behaviors)
-            clazz.behaviors.each do |behavior|
-              unless obj.behaves_as?(behavior)
-                raise BehaviorError.new("undefined callback functions in #{self} (behavior '#{behavior}')")
-              end
-            end
-          end
-        end
-        return obj
-      end
-    end
-  end
-
-  alias :behaviour :behavior
-  alias :behaves_as :behavior
-
-  module_function :behavior
-  module_function :behaviour
-  module_function :behaves_as
-end
-
-class Object
-
-  # Does the object implement the given #behavior_info?
-  #
-  # @note Will return true if the object implements the
-  # required methods. The object's class hierarchy does
-  # not necessarily have to include a corresponding
-  # #behavior call.
-  #
-  # @param name [Symbol] name of the #behavior_info to
-  # verify behavior against.
-  #
-  # @return [Boolean] whether or not the required public
-  # methods are implemented
-  def behaves_as?(name)
-
-    name = name.to_sym
-    bi = $__behavior_info__[name]
-    return false if bi.nil?
-
-    validator = proc do |obj, method, arity|
-      (obj.respond_to?(method) && arity == :any) || obj.method(method).arity == arity
-    end
-
-    if self.is_a?(Class) || self.is_a?(Module)
-      bi = bi.select{|method, arity| method.to_s =~ /^self_/ }
-    end
-
-    bi.each do |method, arity|
-      begin
-        method = method.to_s
-        obj = self
-
-        if (self.is_a?(Class) || self.is_a?(Module)) && method =~ /^self_/
-          method = method.gsub(/^self_/, '')
-        elsif method =~ /^self_/
-          method = method.gsub(/^self_/, '')
-          obj = self.class
-        end
-
-        return false unless validator.call(obj, method, arity)
-      rescue NameError
-        return false
-      end
-    end
-
-    return true
-  end
-end
+module Kernel
+
+  BehaviorError = Class.new(StandardError)
+
+  # Define a behavioral specification (interface).
+  #
+  # @param name [Symbol] the name of the behavior
+  # @param functions [Hash] function names and their arity as key/value pairs
+  def behavior_info(name, functions = {})
+    $__behavior_info__ ||= {}
+    $__behavior_info__[name.to_sym] = functions.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+  end
+
+  alias :behaviour_info :behavior_info
+  alias :interface :behavior_info
+
+  module_function :behavior_info
+  module_function :behaviour_info
+  module_function :interface
+
+  # Specify a #behavior_info to enforce on the enclosing class
+  #
+  # @param name [Symbol] name of the #behavior_info being implemented
+  def behavior(name)
+
+    name = name.to_sym
+    raise BehaviorError.new("undefined behavior '#{name}'") if $__behavior_info__[name].nil?
+
+    clazz = self.method(:behavior).receiver
+
+    unless clazz.instance_methods(false).include?(:behaviors)
+      class << clazz
+        def behaviors
+          @behaviors ||= []
+        end
+      end
+    end
+
+    clazz.behaviors << name
+
+    if self.class == Module
+      (class << self; self; end).class_eval do
+        define_method(:included) do |base|
+          base.class_eval do
+            behavior(name)
+          end
+        end
+      end
+    end
+
+    if self.class == Class
+      unless self.respond_to?(:__new)
+        class << clazz
+          alias_method(:__new, :new)
+        end
+      end
+    end
+
+    class << clazz
+      def new(*args, &block)
+        obj = __new(*args, &block)
+        self.ancestors.each do |clazz|
+          if clazz.respond_to?(:behaviors)
+            clazz.behaviors.each do |behavior|
+              unless obj.behaves_as?(behavior)
+                raise BehaviorError.new("undefined callback functions in #{self} (behavior '#{behavior}')")
+              end
+            end
+          end
+        end
+        return obj
+      end
+    end
+  end
+
+  alias :behaviour :behavior
+  alias :behaves_as :behavior
+
+  module_function :behavior
+  module_function :behaviour
+  module_function :behaves_as
+end
+
+class Object
+
+  # Does the object implement the given #behavior_info?
+  #
+  # @note Will return true if the object implements the
+  # required methods. The object's class hierarchy does
+  # not necessarily have to include a corresponding
+  # #behavior call.
+  #
+  # @param name [Symbol] name of the #behavior_info to
+  # verify behavior against.
+  #
+  # @return [Boolean] whether or not the required public
+  # methods are implemented
+  def behaves_as?(name)
+
+    name = name.to_sym
+    bi = $__behavior_info__[name]
+    return false if bi.nil?
+
+    validator = proc do |obj, method, arity|
+      (obj.respond_to?(method) && arity == :any) || obj.method(method).arity == arity
+    end
+
+    if self.is_a?(Class) || self.is_a?(Module)
+      bi = bi.select{|method, arity| method.to_s =~ /^self_/ }
+    end
+
+    bi.each do |method, arity|
+      begin
+        method = method.to_s
+        obj = self
+
+        if (self.is_a?(Class) || self.is_a?(Module)) && method =~ /^self_/
+          method = method.gsub(/^self_/, '')
+        elsif method =~ /^self_/
+          method = method.gsub(/^self_/, '')
+          obj = self.class
+        end
+
+        return false unless validator.call(obj, method, arity)
+      rescue NameError
+        return false
+      end
+    end
+
+    return true
+  end
+end