casting 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87f6f44b2f7597c28ab23eb2d02fd06479558ac075f3b6646cd583ea98e5f945
-  data.tar.gz: cdf55addbcdbaf848d4991fe8562b5bbeb50ea9b3fde1548f210ebb76d761186
+  metadata.gz: 3e9ce2a6479f584071216d9aa62c7f076525325295cbd4df491dd6cbf4ffad39
+  data.tar.gz: 3c1475f0c68d62ac2ba37c542b5c7d0a8c6fddad91a88a7097c03dcdaa02f5d9
 SHA512:
-  metadata.gz: 71d6eac4b57b571f8c593606f645477402dd9557081ac684c9c5117257e111916b17ec830836cfe9063acae7572aef5b96e20d5219558bf466769119a95b42a1
-  data.tar.gz: b81bf24dc30d94cbb520eb302f5173efe2f64b19b062a128071c30833df2f92c4a643b47717fa3092afdc2f20cc15a78631b2fa0fab1a80a8e6e9ed18c7bddc9
+  metadata.gz: 4942f847d1219c074e2794e8079a22c37bccfb0f011502944835c2b4b1aa1413f957fba526545fc66ea3d53f35e0cad5de206ec2560be51e2b4123624161f42f
+  data.tar.gz: c8b62a94bade49af44f49c49fdf1bca3075dfc68a7b65d57f31f4e6cd201fa32915ad1e5f7c6491806119000e3d350233331fcf5bfca94e8567c1c46b319f388

data/README.md

@@ -1,10 +1,9 @@
 # Casting
 
-[![Code Climate](https://codeclimate.com/github/saturnflyer/casting.png)](https://codeclimate.com/github/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
+
 Do it for the life of the object or only for the life of a block of code.
 
 Casting gives you real delegation that flattens your object structure compared to libraries
@@ -53,7 +52,7 @@ end
 actor = Actor.new
 ```
 
-Your objects will have a few additional methods: `delegation`, `cast`, and if you do not *already* have it defined (from another library, for example): `delegate`. The `delegate` method is aliased to `cast`.
+Your objects will have a few additional methods: `delegation`, `cast`, and if you do not _already_ have it defined (from another library, for example): `delegate`. The `delegate` method is aliased to `cast`.
 
 Then you may delegate a method to an attendant object:
 
@@ -327,11 +326,11 @@ module Special
   def self.cast_object(obj)
     obj.instance_variable_set(:@special_value, 'this is special!')
   end
-  
+
   def self.uncast_object(obj)
     obj.remove_instance_variable(:@special_value)
   end
-  
+
   def special_behavior
     "#{self.name} thinks... #{@special_value}"
   end
@@ -345,6 +344,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,19 @@
 #!/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
+require "reissue/gem"
+
+Reissue::Task.create do |task|
+  task.version_file = "lib/casting/version.rb"
+  task.fragment = :git
+end
+
+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
@@ -104,7 +98,8 @@ module Casting
       # 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 }
+        # Convert snake_case to CamelCase
+        role_name = name.to_s.split('_').map(&:capitalize).join
         self.class.const_get(role_name)
       rescue NameError
         Module.new

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
@@ -54,7 +53,7 @@ module Casting
 
     def method_missing(meth, ...)
       attendant = method_delegate(meth)
-      if !!attendant
+      if attendant
         cast(meth, attendant, ...)
       else
         super
@@ -62,23 +61,23 @@ module Casting
     end
 
     def respond_to_missing?(meth, *)
-      !!method_delegate(meth) || super
+      method_delegate(meth) ? true : super
     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,13 @@
 module Casting
   module SuperDelegate
-    
+    # Cache regex matchers at module level for better performance
+    @casting_library_matcher = nil
+    @gem_home_matcher = nil
+    @debugging_matcher = /internal:trace_point/
+
+    class << self
+      attr_accessor :casting_library_matcher, :gem_home_matcher, :debugging_matcher
+    end
     # 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 +26,7 @@ module Casting
     #
     # module FormalGreeter
     #   include Casting::Super
-    #   
+    #
     #   def greet
     #     "#{super_delegate}, how do you do?"
     #   end
@@ -29,46 +36,63 @@ module Casting
     # some_object.greet #=> 'Hello, how do you do?'
     #
     def super_delegate(mod = :none, *args, **kwargs, &block)
-      method_name = name_of_calling_method(caller_locations)
+      method_name, method_owner = name_and_owner_of_calling_method(caller_locations)
       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}")
+      # Use the method_owner from the call stack for consistent error messages
+      owner_name = method_owner || owner
+      raise NoMethodError.new("super_delegate: no delegate method `#{owner_name}##{method_name}' for #{inspect} from ")
     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
 
     def name_of_calling_method(call_stack)
-      calling_location(call_stack).label.to_sym
+      method_name, _owner = name_and_owner_of_calling_method(call_stack)
+      method_name
+    end
+
+    def name_and_owner_of_calling_method(call_stack)
+      label = calling_location(call_stack).label
+      # Ruby 3.4.7+ includes module name in label (e.g., "ModuleName#method_name")
+      # Ruby 3.3 and earlier just has method name
+      parts = label.split("#")
+      if parts.length > 1
+        # Ruby 3.4.7+: has owner prefix
+        [parts.last.to_sym, parts.first]
+      else
+        # Ruby 3.3 and earlier: no owner prefix
+        [parts.first.to_sym, nil]
+      end
     end
-    
+
     def casting_library_matcher
-      Regexp.new(Dir.pwd.to_s + '/lib')
+      SuperDelegate.casting_library_matcher ||= Regexp.new(Dir.pwd.to_s + "/lib")
     end
 
     def gem_home_matcher
-      Regexp.new(ENV['GEM_HOME'])
+      SuperDelegate.gem_home_matcher ||= Regexp.new(ENV["GEM_HOME"])
     end
 
     def debugging_matcher
-      Regexp.new('internal:trace_point')
+      SuperDelegate.debugging_matcher
     end
   end
 end

data/lib/casting/version.rb

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