meta_programming 0.0.1 → 0.0.8

data/README.rdoc

@@ -12,6 +12,36 @@ Use
 
 * require 'meta_programming'
 
+Concepts/Terminology
+
+* Metaprogramming_Ruby[http://pragprog.com/titles/ppmetr/metaprogramming-ruby]
+
+== Beta Status
+
+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.
+
+I welcome comments and collaborators who
+would like to develop a library for simplifying common patterns and limit
+the pitfalls of Ruby meta-programming.
+
+== Issues
+
+=== 1.9 vs 1.8
+
+There are considerable differences with the way that Ruby 1.9 and 1.8 handle dynamic
+methods, procs and lambdas.  For instance, Ruby 1.8.x cannot handle default parameter
+values in the block parameter list
+
+  call_some_method(*args) do |param1, param2=nil| #oops for Ruby 1.8
+    ...
+  end
+
+This raises support issues for this library.  Should the library fully support both versions
+of Ruby, cripple 1.8 at the expense of 1.9, or kiss the past good-bye and only support version 1.9?
+Of course, the latter is clearer and easier, and may be the best path to pursue.
+
 	
 == Description
 
@@ -19,10 +49,70 @@ Current Methods
 * eigenclass (or metaclass)
 * safe_alias_method_chain
 * define_chained_method
+* define_method_missing_chain
+* define_ghost_method
 * blank_slate
-* clean_room
 
 
+
+== Usage
+
+=== define_ghost_method
+
++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|
+    ...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.
+
+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| ... }
+
+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
+taken to define scrutinizing regular expression matchers.  It is a good practice to use
+the /^ and $/ matchers to limit the scope.
+
+In all cases, the method name is passed in the second parameter as a symbol to the
+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
+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 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 }
+
+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 }
+
+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
+
+I'm not completely satisfied with the design of the implementation.
+
 == Dependencies
 
-none
+none

data/Rakefile

@@ -12,7 +12,6 @@ spec = Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.8.7'
   s.description = 'Collection of meta-programming methods for Ruby'
   s.summary = 'Collection of meta-programming methods for Ruby'
-
  
   exclude_folders = '' # 'spec/rails/{doc,lib,log,nbproject,tmp,vendor,test}'
   exclude_files = [] # FileList['**/*.log'] + FileList[exclude_folders+'/**/*'] + FileList[exclude_folders]
@@ -47,7 +46,7 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.options << '--line-numbers' << '--inline-source'
   rdoc.rdoc_files.include('README.rdoc', 'LICENSE', 'lib/**/*.rb')
 end
- 
+
 desc 'Generate a gemspec file.'
 task :gemspec do
   File.open("#{spec.name}.gemspec", 'w') do |f|

data/lib/meta_programming/class.rb

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

data/lib/meta_programming/object.rb

@@ -13,25 +13,46 @@ module MetaProgramming
     end
     
     module ClassMethods
+
+      module Helpers
+        def self.compose_chaining_symbols(method_name, ext)
+          stripped_method_name, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
+          ["#{stripped_method_name}_with_#{ext}#{punctuation}".to_sym,
+            "#{stripped_method_name}_without_#{ext}#{punctuation}".to_sym]
+        end
+
+        def self.escape_method_name(method_name)
+          method_name.to_s.gsub(/\?/, 'qmark').gsub(/\!/, 'bang').gsub(/\=/, 'equal')
+        end
+      end
+
+      def method_access_level(method_name)
+        case
+        when public_method_defined?(method_name.to_sym) then :public
+        when private_method_defined?(method_name.to_sym) then :private
+        when protected_method_defined?(method_name.to_sym) then :protected
+        else nil
+        end
+      end
+      
       def safe_alias_method_chain(method_name, ext)
         class_eval do
-          stripped_method_name, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
-          method_name_with_ext = "#{stripped_method_name}_with_#{ext}#{punctuation}".to_sym
-          method_name_without_ext = "#{stripped_method_name}_without_#{ext}#{punctuation}".to_sym
-          instance_variable = "#{stripped_method_name}_#{ext}_#{{'?'=>'questmark', '!'=>'bang', '='=>'equals'}[punctuation]}"
-          if (method_defined?(method_name_with_ext) && !(eigenclass.instance_variable_defined?("@#{instance_variable}")))
-            if method_defined?(method_name.to_sym)
+          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)
               alias_method method_name_without_ext, method_name.to_sym
               alias_method method_name.to_sym, method_name_with_ext
-              case
-              when public_method_defined?(method_name_without_ext) then public(method_name.to_sym)
-              when protected_method_defined?(method_name_without_ext) then protected(without_method.to_sym)
-              when private_method_defined?(method_name_without_ext) then private(without_method.to_sym)
+              case method_access_level(method_name_without_ext)
+              when :public then public(method_name.to_sym)
+              when :protected then protected(method_name.to_sym)
+              when :private then private(method_name.to_sym)
               end
             else
-              alias_method method_name.to_sym, method_name_with_ext
               define_method(method_name_without_ext) {|*args| }
+              alias_method method_name.to_sym, method_name_with_ext
             end
             eigenclass.instance_variable_set("@#{instance_variable}", true)
           end
@@ -39,10 +60,48 @@ module MetaProgramming
       end
 
       def define_chained_method(method_name, ext, &block)
-        define_method("#{method_name}_with_#{ext}".to_sym, block)
-        safe_alias_method_chain(method_name.to_sym, ext)
+        raise 'Must have block' unless block_given?
+        with, without = Helpers.compose_chaining_symbols(method_name, ext)
+        define_method(with, block)
+        safe_alias_method_chain(method_name.to_sym, ext.to_sym)
       end
 
+      def define_method_missing_chain(name, &block)
+        raise 'Must have block' unless block_given?
+        define_chained_method(:method_missing, name.to_sym, &block)
+      end
+
+      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
+        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
+            end
+            handled ? result : __send__("method_missing_without_#{ext}".to_sym, symbol, *args)
+          rescue LocalJumpError
+            raise LocalJumpError, "Remove the 'return' keyword in your method block."
+          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 String, Symbol then method_name == matcher.to_sym
+          when Proc then matcher.call(self, method_name)
+          end
+          responds || __send__("respond_to_without_#{ext}?", method_name) #1.9 only, include_private)
+        end
+      end
     end
   end
 end

data/spec/blank_slate_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "blank_slate" do
+
+  def collect_test_methods(instance, exceptions=[])
+    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)
+    all_methods - allowed_methods
+  end
+  
+  it "should only have certain instance methods (it's a blank slate)" do
+    class BlankSlate1
+      blank_slate
+    end
+    test_methods = collect_test_methods(Object.new, [:method_missing, :respond_to?])
+
+    bs = BlankSlate1.new
+    test_methods.each do |method|
+      bs.respond_to?(method).should be_false
+    end
+  end
+
+  it "should remove all but ^__ methods for option :all" do
+    class BlankSlate2
+      blank_slate :all=>true
+      public :__send__
+    end
+    test_methods = collect_test_methods(Object.new)
+
+    bs = BlankSlate2.new
+    test_methods.each do |method|
+#      lambda { bs.__send__(method); nil }.should raise_exception(NoMethodError)
+    end
+  end
+
+  it "should work for exceptions" do
+    class BlankSlate3
+      blank_slate :except=>[:methods]
+    end
+    test_methods = collect_test_methods(Object.new, [:methods, :method_missing, :respond_to?])
+
+    bs=BlankSlate3.new
+    test_methods.each do |method|
+      bs.respond_to?(method).should == false
+    end
+
+  end
+
+end
+
+

data/spec/ghost_methods_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe "MetaProgramming" do
+
+  describe "define_method_missing_chain method" do
+    it "should create a method_missing chain" do
+      class E1
+        def hello; 'hello'; end
+        define_method_missing_chain(:help) do |symbol, *args|
+          if symbol == :help
+            'help'
+          else
+            method_missing_without_help(symbol, *args)
+          end
+        end
+      end
+      lambda { E1.new.help.should == 'help' }.should_not raise_exception
+      lambda { E1.new.helpme }.should raise_exception(NoMethodError)
+    end
+    it "should scream if defined twice" do
+      lambda {
+        class E2
+          define_method_missing_chain(:help) {}
+          define_method_missing_chain(:help) {}
+         end
+      }.should raise_exception
+    end
+    it "should scream if block missing" do
+      lambda {
+        class E3
+          define_method_missing_chain(:help)
+        end
+      }.should raise_exception
+    end
+  end
+  describe "define_ghost_method method" do
+    it "should scream if matcher is not string, symbol or regular expression" do
+      lambda {
+        class GHA2
+          define_ghost_method(1) { puts 1}
+        end
+      }.should raise_exception(ArgumentError)
+    end
+    it "should scream if there's no block given" do
+      lambda {
+        class GHA3
+          define_ghost_method(:tree)
+        end
+      }.should raise_exception
+    end
+    it "should define a ghost method using a symbol" do
+      class GHA1
+        define_ghost_method(:catch_this_one) { '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'}
+      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|
+          symbol
+        end
+      end
+      lambda { GHA6.new.catch_this_one.should == :catch_this_one }.should_not raise_exception
+      lambda { GHA6.new.some_catch_here.should == :some_catch_here }.should_not raise_exception
+      lambda { GHA6.new.atchoo }.should raise_exception(NoMethodError)
+    end
+    it "should pass arguments to the block" do
+      class GHA7
+        define_ghost_method(/ghost/) do |object, symbol, *args|
+          "#{symbol.to_s.gsub(/_/, ' ')} #{args.join(' ')}"
+        end
+      end
+      lambda { GHA7.new.ghost_methods('kick', 'butt').should == 'ghost methods kick butt'}.should_not raise_exception
+    end
+    it "should pass parameters" do
+      class GHA9
+        define_ghost_method('test_args') do |obj, 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 define ghost methods for class Object" do
+      class Object
+        define_ghost_method(:alive!) do
+          '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
+      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'
+        end
+      end
+      lambda { TestObject1.new.yes?.should == true}.should_not raise_exception
+      lambda { TestObject1.new.no?.should == false }.should_not raise_exception
+      lambda { TestObject1.new.yn_yes?.should == 'yes'}.should_not raise_exception
+      lambda { TestObject1.new.yn_no?.should == 'no'}.should_not raise_exception
+      lambda { TestObject1.new.yessir? }.should raise_exception(NoMethodError)
+      lambda { TestObject1.new.yn_yessir? }.should raise_exception(NoMethodError)
+    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'
+        end
+      end
+      lambda { TestObject2.new.yes?.should == true}.should_not raise_exception
+      lambda { TestObject2.new.no?.should == false }.should_not raise_exception
+      lambda { TestObject2.new.yn_yes?.should == 'yes'}.should_not raise_exception
+      lambda { TestObject2.new.yn_no?.should == 'no'}.should_not raise_exception
+      lambda { TestObject2.new.yessir? }.should raise_exception(NoMethodError)
+      lambda { TestObject2.new.yn_yessir? }.should raise_exception(NoMethodError)
+    end
+    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'}
+      end
+      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
+    end
+    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'}
+      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
+      SymbolMatcher.new.respond_to?(:my_method).should be_false
+      SymbolMatcher.new.respond_to?(:hello).should be_true
+    end
+    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'}
+      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'}
+      end
+      lambda { RegexpMatcher2.new.my_method1.should == 'yoo_my_method'}.should_not raise_exception
+      lambda { RegexpMatcher2.new.my_method }.should raise_exception(NoMethodError)
+      lambda { RegexpMatcher2.new.respond_to?(:my_method).should be_false}.should_not raise_exception
+      lambda { RegexpMatcher2.new.respond_to?(:my_method2).should be_true}.should_not raise_exception
+      lambda { RegexpMatcher2.new.respond_to?(:my_method10).should be_false}.should_not raise_exception
+    end
+    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'}
+      end
+      lambda { LambdaMatcher.new.my_method2.should == 'uhhuh_my_method'}.should_not raise_exception
+      lambda { LambdaMatcher.new.my_method}.should raise_exception(NoMethodError)
+      lambda { LambdaMatcher.new.respond_to?(:my_method).should be_false}.should_not raise_exception
+      lambda { LambdaMatcher.new.respond_to?(:my_method5).should be_true}.should_not raise_exception
+      lambda { LambdaMatcher.new.respond_to?(:my_methods).should be_false}.should_not raise_exception
+      LambdaMatcher.new.respond_to?(:hello).should be_true
+    end
+  end
+
+end

data/spec/meta_programming_spec.rb

@@ -1,4 +1,4 @@
-require 'lib/meta_programming'
+require 'spec_helper'
 
 describe "MetaProgramming" do
   describe "eigenclass and metaclass methods" do
@@ -37,6 +37,19 @@ describe "MetaProgramming" do
       end
       B2.new.target(['init']).should == ['init', 'chain', 'target']
     end
+    it "should define and chain a predicate method" do
+      class B5; def hello; 'hello'; end; end
+      B5.new.hello.should == 'hello'
+      B5.new.respond_to?(:hello).should be_true
+      B5.new.respond_to?(:help).should be_false
+      class B5
+        define_chained_method(:respond_to?, :help) do |method_name|
+          method_name == :help ? true : respond_to_without_help?(method_name)
+        end
+      end
+      B5.new.respond_to?(:hello).should be_true
+      B5.new.respond_to?(:help).should be_true
+    end
 #    it "should complain if block has wrong arity" do
 #      lambda {
 #        class B3
@@ -51,14 +64,36 @@ describe "MetaProgramming" do
     it "should define and chain a method safely if there is no target method" do
       class B4
         define_chained_method(:target, :chain) do |array|
-          array << 'chain'
           target_without_chain(array)
+          array << 'chain'
         end
         B4.new.target(['init']).should == ['init', 'chain']
       end
     end
   end
   describe "safe_alias_method_chain method" do
+    it "should chain for a primary protected method" do
+      class D1
+        def primary(array); array << 'primary'; end
+        protected :primary
+        def primary_with_one(array); array << 'one'; primary_without_one(array); end
+        safe_alias_method_chain :primary, :one
+      end
+      D1.new.instance_eval do
+        primary(['init']).should == ['init', 'one', 'primary']
+      end
+    end
+    it "should chain for a primary private method" do
+      class D2
+        def primary(array); array << 'primary'; end
+        protected :primary
+        def primary_with_one(array); array << 'one'; primary_without_one(array); end
+        safe_alias_method_chain :primary, :one
+      end
+      D2.new.instance_eval do
+        primary(['init']).should == ['init', 'one', 'primary']
+      end
+    end
     it "should not chain for non-existent chaining method" do
       class A
         def primary(array); array << 'primary'; end
@@ -109,7 +144,7 @@ describe "MetaProgramming" do
       end
       A2.new.primary(['init']).should == ['init', 'two', 'one', 'primary']
     end
-    it "should not cause endless loop when called twice" do
+    it "should scream if called twice for same method_name and extension" do
       lambda {
         class A3
           def primary(array); array << 'primary'; end
@@ -119,7 +154,7 @@ describe "MetaProgramming" do
           safe_alias_method_chain :primary, :one
         end
         A3.new.primary(['init']).should == ['init', 'one', 'primary']
-      }.should_not raise_exception
+      }.should raise_exception
     end
     it "should chain with = punctuation" do
       class A5
@@ -155,5 +190,16 @@ describe "MetaProgramming" do
         A7.new.primary!(['init']).should == ['init', 'one', 'primary']
       }.should_not raise_exception
     end
+    it "should chain for an inherited method" do
+      class A8
+        def primary(array); array << 'primary'; end
+      end
+      A8.new.primary(['init']).should == ['init', 'primary']
+      class A9 < A8
+        def primary_with_sub(array); array << 'sub'; primary_without_sub(array); end
+        safe_alias_method_chain :primary, :sub
+      end
+      A9.new.primary(['init']).should == ['init', 'sub', 'primary']
+    end
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'lib/meta_programming'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Jeff Patmon
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-29 00:00:00 -07:00
+date: 2010-05-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,9 @@ files:
 - lib/meta_programming/object.rb
 - lib/meta_programming.rb
 - spec/meta_programming_spec.rb
+- spec/ghost_methods_spec.rb
+- spec/spec_helper.rb
+- spec/blank_slate_spec.rb
 - spec/spec.opts
 - init.rb
 - LICENSE
@@ -71,3 +74,5 @@ specification_version: 3
 summary: Collection of meta-programming methods for Ruby
 test_files: 
 - spec/meta_programming_spec.rb
+- spec/ghost_methods_spec.rb
+- spec/blank_slate_spec.rb