casting 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87f6f44b2f7597c28ab23eb2d02fd06479558ac075f3b6646cd583ea98e5f945
-  data.tar.gz: cdf55addbcdbaf848d4991fe8562b5bbeb50ea9b3fde1548f210ebb76d761186
+  metadata.gz: 2d5d851d5d006809d4704472259cd76692d864a6a2ddfc6ae829cfd65c15fe45
+  data.tar.gz: 14e30f699b3cf4a7b488a18f013bd843ee5bcbc8e6d00595205fef5ae0d77a05
 SHA512:
-  metadata.gz: 71d6eac4b57b571f8c593606f645477402dd9557081ac684c9c5117257e111916b17ec830836cfe9063acae7572aef5b96e20d5219558bf466769119a95b42a1
-  data.tar.gz: b81bf24dc30d94cbb520eb302f5173efe2f64b19b062a128071c30833df2f92c4a643b47717fa3092afdc2f20cc15a78631b2fa0fab1a80a8e6e9ed18c7bddc9
+  metadata.gz: 11e74b4ff72316f9bf5ee307b6f4f00603f09263127f59b8a53c22bb30d91b24f6e8bed3e60113b7e22da5903024a86acc170650d665e46e2cb7e0f5fad4b518
+  data.tar.gz: c8d5513c9d70e879be06fc440f345b709a0ba84be8daaa941b3f034e9c1f21aa6aa614b87a24aa30e52cb0147c334adf497afef661ecaf7867df4009782b1b2d

data/README.md

@@ -345,6 +345,47 @@ object.uncast
 
 You'll be able to leave your objects as if they were never touched by the module where you defined your behavior.
 
+## It doesn't work!
+
+You might be trying to override existing methods. Casting can help you apply behavior to an object using `delegate_missing_methods` but that depends on the methods being missing. In other words, if you have an `as_json` method that you want to change with a module, you won't be able to just `cast_as(MyJsonModule)` and have the `as_json` method from it be picked up because that will never hit `method_missing`.
+
+If you want to override an existing method, you must do so explicitly.
+
+This will _not_ work:
+
+```ruby
+module MyJsonModule
+  def as_json
+    super.merge({ extra: 'details' })
+  end
+end
+some_object.cast_as(MyJsonModule)
+some_object.as_json
+```
+
+Instead, you'll need to explicitly override existing methods:
+
+```ruby
+some_object.cast(:as_json, MyJsonModule)
+```
+
+## How can I speed it up?
+
+Are you looping over lots of objects and want see better performance?
+
+If you want to make things a bit faster, you can prepare the method delegation ahead of time and change the client object.
+
+```ruby
+prepared_delegation = some_object.delegation(:some_delegated_method).to(MySpecialModule)
+# Some looping code
+big_list_of_objects.each do |object|
+  prepared_delegation.client = object
+  prepared_delegation.call
+end
+```
+
+Preparing the delegated method like this will probably speed things up for you but be sure to verify for yourself.
+
 ## Installation
 
 If you are using Bundler, add this line to your application's Gemfile:

data/Rakefile

@@ -1,12 +1,12 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/*_test.rb']
+  t.libs << "test"
+  t.test_files = FileList["test/*_test.rb"]
   t.ruby_opts = ["-w"]
   t.verbose = true
 end
 
-task :default => :test
+task default: :test

data/lib/casting/client.rb

@@ -1,22 +1,21 @@
-require 'casting/delegation'
-require 'casting/missing_method_client'
-require 'casting/missing_method_client_class'
+require "casting/delegation"
+require "casting/missing_method_client"
+require "casting/missing_method_client_class"
 
 module Casting
   module Client
-
     def self.included(base)
       def base.delegate_missing_methods(*which)
         Casting::Client.set_delegation_strategy(self, *which.reverse)
       end
 
-      unless base.method_defined?('delegate')
+      unless base.method_defined?(:delegate)
         add_delegate_method_to(base)
       end
     end
 
     def self.extended(base)
-      unless base.respond_to?('delegate')
+      unless base.respond_to?(:delegate)
         add_delegate_method_to(base.singleton_class)
       end
     end
@@ -31,28 +30,28 @@ module Casting
     end
 
     def delegate_missing_methods(*which)
-      Casting::Client.set_delegation_strategy(self.singleton_class, *which.reverse)
+      Casting::Client.set_delegation_strategy(singleton_class, *which.reverse)
     end
 
     private
 
     def validate_attendant(attendant)
       if attendant == self
-        raise Casting::InvalidAttendant.new('client can not delegate to itself')
+        raise Casting::InvalidAttendant.new("client can not delegate to itself")
       end
     end
 
     def self.set_delegation_strategy(base, *which)
       which = [:instance] if which.empty?
-      which.map!{|selection|
-        selection == :instance && selection = self.method(:set_method_missing_client)
-        selection == :class && selection = self.method(:set_method_missing_client_class)
+      which.map! { |selection|
+        selection == :instance && selection = method(:set_method_missing_client)
+        selection == :class && selection = method(:set_method_missing_client_class)
         selection
-      }.map{|meth| meth.call(base) }
+      }.map { |meth| meth.call(base) }
     end
 
     def self.add_delegate_method_to(base)
-      base.class_eval{ alias_method :delegate, :cast }
+      base.class_eval { alias_method :delegate, :cast }
     end
 
     def self.set_method_missing_client(base)

data/lib/casting/context.rb

@@ -29,7 +29,6 @@
 #
 module Casting
   module Context
-
     def self.extended(base)
       base.send(:include, InstanceMethods)
     end
@@ -38,26 +37,21 @@ module Casting
       attr_reader(*setup_args)
       private(*setup_args)
 
-      if block
-        define_method(:__custom_initialize, &block)
-      else
-        define_method(:__custom_initialize) do; end
-      end
+      define_method(:__custom_initialize, &(block || proc {}))
 
       mod = Module.new
-      line = __LINE__; string = %<
-        def initialize(#{setup_args.map{|name| "#{name}:" }.join(',')})
+      mod.class_eval <<~INIT, __FILE__, __LINE__ + 1
+        def initialize(#{setup_args.map { |name| "#{name}:" }.join(",")})
           @assignments = []
           #{setup_args.map do |name|
-            ["assign(",name,", '",name,"')"].join
+            ["assign(", name, ", '", name, "')"].join
           end.join("\n")}
           __custom_initialize
           Thread.current[:context] = self
         end
         attr_reader :assignments
-      >
-      mod.class_eval string, __FILE__, line
-      const_set('Initializer', mod)
+      INIT
+      const_set(:Initializer, mod)
       include mod
     end
 
@@ -73,7 +67,7 @@ module Casting
       # 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)]
+        assignments << [object, role_for(role_name)]
       end
 
       def contains?(obj)
@@ -91,12 +85,12 @@ module Casting
 
       # 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}")
+        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|
+        assignments.select { |pair|
           pair.first == object
         }.map(&:last)
       end

data/lib/casting/delegation.rb

@@ -1,5 +1,4 @@
 module Casting
-
   class MissingAttendant < StandardError
     def message
       "You must set your attendant object using `to'."
@@ -9,7 +8,6 @@ module Casting
   class InvalidAttendant < StandardError; end
 
   class Delegation
-
     def self.prepare(delegated_method_name, client, &block)
       new(delegated_method_name: delegated_method_name, client: client, &block)
     end
@@ -46,41 +44,42 @@ module Casting
     def call(*args, **kwargs, &block)
       raise MissingAttendant.new unless attendant
 
-      call_args = if args && !args.empty?
-        args
-      elsif @arguments && !@arguments.empty?
-        @arguments
-      end
-      call_kwargs = if kwargs && !kwargs.empty?
-        kwargs
-      elsif @keyword_arguments && !@keyword_arguments.empty?
-        @keyword_arguments
-      end
-
-      call_block = block || @block
-      if call_args
-        if call_kwargs
-          bound_method.call(*call_args, **call_kwargs, &call_block)
-        else
-          bound_method.call(*call_args, &call_block)
-        end
+      call_args = positional_arguments(args)
+      call_kwargs = keyword_arguments(kwargs)
+      call_block = block_argument(&block)
+
+      case
+      when call_args && call_kwargs
+        bound_method.call(*call_args, **call_kwargs, &call_block)
+      when call_args
+        bound_method.call(*call_args, &call_block)
+      when call_kwargs
+        bound_method.call(**call_kwargs, &call_block)
       else
-        if call_kwargs
-          bound_method.call(**call_kwargs, &call_block)
-        else
-          bound_method.call(&call_block)
-        end
+        bound_method.call(&call_block)
       end
     end
 
     private
 
+    def block_argument(&block)
+      block || @block
+    end
+
+    def positional_arguments(options)
+      return options unless options.empty?
+      @arguments
+    end
+
+    def keyword_arguments(options)
+      return options unless options.empty?
+      @keyword_arguments
+    end
+
     def bound_method
-      begin
-        delegated_method.bind(client)
-      rescue TypeError
-        raise TypeError.new("`to' argument must be a module or an object with #{delegated_method_name} defined in a module")
-      end
+      delegated_method.bind(client)
+    rescue TypeError
+      raise TypeError.new("`to' argument must be a module or an object with #{delegated_method_name} defined in a module")
     end
 
     def method_module
@@ -92,13 +91,12 @@ module Casting
 
     def delegated_method
       if Module === attendant
-        attendant.instance_method(delegated_method_name)
+        attendant
       else
-        attendant.method(delegated_method_name).owner.instance_method(delegated_method_name)
-      end
+        attendant.method(delegated_method_name).owner
+      end.instance_method(delegated_method_name)
     rescue NameError => e
-      raise InvalidAttendant.new(e.message)
+      raise InvalidAttendant, e.message
     end
-
   end
 end

data/lib/casting/enum.rb

@@ -1,7 +1,9 @@
 module Casting
   module Enum
+    extend self
+
     def enum(collection, *behaviors)
-      enum = Enumerator.new do |yielder|
+      Enumerator.new do |yielder|
         collection.each do |item|
           yielder.yield(item.cast_as(*behaviors))
         end

data/lib/casting/method_consolidator.rb

@@ -1,19 +1,19 @@
 module Casting
   module MethodConsolidator
-    def methods(all=true)
+    def methods(all = true)
       (super + delegated_methods(all)).uniq
     end
 
-    def public_methods(include_super=true)
+    def public_methods(include_super = true)
       (super + delegated_public_methods(include_super)).uniq
     end
 
-    def protected_methods(include_super=true)
+    def protected_methods(include_super = true)
       (super + delegated_protected_methods(include_super)).uniq
     end
 
-    def private_methods(include_super=true)
+    def private_methods(include_super = true)
       (super + delegated_private_methods(include_super)).uniq
     end
   end
-end
+end

data/lib/casting/missing_method_client.rb

@@ -1,8 +1,7 @@
-require 'casting/method_consolidator'
+require "casting/method_consolidator"
 
 module Casting
   module MissingMethodClient
-
     def cast_as(*attendants)
       attendants.each do |attendant|
         validate_attendant(attendant)
@@ -12,7 +11,7 @@ module Casting
       self
     end
 
-    def uncast(count=1)
+    def uncast(count = 1)
       count.times do
         attendant = __delegates__.shift
         attendant.uncast_object(self) if attendant.respond_to?(:uncast_object)
@@ -20,26 +19,26 @@ module Casting
       self
     end
 
-    def delegated_methods(all=true)
-      __delegates__.flat_map{|attendant|
+    def delegated_methods(all = true)
+      __delegates__.flat_map { |attendant|
         attendant_methods(attendant, all)
       }
     end
 
-    def delegated_public_methods(include_super=true)
-      __delegates__.flat_map{|attendant|
+    def delegated_public_methods(include_super = true)
+      __delegates__.flat_map { |attendant|
         attendant_public_methods(attendant, include_super)
       }
     end
 
-    def delegated_protected_methods(include_super=true)
-      __delegates__.flat_map{|attendant|
+    def delegated_protected_methods(include_super = true)
+      __delegates__.flat_map { |attendant|
         attendant_protected_methods(attendant, include_super)
       }
     end
 
-    def delegated_private_methods(include_super=true)
-      __delegates__.flat_map{|attendant|
+    def delegated_private_methods(include_super = true)
+      __delegates__.flat_map { |attendant|
         attendant_private_methods(attendant, include_super)
       }
     end
@@ -66,19 +65,19 @@ module Casting
     end
 
     def method_delegate(meth)
-      __delegates__.find{|attendant|
+      __delegates__.find { |attendant|
         attendant.respond_to?(:method_defined?) && attendant.method_defined?(meth) ||
-        attendant_methods(attendant).include?(meth)
+          attendant_methods(attendant).include?(meth)
       }
     end
 
-    def attendant_methods(attendant, all=true)
+    def attendant_methods(attendant, all = true)
       collection = attendant_public_methods(attendant) + attendant_protected_methods(attendant)
       collection += attendant_private_methods(attendant) if all
       collection
     end
 
-    def attendant_public_methods(attendant, include_super=true)
+    def attendant_public_methods(attendant, include_super = true)
       if Module === attendant
         attendant.public_instance_methods(include_super)
       else
@@ -86,7 +85,7 @@ module Casting
       end
     end
 
-    def attendant_protected_methods(attendant, include_super=true)
+    def attendant_protected_methods(attendant, include_super = true)
       if Module === attendant
         attendant.protected_instance_methods(include_super)
       else
@@ -94,7 +93,7 @@ module Casting
       end
     end
 
-    def attendant_private_methods(attendant, include_super=true)
+    def attendant_private_methods(attendant, include_super = true)
       if Module === attendant
         attendant.private_instance_methods(include_super)
       else

data/lib/casting/missing_method_client_class.rb

@@ -1,6 +1,5 @@
 module Casting
   module MissingMethodClientClass
-
     def self.extended(base)
       base.send(:include, InstanceMethods)
     end
@@ -26,7 +25,7 @@ module Casting
       end
 
       def method_class_delegate(meth)
-        __class_delegates__.find{|attendant|
+        __class_delegates__.find { |attendant|
           attendant.method_defined?(meth)
         }
       end
@@ -44,7 +43,7 @@ module Casting
 
     def __delegates__
       Thread.current[:class_delegates] ||= {}
-      Thread.current[:class_delegates][self.name] ||= []
+      Thread.current[:class_delegates][name] ||= []
     end
   end
-end
+end

data/lib/casting/null.rb

@@ -3,22 +3,28 @@ module Casting
     def self.instance_method(*_)
       Empty.instance_method(:null)
     end
+
     def self.method_defined?(*_)
       true
     end
   end
+
   module Blank
     def self.instance_method(*_)
       Empty.instance_method(:blank)
     end
+
     def self.method_defined?(*_)
       true
     end
   end
+
   module Empty
-    def null(*, &_block); end
+    def null(*, &_block)
+    end
+
     def blank(*, &_block)
       ""
     end
-  end 
+  end
 end

data/lib/casting/super_delegate.rb

@@ -1,6 +1,5 @@
 module Casting
   module SuperDelegate
-    
     # Call the method of the same name defined in the next delegate stored in your object
     #
     # Because Casting creates an alternative method lookup path using a collection of delegates,
@@ -19,7 +18,7 @@ module Casting
     #
     # module FormalGreeter
     #   include Casting::Super
-    #   
+    #
     #   def greet
     #     "#{super_delegate}, how do you do?"
     #   end
@@ -33,24 +32,24 @@ module Casting
       owner = (mod unless mod == :none) || method_delegate(method_name)
 
       super_delegate_method = unbound_method_from_next_delegate(method_name, owner)
-      super_delegate_method.bind(self).call(*args, **kwargs, &block)
+      super_delegate_method.bind_call(self, *args, **kwargs, &block)
     rescue NameError
-      raise NoMethodError.new("super_delegate: no delegate method `#{method_name}' for #{self.inspect} from #{owner}")
+      raise NoMethodError.new("super_delegate: no delegate method `#{method_name}' for #{inspect} from #{owner}")
     end
-    
+
     def unbound_method_from_next_delegate(method_name, *skipped)
       method_delegate_skipping(method_name, *skipped).instance_method(method_name)
     end
-    
+
     def method_delegate_skipping(meth, skipped)
       skipped_index = __delegates__.index(skipped)
-      __delegates__[(skipped_index + 1)..__delegates__.length].find{|attendant|
+      __delegates__[(skipped_index + 1)..__delegates__.length].find { |attendant|
         attendant_methods(attendant).include?(meth)
       }
     end
 
     def calling_location(call_stack)
-      call_stack.reject{|line| 
+      call_stack.reject { |line|
         line.to_s.match? Regexp.union(casting_library_matcher, gem_home_matcher, debugging_matcher)
       }.first
     end
@@ -58,17 +57,17 @@ module Casting
     def name_of_calling_method(call_stack)
       calling_location(call_stack).label.to_sym
     end
-    
+
     def casting_library_matcher
-      Regexp.new(Dir.pwd.to_s + '/lib')
+      Regexp.new(Dir.pwd.to_s + "/lib")
     end
 
     def gem_home_matcher
-      Regexp.new(ENV['GEM_HOME'])
+      Regexp.new(ENV["GEM_HOME"])
     end
 
     def debugging_matcher
-      Regexp.new('internal:trace_point')
+      Regexp.new("internal:trace_point")
     end
   end
 end

data/lib/casting/version.rb

@@ -1,3 +1,3 @@
 module Casting
-  VERSION = '1.0.1'
+  VERSION = "1.0.2"
 end

data/lib/casting.rb

@@ -1,12 +1,11 @@
-require 'casting/version'
-require 'casting/client'
-require 'casting/enum'
-require 'casting/super_delegate'
-require 'casting/null'
-require 'casting/context'
+require "casting/version"
+require "casting/client"
+require "casting/enum"
+require "casting/super_delegate"
+require "casting/null"
+require "casting/context"
 
 module Casting
-
   class InvalidClientError < StandardError; end
 
   def self.delegating(assignments)
@@ -31,5 +30,4 @@ module Casting
 
     object.uncast
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: casting
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Jim Gay
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-17 00:00:00.000000000 Z
+date: 2023-01-07 00:00:00.000000000 Z
 dependencies: []
 description: |-
   Casting assists in method delegation which preserves the binding of 'self' to the object receiving a message.
@@ -34,19 +34,6 @@ files:
 - lib/casting/null.rb
 - lib/casting/super_delegate.rb
 - lib/casting/version.rb
-- test/casting_enum_test.rb
-- test/casting_test.rb
-- test/class_refinement_test.rb
-- test/client_test.rb
-- test/context_test.rb
-- test/delegation_test.rb
-- test/frozen_client_test.rb
-- test/method_consolidator_test.rb
-- test/missing_method_client_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
@@ -70,17 +57,4 @@ rubygems_version: 3.2.27
 signing_key:
 specification_version: 4
 summary: Proper method delegation.
-test_files:
-- test/test_helper.rb
-- test/casting_enum_test.rb
-- test/casting_test.rb
-- test/class_refinement_test.rb
-- test/client_test.rb
-- test/context_test.rb
-- test/delegation_test.rb
-- test/frozen_client_test.rb
-- test/method_consolidator_test.rb
-- test/missing_method_client_test.rb
-- test/module_cleanup_test.rb
-- test/null_module_test.rb
-- test/super_test.rb
+test_files: []