namebox 0.0.2 → 0.0.3

data/lib/namebox.rb

@@ -55,93 +55,88 @@ class Namebox
 
     end
 
-    # get the superclass of ancestor in the base's ancestors list
-    def super_ancestor(base, ancestor)
-      ba = base.ancestors
-      i = ba.index(ancestor)
-      ba[i + 1] if i
-    end
+    ###################################################
+    # INSTANCE METHODS HELPERS
+    ###################################################
 
-    # get the instance method from superclass of ancestor
-    # in the base_class' ancestors list
+    # Get the super methods from klass' ancestors list.
+    # +is_instance+: boolean for instance or class methods
+    # +limit_ancestor+: the last ancestor to check for methods
+    # +default_method+: the method to return case not found
+    # +first+: returns the first method found; else returns an array
     #
-    def super_method(name, base_class, ancestor = base_class)
+    def super_methods(name, klass, is_instance, limit_ancestor, default_method,
+                      first = false, &validator)
 
-      super_class = super_ancestor(base_class, ancestor)
+      ancestors = is_instance ? klass.ancestors : class_ancestors(klass)
 
-      # no super_class!
-      raise NameError unless super_class
+      sm = []
+      limit_index = ancestors.index(limit_ancestor) || ancestors.length - 1
 
-      # get the super method (can throw NameError if it doesn't exist)
-      super_class.instance_method(name)
-    end
+      # skip first ancestor (0) - the class itself
+      #
+      for i in 1..limit_index
+        super_ancestor = ancestors[i]
+        begin
+          m = super_ancestor.instance_method(name)
+        rescue NameError
+          m = nil
+        end
+
+        # only owners (and the last) are interesting
+        next unless m && m.owner == super_ancestor || i == limit_index
+
+        # check if it matches the requisites
+        next unless validator.call(m)
+
+        return m if first
+
+        sm << m
 
-    def super_owner(name, base_class, ancestor)
-      begin
-        super_method(name, base_class, ancestor).owner
-      rescue NameError
       end
+
+      # return found methods
+      return sm unless sm.empty?
+
+      # not found
+      first ? default_method : [default_method]
     end
 
     ###################################################
     # CLASS METHODS HELPERS
     ###################################################
 
-    # build ancestors list for class methods
-    def class_ancestors(klass)
-      list = []
-
-      # in reverse order is easier to add modules in the correct order
-      # and to avoid redundancy thru Array#|
-      #
-      klass.ancestors.reverse.each do |a|
+    # build ancestors list for class methods lookup
+    def class_ancestors(c)
 
-        # get eigenclass ancestors
-        aa = class << a; self; end
-
-        # add new modules to list
-        list |= aa.ancestors.reverse
-
-        # add current ancestor to list
-        list << a
-      end
+      # only classes have superclass
+      return c.ancestors if c.instance_of? Module
 
-      # reverse to the correct order
-      list.reverse
-    end
+      list = []
+      eigenclass = class << c; self; end
+      mod_class = eigenclass.included_modules
 
-    def class_owner(mtd)
-      owner = mtd.owner
-      return owner if owner.instance_of? Module
-      ObjectSpace.each_object(owner).to_a.last
-    end
+      while c
 
-    # get the superclass of ancestor in the base's ancestors list
-    def class_super_ancestor(base, ancestor)
-      ca = class_ancestors(base)
-      i = ca.index(ancestor)
-      ca[i + 1] if i
-    end
+        s = c.superclass
+        eigensuper = class << s; self; end
 
-    # get the class method from superclass of ancestor
-    # in the base_class' ancestors list
-    #
-    def class_super_method(name, base_class, ancestor = base_class)
+        # if there's no superclass, consider Kernel as included module;
+        # so it won't be added now, but later, in the correct order.
+        mod_super = s ? eigensuper.included_modules : [Kernel]
 
-      super_class = class_super_ancestor(base_class, ancestor)
+        # add eigenclass and its included modules
+        # (discarding the ones inherited from superclasses)
+        list << eigenclass
+        list += mod_class - mod_super
 
-      # no super_class!
-      raise NameError unless super_class
+        # rotate values
+        c, eigenclass, mod_class = s, eigensuper, mod_super
 
-      # get the super method (can throw NameError if it doesn't exist)
-      super_class.method(name)
-    end
-
-    def class_super_owner(name, base_class, ancestor)
-      begin
-        class_owner(class_super_method(name, base_class, ancestor))
-      rescue NameError
       end
+
+      # finally adds Class's ancestors (including Kernel)
+      list += Class.ancestors
     end
 
   end
@@ -200,6 +195,8 @@ class Namebox
 
     # save preexisting methods
     methods_before = get_methods
+    $msb = methods_before["Symbol#&"]
+    $mob = methods_before["Object#&"]
 
     # ###############################################################
     # RUN THE CODE, which can change the methods of protected modules
@@ -210,13 +207,14 @@ class Namebox
 
     # get methods after changes
     methods_after = get_methods
+    $msa = methods_after["Symbol#&"]
+    $moa = methods_after["Object#&"]
 
     # compare with preexisting data to discover affected methods
     unless methods_after == methods_before
 
       # thru closure, this namebox will be useful inside redefined methods
       this_nb = self
-
       methods_after.each do |fullname, info|
 
         # get old method
@@ -230,9 +228,11 @@ class Namebox
         # method was modified! take some info
         name = info[:name]
         klass = info[:class]
+        is_instance = info[:is_instance]
+        old_owner = old_m && old_m.owner
 
         # instance and class methods are managed differently
-        if info[:instance]
+        if is_instance
 
           ##########################################################
           #
@@ -240,19 +240,12 @@ class Namebox
           #
           ##########################################################
 
-          # use closure to avoid recalculations inside method
-          old_owner = old_m && old_m.owner
-
-          # owners to skip
-          new_owners = []
-          o = new_m.owner
-          while o && o != old_owner
-            new_owners << o
-            o = Namebox.super_owner(name, klass, o)
+          # new methods to skip
+          new_methods = Namebox.super_methods(name, klass, is_instance,
+                                              old_owner, new_m) do |sm|
+            sm != old_m
           end
 
-          ## print "#{klass}##{name}: "; p new_owners;
-
           # redefine the method, which will check namebox visibility dinamically
           klass.send :define_method, name do |*args, &blk|
 
@@ -269,18 +262,14 @@ class Namebox
               # must be dynamic because it can change anytime
               # (someone can attach a new definition to some ancestor)
 
-              begin
-                # try before owner (after klass - this method)
-                m = Namebox.super_method(name, klass)
-
-                # skip new owners
-                while new_owners.include? m.owner
-                  m = Namebox.super_method(name, klass, m.owner)
-                end
+              m = Namebox.super_methods(name, klass, is_instance,
+                                        old_owner, old_m, true) do |sm|
+                !new_methods.include?(sm)
+              end
 
-              rescue NameError
+              unless m
 
-                # didn't find a different method; raise NoMethodError
+                # didn't find a method; raise NoMethodError
 
                 # if inspect is too big, shorten it
                 obj = self.inspect.to_s
@@ -303,20 +292,13 @@ class Namebox
           #
           ##########################################################
 
-          # use closure to avoid recalculations inside method
-          old_owner = old_m && Namebox.class_owner(old_m)
-
-          # owners to skip
-          new_owners = []
-          o = Namebox.class_owner(new_m)
-          while o && o != old_owner
-            new_owners << o
-            o = Namebox.class_super_owner(name, klass, o)
+          # new methods to skip
+          new_methods = Namebox.super_methods(name, klass, is_instance,
+                                              old_owner, new_m) do |sm|
+            sm != old_m
           end
 
-          ## print "#{klass.inspect}.#{name}: "; p new_owners;
-
-          # redefine class method thru eigenclass
+          # redefine the method thru eigenclass
           class << klass; self; end.send :define_method, name do |*args, &blk|
 
             # check namebox visibility
@@ -330,38 +312,43 @@ class Namebox
 
               # search a different method to call
               # must be dynamic because it can change anytime
-              # (someone can extend an ancestor with some module)
+              # (someone can attach a new definition to some ancestor)
 
-              begin
-                # try before owner (after klass - this method)
-                m = Namebox.class_super_method(name, klass)
+              m = Namebox.super_methods(name, klass, is_instance,
+                                        old_owner, old_m, true) do |sm|
+                !new_methods.include?(sm)
+              end
 
-                # skip new owners
-                while new_owners.include?(m_owner = Namebox.class_owner(m))
-                  m = Namebox.class_super_method(name, klass, m_owner)
-                end
+              unless m
 
-                # bind to self (can throw TypeError in 1.8.7)
-                m = m.unbind.bind(self)
+                # didn't find a method; raise NoMethodError
 
-              rescue NameError
+                # if inspect is too big, shorten it
+                obj = self.inspect.to_s
+                obj = obj[0..45] + '...' + obj[-1] if obj.length > 50
 
-                # didn't find a different method
                 raise NoMethodError.new("Undefined class method `#{name}' " +
-                                        "for #{self}:#{self.class}")
+                                        "for #{obj}:#{self.class}")
+              end
+
+              begin
+
+                # bind to self (raises TypeError in 1.8.7)
+                m = m.bind(self) if m.instance_of? UnboundMethod
 
               rescue TypeError
 
                 # Ruby 1.8.7 does not bind singleton methods to descendant class;
-                # use current m anyway
+                # try to use a pre-bound method
+                m = ObjectSpace.each_object(m.owner).to_a.last.method(name)
 
               end
 
               # run!
               m.call(*args, &blk)
-
             end
           end
+
         end
       end
     end
@@ -465,7 +452,7 @@ class Namebox
 
       c.instance_methods.each do |m|
         fullname = "#{c}##{m}"
-        gm[fullname] = {:class => c, :instance => true, :name => m,
+        gm[fullname] = {:class => c, :is_instance => true, :name => m,
                         :method => c.instance_method(m) }
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namebox
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-11 00:00:00.000000000 Z
+date: 2013-01-15 00:00:00.000000000 Z
 dependencies: []
-description: 
+description: ! 'Please, note: this version is very unstable and it''s under tests.
+  Came back soon to check new versions with bug fixes.'
 email: sony.fermino@gmail.com
 executables: []
 extensions: []