forwardable 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c08b5a019cfdbf0cfcf51bfb66d6500065d8f6492fc50a8e481d1e427a6d2df8
+  data.tar.gz: 9a25242aae4c2214ffffc7027eb680a9e09f0fda47f1bcf35cd15cea06c35ac9
+SHA512:
+  metadata.gz: a23ba5a69ad8fe490e81bb01815fda286e97259c7010e48c3491c9e2537a1a7cbf78da7805f07c6ac302cab8458152c9343e0f19d3669269afc33c94a11d7b42
+  data.tar.gz: 1e809b3fd7e1ff732cbd9abb384e1ad914d1bf53b4ce23973989741414cfe3015ce7cb744222dd4694b58ee1b17ec0e722406770b908ea6cafc1c19387111c3e

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+  - ruby-head
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,79 @@
+# Forwardable
+
+The Forwardable module provides delegation of specified methods to a designated object, using the methods #def_delegator and #def_delegators.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'forwardable'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install forwardable
+
+## Usage
+
+For example, say you have a class RecordCollection which contains an array <tt>@records</tt>.  You could provide the lookup ethod `#record_number()`, which simply calls #[] on the <tt>@records</tt> array, like this:
+
+```
+  require 'forwardable'
+
+  class RecordCollection
+    attr_accessor :records
+    extend Forwardable
+    def_delegator :@records, :[], :record_number
+  end
+```
+
+We can use the lookup method like so:
+
+```
+  r = RecordCollection.new
+  r.records = [4,5,6]
+  r.record_number(0)  # => 4
+```
+
+Further, if you wish to provide the methods #size, #<<, and #map, all of which delegate to @records, this is how you can do it:
+
+```
+  class RecordCollection # re-open RecordCollection class
+    def_delegators :@records, :size, :<<, :map
+  end
+
+  r = RecordCollection.new
+  r.records = [1,2,3]
+  r.record_number(0)   # => 1
+  r.size               # => 3
+  r << 4               # => [1, 2, 3, 4]
+  r.map { |x| x * 2 }  # => [2, 4, 6, 8]
+```
+
+You can even extend regular objects with Forwardable.
+
+```
+  my_hash = Hash.new
+  my_hash.extend Forwardable              # prepare object for delegation
+  my_hash.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+  my_hash.puts "Howdy!"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/forwardable.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test" << "test/lib"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require_relative "../lib/forwardable"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/forwardable.gemspec

@@ -0,0 +1,26 @@
+begin
+  require_relative "lib/forwardable"
+rescue LoadError
+  # for Ruby core repository
+  require_relative "../forwardable"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "forwardable"
+  spec.version       = Forwardable::VERSION
+  spec.authors       = ["Keiju ISHITSUKA"]
+  spec.email         = ["keiju@ruby-lang.org"]
+
+  spec.summary       = %q{Provides delegation of specified methods to a designated object.}
+  spec.description   = %q{Provides delegation of specified methods to a designated object.}
+  spec.homepage      = "https://github.com/ruby/forwardable"
+  spec.license       = "BSD-2-Clause"
+
+  spec.files         = [".gitignore", ".travis.yml", "Gemfile", "LICENSE.txt", "README.md", "Rakefile", "bin/console", "bin/setup", "forwardable.gemspec", "lib/forwardable.rb", "lib/forwardable/impl.rb"]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

data/lib/forwardable.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: false
+#
+#   forwardable.rb -
+#       $Release Version: 1.1$
+#       $Revision$
+#       by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#       original definition by delegator.rb
+#       Revised by Daniel J. Berger with suggestions from Florian Gross.
+#
+#       Documentation by James Edward Gray II and Gavin Sinclair
+
+
+
+# The Forwardable module provides delegation of specified
+# methods to a designated object, using the methods #def_delegator
+# and #def_delegators.
+#
+# For example, say you have a class RecordCollection which
+# contains an array <tt>@records</tt>.  You could provide the lookup method
+# #record_number(), which simply calls #[] on the <tt>@records</tt>
+# array, like this:
+#
+#   require 'forwardable'
+#
+#   class RecordCollection
+#     attr_accessor :records
+#     extend Forwardable
+#     def_delegator :@records, :[], :record_number
+#   end
+#
+# We can use the lookup method like so:
+#
+#   r = RecordCollection.new
+#   r.records = [4,5,6]
+#   r.record_number(0)  # => 4
+#
+# Further, if you wish to provide the methods #size, #<<, and #map,
+# all of which delegate to @records, this is how you can do it:
+#
+#   class RecordCollection # re-open RecordCollection class
+#     def_delegators :@records, :size, :<<, :map
+#   end
+#
+#   r = RecordCollection.new
+#   r.records = [1,2,3]
+#   r.record_number(0)   # => 1
+#   r.size               # => 3
+#   r << 4               # => [1, 2, 3, 4]
+#   r.map { |x| x * 2 }  # => [2, 4, 6, 8]
+#
+# You can even extend regular objects with Forwardable.
+#
+#   my_hash = Hash.new
+#   my_hash.extend Forwardable              # prepare object for delegation
+#   my_hash.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#   my_hash.puts "Howdy!"
+#
+# == 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.
+#
+#   class Queue
+#     extend Forwardable
+#
+#     def initialize
+#       @q = [ ]    # prepare delegate object
+#     end
+#
+#     # setup preferred interface, enq() and deq()...
+#     def_delegator :@q, :push, :enq
+#     def_delegator :@q, :shift, :deq
+#
+#     # support some general Array methods that fit Queues well
+#     def_delegators :@q, :clear, :first, :push, :shift, :size
+#   end
+#
+#   q = Queue.new
+#   q.enq 1, 2, 3, 4, 5
+#   q.push 6
+#
+#   q.shift    # => 1
+#   while q.size > 0
+#     puts q.deq
+#   end
+#
+#   q.enq "Ruby", "Perl", "Python"
+#   puts q.first
+#   q.clear
+#   puts q.first
+#
+# This should output:
+#
+#   2
+#   3
+#   4
+#   5
+#   6
+#   Ruby
+#   nil
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# +forwardable.rb+ provides single-method delegation via the def_delegator and
+# def_delegators methods. For full-class delegation via DelegateClass, see
+# +delegate.rb+.
+#
+module Forwardable
+  require 'forwardable/impl'
+
+  # Version of +forwardable.rb+
+  VERSION = "1.2.0"
+  FORWARDABLE_VERSION = VERSION
+
+  @debug = nil
+  class << self
+    # 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
+  # the accessor to which the methods will be delegated.
+  #
+  # :call-seq:
+  #    delegate method => accessor
+  #    delegate [method, method, ...] => accessor
+  #
+  def instance_delegate(hash)
+    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
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  def def_instance_delegators(accessor, *methods)
+    methods.delete("__send__")
+    methods.delete("__id__")
+    for method in methods
+      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+.
+  #
+  #   class MyQueue
+  #     extend Forwardable
+  #     attr_reader :queue
+  #     def initialize
+  #       @queue = []
+  #     end
+  #
+  #     def_delegator :@queue, :push, :mypush
+  #   end
+  #
+  #   q = MyQueue.new
+  #   q.mypush 42
+  #   q.queue    #=> [42]
+  #   q.push 23  #=> NoMethodError
+  #
+  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)
+  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
+
+    if Module === obj ?
+         obj.method_defined?(accessor) || obj.private_method_defined?(accessor) :
+         obj.respond_to?(accessor, true)
+      accessor = "#{accessor}()"
+    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}
+          end#{method_call}#{FILTER_EXCEPTION}
+        end
+      end
+    end;
+  end
+end
+
+# SingleForwardable can be used to setup delegation at the object level as well.
+#
+#    printer = String.new
+#    printer.extend SingleForwardable        # prepare object for delegation
+#    printer.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#    printer.puts "Howdy!"
+#
+# Also, SingleForwardable can be used to set up delegation for a Class or Module.
+#
+#   class Implementation
+#     def self.service
+#       puts "serviced!"
+#     end
+#   end
+#
+#   module Facade
+#     extend SingleForwardable
+#     def_delegator :Implementation, :service
+#   end
+#
+#   Facade.service #=> serviced!
+#
+# If you want to use both Forwardable and SingleForwardable, you can
+# use methods def_instance_delegator and def_single_delegator, etc.
+module SingleForwardable
+  # 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
+  # the accessor to which the methods will be delegated.
+  #
+  # :call-seq:
+  #    delegate method => accessor
+  #    delegate [method, method, ...] => accessor
+  #
+  def single_delegate(hash)
+    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
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  def def_single_delegators(accessor, *methods)
+    methods.delete("__send__")
+    methods.delete("__id__")
+    for method in methods
+      def_single_delegator(accessor, method)
+    end
+  end
+
+  # :call-seq:
+  #   def_single_delegator(accessor, method, new_name=method)
+  #
+  # 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.
+  def def_single_delegator(accessor, method, ali = method)
+    gen = Forwardable._delegator_method(self, accessor, method, ali)
+
+    instance_eval(&gen)
+  end
+
+  alias delegate single_delegate
+  alias def_delegators def_single_delegators
+  alias def_delegator def_single_delegator
+end

data/lib/forwardable/impl.rb

@@ -0,0 +1,24 @@
+# :stopdoc:
+module Forwardable
+  FILE_REGEXP = %r"#{Regexp.quote(File.dirname(__FILE__))}"
+  FILTER_EXCEPTION = <<-'END'
+
+        rescue ::Exception
+          $@.delete_if {|s| ::Forwardable::FILE_REGEXP =~ s} unless ::Forwardable::debug
+          ::Kernel::raise
+  END
+
+  def self._valid_method?(method)
+    catch {|tag|
+      eval("BEGIN{throw tag}; ().#{method}", binding, __FILE__, __LINE__)
+    }
+  rescue SyntaxError
+    false
+  else
+    true
+  end
+
+  def self._compile_method(src, file, line)
+    eval(src, nil, file, line)
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: forwardable
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Keiju ISHITSUKA
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides delegation of specified methods to a designated object.
+email:
+- keiju@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- forwardable.gemspec
+- lib/forwardable.rb
+- lib/forwardable/impl.rb
+homepage: https://github.com/ruby/forwardable
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Provides delegation of specified methods to a designated object.
+test_files: []