meta_programming 0.0.8 → 0.2.0

data/README.rdoc

@@ -16,6 +16,11 @@ Concepts/Terminology
 
 * Metaprogramming_Ruby[http://pragprog.com/titles/ppmetr/metaprogramming-ruby]
 
+Example Code
+
+* why_not[http://github.com/jeffp/why_not/blob/master/lib/why_not.rb]
+* easy_nils[http://github.com/jeffp/easy_nils/blob/master/lib/easy_nils.rb]
+
 == Beta Status
 
 I consider this Gem in personal beta and suspect it will be in this state for
@@ -26,6 +31,21 @@ I welcome comments and collaborators who
 would like to develop a library for simplifying common patterns and limit
 the pitfalls of Ruby meta-programming.
 
+== Changelog
+
+* 0.2.0
+
+Removes object parameter from method blocks and lambda matchers in define_ghost_method, and
+adds more descriptive error handling.  define_ghost_method block and matchers are now
+evaluated in the context of the object instance.
+
+I've bumped the version to 0.2.0 because this changes the interface.
+
+* 0.0.8
+
+initial implementation
+
+
 == Issues
 
 === 1.9 vs 1.8
@@ -54,7 +74,6 @@ Current Methods
 * blank_slate
 
 
-
 == Usage
 
 === define_ghost_method
@@ -62,20 +81,21 @@ Current Methods
 +define_ghost_method+ creates a 'ghost' method for an undefined method that corresponds
 to the 'matcher' parameter.
 
-  define_ghost_method(matcher) do |object, method_name_symbol, *args|
+  define_ghost_method(matcher) do |method_name_symbol, *args|
     ...method body...
   end
 
 A block must be present and it takes (optionally) the receiving object, the method name (as
-a symbol with exception of a lambda matcher) and the method arguments.
+a symbol with exception of a lambda matcher) and the method arguments.  As of 0.2.0, the
+block and lambda matcher is evaluated in the context of the object.
 
 The matcher may be any of a symbol, string, regular expression or Proc/lambda.
 
 ==== String, symbols and regular expression matchers
 
-  define_ghost_method('my_method) {|obj, sym, *args| ... }
-  define_ghost_method(':my_method) {|obj, sym, *args| ... }
-  define_ghost_method(/^my_method$/) {|obj, sym, *args| ... }
+  define_ghost_method('my_method) {|sym, *args| ... }
+  define_ghost_method(':my_method) {|sym, *args| ... }
+  define_ghost_method(/^my_method$/) {|sym, *args| ... }
 
 String and symbol matchers will only process the method if its name matches the string
 or symbol exactly.  Regular expressions provide greater flexibility and care must be
@@ -87,27 +107,28 @@ method block.  This is not the case with lambda matchers.
 
 ==== Proc/lambda matchers
 
-Lambda matchers provide an opportunity to greatly scrutinize the method call based on the
-parameters passed to the method block (object, method_name, *args).  The method is
+Lambda matchers provide an opportunity to greatly scrutinize the method call.  The method is
 invoked for any lambda not evaluating to nil or false.
 
-  proc = lambda{|object, method_name, *args| ...matching code... }
-  define_ghost_method(proc) {|obj, proc_result, *args| ... }
+  proc = lambda{|method_name, *args| ...matching code... }
+  define_ghost_method(proc) {|proc_result, *args| ... }
 
 Proc and lambda matchers differ from the other matcher in that the second parameter passes
 the result of the Proc/lambda matcher to the method block.  This feature lets the matcher
 pre-process the name of the method passed to the body.
 
-  proc = lambda{|obj, sym, *args| sym =~ /^not_(.+\?)$/ && $1.to_sym }
+  proc = lambda{|sym, *args| sym =~ /^not_(.+\?)$/ && self.class.method_defined?($1.to_sym) && $1.to_sym }
+
+The lambda matcher is evaluated in the context of the object and can
+call methods of the object as in the above example.  The lambda matcher is also called
+in the respond_to? method, so it is a good idea to avoid usind respond_to? in the lambda
+matcher to avoid a stack overflow error.  Instead call method_defined? on the class object.
 
 The extra flexibility comes at greater responsibility.  If you only want to pass the
 method name symbol to the method block, don't forget to return it from the lambda.
 
-  proc = lambda{|obj, sym, *args| sym =~ /^not_.+\?$/ && sym }
+  proc = lambda{|sym, *args| sym =~ /^not_.+\?$/ && sym }
 
-Additionally, the 'return' keyword has different effects between Procs and lambdas.
-I suggest not explicitly using the 'return' keyword in your method blocks.  It's a Ruby thing.
-define_ghost_method will remind you if a LocalJumpError is raised.
 
 ==== Critique
 

data/lib/meta_programming/class.rb

@@ -7,9 +7,10 @@ module MetaProgramming
     def blank_slate(opts={})
       opts[:except] = opts[:except] ? (opts[:except].is_a?(Array) ? opts[:except] : [opts[:except]]) : []
       exceptions =  opts[:except].map(&:to_s)
-      exceptions += ['method_missing', 'respond_to?'] unless opts[:all]
       matchers = exceptions.map{|ex| "^#{ex.gsub(/\?/, '\?')}$" }
+      matchers += ['^method_missing', '^respond_to'] unless opts[:all]
       matchers << '^__'
+      matchers << '^object_id$'
       regexp = Regexp.new(matchers.join('|'))
       instance_methods.each do |m|
         undef_method m unless regexp.match(m.to_s)

data/lib/meta_programming/object.rb

@@ -74,32 +74,50 @@ module MetaProgramming
       def define_ghost_method(matcher, &block)
         raise "Must have a block" unless block_given?
         raise ArgumentError, "Matcher argument must be either a 'string', :symbol, /regexp/ or proc" unless (matcher.nil? || [String, Symbol, Regexp, Proc].any?{|c| matcher.is_a?(c)})
-        ext = matcher.hash.abs.to_s
+        ext = "#{self.name.gsub(/^.+>::/,'')}_#{matcher.class.name.gsub(/^.+>::/,'')}#{matcher.hash.abs.to_s}"
+        _ghost_method_handler = "_ghost_method_handler_#{ext}".to_sym
+        _ghost_method_matcher = "_ghost_method_matcher_#{ext}".to_sym
+        define_method(_ghost_method_handler, block)
+        private _ghost_method_handler
+        if matcher.is_a?(Proc)
+          define_method(_ghost_method_matcher, matcher)
+          private _ghost_method_matcher
+        end
         define_chained_method(:method_missing, ext.to_sym) do |symbol, *args|
-          begin
-            handled = nil
-            result = case matcher
-            when Regexp
-              yield(self, symbol, *args) if (handled = (symbol.to_s =~ matcher))
-            when String, Symbol
-              yield(self, symbol, *args) if (handled = (symbol == matcher.to_sym))
-            when Proc
-              handled = matcher.call(self, symbol)
-              yield(self, handled == true ? symbol : handled, *args) if handled
+          handled = case matcher
+          when Regexp then !(symbol.to_s =~ matcher).nil?
+          when String, Symbol then (symbol == matcher.to_sym)
+          when Proc
+            begin
+              __send__(_ghost_method_matcher, symbol)
+            rescue Exception => matcher_error
+              raise matcher_error, "#{matcher_error.message} in a ghost method matcher called for symbol :#{symbol}. Be sure to use self.class.method_defined? instead of respond_to? in a lambda matcher."
+            end
+          else nil
+          end
+          if handled
+            begin
+              __send__(_ghost_method_handler, (handled == true ? symbol : handled), *args)
+            rescue Exception => handler_error
+              raise handler_error, "#{handler_error.message} in a ghost method block called with symbol :#{symbol}."
             end
-            handled ? result : __send__("method_missing_without_#{ext}".to_sym, symbol, *args)
-          rescue LocalJumpError
-            raise LocalJumpError, "Remove the 'return' keyword in your method block."
+          else
+            __send__("method_missing_without_#{ext}".to_sym, symbol, *args)
           end
         end
         #cripple respond_to? in deference of 1.8 -- the include_private no longer works
         define_chained_method(:respond_to?, ext.to_sym) do |method_name| #1.9 only, include_private=nil|
           responds = case matcher
-          when Regexp then method_name.to_s =~ matcher
+          when Regexp then !(method_name.to_s =~ matcher).nil?
           when String, Symbol then method_name == matcher.to_sym
-          when Proc then matcher.call(self, method_name)
+          when Proc
+            begin
+              __send__(_ghost_method_matcher, method_name)
+            rescue Exception => matcher_error
+              raise matcher_error, "#{matcher_error.message} in a ghost method matcher called in respond_to? for symbol :#{method_name}. Be sure to use self.class.method_defined? instead of respond_to? in a lambda matcher."
+            end
           end
-          responds || __send__("respond_to_without_#{ext}?", method_name) #1.9 only, include_private)
+          responds || __send__("respond_to_without_#{ext}?".to_sym, method_name) #1.9 only, include_private)
         end
       end
     end

data/spec/blank_slate_spec.rb

@@ -6,7 +6,8 @@ describe "blank_slate" do
     all_methods = [:public_methods, :protected_methods, :private_methods].map do |method|
       instance.send(method)
     end.flatten.map(&:to_sym).uniq
-    allowed_methods = all_methods.select{|method| method.to_s =~ /^__/} + (exceptions.is_a?(Array) ? exceptions : [exceptions]).map(&:to_sym)
+    matchers = (['^__', '^object_id$'] + (exceptions.is_a?(Array) ? exceptions : [exceptions])).join('|')
+    allowed_methods = all_methods.select{|method| method.to_s =~ Regexp.new(matchers)}.map(&:to_sym)
     all_methods - allowed_methods
   end
   
@@ -14,7 +15,7 @@ describe "blank_slate" do
     class BlankSlate1
       blank_slate
     end
-    test_methods = collect_test_methods(Object.new, [:method_missing, :respond_to?])
+    test_methods = collect_test_methods(Object.new, ['^method_missing', '^respond_to'])
 
     bs = BlankSlate1.new
     test_methods.each do |method|
@@ -39,7 +40,7 @@ describe "blank_slate" do
     class BlankSlate3
       blank_slate :except=>[:methods]
     end
-    test_methods = collect_test_methods(Object.new, [:methods, :method_missing, :respond_to?])
+    test_methods = collect_test_methods(Object.new, ['^methods$', '^method_missing', '^respond_to'])
 
     bs=BlankSlate3.new
     test_methods.each do |method|
@@ -51,3 +52,4 @@ describe "blank_slate" do
 end
 
 
+  

data/spec/ghost_methods_spec.rb

@@ -37,7 +37,7 @@ describe "MetaProgramming" do
     it "should scream if matcher is not string, symbol or regular expression" do
       lambda {
         class GHA2
-          define_ghost_method(1) { puts 1}
+          define_ghost_method(1) {|sym| puts 1}
         end
       }.should raise_exception(ArgumentError)
     end
@@ -50,28 +50,22 @@ describe "MetaProgramming" do
     end
     it "should define a ghost method using a symbol" do
       class GHA1
-        define_ghost_method(:catch_this_one) { 'catch_this_one' }
+        define_ghost_method(:catch_this_one) {|sym| 'catch_this_one' }
       end
       lambda { GHA1.new.not_this_one }.should raise_exception(NoMethodError)
       lambda { GHA1.new.catch_this_one.should == 'catch_this_one' }.should_not raise_exception
       lambda { GHA1.new.catch_this_one_too }.should raise_exception(NoMethodError)
     end
-    it "should warn about using 'return' keyword in method block" do
-      class GHA4
-        define_ghost_method(:catch_this_one) { return 'catch_this_one'}
-      end
-      lambda { GHA4.new.catch_this_one }.should raise_exception(LocalJumpError, /'return' keyword/)
-    end
     it "should define a ghost method using a string" do
       class GHA5
-        define_ghost_method('catch_another') { 'catch_another_one'}
+        define_ghost_method('catch_another') {|sym| 'catch_another_one'}
       end
       lambda { GHA5.new.catch_another.should == 'catch_another_one'}.should_not raise_exception
       lambda { GHA5.new.catch_another_one }.should raise_exception(NoMethodError)
     end
     it "should define a ghost method using a regular expression" do
       class GHA6
-        define_ghost_method(/catch/) do |object, symbol|
+        define_ghost_method(/catch/) do |symbol|
           symbol
         end
       end
@@ -81,7 +75,7 @@ describe "MetaProgramming" do
     end
     it "should pass arguments to the block" do
       class GHA7
-        define_ghost_method(/ghost/) do |object, symbol, *args|
+        define_ghost_method(/ghost/) do |symbol, *args|
           "#{symbol.to_s.gsub(/_/, ' ')} #{args.join(' ')}"
         end
       end
@@ -89,39 +83,39 @@ describe "MetaProgramming" do
     end
     it "should pass parameters" do
       class GHA9
-        define_ghost_method('test_args') do |obj, sym, *args|
+        define_ghost_method('test_args') do |sym, *args|
           args.join(' ')
         end
       end
       GHA9.new.test_args('hi', 'you').should == 'hi you'
     end
     #ghost methods that can call blocks are not supported
-#    it "should work for methods called with blocks in 1.9" do
-#      class GHA8
-#        define_ghost_method(:call_block) do |obj, sym, *args|
-#          yield(*args)
-#        end
-#      end
-#      GHA8.new.call_block(%w(hi you)) do |*args|
-#        args.join(' ')
-#      end.should == 'hi you'
-#    end
+    #it "should work for methods called with blocks in 1.9" do
+    #  class GHA8
+    #    define_ghost_method(:call_block) do |obj, sym, *args|
+    #      yield(*args)
+    #    end
+    #  end
+    #  GHA8.new.call_block(%w(hi you)) do |*args|
+    #    args.join(' ')
+    #  end.should == 'hi you'
+    #end
     it "should define ghost methods for class Object" do
       class Object
-        define_ghost_method(:alive!) do
+        define_ghost_method(:alive!) do |sym|
           'ALIVE'
         end
       end
       lambda { Object.new.alive!.should == 'ALIVE'}.should_not raise_exception
     end
-    it "should accept lambda as an advanced matcher and lambda parameters should be object, matcher_result, *args" do
+    it "should accept lambda as an advanced matcher and lambda parameters should be matcher_result, *args" do
       class TestObject1
         def yes?; true; end
         def no?; false; end
 
-        matcher = lambda {|obj, sym, *args| sym.to_s =~ /^yn_(.*\?)$/ && obj.methods.map(&:to_sym).include?($1.to_sym) && $1.to_sym }
-        define_ghost_method(matcher) do |obj, res, *args|
-          obj.__send__(res, *args) ? 'yes' : 'no'
+        matcher = lambda {|sym| sym.to_s =~ /^yn_(.*\?)$/ && self.class.method_defined?($1.to_sym) && $1.to_sym }
+        define_ghost_method(matcher) do |res, *args|
+          self.__send__(res, *args) ? 'yes' : 'no'
         end
       end
       lambda { TestObject1.new.yes?.should == true}.should_not raise_exception
@@ -131,14 +125,23 @@ describe "MetaProgramming" do
       lambda { TestObject1.new.yessir? }.should raise_exception(NoMethodError)
       lambda { TestObject1.new.yn_yessir? }.should raise_exception(NoMethodError)
     end
+    it "should create a private ghost_method_handler and ghost_method_matcher and not a public ones" do
+      class TestObject3
+        matcher = lambda {|sym| sym.to_s =~ /asdfjf/ && sym}
+        define_ghost_method(matcher) {|sym| 'hello' }
+      end
+      obj = TestObject3.new
+      obj.private_methods.map(&:to_s).detect{|method| method =~ /ghost_method_handler/}.should_not be_nil
+      obj.private_methods.map(&:to_s).detect{|method| method =~ /ghost_method_matcher/}.should_not be_nil
+    end
     it "should accept Procs as an advanced matcher and the parameters should be obj, matcher_result, *args" do
       class TestObject2
         def yes?; true; end
         def no?; false; end
 
-        matcher = Proc.new{|obj, sym, *args| sym.to_s =~ /^yn_(.*\?)$/ && obj.methods.map(&:to_sym).include?($1.to_sym) && $1.to_sym }
-        define_ghost_method(matcher) do |obj, res, *args|
-          obj.__send__(res, *args) ? 'yes' : 'no'
+        matcher = Proc.new{|sym| sym.to_s =~ /^yn_(.*\?)$/ && methods.map(&:to_sym).include?($1.to_sym) && $1.to_sym }
+        define_ghost_method(matcher) do |res, *args|
+          __send__(res, *args) ? 'yes' : 'no'
         end
       end
       lambda { TestObject2.new.yes?.should == true}.should_not raise_exception
@@ -151,9 +154,9 @@ describe "MetaProgramming" do
     it "should create an appropriate respond_to? for the string matchers" do
       class StringMatcher
         def hello; end
-        define_ghost_method('my_method') { 'yes_my_method'}
+        define_ghost_method('my_method') {|sym| 'yes_my_method'}
       end
-      lambda { StringMatcher.new.my_method.should == 'yes_my_method'}.should_not raise_exception      
+      lambda { StringMatcher.new.my_method.should == 'yes_my_method'}.should_not raise_exception
       lambda { StringMatcher.new.respond_to?(:my_method2).should be_false}.should_not raise_exception
       lambda { StringMatcher.new.respond_to?(:my_method).should be_true }.should_not raise_exception
       StringMatcher.new.respond_to?(:hello).should be_true
@@ -161,7 +164,7 @@ describe "MetaProgramming" do
     it "should create an appropriate respond_to? for the symbol matchers" do
       class SymbolMatcher
         def hello; end
-        define_ghost_method(:my_method2) { 'yep_my_method'}
+        define_ghost_method(:my_method2) {|sym| 'yep_my_method'}
       end
       lambda { SymbolMatcher.new.my_method2.should == 'yep_my_method'}.should_not raise_exception
       lambda { SymbolMatcher.new.respond_to?(:my_method2).should be_true}.should_not raise_exception
@@ -171,14 +174,14 @@ describe "MetaProgramming" do
     it "should create an appropriate respond_to? for the regexp matchers" do
       class RegexpMatcher
         def hello; end
-        define_ghost_method(/^my_method$/) { 'yo_my_method'}
+        define_ghost_method(/^my_method$/) {|sym| 'yo_my_method'}
       end
       lambda { RegexpMatcher.new.my_method.should == 'yo_my_method'}.should_not raise_exception
       lambda { RegexpMatcher.new.respond_to?(:my_method).should be_true}.should_not raise_exception
       RegexpMatcher.new.respond_to?(:hello).should be_true
       class RegexpMatcher2
         def hello; end
-        define_ghost_method(/^my_method\d$/) { 'yoo_my_method'}
+        define_ghost_method(/^my_method\d$/) {|sym| 'yoo_my_method'}
       end
       lambda { RegexpMatcher2.new.my_method1.should == 'yoo_my_method'}.should_not raise_exception
       lambda { RegexpMatcher2.new.my_method }.should raise_exception(NoMethodError)
@@ -189,7 +192,7 @@ describe "MetaProgramming" do
     it "should create an appropriate respond_to? for the lambda matchers" do
       class LambdaMatcher
         def hello; end
-        define_ghost_method(lambda{|obj, sym| sym.to_s =~ /^my_method\d$/ }) { 'uhhuh_my_method'}
+        define_ghost_method(lambda{|sym| sym.to_s =~ /^my_method\d$/ }) {|sym| 'uhhuh_my_method'}
       end
       lambda { LambdaMatcher.new.my_method2.should == 'uhhuh_my_method'}.should_not raise_exception
       lambda { LambdaMatcher.new.my_method}.should raise_exception(NoMethodError)
@@ -198,6 +201,54 @@ describe "MetaProgramming" do
       lambda { LambdaMatcher.new.respond_to?(:my_methods).should be_false}.should_not raise_exception
       LambdaMatcher.new.respond_to?(:hello).should be_true
     end
+
+    if RUBY_VERSION >= '1.9'
+      it "should not raise a LocalJump error when 'return' keyword used in method block" do
+        class GHB1
+          define_ghost_method(:my_method) {|sym| return 'hello'}
+        end
+        lambda { GHB1.new.my_method.should == 'hello'}.should_not raise_exception
+        lambda { GHB1.new.my_method2}.should raise_exception(NoMethodError)
+      end
+    end
+    it "should not raise a LocalJumpError when 'return' keyword used in lambda matcher" do
+       class GHB2
+         matcher = lambda{|sym| return true if sym == :my_method; return false }
+         define_ghost_method(matcher){|sym| 'hello'}
+       end
+       lambda { GHB2.new.my_method.should == 'hello'}.should_not raise_exception
+       lambda { GHB2.new.my_method2 }.should raise_exception(NoMethodError)
+    end
+    it "should indicate exceptions come from method block when originating in method block" do
+      class GHB3
+        define_ghost_method(:my_method){|sym| raise "my cool exception"}
+      end
+      lambda { GHB3.new.my_method}.should raise_exception(/ghost method block/)
+      lambda { GHB3.new.my_method}.should raise_exception(/my cool exception/)
+    end
+    it "should indicate exceptions come from lambda matcher when originating in lambda matcher" do
+      class GHB4
+        matcher = lambda{|sym| raise 'my cooler exception'}
+        define_ghost_method(matcher){|sym| 'hello'}
+      end
+      lambda { GHB4.new.my_method}.should raise_exception(/ghost method matcher/)
+      lambda { GHB4.new.my_method}.should raise_exception(/my cooler exception/)
+    end
+    it "should indicate exceptions come from respond_to? matcher when originating from there" do
+      class GHB6
+        matcher = lambda{|sym| raise 'my respond_to exception'}
+        define_ghost_method(matcher){|sym| 'hello'}
+      end
+      lambda { GHB6.new.respond_to?(:my_method)}.should raise_exception(/ghost method matcher/)
+      lambda { GHB6.new.respond_to?(:my_method)}.should raise_exception(/my respond_to exception/)
+    end
+    it "should inform about using method_defined? instead of respond_to? in matcher" do
+      class GHB5
+        matcher = lambda{|sym| sym.to_s =~ /^x_(.+)$/ && self.respond_to?($1.to_sym) && $1.to_sym }
+        define_ghost_method(matcher){|sym, *args| __send__(sym, *args) }
+      end
+      lambda { GHB5.new.x_methods }.should raise_exception(/method_defined\?/)
+    end
   end
 
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 2
   - 0
-  - 8
-  version: 0.0.8
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jeff Patmon
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-01 00:00:00 -07:00
+date: 2010-05-02 00:00:00 -07:00
 default_executable: 
 dependencies: []