overider 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in overider.gemspec
+gemspec

data/README.mkd

@@ -0,0 +1,50 @@
+# Overider
+
+## Background
+Despite Ruby's clean design and flexibility, the language has no native feature
+that allows one to over-ride a method without irrevocably losing the original binding
+of the method name.
+`alias` is a well-worn idiom that circumvents this limitation,
+but blogger Jay Fields wrote an [interesting post](http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html)
+that reminds us that `alias` comes with some less-than-desireable side-effects
+that may not be significant in small scripts and projects 
+but may become a problem for larger projects.
+
+In the [same post](http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html),
+Jay offered an interesting alternative to `alias`,
+using instead `Module#instance_method` and `Module#define_method`.
+This is much better,
+but I'm not a Ruby ninja yet,
+and I would rather not have to remember the Baroque syntax in `x = self.instance_method(:on!)`
+and `x.bind(self).call` every time I want to do this,
+let alone what they mean when I look at my code several weeks later.
+
+So I thought about how I could take Jay's example one step further 
+and after some trial and lots of error came up with this.
+
+## Description
+A mix-in module that allows for super-clean method over-riding without resorting to `alias` 
+or making unbound methods visible.
+
+## Synopsis
+    class A
+      def hello
+        "hello"
+      end
+    end
+
+    # Later, I want to overide class A methods
+
+    class A
+      extend Overider
+
+      overide (:hello) do |*a|
+        overiden(*a) + " overide"
+      end
+    end
+
+    puts A.new.hello # ==> "hello overide"
+
+## See also
+  * [Ruby: Alias method alternative, Jay Fields](http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html)
+  * <https://github.com/soveran/override>

data/Rakefile

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

data/lib/overider.rb

@@ -0,0 +1,28 @@
+require "overider/version"
+
+module Overider
+  def overide(sym, &pr)
+    orig_unbound_method = self.instance_method(sym)
+
+    define_method(sym) do |*a, &blk|
+      orig_self = self
+      obj = Object.new
+
+      obj.define_singleton_method(:overiden) do |*a, &blk|
+        orig_bound_method = orig_unbound_method.bind(orig_self)
+
+        if !!blk then
+          orig_bound_method.call *a, &blk
+        else
+          orig_bound_method.call *a
+        end
+      end
+
+      if !!blk then
+        obj.instance_exec(*a, blk, &pr)
+      else
+        obj.instance_exec(*a, &pr)
+      end
+    end
+  end
+end

data/lib/overider/version.rb

@@ -0,0 +1,3 @@
+module Overider
+  VERSION = "0.0.1"
+end

data/overider.gemspec

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "overider/version"
+
+Gem::Specification.new do |s|
+  s.name        = "overider"
+  s.version     = Overider::VERSION
+  s.authors     = ["Larry Siden, Westside Consulting LLC"]
+  s.email       = ["lsiden@westside-consulting.com"]
+  s.homepage    = "https://github.com/lsiden/overider"
+  s.summary     = %q{
+A mix-in module that allows for super-clean method over-riding without resorting to =alias= 
+or making unbound methods visible.
+  }
+  s.description = %q{
+    class A
+      def hello
+        "hello"
+      end
+    end
+
+    # Later, I want to overide class A methods
+
+    class A
+      extend Overider
+
+      overide (:hello) do |*a|
+        overiden(*a) + " overide"
+      end
+    end
+
+    A.new.hello # ==> "hello overide"
+  }
+
+  s.rubyforge_project = "overider"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/overider_spec.rb

@@ -0,0 +1,156 @@
+require 'rspec'
+require 'overider'
+
+describe Overider do
+  it 'over-rides method names while allowing access to original method with name "overiden"' do
+
+    class A
+      def hello
+        "hello"
+      end
+    end
+
+    # Later, I want to overide class A methods
+
+    class A
+      extend Overider
+
+      overide (:hello) do |*a|
+        overiden(*a) + " overide"
+      end
+    end
+
+    a = A.new
+    a.hello.should == "hello overide"
+  end
+
+  it 'the name "overiden" is not overiden!' do
+
+    class A
+      def hello
+        "hello"
+      end
+
+      def goodby
+        "goodby"
+      end
+    end
+
+    # Later, I want to overide class A methods
+
+    class A
+      extend Overider
+
+      overide (:hello) do |*a|
+        overiden(*a) + " overide"
+      end
+
+      overide (:goodby) do |*a|
+        overiden(*a) + " overide"
+      end
+    end
+
+    a = A.new
+    a.hello.should == "hello overide"
+    a.goodby.should == "goodby overide"
+    a.hello.should == "hello overide" # "overiden" overiden!
+  end
+
+  it 'works with inheritance' do
+
+    class B < A
+      extend Overider
+
+      overide :hello do |*a|
+        overiden(*a) + " B then A"
+      end
+    end
+
+    B.new.hello.should == "hello overide B then A"
+  end
+
+  it 'works with modules' do
+    module HelloModule
+      def hello
+        "hello"
+      end
+    end
+
+    class C
+      include HelloModule
+      extend Overider
+
+      overide :hello do |*a|
+        overiden(*a) + " C"
+      end
+    end
+
+    C.new.hello.should == "hello C"
+  end
+
+  it 'works with args' do
+    module HelloWithArgs
+      def hello(a, b, c)
+        "hello #{a}, #{b}, #{c}"
+      end
+    end
+
+    class D
+      include HelloWithArgs
+      extend Overider
+
+      overide :hello do |a, b, c|
+        overiden(a, b, c) + " D"
+      end
+    end
+
+    result = D.new.hello 1, 2, 3
+    result.should == "hello 1, 2, 3 D"
+  end
+
+  it 'plays nice with blocks' do
+    module HelloModule
+      def hello(&blk)
+        "hello " + blk.call
+      end
+    end
+
+    class E
+      include HelloModule
+      extend Overider
+
+      # In the overide block, we have to declare blk as a normal block arg, not &blk.
+      # It must be a Proc or lambda
+      overide :hello do |blk|
+        overiden { blk.call } + " in E"
+      end
+    end
+
+    result = E.new.hello do
+      "block" 
+    end
+    result.should == "hello block in E"
+  end
+
+  it 'plays nice with lambda' do
+    module HelloModule
+      def hello(&blk)
+        "hello " + blk.call
+      end
+    end
+
+    class F
+      include HelloModule
+      extend Overider
+
+      # In the overide block, we have to declare blk as a normal block arg, not &blk.
+      # It must be a Proc or lambda
+      overide :hello do |blk|
+        overiden { blk.call } + " in F"
+      end
+    end
+
+    result = F.new.hello ->{ "block" }
+    result.should == "hello block in F"
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: overider
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Larry Siden, Westside Consulting LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-23 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &76593190 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *76593190
+description: ! "\n    class A\n      def hello\n        \"hello\"\n      end\n    end\n\n
+  \   # Later, I want to overide class A methods\n\n    class A\n      extend Overider\n\n
+  \     overide (:hello) do |*a|\n        overiden(*a) + \" overide\"\n      end\n
+  \   end\n\n    A.new.hello # ==> \"hello overide\"\n  "
+email:
+- lsiden@westside-consulting.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.mkd
+- Rakefile
+- lib/overider.rb
+- lib/overider/version.rb
+- overider.gemspec
+- spec/overider_spec.rb
+homepage: https://github.com/lsiden/overider
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: overider
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A mix-in module that allows for super-clean method over-riding without resorting
+  to =alias=  or making unbound methods visible.
+test_files: []