diff options
Diffstat (limited to 'lib/forwardable.rb')
| -rw-r--r-- | lib/forwardable.rb | 106 |
1 files changed, 64 insertions, 42 deletions
diff --git a/lib/forwardable.rb b/lib/forwardable.rb index e78b9ed1e0..c9c4128f9f 100644 --- a/lib/forwardable.rb +++ b/lib/forwardable.rb @@ -57,10 +57,9 @@ # # == Another example # -# We want to rely on what has come before obviously, but with delegation we can -# take just the methods we need and even rename them as appropriate. In many -# cases this is preferable to inheritance, which gives us the entire old -# interface, even if much of it isn't needed. +# You could use Forwardable as an alternative to inheritance, when you don't want +# to inherit all methods from the superclass. For instance, here is how you might +# add a range of +Array+ instance methods to a new class +Queue+: # # class Queue # extend Forwardable @@ -77,7 +76,7 @@ # def_delegators :@q, :clear, :first, :push, :shift, :size # end # -# q = Queue.new +# q = Thread::Queue.new # q.enq 1, 2, 3, 4, 5 # q.push 6 # @@ -110,20 +109,21 @@ # +delegate.rb+. # module Forwardable - # Version of +forwardable.rb+ - FORWARDABLE_VERSION = "1.1.0" + require 'forwardable/impl' - FILE_REGEXP = %r"#{Regexp.quote(__FILE__)}" + # Version of +forwardable.rb+ + VERSION = "1.3.2" + FORWARDABLE_VERSION = VERSION @debug = nil class << self - # If true, <tt>__FILE__</tt> will remain in the backtrace in the event an - # Exception is raised. + # ignored attr_accessor :debug end # Takes a hash as its argument. The key is a symbol or an array of - # symbols. These symbols correspond to method names. The value is + # symbols. These symbols correspond to method names, instance variable + # names, or constant names (see def_delegator). The value is # the accessor to which the methods will be delegated. # # :call-seq: @@ -131,12 +131,13 @@ module Forwardable # delegate [method, method, ...] => accessor # def instance_delegate(hash) - hash.each{ |methods, accessor| - methods = [methods] unless methods.respond_to?(:each) - methods.each{ |method| - def_instance_delegator(accessor, method) - } - } + hash.each do |methods, accessor| + unless defined?(methods.each) + def_instance_delegator(accessor, methods) + else + methods.each {|method| def_instance_delegator(accessor, method)} + end + end end # @@ -151,18 +152,21 @@ module Forwardable # def_delegator :@records, :map # def def_instance_delegators(accessor, *methods) - methods.delete("__send__") - methods.delete("__id__") - for method in methods + methods.each do |method| + next if /\A__(?:send|id)__\z/ =~ method def_instance_delegator(accessor, method) end end # Define +method+ as delegator instance method with an optional # alias name +ali+. Method calls to +ali+ will be delegated to - # +accessor.method+. + # +accessor.method+. +accessor+ should be a method name, instance + # variable name, or constant name. Use the full path to the + # constant if providing the constant name. + # Returns the name of the method defined. # # class MyQueue + # CONST = 1 # extend Forwardable # attr_reader :queue # def initialize @@ -170,24 +174,30 @@ module Forwardable # end # # def_delegator :@queue, :push, :mypush + # def_delegator 'MyQueue::CONST', :to_i # end # # q = MyQueue.new # q.mypush 42 # q.queue #=> [42] # q.push 23 #=> NoMethodError + # q.to_i #=> 1 # def def_instance_delegator(accessor, method, ali = method) gen = Forwardable._delegator_method(self, accessor, method, ali) # If it's not a class or module, it's an instance - (Module === self ? self : singleton_class).module_eval(&gen) + mod = Module === self ? self : singleton_class + ret = mod.module_eval(&gen) + mod.__send__(:ruby2_keywords, ali) if RUBY_VERSION >= '2.7' + ret end alias delegate instance_delegate alias def_delegators def_instance_delegators alias def_delegator def_instance_delegator + # :nodoc: def self._delegator_method(obj, accessor, method, ali) accessor = accessor.to_s unless Symbol === accessor @@ -197,24 +207,33 @@ module Forwardable accessor = "#{accessor}()" end - line_no = __LINE__+1; str = "#{<<-"begin;"}\n#{<<-"end;"}" + method_call = ".__send__(:#{method}, *args, &block)" + if _valid_method?(method) + loc, = caller_locations(2,1) + pre = "_ =" + mesg = "#{Module === obj ? obj : obj.class}\##{ali} at #{loc.path}:#{loc.lineno} forwarding to private method " + method_call = "#{<<-"begin;"}\n#{<<-"end;".chomp}" + begin; + unless defined? _.#{method} + ::Kernel.warn #{mesg.dump}"\#{_.class}"'##{method}', uplevel: 1 + _#{method_call} + else + _.#{method}(*args, &block) + end + end; + end + + _compile_method("#{<<-"begin;"}\n#{<<-"end;"}", __FILE__, __LINE__+1) begin; proc do def #{ali}(*args, &block) + #{pre} begin #{accessor} - ensure - $@.delete_if {|s| ::Forwardable::FILE_REGEXP =~ s} if $@ and !::Forwardable::debug - end.__send__ :#{method}, *args, &block + end#{method_call} end end end; - - RubyVM::InstructionSequence - .compile(str, __FILE__, __FILE__, line_no, - trace_instruction: false, - tailcall_optimization: true) - .eval end end @@ -252,12 +271,13 @@ module SingleForwardable # delegate [method, method, ...] => accessor # def single_delegate(hash) - hash.each{ |methods, accessor| - methods = [methods] unless methods.respond_to?(:each) - methods.each{ |method| - def_single_delegator(accessor, method) - } - } + hash.each do |methods, accessor| + unless defined?(methods.each) + def_single_delegator(accessor, methods) + else + methods.each {|method| def_single_delegator(accessor, method)} + end + end end # @@ -272,9 +292,8 @@ module SingleForwardable # def_delegator :@records, :map # def def_single_delegators(accessor, *methods) - methods.delete("__send__") - methods.delete("__id__") - for method in methods + methods.each do |method| + next if /\A__(?:send|id)__\z/ =~ method def_single_delegator(accessor, method) end end @@ -285,10 +304,13 @@ module SingleForwardable # Defines a method _method_ which delegates to _accessor_ (i.e. it calls # the method of the same name in _accessor_). If _new_name_ is # provided, it is used as the name for the delegate method. + # Returns the name of the method defined. def def_single_delegator(accessor, method, ali = method) gen = Forwardable._delegator_method(self, accessor, method, ali) - instance_eval(&gen) + ret = instance_eval(&gen) + singleton_class.__send__(:ruby2_keywords, ali) if RUBY_VERSION >= '2.7' + ret end alias delegate single_delegate |