casting 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2c87cd8917d7140a16d55d487f4f0999ee44824
-  data.tar.gz: 2ffb23af2a79836b0705efe5aa8ac00df0144881
+  metadata.gz: c87234df3ca2237a6d2e9d0d6de0f4beb8808cae
+  data.tar.gz: 114ccf9e9984a2323288b66982465ef7068a4dd0
 SHA512:
-  metadata.gz: 82e5c33d84c41df11ead6966456bd8b42d0f665c0ba50345ba9b5fa3241dd4b42eaf74a9cd6c08b6212007b7ca1d009f8fe4a6c41a76a1a81ace87e2800be759
-  data.tar.gz: 502e4254feb758ddff742e3296eed05282b7690d5dda8ab530475da871603db0f3926a31150edcc4140120035ac1f06e059c000b8dbff4eda9337fa81a132bea
+  metadata.gz: cc11494446dad4f1b1cd367d9fbd485ad78cf961884348344d076ff9456e1e8235af7be0d8547c1db84c0f953d79428da99d1a649702aa61d7b397d00b776fb9
+  data.tar.gz: e3d49bea1aaa35a9c08220cd3c07407fcf34657cdd02934ea2f9bd37adb999e3130e37690eebd21b44c884e5a542381b135f207eaaffe3919583877bee70fee4

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/saturnflyer/casting.png?branch=master)](https://travis-ci.org/saturnflyer/casting)
 [![Code Climate](https://codeclimate.com/github/saturnflyer/casting.png)](https://codeclimate.com/github/saturnflyer/casting)
-[![Coverage Status](https://coveralls.io/repos/saturnflyer/casting/badge.png)](https://coveralls.io/r/saturnflyer/casting)
+[![Test Coverage](https://codeclimate.com/github/saturnflyer/casting/badges/coverage.svg)](https://codeclimate.com/github/saturnflyer/casting/coverage)
 [![Gem Version](https://badge.fury.io/rb/casting.png)](http://badge.fury.io/rb/casting)
 
 ## Add behavior to your objects without using extend
@@ -18,7 +18,7 @@ Here's a quick example that you might try in a Rails project:
 # implement a module that contains information for the request response
 # and apply it to an object in your system.
 def show
-  respond_with user.cast_as(UserRepresenter)
+  @user = user.cast_as(UserRepresenter)
 end
 ```
 
@@ -293,22 +293,14 @@ Person.instance_method(:hello) #=> #<UnboundMethod: Person#hello>
 But if you attempt to use that `UnboundMethod` on an object that is not a `Person` you'll get
 an error about a type mismatch.
 
-Casting will bind an unbound method to a client object and execute the method as though it is
+Casting will bind an UnboundMethod method to a client object and execute the method as though it is
 defined on the client object. Any reference to `self` from the method block will refer to the
 client object.
 
-This behavior is different in Ruby 1.9 vs. 2.x.
-
-According to [http://rubyspec.org](http://rubyspec.org) the behavior in MRI in 1.9 that allows this to happen is incorrect. In MRI (and JRuby) 1.9 you may unbind methods from an object that has been extended with a module, and bind them to another object of the same type that has *not* been extended with that module.
-
-Casting uses this as a way to trick the interpreter into using the method where we want it and avoid forever extending the object of concern.
-
-This changed in Ruby 2.0 and does not work. What does work (and is so much better) in 2.0 is that you may take any method from a module and apply it to any object. This means that Casting doesn't have to perform any tricks to temporarily apply behavior to an object.
-
-For example, this fails in 1.9, but works in 2.0:
+Rather than define methods on classes, you may take any method from a module and apply it to any object regardless of its class.
 
 ```ruby
-GreetingModule.instance_method(:hello_world).bind(actor).call
+GreetingModule.instance_method(:hello).bind(actor).call
 ```
 
 Casting provides a convenience for doing this.
@@ -350,12 +342,6 @@ If you are using Bundler, add this line to your application's Gemfile:
 gem 'casting'
 ```
 
-If you're using Ruby 1.9, be sure to use a version lower than 0.7
-
-```ruby
-gem 'casting', '~> 0.6.9'
-```
-
 And then execute:
 
     $ bundle

data/lib/casting/context.rb

@@ -0,0 +1,125 @@
+# This is an experimental implementation of allowing contextual use of behaviors.
+#
+# This relies on versions of Ruby supporting refinements.
+#
+# You *must* include the following module and use it for refinements, and
+# you *must* set the current context for the thread:
+#
+#  class SomeContext
+#    using Casting::Context
+#    include Casting::Context
+#
+#    initialize(:some, :thing)
+#    # doing that defines your constructor but would cause it too look for
+#    # modules named Some and Thing
+#    module Some; end
+#    module Thing; end
+#
+#    # if you want different module names (why would you?) then you'd need
+#    # to do all this:
+#    def initialize(some, thing)
+#      @assignments = []
+#      assign [some, SomeRole], [thing, OtherRole]
+#      Thread.current[:context] = self
+#    end
+#    attr_reader :some, :thing, :assignments
+#
+#    module SomeRole; end
+#    module OtherRole; end
+#  end
+#
+# In order to use this the objects sent into the context contstructor *must*
+# `include Casting::Client` so that the `cast` method is available to them
+#
+module Casting
+  module Context
+
+    def self.extended(base)
+      base.send(:include, InstanceMethods)
+    end
+
+    def initialize(*setup_args)
+      attr_reader(*setup_args)
+      private(*setup_args)
+
+      mod = Module.new
+      line = __LINE__; string = %<
+        def initialize(#{setup_args.map{|name| "#{name}:" }.join(',')})
+          @assignments = []
+          #{setup_args.map do |name|
+            ["assign(",name,", '",name,"')"].join
+          end.join("\n")}
+          Thread.current[:context] = self
+        end
+        attr_reader :assignments
+      >
+      mod.class_eval string, __FILE__, line
+      const_set('Initializer', mod)
+      include mod
+    end
+
+    module InstanceMethods
+      def context
+        self
+      end
+  
+      # Keep track of objects and their behaviors
+      def assign(object, role_name)
+        instance_variable_set("@#{role_name}", object)
+        self.assignments << [object, self.role_for(role_name)]
+      end
+
+      def contains?(obj)
+        assignments.map(&:first).include?(obj)
+      end
+
+      # Execute the behavior from the role on the specifed object
+      def dispatch(object, method_name, *args, &block)
+        object.cast(method_name, context.role_implementing(object, method_name), *args, &block)
+      end
+    
+      # Find the first assigned role which implements a response for the given method name
+      def role_implementing(object, method_name)
+        assigned_roles(object).find{|role| role.method_defined?(method_name) } || raise(NoMethodError, "unknown method '#{method_name}' expected for #{object}")
+      end
+    
+      # Get the roles for the given object
+      def assigned_roles(object)
+        assignments.select{|pair|
+          pair.first == object
+        }.map(&:last)
+      end
+
+      # Get the behavior module for the named role.
+      # This role constant for special_person is SpecialPerson.
+      def role_for(name)
+        role_name = name.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }
+        self.class.const_get(role_name)
+      rescue NameError
+        Module
+      end
+    end
+
+    refine Object do
+      def context
+        Thread.current[:context]
+      end
+
+      def context=(obj)
+        Thread.current[:context] = obj
+      end
+
+      # Get the object playing a particular role
+      def role(role_name)
+        context.send(role_name)
+      end
+
+      # Execute the named method on the object plaing the name role
+      def tell(role_name, method_name, *args, &block)
+        if context == self || context.contains?(self)
+          context.dispatch(role(role_name), method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/casting/delegation.rb

@@ -7,7 +7,7 @@ module Casting
     private :prepared_delegation
 
     def initialize(delegated_method_name, client)
-      @prepared_delegation = PreparedDelegation.new(:delegated_method_name => delegated_method_name, :client => client)
+      @prepared_delegation = PreparedDelegation.new(delegated_method_name: delegated_method_name, client: client)
     end
 
     def client

data/lib/casting/missing_method_client.rb

@@ -47,7 +47,12 @@ module Casting
     private
 
     def __delegates__
-      @__delegates__ ||= []
+      return @__delegates__ if defined?(@__delegates__)
+      if frozen?
+        []
+      else
+        @__delegates__ = []
+      end
     end
 
     def method_missing(meth, *args, &block)

data/lib/casting/null.rb

@@ -1,24 +1,24 @@
 module Casting
   module Null
-    def self.instance_method(name)
+    def self.instance_method(_)
       Empty.instance_method(:null)
     end
-    def self.method_defined?(meth)
+    def self.method_defined?(_)
       true
     end
   end
   module Blank
-    def self.instance_method(name)
+    def self.instance_method(_)
       Empty.instance_method(:blank)
     end
-    def self.method_defined?(meth)
+    def self.method_defined?(_)
       true
     end
   end
   module Empty
-    def null(*args, &block); end
-    def blank(*args, &block)
+    def null(*, &_block); end
+    def blank(*, &_block)
       ""
     end
   end 
-end
+end

data/lib/casting/prepared_delegation.rb

@@ -10,15 +10,15 @@ module Casting
 
   class PreparedDelegation
 
-    attr_reader :client
-    attr_reader :delegated_method_name, :attendant, :arguments, :block
-    private :delegated_method_name, :attendant, :arguments, :block
+    attr_accessor :client, :delegated_method_name, :attendant, :arguments, :block
+    private :block
 
-    def initialize(settings)
+    def initialize(**settings, &block)
       @delegated_method_name = settings[:delegated_method_name]
       @client = settings[:client]
       @attendant = settings[:attendant]
       @arguments = settings[:arguments]
+      @block = block
     end
 
     def to(object_or_module)
@@ -59,7 +59,10 @@ module Casting
     end
 
     def method_module
-      delegated_method.owner unless delegated_method.owner.is_a?(Class)
+      mod = delegated_method.owner
+      unless mod.is_a?(Class)
+        mod
+      end
     end
 
     def delegated_method

data/lib/casting/version.rb

@@ -1,3 +1,3 @@
 module Casting
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

data/test/test_helper.rb

@@ -1,12 +1,5 @@
-require 'simplecov'
-SimpleCov.start do
-  add_filter 'test'
-end
-
-require 'coveralls'
-if ENV['COVERALLS']
-  Coveralls.wear!
-end
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
 
 require 'minitest/autorun'
 require 'casting'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: casting
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Jim Gay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-27 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Casting assists in method delegation which preserves the binding of 'self' to the object receiving a message.
@@ -20,8 +20,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
+- Rakefile
 - lib/casting.rb
 - lib/casting/client.rb
+- lib/casting/context.rb
 - lib/casting/delegation.rb
 - lib/casting/method_consolidator.rb
 - lib/casting/missing_method_client.rb
@@ -30,10 +34,6 @@ files:
 - lib/casting/prepared_delegation.rb
 - lib/casting/super_delegate.rb
 - lib/casting/version.rb
-- LICENSE
-- Rakefile
-- README.md
-- test/test_helper.rb
 - test/casting_19_test.rb
 - test/casting_20_test.rb
 - test/casting_test.rb
@@ -42,9 +42,10 @@ files:
 - test/delegation_test.rb
 - test/method_consolidator_test.rb
 - test/missing_method_client_test.rb
-- test/null_module_test.rb
 - test/module_cleanup_test.rb
+- test/null_module_test.rb
 - test/super_test.rb
+- test/test_helper.rb
 homepage: http://github.com/saturnflyer/casting
 licenses:
 - MIT
@@ -55,17 +56,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: Proper method delegation.