namebox 0.1.9 → 0.2.0

data/lib/namebox.rb

@@ -8,11 +8,8 @@
 # This software is released "AS IS", without any warranty.
 # The author is not responsible for the consequences of use of this software.
 #
-# Version 0.1.9 - This is the last version compatible with Ruby 1.8.7 and 1.9.1.
-# It's slow, memory-consuming and it has some issues about loosing 'self'
-# when in class methods changed by extending modules in subclasses
-# (self will be the class instead of subclass when namebox is closed).
-# Next versions will be only compatible with Ruby 1.9.2 or greater.
+# This version is only compatible with Ruby 1.9.2 or greater.
+# For use with Ruby 1.8.7 or 1.9.1, get the version 0.1.8 or 0.1.9.
 
 class Namebox
 
@@ -21,9 +18,6 @@ class Namebox
     map { |c| Object.const_get(c) }.
     select { |m| m.is_a? Module }.uniq
 
-  ### FOR RUBY 1.8.7 USE ###
-  CLASS_EIGENCLASS = class << Class; self; end
-
   class << self
 
     # Wrapper to create a namebox only to protect modules when requiring.
@@ -150,16 +144,12 @@ class Namebox
     # select classes to protect against included modules
     @classes = @modules.select { |m| m.is_a? Class }
 
-    # hash for fast search for instances of eigenclasses
-    @eigen_instances = Hash[*@classes.map { |c| [class << c; self; end, c] }.flatten]
-
-    # include eigenclasses in @classes
-    @classes |= @eigen_instances.keys
+    # get eigenclasses
+    eigenclasses = @classes.map { |c| class << c; self; end }
 
-    # eigen_instances will be useful as bound local variable in a closure
-    # for another object; so we can't use instance var @eigen_instances
-    #
-    eigen_instances = @eigen_instances
+    # include eigenclasses into @classes and @modules
+    @classes |= eigenclasses
+    @modules |= eigenclasses
 
     # save preexisting methods and included modules
     inc_mods_before = get_included_modules
@@ -191,98 +181,14 @@ class Namebox
 
         new_modules.each do |new_module|
 
-          # Create a protector module to protect the changed methods.
-          # This protector module is specifc to new_module and klass.
-          #
-          protector = Module.new
-
-          # Create a module to enable a tunnel to bypass the new_module
-          # in super method lookup when namebox is closed to new_module.
+          # Get a protector module for new_module; don't recreate it
+          # if a protector was already created for new_module.
           #
-          super_tunnel = Module.new
+          protector = protector_module(new_module)
 
-          # Give name to protector module; useful when using Method#owner.
+          # reincludes the new_module with super_tunnel
+          # to allow bind(self) inside protector code.
           #
-          class << protector; self; end.send(:define_method, :to_s) do
-            "Protector:#{new_module}/#{klass}"
-          end
-
-          new_module.instance_methods.each do |method_name|
-
-            new_method = new_module.instance_method(method_name)
-
-            protector.send :define_method, method_name do |*args, &blk|
-              if this_nb.open?
-                new_method.bind(self).call(*args, &blk)
-              else
-                begin
-                  super_tunnel.instance_method(method_name).bind(self).call(*args, &blk)
-                rescue NoMethodError
-
-                  # Can throw error in two cases:
-                  # 1. There's really no super method (Ruby >= 1.9)
-                  # 2. 1.8.7 does not find super when in a module after binding.
-                  #
-                  raise if RUBY_VERSION >= '1.9.0'
-
-                  # future method
-                  m = nil
-
-                  # search the method in old modules
-                  old_modules.each do |old_module|
-                    begin
-                      m = old_module.instance_method(method_name).bind(self)
-                      break
-                    rescue NameError
-                      # try next
-                    end
-                  end
-
-                  unless m
-
-                    # last try: superklass
-                    begin
-                      superklass = klass.superclass
-
-                      # superklass exist?
-                      raise NameError unless superklass
-
-                      # Ruby 1.8.7 get wrong superclass for eigenclasses
-                      if superklass == CLASS_EIGENCLASS
-
-                        # Get a bound method for superclass (although self
-                        # won't be the same: superclass instead of klass).
-                        # Can raise NameError if method does not exist.
-                        #
-                        m = eigen_instances[klass].superclass.method(method_name)
-
-                      else
-
-                        # Try to get method; raises NameError if it doesn't exist.
-                        m = superklass.instance_method(method_name).bind(self)
-
-                      end
-
-                    rescue NameError
-                      Namebox.no_method_error(self, method_name)
-                    end
-                  end
-
-                  m.call(*args, &blk)
-                end
-              end
-            end
-
-            super_tunnel.send :define_method, method_name do |*args, &blk|
-              super(*args, &blk)
-            end
-
-          end
-
-          # include super_tunnel in new_module
-          new_module.send :include, super_tunnel
-
-          # reincludes the new_module with super_tunnel to allow bind(self)
           klass.send :include, new_module
 
           # finally, include the protector in the class
@@ -299,38 +205,32 @@ class Namebox
 
         # get old method
         info_old = methods_before[fullname] || {}
-        new_m = info[:method]
-        old_m = info_old[:method]
+        new_method = info[:method]
+        old_method = info_old[:method]
 
         # don't touch unmodified methods
-        next if new_m == old_m
+        next if new_method == old_method
 
         # method was modified! take some info
-        m_name = info[:name]
+        method_name = info[:name]
         klass = info[:class]
-        new_bound_m = info[:bound]
-        old_bound_m = info_old[:bound]
 
         # redefine the method, which will check namebox visibility dinamically
-        klass.send :define_method, m_name do |*args, &blk|
+        klass.send :define_method, method_name do |*args, &blk|
 
           # check namebox visibility
           if this_nb.open?
 
-            # Call the new method. Instance methods are unbound; bind to self.
-            m = (new_bound_m || new_m.bind(self)).call(*args, &blk)
+            # namebox method; bind instance method to self.
+            new_method.bind(self).call(*args, &blk)
 
           else
 
             # old method or super
-            if old_m
-              (old_bound_m || old_m.bind(self)).call(*args, &blk)
+            if old_method
+              old_method.bind(self).call(*args, &blk)
             else
-              begin
-                super(*args, &blk)
-              rescue NoMethodError
-                Namebox.no_method_error(self, m_name)
-              end
+              super(*args, &blk)
             end
 
           end
@@ -433,18 +333,9 @@ class Namebox
 
     @modules.each do |c|
 
-      # get eigenclass
-      ec = class << c; self; end
-
       c.instance_methods(false).each do |m|
         fullname = "#{c}##{m}"
-        gm[fullname] = {:class => c, :name => m, :method => c.instance_method(m) }
-      end
-
-      c.methods(false).each do |m|
-        fullname = "#{c}.#{m}"
-        gm[fullname] = {:class => ec, :name => m, :method => ec.instance_method(m),
-                        :bound => c.method(m) }
+        gm[fullname] = {:class => c, :name => m, :method => c.instance_method(m)}
       end
 
     end
@@ -457,7 +348,7 @@ class Namebox
     inc_mods = {}
 
     @classes.each do |c|
-      super_c = get_superclass(c)
+      super_c = c.superclass
 
       # superclass included modules must be [] even when superclass is nil
       super_inc_mods = super_c && super_c.included_modules || []
@@ -469,14 +360,60 @@ class Namebox
     inc_mods
   end
 
-  # Get superclass of a class; correct values for eigenclasses in 1.8.7.
-  def get_superclass(c)
-    s = c.superclass
-    if s == CLASS_EIGENCLASS
-      # Ruby 1.8.7 limitation
-      s = class << @eigen_instances[c].superclass; self; end
+  def protector_module(new_module)
+    @protector_modules ||= {}
+    if @protector_modules[new_module]
+      @protector_modules[new_module]
+    else
+
+      this_nb = self
+
+      # Create a protector module to protect the changed methods.
+      protector = Module.new
+
+      # Create a module to enable a tunnel to bypass the new_module
+      # in super method lookup when namebox is closed to new_module.
+      #
+      super_tunnel = Module.new
+
+      # Give a name to protector module; useful when using Method#owner.
+      #
+      class << protector; self; end.send(:define_method, :to_s) do
+        "Protector:#{new_module}"
+      end
+
+      new_module.instance_methods.each do |method_name|
+
+        new_method = new_module.instance_method(method_name)
+
+        protector.send :define_method, method_name do |*args, &blk|
+
+          # check namebox visibility
+          if this_nb.open?
+
+            # namebox method; bind instance method to self.
+            new_method.bind(self).call(*args, &blk)
+
+          else
+
+            # super (above module thru super_tunnel); can raise NoMethodError.
+            super_tunnel.instance_method(method_name).bind(self).call(*args, &blk)
+
+          end
+
+        end
+
+        super_tunnel.send :define_method, method_name do |*args, &blk|
+          super(*args, &blk)
+        end
+
+      end
+
+      # include super_tunnel in new_module
+      new_module.send :include, super_tunnel
+
+      @protector_modules[new_module] = protector
     end
-    s
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namebox
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -15,11 +15,12 @@ description: ! 'Create namespace boxes to protect the core classes'' methods fro
   changes, like refinements.
 
 
-  Note: this is the last version compatible with Ruby 1.8.7 and 1.9.1. It''s slow,
-  memory-consuming and it has some issues about loosing ''self'' when in class methods
-  changed by extending modules in subclasses (self will be the class instead of subclass
-  when namebox is closed). Next versions will be only compatible with Ruby 1.9.2 or
-  greater.'
+  This version is only compatible with Ruby 1.9.2 or greater. For use with Ruby 1.8.7
+  or 1.9.1, get the version 0.1.8 or 0.1.9.
+
+
+  Note: this version is under tests, and can be considered a pre-release for 1.0.0.
+  Please, came back soon to check for that version. ;-)'
 email: sony.fermino@gmail.com
 executables: []
 extensions: []
@@ -38,7 +39,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: