meta_programming 0.2.0 → 0.2.1

data/README.rdoc

@@ -27,6 +27,14 @@ I consider this Gem in personal beta and suspect it will be in this state for
 a while.  If you use it, expect changes that may break your code until the
 lexigraph has a chance to mature.
 
+If you include metaprogramming in your projects, I suggest you limit the version
+dependency to 0.2.x, something like
+
+  s.add_dependency('meta_programming', '>= 0.2.0', '< 0.3.0')
+
+Any 0.2.x version will be backward compatible with any earlier 0.2.x version.  A
+bump to 0.3.0 cannot be guaranteed backward compatible.
+
 I welcome comments and collaborators who
 would like to develop a library for simplifying common patterns and limit
 the pitfalls of Ruby meta-programming.
@@ -94,7 +102,7 @@ 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) {|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
@@ -110,14 +118,14 @@ method block.  This is not the case with lambda matchers.
 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{|method_name, *args| ...matching code... }
+  proc = lambda{|method_name| ...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{|sym, *args| sym =~ /^not_(.+\?)$/ && self.class.method_defined?($1.to_sym) && $1.to_sym }
+  proc = lambda{|sym| 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
@@ -127,12 +135,26 @@ matcher to avoid a stack overflow error.  Instead call method_defined? on the cl
 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{|sym, *args| sym =~ /^not_.+\?$/ && sym }
+  proc = lambda{|sym| sym =~ /^not_.+\?$/ && sym }
 
 
 ==== Critique
 
-I'm not completely satisfied with the design of the implementation.
+2010.04.30
+
+I'm not satisfied with the ghost method implementation.
+
+2010.05.02
+
+I like the fact that define_ghost_method blocks and lambda matchers are now evaluated
+in the context of the object and that the object is no longer passed into the method block
+and lambda matcher.  The method now behaves similarly to its cousin, +define_method+.
+
+== Testing
+
+Passes for Ruby
+* 1.8.7
+* 1.9.1
 
 == Dependencies
 

data/lib/meta_programming/class.rb

@@ -4,6 +4,16 @@ module MetaProgramming
       raise 'This module may only be included in class Class' unless base.name == 'Class'
     end
 
+    #opts :matcher=>/xx/, :except=>[:method_name, //, ''], :only=>[:method_name, //, '']
+#    def cast_proxy(target_klass, opts={}, &block)
+#      matcher = lambda{|sym| target_klass.method_defined?(sym) && sym}
+#      define_ghost_method(matcher) {|sym, *args| block.call }
+#    end
+
+    def dynamic_proxy(target, opts={}, &block)
+
+    end
+
     def blank_slate(opts={})
       opts[:except] = opts[:except] ? (opts[:except].is_a?(Array) ? opts[:except] : [opts[:except]]) : []
       exceptions =  opts[:except].map(&:to_s)

data/lib/meta_programming/object.rb

@@ -39,10 +39,10 @@ module MetaProgramming
         class_eval do
           method_name_with_ext, method_name_without_ext = Helpers.compose_chaining_symbols(method_name, ext)
           instance_variable = Helpers.escape_method_name(method_name_with_ext)
-          if method_access_level(method_name_with_ext)
-            raise "#{method_name_with_ext} already chained. Rechaining not permitted" if eigenclass.instance_variable_defined?("@#{instance_variable}")
-            if method_access_level(method_name.to_sym)
-              #alias_method_chain(method_name.to_sym, ext.to_sym)
+          if (method_defined?(method_name_with_ext) || private_method_defined?(method_name_with_ext))
+            raise(MetaProgramming::AliasMethodChainError, "#{method_name_without_ext} already exists.  Circular references not permitted.") if (method_defined?(method_name_without_ext) || private_method_defined?(method_name_without_ext))
+            raise(MetaProgramming::AliasMethodChainError, "#{method_name_with_ext} already chained. Rechaining not permitted") if eigenclass.instance_variable_defined?("@#{instance_variable}")
+            if (method_defined?(method_name.to_sym) || private_method_defined?(method_name.to_sym))
               alias_method method_name_without_ext, method_name.to_sym
               alias_method method_name.to_sym, method_name_with_ext
               case method_access_level(method_name_without_ext)
@@ -74,16 +74,16 @@ 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 = "#{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
+        uniq_ext = "#{self.name.gsub(/^.+>::/,'')}_#{matcher.class.name.gsub(/^.+>::/,'')}#{matcher.hash.abs.to_s}"
+        _ghost_method_handler = "_ghost_method_handler_#{uniq_ext}".to_sym
+        _ghost_method_matcher = "_ghost_method_matcher_#{uniq_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|
+        define_chained_method(:method_missing, uniq_ext.to_sym) do |symbol, *args|
           handled = case matcher
           when Regexp then !(symbol.to_s =~ matcher).nil?
           when String, Symbol then (symbol == matcher.to_sym)
@@ -102,11 +102,11 @@ module MetaProgramming
               raise handler_error, "#{handler_error.message} in a ghost method block called with symbol :#{symbol}."
             end
           else
-            __send__("method_missing_without_#{ext}".to_sym, symbol, *args)
+            __send__("method_missing_without_#{uniq_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|
+        define_chained_method(:respond_to?, uniq_ext.to_sym) do |method_name| #1.9 only, include_private=nil|
           responds = case matcher
           when Regexp then !(method_name.to_s =~ matcher).nil?
           when String, Symbol then method_name == matcher.to_sym
@@ -117,7 +117,7 @@ module MetaProgramming
               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}?".to_sym, method_name) #1.9 only, include_private)
+          responds || __send__("respond_to_without_#{uniq_ext}?".to_sym, method_name) #1.9 only, include_private)
         end
       end
     end

data/lib/meta_programming.rb

@@ -2,6 +2,7 @@ require 'meta_programming/object'
 require 'meta_programming/class'
 
 module MetaProgramming
+  class AliasMethodChainError < Exception; end
 end
 
 Object.send :include, MetaProgramming::Object

data/spec/dynamic_proxy_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "MetaProgramming" do
+
+  describe "dynamic_proxy method" do
+#    it "should result in NoMethodError when target object is nil"
+#    it "should take the symbol of an instance variable as the target"
+#    it "should take the string representation of an instance variable as the target"
+#    it "should take the symbol of a method as the target"
+#    it "should accept and obey a :matcher option"
+#    it "should accept and obey an :except option"
+#    it "should accept and obey an :only option"
+#    it "should delegate method calls when no block given"
+#    it "should pass the method name to the block"
+#    it "should pass a block to forward "
+  end
+
+end
+
+

data/spec/meta_programming_spec.rb

@@ -72,6 +72,23 @@ describe "MetaProgramming" do
     end
   end
   describe "safe_alias_method_chain method" do
+    it "should warn against circular references" do
+      class L1
+        def method_call
+          'the real one'
+        end
+        def method_call_with_alias
+          method_call_without_alias
+        end
+        safe_alias_method_chain :method_call, :alias
+      end
+      class L2 < L1
+        def method_call_with_alias
+          method_call_without_alias
+        end
+      end
+      lambda { L2.class_eval { safe_alias_method_chain :method_call, :alias } }.should raise_exception(MetaProgramming::AliasMethodChainError, /Circular references/)
+    end
     it "should chain for a primary protected method" do
       class D1
         def primary(array); array << 'primary'; end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Jeff Patmon
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-02 00:00:00 -07:00
+date: 2010-05-21 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - spec/spec_helper.rb
 - spec/blank_slate_spec.rb
 - spec/spec.opts
+- spec/dynamic_proxy_spec.rb
 - init.rb
 - LICENSE
 - Rakefile
@@ -76,3 +77,4 @@ test_files:
 - spec/meta_programming_spec.rb
 - spec/ghost_methods_spec.rb
 - spec/blank_slate_spec.rb
+- spec/dynamic_proxy_spec.rb