rubysl-delegate 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf8ff4ff2f94d4ba5c50fedd156c62938ad603fa
+  data.tar.gz: e491184acb98306a8c7b52950e78a187b012ab83
+SHA512:
+  metadata.gz: 5f7facd1e4e160e0e333d4419bf58f9dbdbc401cdc2f48a050cc4c9bc2a58f6ac02ff12bfc65a10b51a8a7c65fa230a8b41a8a66feddf24a0b4f433143e2a6ef
+  data.tar.gz: a184e130c057571eb98c38a0949024912447e0de40742ac08abe47e4d53fb564fea2d86956caf39f9177c527ffea1c267588f360a2e662edf794722cab97ad29

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+env:
+  - RUBYLIB=lib
+script: bundle exec mspec
+rvm:
+  - 1.8.7
+  - rbx-nightly-18mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubysl-delegate.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+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.
+3. Neither the name of the library nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 <COPYRIGHT HOLDER> 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,29 @@
+# Rubysl::Delegate
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubysl-delegate'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubysl-delegate
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/delegate.rb

@@ -0,0 +1 @@
+require "rubysl/delegate"

data/lib/rubysl/delegate.rb

@@ -0,0 +1,2 @@
+require "rubysl/delegate/version"
+require "rubysl/delegate/delegate"

data/lib/rubysl/delegate/delegate.rb

@@ -0,0 +1,337 @@
+# = delegate -- Support for the Delegation Pattern
+#
+# Documentation by James Edward Gray II and Gavin Sinclair
+#
+# == Introduction
+#
+# 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_, also in the
+# standard library.  It may suit your needs better.)
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# <b>delegate.rb provides full-class delegation via the
+# DelegateClass() method.  For single-method delegation via
+# def_delegator(), see forwardable.rb.</b>
+#
+# == Examples
+#
+# === SimpleDelegator
+#
+# 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])
+#
+# <i>Prints:</i>
+#
+#   Elements:  4
+#    Non-Nil:  4
+#     Unique:  4
+# 
+#   Elements:  8
+#    Non-Nil:  7
+#     Unique:  6
+#
+# === DelegateClass()
+#
+# Here's a sample of use from <i>tempfile.rb</i>.
+#
+# A _Tempfile_ object is really just a _File_ object with a few special rules
+# about storage location and/or 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
+#
+# === Delegator
+#
+# SimpleDelegator's implementation serves as a nice example here.
+#
+#    class SimpleDelegator < Delegator
+#      def initialize(obj)
+#        super             # pass obj to Delegator constructor, required
+#        @_sd_obj = obj    # store obj for future use
+#      end
+# 
+#      def __getobj__
+#        @_sd_obj          # return object we are delegating to, required
+#      end
+# 
+#      def __setobj__(obj)
+#        @_sd_obj = obj    # change delegation object, a feature we're providing
+#      end
+# 
+#      # ...
+#    end
+
+#
+# Delegator is an abstract class used to build delegator pattern objects from
+# subclasses.  Subclasses should redefine \_\_getobj\_\_.  For a concrete
+# implementation, see SimpleDelegator.
+#
+class Delegator
+  IgnoreBacktracePat = %r"\A#{Regexp.quote(__FILE__)}:\d+:in `"
+
+  #
+  # Pass in the _obj_ to delegate method calls to.  All methods supported by
+  # _obj_ will be delegated to.
+  #
+  def initialize(obj)
+    preserved = ::Kernel.public_instance_methods(false)
+    preserved -= ["to_s","to_a","inspect","==","=~","==="]
+    for t in self.class.ancestors
+      preserved |= t.public_instance_methods(false)
+      preserved |= t.private_instance_methods(false)
+      preserved |= t.protected_instance_methods(false)
+      break if t == Delegator
+    end
+    preserved << "singleton_method_added"
+    for method in obj.methods
+      next if preserved.include? method
+      begin
+	eval <<-EOS, nil, __FILE__, __LINE__+1
+	  def self.#{method}(*args, &block)
+	    begin
+	      __getobj__.__send__(:#{method}, *args, &block)
+	    ensure
+	      $@.delete_if{|s|IgnoreBacktracePat=~s} if $@
+	    end
+	  end
+	EOS
+      rescue SyntaxError
+        raise NameError, "invalid identifier %s" % method, caller(4)
+      end
+    end
+  end
+  alias initialize_methods initialize
+
+  # Handles the magic of delegation through \_\_getobj\_\_.
+  def method_missing(m, *args, &block)
+    target = self.__getobj__
+    unless target.respond_to?(m)
+      super(m, *args, &block)
+    end
+    target.__send__(m, *args, &block)
+  end
+
+  # 
+  # Checks for a method provided by this the delegate object by fowarding the 
+  # call through \_\_getobj\_\_.
+  # 
+  def respond_to?(m, include_private = false)
+    return true if super
+    return self.__getobj__.respond_to?(m, include_private)
+  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
+
+  # Serialization support for the object returned by \_\_getobj\_\_.
+  def marshal_dump
+    __getobj__
+  end
+  # Reinitializes delegation from a serialized object.
+  def marshal_load(obj)
+    initialize_methods(obj)
+    __setobj__(obj)
+  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 SimpleDelegator<Delegator
+
+  # Pass in the _obj_ you would like to delegate method calls to.
+  def initialize(obj)
+    super
+    @_sd_obj = obj
+  end
+
+  # Returns the current object method calls are being delegated to.
+  def __getobj__
+    @_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)
+    @_sd_obj = obj
+  end
+
+  # Clone support for the object returned by \_\_getobj\_\_.
+  def clone
+    new = super
+    new.__setobj__(__getobj__.clone)
+    new
+  end
+  # Duplication support for the object returned by \_\_getobj\_\_.
+  def dup
+    new = super
+    new.__setobj__(__getobj__.clone)
+    new
+  end
+end
+
+# :stopdoc:
+# backward compatibility ^_^;;;
+Delegater = Delegator
+SimpleDelegater = SimpleDelegator
+# :startdoc:
+
+#
+# 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
+#
+def DelegateClass(superclass)
+  klass = Class.new
+  methods = superclass.public_instance_methods(true)
+  methods -= ::Kernel.public_instance_methods(false)
+  methods |= ["to_s","to_a","inspect","==","=~","==="]
+  klass.module_eval {
+    def initialize(obj)  # :nodoc:
+      @_dc_obj = obj
+    end
+    def method_missing(m, *args, &block)  # :nodoc:
+      unless @_dc_obj.respond_to?(m)
+        super(m, *args, &block)
+      end
+      @_dc_obj.__send__(m, *args, &block)
+    end
+    def respond_to?(m, include_private = false)  # :nodoc:
+      return true if super
+      return @_dc_obj.respond_to?(m, include_private)
+    end
+    def __getobj__  # :nodoc:
+      @_dc_obj
+    end
+    def __setobj__(obj)  # :nodoc:
+      raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @_dc_obj = obj
+    end
+    def clone  # :nodoc:
+      new = super
+      new.__setobj__(__getobj__.clone)
+      new
+    end
+    def dup  # :nodoc:
+      new = super
+      new.__setobj__(__getobj__.clone)
+      new
+    end
+  }
+  for method in methods
+    begin
+      klass.module_eval <<-EOS, __FILE__, __LINE__+1
+        def #{method}(*args, &block)
+	  begin
+	    @_dc_obj.__send__(:#{method}, *args, &block)
+	  ensure
+	    $@.delete_if{|s| ::Delegator::IgnoreBacktracePat =~ s} if $@
+	  end
+	end
+      EOS
+    rescue SyntaxError
+      raise NameError, "invalid identifier %s" % method, caller(3)
+    end
+  end
+  return klass
+end
+
+# :enddoc:
+
+if __FILE__ == $0
+  class ExtArray<DelegateClass(Array)
+    def initialize()
+      super([])
+    end
+  end
+
+  ary = ExtArray.new
+  p ary.class
+  ary.push 25
+  p ary
+
+  foo = Object.new
+  def foo.test
+    25
+  end
+  def foo.error
+    raise 'this is OK'
+  end
+  foo2 = SimpleDelegator.new(foo)
+  p foo.test == foo2.test	# => true
+  foo2.error			# raise error!
+end