delegate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6cd16ea3c730a702d06a1721e2213829db7c2ccc0109aa267fa62201f9f5b910
+  data.tar.gz: 7e46d4c7174ff100079239050e33e41589c9d1a553d8497ab0fb763b22939835
+SHA512:
+  metadata.gz: 9779b0aa3f86278c7ddef289936be20530e6056c22cfca97039740495a80e9cd9f77d22cb51ff6bc02e9b43e7dfdb3917dd22bd0fb93bf6e38c8858d6080e174
+  data.tar.gz: 7d1ce7b641a66022ac9ef56f46dbcfd0999fdd4f6834fbdfb4142d0fbb39fa689a4007395657704f174181709ca251e5f78965e9cbead70b8a8f9cb0f0d8bc3a

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "bundler"
+  gem "rake"
+  gem "test-unit"
+end

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,59 @@
+# Delegator
+
+This library provides three different ways to delegate method calls to an
+object.  The easiest to use is SimpleDelegator.  Pass an object to the
+constructor and all methods supported by the object will be delegated.  This
+object can be changed later.
+
+Going a step further, the top level DelegateClass method allows you to easily
+setup delegation through class inheritance.  This is considerably more
+flexible and thus probably the most common use for this library.
+
+Finally, if you need full control over the delegation scheme, you can inherit
+from the abstract class Delegator and customize as needed.  (If you find
+yourself needing this control, have a look at Forwardable which is also in
+the standard library.  It may suit your needs better.)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'delegate'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install delegate
+
+## Usage
+
+SimpleDelegator's implementation serves as a nice example of the use of
+Delegator:
+
+```ruby
+class SimpleDelegator < Delegator
+  def __getobj__
+    @delegate_sd_obj # return object we are delegating to, required
+  end
+
+  def __setobj__(obj)
+    @delegate_sd_obj = obj # change delegation object,
+                           # a feature we're providing
+  end
+end
+```
+
+## 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/hsbt/delegate.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test/lib"
+  t.ruby_opts << "-rhelper"
+  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 "delegate"
+
+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/delegate.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "delegate/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "delegate"
+  spec.version       = Delegator::VERSION
+  spec.authors       = ["Hiroshi SHIBATA"]
+  spec.email         = ["hsbt@ruby-lang.org"]
+
+  spec.summary       = %q{Provides three abilities to delegate method calls to an object.}
+  spec.description   = %q{Provides three abilities to delegate method calls to an object.}
+  spec.homepage      = "https://github.com/ruby/delegate"
+  spec.license       = "BSD-2-Clause"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/delegate.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+# = delegate -- Support for the Delegation Pattern
+#
+# Documentation by James Edward Gray II and Gavin Sinclair
+
+##
+# This library provides three different ways to delegate method calls to an
+# object.  The easiest to use is SimpleDelegator.  Pass an object to the
+# constructor and all methods supported by the object will be delegated.  This
+# object can be changed later.
+#
+# Going a step further, the top level DelegateClass method allows you to easily
+# setup delegation through class inheritance.  This is considerably more
+# flexible and thus probably the most common use for this library.
+#
+# Finally, if you need full control over the delegation scheme, you can inherit
+# from the abstract class Delegator and customize as needed.  (If you find
+# yourself needing this control, have a look at Forwardable which is also in
+# the standard library.  It may suit your needs better.)
+#
+# SimpleDelegator's implementation serves as a nice example of the use of
+# Delegator:
+#
+#   class SimpleDelegator < Delegator
+#     def __getobj__
+#       @delegate_sd_obj # return object we are delegating to, required
+#     end
+#
+#     def __setobj__(obj)
+#       @delegate_sd_obj = obj # change delegation object,
+#                              # a feature we're providing
+#     end
+#   end
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+class Delegator < BasicObject
+  kernel = ::Kernel.dup
+  kernel.class_eval do
+    alias __raise__ raise
+    [:to_s, :inspect, :=~, :!~, :===, :<=>, :hash].each do |m|
+      undef_method m
+    end
+    private_instance_methods.each do |m|
+      if /\Ablock_given\?\z|\Aiterator\?\z|\A__.*__\z/ =~ m
+        next
+      end
+      undef_method m
+    end
+  end
+  include kernel
+
+  # :stopdoc:
+  def self.const_missing(n)
+    ::Object.const_get(n)
+  end
+  # :startdoc:
+
+  ##
+  # :method: raise
+  # Use #__raise__ if your Delegator does not have a object to delegate the
+  # #raise method call.
+  #
+
+  #
+  # Pass in the _obj_ to delegate method calls to.  All methods supported by
+  # _obj_ will be delegated to.
+  #
+  def initialize(obj)
+    __setobj__(obj)
+  end
+
+  #
+  # Handles the magic of delegation through \_\_getobj\_\_.
+  #
+  def method_missing(m, *args, &block)
+    r = true
+    target = self.__getobj__ {r = false}
+
+    if r && target.respond_to?(m)
+      target.__send__(m, *args, &block)
+    elsif ::Kernel.method_defined?(m) || ::Kernel.private_method_defined?(m)
+      ::Kernel.instance_method(m).bind(self).(*args, &block)
+    else
+      super(m, *args, &block)
+    end
+  end
+
+  #
+  # Checks for a method provided by this the delegate object by forwarding the
+  # call through \_\_getobj\_\_.
+  #
+  def respond_to_missing?(m, include_private)
+    r = true
+    target = self.__getobj__ {r = false}
+    r &&= target.respond_to?(m, include_private)
+    if r && include_private && !target.respond_to?(m, false)
+      warn "delegator does not forward private method \##{m}", uplevel: 3
+      return false
+    end
+    r
+  end
+
+  #
+  # Returns the methods available to this delegate object as the union
+  # of this object's and \_\_getobj\_\_ methods.
+  #
+  def methods(all=true)
+    __getobj__.methods(all) | super
+  end
+
+  #
+  # Returns the methods available to this delegate object as the union
+  # of this object's and \_\_getobj\_\_ public methods.
+  #
+  def public_methods(all=true)
+    __getobj__.public_methods(all) | super
+  end
+
+  #
+  # Returns the methods available to this delegate object as the union
+  # of this object's and \_\_getobj\_\_ protected methods.
+  #
+  def protected_methods(all=true)
+    __getobj__.protected_methods(all) | super
+  end
+
+  # Note: no need to specialize private_methods, since they are not forwarded
+
+  #
+  # Returns true if two objects are considered of equal value.
+  #
+  def ==(obj)
+    return true if obj.equal?(self)
+    self.__getobj__ == obj
+  end
+
+  #
+  # Returns true if two objects are not considered of equal value.
+  #
+  def !=(obj)
+    return false if obj.equal?(self)
+    __getobj__ != obj
+  end
+
+  #
+  # Returns true if two objects are considered of equal value.
+  #
+  def eql?(obj)
+    return true if obj.equal?(self)
+    obj.eql?(__getobj__)
+  end
+
+  #
+  # Delegates ! to the \_\_getobj\_\_
+  #
+  def !
+    !__getobj__
+  end
+
+  #
+  # This method must be overridden by subclasses and should return the object
+  # method calls are being delegated to.
+  #
+  def __getobj__
+    __raise__ ::NotImplementedError, "need to define `__getobj__'"
+  end
+
+  #
+  # This method must be overridden by subclasses and change the object delegate
+  # to _obj_.
+  #
+  def __setobj__(obj)
+    __raise__ ::NotImplementedError, "need to define `__setobj__'"
+  end
+
+  #
+  # Serialization support for the object returned by \_\_getobj\_\_.
+  #
+  def marshal_dump
+    ivars = instance_variables.reject {|var| /\A@delegate_/ =~ var}
+    [
+      :__v2__,
+      ivars, ivars.map {|var| instance_variable_get(var)},
+      __getobj__
+    ]
+  end
+
+  #
+  # Reinitializes delegation from a serialized object.
+  #
+  def marshal_load(data)
+    version, vars, values, obj = data
+    if version == :__v2__
+      vars.each_with_index {|var, i| instance_variable_set(var, values[i])}
+      __setobj__(obj)
+    else
+      __setobj__(data)
+    end
+  end
+
+  def initialize_clone(obj) # :nodoc:
+    self.__setobj__(obj.__getobj__.clone)
+  end
+  def initialize_dup(obj) # :nodoc:
+    self.__setobj__(obj.__getobj__.dup)
+  end
+  private :initialize_clone, :initialize_dup
+
+  ##
+  # :method: trust
+  # Trust both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: untrust
+  # Untrust both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: taint
+  # Taint both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: untaint
+  # Untaint both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: freeze
+  # Freeze both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  [:trust, :untrust, :taint, :untaint, :freeze].each do |method|
+    define_method method do
+      __getobj__.send(method)
+      super()
+    end
+  end
+
+  @delegator_api = self.public_instance_methods
+  def self.public_api # :nodoc:
+    @delegator_api
+  end
+end
+
+##
+# A concrete implementation of Delegator, this class provides the means to
+# delegate all supported method calls to the object passed into the constructor
+# and even to change the object being delegated to at a later time with
+# #__setobj__.
+#
+#   class User
+#     def born_on
+#       Date.new(1989, 9, 10)
+#     end
+#   end
+#
+#   class UserDecorator < SimpleDelegator
+#     def birth_year
+#       born_on.year
+#     end
+#   end
+#
+#   decorated_user = UserDecorator.new(User.new)
+#   decorated_user.birth_year  #=> 1989
+#   decorated_user.__getobj__  #=> #<User: ...>
+#
+# A SimpleDelegator instance can take advantage of the fact that SimpleDelegator
+# is a subclass of +Delegator+ to call <tt>super</tt> to have methods called on
+# the object being delegated to.
+#
+#   class SuperArray < SimpleDelegator
+#     def [](*args)
+#       super + 1
+#     end
+#   end
+#
+#   SuperArray.new([1])[0]  #=> 2
+#
+# Here's a simple example that takes advantage of the fact that
+# SimpleDelegator's delegation object can be changed at any time.
+#
+#   class Stats
+#     def initialize
+#       @source = SimpleDelegator.new([])
+#     end
+#
+#     def stats(records)
+#       @source.__setobj__(records)
+#
+#       "Elements:  #{@source.size}\n" +
+#       " Non-Nil:  #{@source.compact.size}\n" +
+#       "  Unique:  #{@source.uniq.size}\n"
+#     end
+#   end
+#
+#   s = Stats.new
+#   puts s.stats(%w{James Edward Gray II})
+#   puts
+#   puts s.stats([1, 2, 3, nil, 4, 5, 1, 2])
+#
+# Prints:
+#
+#   Elements:  4
+#    Non-Nil:  4
+#     Unique:  4
+#
+#   Elements:  8
+#    Non-Nil:  7
+#     Unique:  6
+#
+class SimpleDelegator < Delegator
+  # Returns the current object method calls are being delegated to.
+  def __getobj__
+    unless defined?(@delegate_sd_obj)
+      return yield if block_given?
+      __raise__ ::ArgumentError, "not delegated"
+    end
+    @delegate_sd_obj
+  end
+
+  #
+  # Changes the delegate object to _obj_.
+  #
+  # It's important to note that this does *not* cause SimpleDelegator's methods
+  # to change.  Because of this, you probably only want to change delegation
+  # to objects of the same type as the original delegate.
+  #
+  # Here's an example of changing the delegation object.
+  #
+  #   names = SimpleDelegator.new(%w{James Edward Gray II})
+  #   puts names[1]    # => Edward
+  #   names.__setobj__(%w{Gavin Sinclair})
+  #   puts names[1]    # => Sinclair
+  #
+  def __setobj__(obj)
+    __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
+    @delegate_sd_obj = obj
+  end
+end
+
+def Delegator.delegating_block(mid) # :nodoc:
+  lambda do |*args, &block|
+    target = self.__getobj__
+    target.__send__(mid, *args, &block)
+  end
+end
+
+#
+# The primary interface to this library.  Use to setup delegation when defining
+# your class.
+#
+#   class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
+#     def initialize
+#       super(obj_of_ClassToDelegateTo)              # Step 2
+#     end
+#   end
+#
+# or:
+#
+#   MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
+#     def initialize
+#       super(obj_of_ClassToDelegateTo)              # Step 2
+#     end
+#   end
+#
+# Here's a sample of use from Tempfile which is really a File object with a
+# few special rules about storage location and when the File should be
+# deleted.  That makes for an almost textbook perfect example of how to use
+# delegation.
+#
+#   class Tempfile < DelegateClass(File)
+#     # constant and class member data initialization...
+#
+#     def initialize(basename, tmpdir=Dir::tmpdir)
+#       # build up file path/name in var tmpname...
+#
+#       @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+#
+#       # ...
+#
+#       super(@tmpfile)
+#
+#       # below this point, all methods of File are supported...
+#     end
+#
+#     # ...
+#   end
+#
+def DelegateClass(superclass, &block)
+  klass = Class.new(Delegator)
+  ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
+  protected_instance_methods = superclass.protected_instance_methods
+  protected_instance_methods -= ignores
+  public_instance_methods = superclass.public_instance_methods
+  public_instance_methods -= ignores
+  klass.module_eval do
+    def __getobj__ # :nodoc:
+      unless defined?(@delegate_dc_obj)
+        return yield if block_given?
+        __raise__ ::ArgumentError, "not delegated"
+      end
+      @delegate_dc_obj
+    end
+    def __setobj__(obj)  # :nodoc:
+      __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @delegate_dc_obj = obj
+    end
+    protected_instance_methods.each do |method|
+      define_method(method, Delegator.delegating_block(method))
+      protected method
+    end
+    public_instance_methods.each do |method|
+      define_method(method, Delegator.delegating_block(method))
+    end
+  end
+  klass.define_singleton_method :public_instance_methods do |all=true|
+    super(all) | superclass.public_instance_methods
+  end
+  klass.define_singleton_method :protected_instance_methods do |all=true|
+    super(all) | superclass.protected_instance_methods
+  end
+  klass.module_eval(&block) if block
+  return klass
+end

data/lib/delegate/version.rb

@@ -0,0 +1,3 @@
+class Delegator
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: delegate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hiroshi SHIBATA
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-06 00:00:00.000000000 Z
+dependencies: []
+description: Provides three abilities to delegate method calls to an object.
+email:
+- hsbt@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- delegate.gemspec
+- lib/delegate.rb
+- lib/delegate/version.rb
+homepage: https://github.com/ruby/delegate
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/ruby/delegate
+  source_code_uri: https://github.com/ruby/delegate
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Provides three abilities to delegate method calls to an object.
+test_files: []