namebox 0.2.0 → 0.2.1

data/lib/namebox.rb

@@ -13,11 +13,44 @@
 
 class Namebox
 
-  # currently loaded top-level modules
+  # Currently loaded top-level modules
   CORE = (Module.constants - [:Config]).
     map { |c| Object.const_get(c) }.
     select { |m| m.is_a? Module }.uniq
 
+  # Permits to call the previous (old) version of the method, by calling _old(...)
+  module Old
+
+    # Check if it's already calling old, to call old and avoid recallings.
+    def _calling_old? fullname
+      _calling_old.include? fullname
+    end
+
+    # Call the previous (old) version of the method.
+    def _old(*args, &blk)
+      info = Namebox.caller_to_hash(caller[0])
+      method_name = info[:method]
+      method = self.method(method_name)
+      owner = method.owner
+      fullname = "#{owner}##{method_name}"
+      set_calling_old fullname
+      r = method.call(*args, &blk)
+      @_calling_old.delete(fullname)
+      r
+    end
+
+    private
+
+    # stores info whether is calling the old version
+    def _calling_old
+      @_calling_old ||= []
+    end
+
+    def set_calling_old fullname
+      _calling_old.push fullname
+    end
+  end
+
   class << self
 
     # Wrapper to create a namebox only to protect modules when requiring.
@@ -57,12 +90,8 @@ class Namebox
       c = cr[cr.index { |s| s.start_with? __FILE__ } - 1]
       raise "Unable to find a valid caller file in #{caller.inspect}" unless c
 
-      # match the info
-      m = c.match(/^(.*?):(\d+)(:in `(.*)')?$/)
-      raise "Unexpected caller syntax in \"#{c}\"" unless m
-
-      # label them
-      {:file => m[1], :line => m[2].to_i, :method => m[4]}
+      # convert into hash
+      caller_to_hash c
 
     end
 
@@ -78,6 +107,17 @@ class Namebox
       raise NoMethodError.new(msg)
     end
 
+    def caller_to_hash a_caller
+
+      # match the info
+      m = a_caller.match(/^(.*?):(\d+)(:in `(.*)')?$/)
+      raise "Unexpected caller syntax in \"#{a_caller}\"" unless m
+
+      # label them
+      {:file => m[1], :line => m[2].to_i, :method => m[4]}
+
+    end
+
   end
 
   # +modules_to_protect+ must be the classes themselves, e.g., String, Symbol,
@@ -127,10 +167,10 @@ class Namebox
       # avoid redundancy
       @modules.uniq!
 
-      # include all ancestors for modules and eigenclasses of classes
+      # include all ancestors for modules and singleton classes of classes
       modules.each do |m|
         @modules |= m.ancestors
-        @modules |= class << m; self; end.ancestors if m.is_a? Class
+        @modules |= m.singleton_class.ancestors if m.is_a? Class
       end
     end
 
@@ -144,12 +184,12 @@ class Namebox
     # select classes to protect against included modules
     @classes = @modules.select { |m| m.is_a? Class }
 
-    # get eigenclasses
-    eigenclasses = @classes.map { |c| class << c; self; end }
+    # get singleton_classes
+    singleton_classes = @classes.map { |c| c.singleton_class }
 
-    # include eigenclasses into @classes and @modules
-    @classes |= eigenclasses
-    @modules |= eigenclasses
+    # include singleton_classes into @classes and @modules
+    @classes |= singleton_classes
+    @modules |= singleton_classes
 
     # save preexisting methods and included modules
     inc_mods_before = get_included_modules
@@ -219,10 +259,10 @@ class Namebox
         klass.send :define_method, method_name do |*args, &blk|
 
           # check namebox visibility
-          if this_nb.open?
+          if this_nb.open? && !_calling_old?(fullname)
 
             # namebox method; bind instance method to self.
-            new_method.bind(self).call(*args, &blk)
+            r = new_method.bind(self).call(*args, &blk)
 
           else
 
@@ -234,7 +274,12 @@ class Namebox
             end
 
           end
+
         end
+
+        # permits to call the old methods
+        klass.send :include, Namebox::Old
+
       end
     end
   end
@@ -378,7 +423,7 @@ class Namebox
 
       # Give a name to protector module; useful when using Method#owner.
       #
-      class << protector; self; end.send(:define_method, :to_s) do
+      protector.singleton_class.send(:define_method, :to_s) do
         "Protector:#{new_module}"
       end
 
@@ -389,10 +434,11 @@ class Namebox
         protector.send :define_method, method_name do |*args, &blk|
 
           # check namebox visibility
-          if this_nb.open?
+          fullname = "#{protector}##{method_name}"
+          if this_nb.open? && !_calling_old?(fullname)
 
             # namebox method; bind instance method to self.
-            new_method.bind(self).call(*args, &blk)
+            r = new_method.bind(self).call(*args, &blk)
 
           else
 
@@ -409,7 +455,10 @@ class Namebox
 
       end
 
-      # include super_tunnel in new_module
+      # permits to call the old methods
+      new_module.send :include, Namebox::Old
+
+      # include super_tunnel in new_module (must be included after Old)
       new_module.send :include, super_tunnel
 
       @protector_modules[new_module] = protector

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namebox
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-20 00:00:00.000000000 Z
+date: 2013-01-27 00:00:00.000000000 Z
 dependencies: []
 description: ! 'Create namespace boxes to protect the core classes'' methods from
   changes, like refinements.