eager_beaver 0.0.3 → 0.0.4

data/README.md

@@ -5,12 +5,122 @@
 `EagerBeaver` provides an interface for adding `#method_missing`-related abilities
 to a class or module.
 
+## Baseline Implementation
+
+The following is a bare-bones implementation of class which defines `#method_missing`:
+
+```ruby
+class NeedsMethods
+  def method_missing(method_name, *args, &block)
+    if data = NeedsMethods.match_pattern1(method_name)
+      puts "pattern1: #{data[:val]}"
+    elsif data = NeedsMethods.match_pattern2(method_name)
+      puts "pattern2: #{data[:val1]} #{data[:val2]}"
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private=false)
+    NeedsMethods.match_pattern1(method_name) || NeedsMethods.match_pattern2(method_name)
+  end
+
+  def self.match_pattern1(method_name)
+    return {val: $1} if /\Apattern1_(\w+)/ =~ method_name
+  end
+
+  def self.match_pattern2(method_name)
+    return {val1: $1, val2: $2} if /\Apattern2_(\w+)_(\w+)/ =~ method_name
+  end
+end
+
+nm1 = NeedsMethods.new
+puts "#{nm1.methods.grep /pattern/}"
+# => []                                     ## overriding #method_missing doesn't actually add methods
+puts "#{nm1.respond_to? :pattern1_match}"
+# => true                                   ## #respond_to_missing? in action!
+puts "#{nm1.method :pattern1_match}"
+# => #<Method: NeedsMethods#pattern1_match> ## #respond_to_missing? in action!
+nm1.pattern1_match
+# => pattern1: match
+
+nm2 = NeedsMethods.new
+puts "#{nm2.methods.grep /pattern/}"
+# => []                                     ## missing method was NOT added!
+nm2.pattern1_match
+# => pattern1: match
+nm2.pattern2_another_match
+# => pattern2: another match
+puts "#{nm1.methods.grep /pattern/}"
+# => []                                     ## missing methods were NOT added!
+puts "#{nm2.methods.grep /pattern/}"
+# => []                                     ## missing methods were NOT added!
+
+nm.blah
+# => undefined method `blah' for #<NeedsMethods:0x007fb37b086548> (NoMethodError)
+```
+
+## Downsides to the Baseline Implementation
+
+### It's easy to forget something
+
+Changes to `#method_missing` should be accompanied by corresponding changes to `#respond_to_missing?`,
+which allows instances of a class to correcly respond to `#respond_to?` and `#method` calls.  It's
+easy to overlook this detail since it's likely not the primary focus of adding handlers to
+`#method_missing`.
+
+It's also easy to forget the call to `super` when no pattern match is found - in which case all
+unmatched method patterns are silently handled!
+
+### Extension requires changes in multiple places
+
+To add handling of another method pattern, the following changes need to be made:
+- addition of another `elsif` block in `#method_missing`
+- addition of another `||`-ed value in `#respond_to_missing?`
+- addition of another pattern-matching class method
+
+### Large method size and method proliferation
+
+As more and more method patterns are added, `#method_missing` and `#respond_to_missing?` will grow
+endlessly, as will the number of pattern-matching class methods.
+
+### Tight coupling
+
+Pattern-matching class methods and their corresponding `elsif` blocks in `#method_missing` are
+tightly coupled, despite their spatial separation in the code.
+
+The shared code in `#method_missing` and `#respond_to_missing?` means that changes to one pattern
+handler can break another if not done properly.
+
+### Handled methods are not added to the class
+
+Each time a matched method is called, the entire `#method_missing` infrastructure is executed.
+
+### Dynamic updates
+
+The baseline implementation assumes that all method patterns should be handled at all times,
+which is not always the case.  Sometimes the matched patterns are derived from data not
+available to the class until the code is executing.  Correctly redefining (or perpetually
+re-aliasing) `#method_missing` and `#respond_to_missing?` can get tricky fast.
+
+## Correcting the Downsides
+
+Most of the downsides to the baseline implementation can be solved by adding an array
+of `MethodHandler`s to the class.  Each `MethodHandler` has two parts: one which checks
+if the missing method should be handled, and one which does the work.  `#method_missing`
+and `#respond_to_missing?` could then be rewritten to iterate over the `MethodHandler`
+array and act accordingly.
+
+`EagerBeaver` does this (essentially) but goes one step further: it actually adds the
+missing method to the including class and invokes it so that future calls to that
+method won't need to invoke the `#method_missing` infrastructure.
+
 ## Key Features
 
-- Method matchers can be added dynamically and cumulatively, reducing the risk
+- Method matchers can be added dynamically and independently, reducing the risk
   of accidentally altering or removing previously-added functionality.
 - Matched methods are automatically reflected in calls to `#respond_to?` and
-  `#method`, DRY-ing up code by centralizing method-matching logic.
+  `#method`.
 - Matched methods are automatically added to the including class/module and
   invoked.  Subsequent calls won't trigger `#method_missing`.
 - When a method cannot be matched, `super`'s `#method_missing` is automatically
@@ -34,9 +144,8 @@ Or install it yourself as:
 
 ### Inclusion
 
-Any class or module which includes `EagerBeaver` will gain the `add_method_matcher`
-pseudo-keyword, which [indirectly] yields an `EagerBeaver::MethodMatcher` to the
-given block:
+Any class or module which includes `EagerBeaver` will gain the `add_method_handler`
+pseudo-keyword, which [indirectly] yields a `MethodHandler` to the given block:
 
 ```ruby
 require 'eager_beaver'
@@ -44,22 +153,22 @@ require 'eager_beaver'
 class NeedsMethods
   include EagerBeaver
 
-  add_method_matcher do |mm|
+  add_method_handler do |mh|
     ...
   end
 end
 ```
 
-In this case, the resulting `MethodMatcher` is added to the end of a `MethodMatcher` list
+In this case, the resulting `MethodHandler` is added to the end of a `MethodHandler` list
 associated with `NeedsMethods`.
 
-Each `MethodMatcher` needs two things: a lambda for matching missing method names
-and a lambda for creating the code for any method names it matches:
+Each `MethodHandler` needs two things: a lambda for matching missing method names
+and a lambda for handling any method names it matches:
 
 ```ruby
-  add_method_matcher do |mm|
-    mm.match = lambda { ... }
-    mm.new_method_code = lambda { ...}
+  add_method_handler do |mh|
+    mh.match  = lambda { ... }
+    mh.handle = lambda { ... }
   end
 end
 ```
@@ -67,14 +176,12 @@ end
 ### Matching
 
 The `match` lambda should return a true value if the missing method name is one
-can be handled by the `MethodMatcher`.  The following example will match
-missing methods of the form `#make_<attr_name>`:
+can be handled by the `MethodHandler`.  The following example will match
+missing methods of the form `#pattern1_<data>`:
 
 ```ruby
-    mm.match = lambda {
-      /\Amake_(\w+)\z/ =~ context.missing_method_name
-      context.attr_name = Regexp.last_match ? Regexp.last_match[1] : nil
-      return Regexp.last_match
+    mh.match = lambda {
+      context.data = $1 if /\Apattern1_(\w+)/ =~ context.missing_method_name
     }
 ```
 
@@ -84,173 +191,95 @@ As the example shows, each `MethodMatcher` contains a `context` which provides:
 
 - the name of the missing method (`context.missing_method_name`)
 - the original method receiver instance (`context.original_receiver`)
-- a place to stash information (`context.<attr_name>` and `context.<attr_name>=`)
+- a place to stash information (dynamically-generated accessors `context.<attr_name>` and `context.<attr_name>=`)
 
-This `context` is shared between the `match` and `new_method_code` lambdas, and
+This `context` is shared between the `match` and `handle` lambdas, and
 is reset between uses of each `MethodMatcher`.
 
-### Code Generation
+### Handling
 
-The `new_method_code` lambda should return a string which will create the
+The `handle` lambda should return a string which will create the
 missing method in `NeedsMethods`:
 
 ```ruby
-    mm.new_method_code = lambda {
-      code = %Q{
-        def #{context.missing_method_name}(arg)
-          puts "method \##{context.missing_method_name} has been called"
-          puts "\##{context.missing_method_name} was originally called on #{context.original_receiver}"
-          puts "#{context.attr_name} was passed from matching to code generation"
-          puts "the current call has arguments: \#{arg}"
-          return "result = \#{arg}"
-        end
-      }
-      return code
+    mh.handle = lambda {
+      %Q{ def #{context.missing_method_name}
+            puts "pattern1: #{context.data}"
+          end }
     }
 ```
 
 As the example shows, it is perfectly reasonable to take advantage of work done
-by the `match` lambda (in this case, the parsing of `<attr_name>`).
+by the `match` lambda (in this case, the parsing of `<data>`).
 
 After the generated code is inserted into `NeedsMethods`, the missing method 
 call is resent to the original receiver.
 
 ### Complete Example
 
+The following is the baseline implementation above using `EagerBeaver`:
+
 ```ruby
 require 'eager_beaver'
 
 class NeedsMethods
   include EagerBeaver
 
-  add_method_matcher do |mm|
-    mm.match = lambda {
-      /\Amake_(\w+)\z/ =~ context.missing_method_name
-      context.attr_name = Regexp.last_match ? Regexp.last_match[1] : nil
-      return Regexp.last_match
+  add_method_handler do |mh|
+    mh.match = lambda {
+      context.data = $1 if /\Apattern1_(\w+)/ =~ context.missing_method_name
     }
+    mh.handle = lambda {
+      %Q{ def #{context.missing_method_name}
+            puts "pattern1: #{context.data}"
+          end }
+    }
+  end
 
-    mm.new_method_code = lambda {
-      code = %Q{
-        def #{context.missing_method_name}(arg)
-          puts "method \##{context.missing_method_name} has been called"
-          puts "\##{context.missing_method_name} was originally called on #{context.original_receiver}"
-          puts "#{context.attr_name} was passed from matching to code generation"
-          puts "the current call has arguments: \#{arg}"
-          return "result = \#{arg}"
-        end
-      }
-      return code
+  add_method_handler do |mh|
+    mh.match = lambda {
+      context.data = {val1: $1, val2: $2} if /\Apattern2_(\w+)_(\w+)/ =~ context.missing_method_name
+    }
+    mh.handle = lambda {
+      %Q{ def #{context.missing_method_name}
+            puts "pattern2: #{context.data[:val1]} #{context.data[:val2]}"
+          end }
     }
   end
 end
-```
-
-## Execution
-
-Given the `NeedsMethods` class in the example above, let's work through the
-following code:
 
-```ruby
 nm1 = NeedsMethods.new
-puts nm1.make_thingy(10)
-puts nm1.make_widget("hi")
-
-nm2 = NeedsMethods.new
-puts nm2.make_thingy(20)
-puts nm2.make_widget("hello")
-
-nm2.dont_make_this
-```
-
-As instances of `NeedsMethods`, `nm1` and `nm2` will automatically hande
-methods of the form `#make_<attr_name>`.
-
-The line:
-```ruby
-puts nm1.make_thingy(10)
-```
-will trigger `nm1`'s `#method_missing`, which `NeedsMethods` implements thanks to
-`EagerBeaver`.  Each `MethodMatcher` associated with `EagerBeaver` is run against
-the method name `make_thingy`, and sure enough one matches.  This causes the
-following methods to be inserted to `NeedsMethods`:
-```ruby
-  def make_thingy(arg)
-    puts "method #make_thingy has been called"
-    puts "#make_thingy was originally called on #<NeedsMethods:0x007fa1bc17f498>"
-    puts "thingy was passed from matching to code generation"
-    puts "the current call has arguments: #{arg}"
-    return "result = #{arg}"
-  end
-```
-and when `#make_thingy` is resent to `nm1`, the existing method is called and 
-outputs:
 
-> method \#make_thingy has been called<br/>
-> \#make_thingy was originally called on \#\<NeedsMethods:0x007fa1bc17f498\><br/>
-> thingy was passed from matching to code generation<br/>
-> the current call has arguments: 10<br/>
-> result = 10
+puts "#{nm1.methods.grep /pattern/}"
+# => []                                     ## overriding #method_missing doesn't actually add methods
+puts "#{nm1.respond_to? :pattern1_match}"
+# => true                                   ## #respond_to_missing? in action!
+puts "#{nm1.method :pattern1_match}"
+# => #<Method: NeedsMethods#pattern1_match> ## #respond_to_missing? in action!
+nm1.pattern1_match
+# => pattern1: match
 
-Similarly, the line:
-```ruby
-puts nm1.make_widget("hi")
-```
-generates the code:
-```ruby
-  def make_widget(arg)
-    puts "method #make_widget has been called"
-    puts "#make_widget was originally called on #<NeedsMethods:0x007fa1bc17f498>"
-    puts "widget was passed from matching to code generation"
-    puts "the current call has arguments: #{arg}"
-    return "result = #{arg}"
-  end
-```
-and outputs:
-> method \#make_widget has been called<br/>
-> \#make_widget was originally called on \#\<NeedsMethods:0x007fa1bc17f498\><br/>
-> widget was passed from matching to code generation<br/>
-> the current call has arguments: hi<br/>
-> result = hi
-
-Note that the following lines do NOT trigger `#method_missing` because both methods
-have already been added to `NeedsMethods`:
-```ruby
-puts nm2.make_thingy(20)
-puts nm2.make_widget("hello")
-```
-This can be seen by examining the identity of the original receiver in the output:
-
-> **method \#make_thingy has been called**<br/>
-> **\#make_thingy was originally called on \#\<NeedsMethods:0x007fa1bc17f498\>**<br/>
-> **thingy was passed from matching to code generation**<br/>
-> the current call has arguments: 20<br/>
-> result = 20
-
-> **method \#make_widget has been called**<br/>
-> **\#make_widget was originally called on \#\<NeedsMethods:0x007fa1bc17f498\>**<br/>
-> **widget was passed from matching to code generation**<br/>
-> the current call has arguments: hello<br/>
-> result = hello
-
-String substitutions which were part of the generated code body (emphasized)
-reflect the circumstances of the first set of method calls, as opposed to 
-those which reflect the current call's argument.
+nm2 = NeedsMethods.new
 
-Finally, the call:
+puts "#{nm2.methods.grep /pattern/}"
+# => [:pattern1_match]                      ## missing method added to NeedsMethods!
+nm2.pattern1_match
+# => pattern1: match                        ## no call to #method_missing
+nm2.pattern2_another_match
+# => pattern2: another match
+puts "#{nm1.methods.grep /pattern/}"
+# => [:pattern1_match, :pattern2_another_match]
+puts "#{nm2.methods.grep /pattern/}"
+# => [:pattern1_match, :pattern2_another_match]
+
+nm2.blah
+# => undefined method `blah' for #<NeedsMethods:0x007fefac1a8080> (NoMethodError)
 ```
-nm2.dont_make_this
-```
-will cause `NeedsMethods` to examine all of its `MethodMatcher`s and finally call
-`super`'s `#method_missing`.  Because no superclass of `NeedsMethods` handles
-`#dont_make_this`, the output is:
-
-> undefined method `dont_make_this' for \#\<NeedsMethods:0x007f8e2b991f90\> (NoMethodError)
 
 ## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
+3. Comhit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request

data/lib/eager_beaver.rb

@@ -1,5 +1,5 @@
 require "eager_beaver/version"
-require "eager_beaver/method_matcher"
+require "eager_beaver/method_handler"
 
 module EagerBeaver
 
@@ -8,10 +8,10 @@ module EagerBeaver
   end
 
   def method_missing(method_name, *args, &block)
-    self.class.method_matchers.each do |method_matcher|
-      mm = configure_matcher method_matcher
-      if mm.match?(method_name)
-        method_string = mm.evaluate mm.new_method_code_maker
+    self.class.method_handlers.each do |method_handler|
+      mh = configure_handler method_handler
+      if mh.handles?(method_name)
+        method_string = mh.evaluate mh.handle
         self.class.class_eval method_string, __FILE__, __LINE__ + 1
         return self.send(method_name, *args, &block)
       end
@@ -20,26 +20,26 @@ module EagerBeaver
   end
 
   def respond_to_missing?(method_name, include_private=false)
-    self.class.method_matchers.each do |method_matcher|
-      mm = configure_matcher method_matcher
-      return true if mm.match?(method_name)
+    self.class.method_handlers.each do |method_handler|
+      mh = configure_handler method_handler
+      return true if mh.handles?(method_name)
     end
     super
   end
 
-  def configure_matcher(matcher)
-    mm = matcher.dup
-    mm.original_receiver = self
-    mm.original_receiver.class.context = mm
+  def configure_handler(handler)
+    mh = handler.dup
+    mh.original_receiver = self
+    mh.original_receiver.class.context = mh
   end
 
   module ClassMethods
-    def method_matchers
-      @method_matchers ||= []
+    def method_handlers
+      @method_handlers ||= []
     end
 
-    def add_method_matcher(&block)
-      method_matchers << MethodMatcher.new(&block)
+    def add_method_handler(&block)
+      method_handlers << MethodHandler.new(&block)
     end
 
     attr_accessor :context

data/lib/eager_beaver/method_handler.rb

@@ -0,0 +1,52 @@
+module EagerBeaver
+
+  class MethodHandler
+
+    attr_accessor :original_receiver
+    attr_accessor :missing_method_name
+    attr_accessor :match
+    attr_accessor :handle
+
+    def initialize(&block)
+      block.call(self)
+
+      raise "match must be given" \
+        if match.nil?
+      raise "match must be a lambda" \
+        unless match.lambda?
+
+      raise "handle must be given" \
+        if handle.nil?
+      raise "handle must be a lambda" \
+        unless handle.lambda?
+
+      self
+    end
+
+    def handles?(method_name)
+      self.missing_method_name = method_name.to_s
+      return evaluate(match)
+    end
+
+    def evaluate(inner)
+      outer = lambda { |*args|
+        args.shift
+        inner.call(*args)
+      }
+      self.instance_eval &outer
+    end
+
+    def method_missing(method_name, *args, &block)
+      if /\A(?<attr_name>[a-zA-Z]\w*)=?\z/ =~ method_name
+        code = %Q{
+          attr_accessor :#{attr_name}
+        }
+        self.singleton_class.instance_eval code, __FILE__, __LINE__ + 1
+        return self.send(method_name, *args, &block)
+      end
+      super
+    end
+
+  end
+
+end

data/lib/eager_beaver/version.rb

@@ -1,3 +1,3 @@
 module EagerBeaver
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/eager_beaver/context_spec.rb

@@ -7,13 +7,13 @@ describe "EagerBeaver matcher context" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda {
             raise context.missing_method_name \
               unless context.missing_method_name == "aaa"
             /\Aaaa\z/ =~ context.missing_method_name 
           }
-          mm.new_method_code = lambda {
+          mh.handle = lambda {
             raise context.missing_method_name \
               unless context.missing_method_name == "aaa"
             %Q{
@@ -32,11 +32,11 @@ describe "EagerBeaver matcher context" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda {
             /\Aaaa\z/ =~ context.missing_method_name
           }
-          mm.new_method_code = lambda {
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
                 #{context.original_receiver.__id__}
@@ -56,12 +56,12 @@ describe "EagerBeaver matcher context" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda {
             context.my_data = "hello"
             /\Aaaa\z/ =~ context.missing_method_name
           }
-          mm.new_method_code = lambda {
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
                 "#{context.my_data}"

data/spec/eager_beaver/includer_spec.rb

@@ -10,25 +10,25 @@ describe "EagerBeaver includer" do
       end
     end
 
-    it "has #add_method_matcher" do
-      expect(@klass.methods).to include :add_method_matcher
+    it "has #add_method_handler" do
+      expect(@klass.methods).to include :add_method_handler
     end
 
-    it "has #method_matchers" do
-      expect(@klass.methods).to include :method_matchers
+    it "has #method_handlers" do
+      expect(@klass.methods).to include :method_handlers
     end
 
   end
 
-  describe "#add_method_matcher" do
+  describe "#add_method_handler" do
 
     it "registers a new method matcher" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { true }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match  = lambda { true }
+          mh.handle = lambda {
             return %Q{
               def #{context.missing_method_name}
               end
@@ -37,7 +37,7 @@ describe "EagerBeaver includer" do
         end
       end
 
-      klass.method_matchers.size.should == 1
+      klass.method_handlers.size.should == 1
     end
 
   end

data/spec/eager_beaver/instance_spec.rb

@@ -22,9 +22,9 @@ describe "instance of EagerBeaver includer" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { /\Aaaa_\w+\z/ =~ context.missing_method_name }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda { /\Aaaa_\w+\z/ =~ context.missing_method_name }
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
               end
@@ -53,9 +53,9 @@ describe "instance of EagerBeaver includer" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { /\Aaaa_\w+\z/ =~ context.missing_method_name }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda { /\Aaaa_\w+\z/ =~ context.missing_method_name }
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
               end
@@ -83,9 +83,9 @@ describe "instance of EagerBeaver includer" do
       klass = Class.new do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { /\Aaaa\z/ =~ context.missing_method_name }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda { /\Aaaa\z/ =~ context.missing_method_name }
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
                 1
@@ -94,9 +94,9 @@ describe "instance of EagerBeaver includer" do
           }
         end
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { /\Abbb\z/ =~ context.missing_method_name }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda { /\Abbb\z/ =~ context.missing_method_name }
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
                 2
@@ -105,9 +105,9 @@ describe "instance of EagerBeaver includer" do
           }
         end
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { /\Abbb\z/ =~ context.missing_method_name }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda { /\Abbb\z/ =~ context.missing_method_name }
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
                 3
@@ -130,9 +130,9 @@ describe "instance of EagerBeaver includer" do
       klass2 = Class.new(klass1) do
         include EagerBeaver
 
-        add_method_matcher do |mm|
-          mm.matcher = lambda { /\Aaaa\z/ =~ context.missing_method_name }
-          mm.new_method_code = lambda {
+        add_method_handler do |mh|
+          mh.match = lambda { /\Aaaa\z/ =~ context.missing_method_name }
+          mh.handle = lambda {
             %Q{
               def #{context.missing_method_name}
                 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eager_beaver
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -43,7 +43,7 @@ files:
 - Rakefile
 - eager_beaver.gemspec
 - lib/eager_beaver.rb
-- lib/eager_beaver/method_matcher.rb
+- lib/eager_beaver/method_handler.rb
 - lib/eager_beaver/version.rb
 - spec/eager_beaver/context_spec.rb
 - spec/eager_beaver/includer_spec.rb

data/lib/eager_beaver/method_matcher.rb

@@ -1,60 +0,0 @@
-module EagerBeaver
-
-  class MethodMatcher
-
-    attr_accessor :original_receiver
-    attr_accessor :matcher
-    attr_accessor :new_method_code_maker
-    attr_accessor :missing_method_name
-
-    def initialize(&block)
-      block.call(self)
-
-      raise "matcher must be given" \
-        if matcher.nil?
-      raise "matcher lmust be a lambda" \
-        unless matcher.lambda?
-
-      raise "new_method_code_maker must be given" \
-        if new_method_code_maker.nil?
-      raise "new_method_code_maker must be a lambda" \
-        unless new_method_code_maker.lambda?
-
-      self
-    end
-
-    def match=(lambda_proc)
-      self.matcher = lambda_proc
-    end
-
-    def match?(method_name)
-      self.missing_method_name = method_name.to_s
-      return evaluate(matcher)
-    end
-
-    def new_method_code=(lambda_proc)
-      self.new_method_code_maker = lambda_proc
-    end
-
-    def evaluate(inner)
-      outer = lambda { |*args|
-        args.shift
-        inner.call(*args)
-      }
-      self.instance_eval &outer
-    end
-
-    def method_missing(method_name, *args, &block)
-      if /\A(?<attr_name>\w+)=?\z/ =~ method_name
-        code = %Q{
-          attr_accessor :#{attr_name}
-        }
-        self.singleton_class.instance_eval code, __FILE__, __LINE__ + 1
-        return self.send(method_name, *args, &block)
-      end
-      super
-    end
-
-  end
-
-end