functional-ruby 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ebc0dab7cc6ee079416729c8cc131bf239ca2bb
-  data.tar.gz: 24b3193d7e6fef20addd8688ab372c104163edae
+  metadata.gz: 9bc4db6eba8d3f68f626e27415bb5e5b20e69fc3
+  data.tar.gz: fa353eb6d4d4fc0d2557e7340d2874d68159050d
 SHA512:
-  metadata.gz: 65b487a457f8b8a4dcb3adfe98e8429ae0184656d3ddf6292c515c598f4cb6e610f8aca4185950626bf4e67cda95a77eb081031caf5f7ea95ccf3592df6c9d0a
-  data.tar.gz: bbe8b613ee9ac7a4aa4ed6626a36a2bfc148e4ddc42ef5fd2f5be5703f74567beb15dd772d0b4e63156f6ca46accae1425dfdeac0a36d75a34a09aa4bceafc45
+  metadata.gz: 7d482b7d25a1066ef058ca13cc5e8b7b5b0d7e249a7356d4b7cb815288b18daff9c3f5fb789fdbe2ef4c47e0a3e26f9f3437b244bed244b69cbd16d72f415c2e
+  data.tar.gz: 693b09f4e460522ff1aad1db7098414138ec076d90674c0303f699c476cd2fc4b5f745c032508aa93559ea4ebbf37e2c4ebb509965a104e531b7b50d822b3e37

data/README.md

@@ -120,7 +120,7 @@ Documentation: [Behavior](https://github.com/jdantonio/functional-ruby/blob/mast
 ```ruby
 require 'functional/behavior'
 
-behaviour_info(:gen_foo, foo: 0, bar: 1)
+behaviour_info(:gen_foo, foo: 0, self_bar: 1)
 
 class Foo
   behavior(:gen_foo)
@@ -129,14 +129,15 @@ class Foo
     return 'foo/0'
   end
 
-  def bar(one, &block)
+  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?(:gen_foo)   #=> true
 foo.behaves_as?(:bogus)     #=> false
 'foo'.behaves_as? :gen_foo  #=> false
 ```

data/lib/functional/behavior.rb

@@ -38,15 +38,29 @@ module Kernel
 
     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)
-        name = self.behaviors.first
         obj = super
-        unless obj.behaves_as?(name)
-          raise BehaviorError.new("undefined callback functions in #{self} (behavior '#{name}')")
-        else
-          return obj
+        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
@@ -79,9 +93,27 @@ class Object
     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
-        return false unless arity == :any || self.method(method).arity == arity
+        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

data/lib/functional/utilities.rb

@@ -1,6 +1,7 @@
 require 'pp'
 require 'stringio'
 require 'erb'
+require 'rbconfig'
 
 Infinity = 1/0.0 unless defined?(Infinity)
 NaN = 0/0.0 unless defined?(NaN)
@@ -79,24 +80,28 @@ module Kernel
   # Sandbox the given operation at a high $SAFE level.
   #
   # @param args [Array] zero or more arguments to pass to the block
-  # @param block [Proc] the block to isolate
   #
   # @return [Object] the result of the block operation
   def safe(*args)
     raise ArgumentError.new('no block given') unless block_given?
-    result = nil
-    t = Thread.new do
-      $SAFE = 3
-      result = yield(*args)
+    if RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
+      result = nil
+      t = Thread.new do
+        $SAFE = 3
+        result = yield(*args)
+      end
+      t.join
+      return result
+    else
+      return yield(*args)
     end
-    t.join
-    return result
   end
   module_function :safe
 
   # Open a file, read it, close the file, and return its contents.
   #
   # @param file [String] path to and name of the file to open
+  #
   # @return [String] file contents
   #
   # @see slurpee
@@ -110,6 +115,7 @@ module Kernel
   #
   # @param file [String] path to and name of the file to open
   # @param safe_level [Integer] when not nil, ERB will $SAFE set to this
+  #
   # @return [String] file contents
   #
   # @see slurpee
@@ -118,33 +124,36 @@ module Kernel
   end
   module_function :slurpee
 
-  #############################################################################
-
-  # @private
-  def repl? # :nodoc:
-    return ($0 == 'irb' || $0 == 'pry' || $0 == 'script/rails' || !!($0 =~ /bin\/bundle$/))
-  end
-  module_function :repl?
-
-  # @private
-  def timestamp # :nodoc:
-    return Time.now.getutc.to_i
-  end
-
-  # @private
-  def timer(*args) # :nodoc:
+  # Run the given block and time how long it takes in seconds. All arguments
+  # will be passed to the block. The function will return two values. The
+  # first value will be the duration of the timer in seconds. The second
+  # return value will be the result of the block.
+  #
+  # @param args [Array] zero or more arguments to pass to the block
+  #
+  # @return [Integer, Object] the duration of the operation in seconds and
+  #   the result of the block operation
+  def timer(*args)
+    return 0,nil unless block_given?
     t1 = Time.now
     result = yield(*args)
     t2 = Time.now
-    return (t2 - t1)
+    return (t2 - t1), result
   end
   module_function :timer
 
+  #############################################################################
+
   # @private
-  def strftimer(seconds) # :nodoc:
-    Time.at(seconds).gmtime.strftime('%R:%S.%L')
+  # @see http://cirw.in/blog/find-references
+  def object_counts # :nodoc:
+    counts = Hash.new{ 0 }
+    ObjectSpace.each_object do |obj|
+      counts[obj.class] += 1
+    end
+    return counts
   end
-  module_function :strftimer
+  module_function :object_counts
 
   # @private
   # @see http://rhaseventh.blogspot.com/2008/07/ruby-and-rails-how-to-get-pp-pretty.html
@@ -157,4 +166,27 @@ module Kernel
     s.read
   end
   module_function :pp_s
+
+  # @private
+  def repl? # :nodoc:
+    return ($0 == 'irb' || $0 == 'pry' || $0 == 'script/rails' || !!($0 =~ /bin\/bundle$/))
+  end
+  module_function :repl?
+
+  # @private
+  def strftimer(seconds) # :nodoc:
+    Time.at(seconds).gmtime.strftime('%R:%S.%L')
+  end
+  module_function :strftimer
+
+  # @private
+  def timestamp # :nodoc:
+    return Time.now.getutc.to_i
+  end
+
+  def write_object_counts(name = 'ruby')
+    file = "#{name}_#{Time.now.to_i}.txt"
+    File.open(file, 'w') {|f| f.write(pp_s(object_counts)) }
+  end
+  module_function :write_object_counts
 end

data/lib/functional/version.rb

@@ -1,3 +1,3 @@
 module Functional
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/md/behavior.md

@@ -11,14 +11,10 @@ Forget to implement a required method and Ruby will let you know. See the exampl
 
 ## Usage
 
-The `behavior` functionality is not imported by default. It needs a separate `require` statement:
+Require the gem
 
 ```ruby
-require 'functional/behavior'
-
-# -or-
-
-require 'functional/behaviour'
+require 'functional'
 ```
 
 ### behavior_info
@@ -34,7 +30,6 @@ behaviour_info(:gen_foo, foo: 0, bar: 1, baz: 2)
 # -or (for the Java/C# crowd)
 
 interface(:gen_foo, foo: 0, bar: 1, baz: 2)
-
 ```
 
 Each function name can be listed only once and the arity must follow the rules of the
@@ -43,6 +38,12 @@ Though not explicitly documented, block arguments do not count toward a method's
 methods defined using this gem's `defn` function will always have an arity of -1,
 regardless of how many overloads are defined.
 
+To specify class/module methods prepend the methid name with 'self_'
+
+```ruby
+behaviour_info(:gen_foo, self_foo: 0, self_bar: 1, baz: 2)
+```
+
 ### behavior
 
 To enforce a behavior on a class simply call the `behavior` function within the class,
@@ -74,6 +75,45 @@ raise an exception when you try to create an object from the class:
 Baz.new #=> ArgumentError: undefined callback functions in Baz (behavior 'gen_foo')
 ```
 
+A class may support multiple behaviors:
+
+```ruby
+behavior_info(:gen_foo, foo: 0)
+behavior_info(:gen_bar, bar: 1)
+
+class FooBar
+  behavior(:gen_foo)
+  behavior(:gen_bar)
+  ...
+end
+```
+
+Inheritance and module inclusion are supported as well:
+
+```ruby
+behavior_info(:gen_foo, foo: 0)
+behavior_info(:gen_bar, bar: 0)
+
+class Foo
+  behavior(:gen_foo)
+  def foo() nil; end
+end
+
+module Bar
+  behavior(:gen_bar)
+  def bar() nil; end
+end
+
+class FooBar < Foo
+  include Bar
+end
+
+foobar = FooBar.new
+
+foobar.behaves_as?(:gen_foo) #=> true
+foobar.behaves_as?(:gen_bar) #=> true
+```
+
 ### behaves_as?
 
 As an added bonus, Ruby [Object](http://ruby-doc.org/core-1.9.3/Object.html) will be
@@ -84,12 +124,12 @@ monkey-patched with a `behaves_as?` predicate method.
 A complete example:
 
 ```ruby
-behaviour_info(:gen_foo, foo: 0, bar: 1, baz: 2, boom: -1, bam: :any)
+behaviour_info(:gen_foo, self_foo: 0, bar: 1, baz: 2, boom: -1, bam: :any)
 
 class Foo
   behavior(:gen_foo)
 
-  def foo
+  def self.foo
     return 'foo/0'
   end
 
@@ -112,6 +152,7 @@ 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

data/spec/functional/behavior_spec.rb

@@ -74,93 +74,166 @@ describe '-behavior' do
 
   context 'object creation' do
 
-    it 'raises an exception when one or more function definitions are missing' do
-      behavior_info(:gen_foo, foo: 0, bar: 1)
+    it 'checks all required behaviors' do
+      behavior_info(:gen_foo, foo: 0)
+      behavior_info(:gen_bar, bar: 1)
+
       clazz = Class.new {
         behavior(:gen_foo)
+        behavior(:gen_bar)
         def foo() nil; end
       }
+      lambda{ clazz.new }.should raise_error(BehaviorError)
 
-      lambda {
-        clazz.new
-      }.should raise_error(BehaviorError)
-    end
-
-    it 'raises an exception when one or more functions do not have proper arity' do
-      behavior_info(:gen_foo, foo: 0)
       clazz = Class.new {
         behavior(:gen_foo)
-        def foo(broken) nil; end
+        behavior(:gen_bar)
+        def bar() nil; end
       }
+      lambda{ clazz.new }.should raise_error(BehaviorError)
 
-      lambda {
-        clazz.new
-      }.should raise_error(BehaviorError)
-    end
-
-    it 'accepts any arity when function arity is set to :any' do
-      behavior_info(:gen_foo, foo: :any)
       clazz = Class.new {
         behavior(:gen_foo)
-        def foo(first) nil; end
+        behavior(:gen_bar)
       }
-
-      lambda {
-        clazz.new
-      }.should_not raise_error
+      lambda{ clazz.new }.should raise_error(BehaviorError)
     end
 
-    it 'creates the object when function definitions match' do
-      behavior_info(:gen_foo, foo: 0, bar: 1)
-      clazz = Class.new {
-        behavior(:gen_foo)
-        def foo() nil; end
-        def bar(first) nil; end
-      }
+    context 'instance methods' do
 
-      lambda {
-        clazz.new
-      }.should_not raise_error
-    end
-  end
+      it 'raises an exception when one or more function definitions are missing' do
+        behavior_info(:gen_foo, foo: 0, bar: 1)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def foo() nil; end
+        }
 
-  context '#behaves_as?' do
+        lambda {
+          clazz.new
+        }.should raise_error(BehaviorError)
+      end
 
-    it 'returns true when the behavior is fully suported' do
-      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
-      clazz = Class.new {
-        def foo() nil; end
-        def bar(first) nil; end
-        def baz(first, second) nil; end
-      }
+      it 'raises an exception when one or more functions do not have proper arity' do
+        behavior_info(:gen_foo, foo: 0)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def foo(broken) nil; end
+        }
 
-      clazz.new.behaves_as?(:gen_foo).should be_true
-    end
+        lambda {
+          clazz.new
+        }.should raise_error(BehaviorError)
+      end
 
-    it 'accepts any arity when function arity is set to :any' do
-      behavior_info(:gen_foo, foo: :any)
-      clazz = Class.new {
-        def foo(*args, &block) nil; end
-      }
+      it 'accepts any arity when function arity is set to :any' do
+        behavior_info(:gen_foo, foo: :any)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def foo(first) nil; end
+        }
 
-      clazz.new.behaves_as?(:gen_foo).should be_true
+        lambda {
+          clazz.new
+        }.should_not raise_error
+      end
+
+      it 'creates the object when function definitions match' do
+        behavior_info(:gen_foo, foo: 0, bar: 1)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def foo() nil; end
+          def bar(first) nil; end
+        }
+
+        lambda {
+          clazz.new
+        }.should_not raise_error
+      end
     end
 
-    it 'returns false when the behavior is partially supported' do
-      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
-      clazz = Class.new {
-        def foo() nil; end
-        def bar(first) nil; end
-      }
+    context 'class methods' do
 
-      clazz.new.behaves_as?(:gen_foo).should be_false
+      it 'raises an exception when one or more function definitions are missing' do
+        behavior_info(:gen_foo, self_foo: 0, self_bar: 1)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def self.foo() nil; end
+        }
+
+        lambda {
+          clazz.new
+        }.should raise_error(BehaviorError)
+      end
+
+      it 'raises an exception when one or more functions do not have proper arity' do
+        behavior_info(:gen_foo, self_foo: 0)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def self.foo(broken) nil; end
+        }
+
+        lambda {
+          clazz.new
+        }.should raise_error(BehaviorError)
+      end
+
+      it 'accepts any arity when function arity is set to :any' do
+        behavior_info(:gen_foo, self_foo: :any)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def self.foo(first) nil; end
+        }
+
+        lambda {
+          clazz.new
+        }.should_not raise_error
+      end
+
+      it 'creates the object when function definitions match' do
+        behavior_info(:gen_foo, self_foo: 0, self_bar: 1)
+        clazz = Class.new {
+          behavior(:gen_foo)
+          def self.foo() nil; end
+          def self.bar(first) nil; end
+        }
+
+        lambda {
+          clazz.new
+        }.should_not raise_error
+      end
     end
 
-    it 'returns false when the behavior is not supported at all' do
-      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
-      clazz = Class.new { }
-      clazz.new.behaves_as?(:gen_foo).should be_false
+    context 'inheritance' do
+
+      it 'raises an exception if a superclass includes a behavior the subclass does not support' do
+        behavior_info(:gen_foo, foo: 0)
+        superclass = Class.new{
+          behavior(:gen_foo)
+        }
+        subclass = Class.new(superclass)
+
+        lambda {
+          subclass.new
+        }.should raise_error(BehaviorError)
+      end
+
+      it 'raises an exception if a module includes a behavior the containing class does not support' do
+        behavior_info(:gen_foo, foo: 0)
+        mod = Module.new{
+          behavior(:gen_foo)
+        }
+        subclass = Class.new{
+          include mod
+        }
+
+        lambda {
+          subclass.new
+        }.should raise_error(BehaviorError)
+      end
     end
+  end
+
+  context '#behaves_as?' do
 
     it 'returns false when the behavior does not exist' do
       clazz = Class.new { }
@@ -178,6 +251,87 @@ describe '-behavior' do
       clazz = Class.new { }
       clazz.new.behaves_as?('gen_foo').should be_true
     end
+
+    context 'Object' do
+
+      it 'returns true when the behavior is fully suported' do
+        behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+        clazz = Class.new {
+          def foo() nil; end
+          def bar(first) nil; end
+          def baz(first, second) nil; end
+        }
+
+        clazz.new.behaves_as?(:gen_foo).should be_true
+      end
+
+      it 'accepts any arity when function arity is set to :any' do
+        behavior_info(:gen_foo, foo: :any)
+        clazz = Class.new {
+          def foo(*args, &block) nil; end
+        }
+
+        clazz.new.behaves_as?(:gen_foo).should be_true
+      end
+
+      it 'returns false when the behavior is partially supported' do
+        behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+        clazz = Class.new {
+          def foo() nil; end
+          def bar(first) nil; end
+        }
+
+        clazz.new.behaves_as?(:gen_foo).should be_false
+      end
+
+      it 'returns false when the behavior is not supported at all' do
+        behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+        clazz = Class.new { }
+        clazz.new.behaves_as?(:gen_foo).should be_false
+      end
+    end
+
+    context 'Class' do
+
+      it 'returns true when the behavior is fully suported' do
+        behavior_info(:gen_foo, self_foo: 0, self_bar: 1, baz: 2)
+        clazz = Class.new {
+          def self.foo() nil; end
+          def self.bar(first) nil; end
+          def baz(first, second) nil; end
+        }
+
+        clazz.behaves_as?(:gen_foo).should be_true
+        clazz.new.behaves_as?(:gen_foo).should be_true
+      end
+
+      it 'accepts any arity when function arity is set to :any' do
+        behavior_info(:gen_foo, self_foo: :any)
+        clazz = Class.new {
+          def self.foo(*args, &block) nil; end
+        }
+
+        clazz.behaves_as?(:gen_foo).should be_true
+        clazz.new.behaves_as?(:gen_foo).should be_true
+      end
+
+      it 'returns false when the behavior is partially supported' do
+        behavior_info(:gen_foo, self_foo: 0, bar: 1, self_baz: 2)
+        clazz = Class.new {
+          def self.foo() nil; end
+          def self(first) nil; end
+        }
+
+        clazz.behaves_as?(:gen_foo).should be_false
+        clazz.new.behaves_as?(:gen_foo).should be_false
+      end
+
+      it 'returns false when the behavior is not supported at all' do
+        behavior_info(:gen_foo, self_foo: 0, self_bar: 1, self_baz: 2)
+        clazz = Class.new { }
+        clazz.new.behaves_as?(:gen_foo).should be_false
+      end
+    end
   end
 
   context 'aliases' do
@@ -212,5 +366,4 @@ describe '-behavior' do
       clazz.new.behaves_as?(:gen_foo).should be_true
     end
   end
-
 end

data/spec/functional/utilities_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'fakefs/safe'
+require 'rbconfig'
 
 describe 'utilities' do
 
@@ -125,32 +126,34 @@ describe 'utilities' do
     end
   end
 
-  context '#safe' do
+  if RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
+    context '#safe' do
 
-    it 'allows safe operations' do
-      lambda {
-        safe{ 1 + 1 }
-      }.should_not raise_error
-    end
+      it 'allows safe operations' do
+        lambda {
+          safe{ 1 + 1 }
+        }.should_not raise_error
+      end
 
-    it 'returns the value of the block when safe' do
-      safe{ 1 + 1 }.should eq 2
-    end
+      it 'returns the value of the block when safe' do
+        safe{ 1 + 1 }.should eq 2
+      end
 
-    it 'passes all arguments to the block' do
-      safe(1, 2, 3){|x, y, z| x + y + z }.should eq 6
-    end
+      it 'passes all arguments to the block' do
+        safe(1, 2, 3){|x, y, z| x + y + z }.should eq 6
+      end
 
-    it 'rejects unsafe operations on tainted objects' do
-      lambda {
-        safe{ Signal.trap('INT'.taint) }
-      }.should raise_error(SecurityError)
-    end
+      it 'rejects unsafe operations on tainted objects' do
+        lambda {
+          safe{ Signal.trap('INT'.taint) }
+        }.should raise_error(SecurityError)
+      end
 
-    it 'rejects the use of #eval' do
-      lambda {
-        safe{ eval 'puts 1' }
-      }.should raise_error(SecurityError)
+      it 'rejects the use of #eval' do
+        lambda {
+          safe{ eval 'puts 1' }
+        }.should raise_error(SecurityError)
+      end
     end
   end
 
@@ -234,4 +237,35 @@ describe 'utilities' do
       repl?.should be_false
     end
   end
+
+  context '#timer' do
+
+    it 'returns [0, nil] if no block is given' do
+      duration, result = timer()
+      duration.should eq 0
+      result.should be_nil
+    end
+
+    it 'yields to the block' do
+      @expected = false
+      duration, result = timer{ @expected = true }
+      @expected.should be_true
+    end
+
+    it 'passes all arguments to the block' do
+      @expected = nil
+      duration, result = timer(1,2,3){|a,b,c| @expected = [a,b,c]}
+      @expected.should eq [1,2,3]
+    end
+
+    it 'returns the duration as the first return value' do
+      duration, result = timer{ sleep(0.1) }
+      duration.should > 0
+    end
+
+    it 'returns the block result as the second return value' do
+      duration, result = timer{ 42 }
+      result.should eq 42
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'functional'
 Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
 
 RSpec.configure do |config|
+  config.order = 'random'
 
   config.before(:suite) do
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: functional-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-24 00:00:00.000000000 Z
+date: 2013-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler