namebox 0.0.1 → 0.0.2

data/lib/namebox.rb

@@ -1,95 +1,160 @@
 # Namebox for Ruby
 #
-# (c) 2012 Sony Fermino dos Santos
+# (c) 2013 Sony Fermino dos Santos
 # http://rubychallenger.blogspot.com.br/2013/01/namebox.html
 #
 # License: Public Domain
+#
 # This software is released "AS IS", without any warranty.
 # The author is not responsible for the consequences of use of this software.
-#
-# This code is not intended to look professional,
-# provided that it does what it is supposed to do.
 
 class Namebox
 
-  CORE = (Module.constants - [:Config]).map { |c| Object.const_get(c) }.select { |m| m.is_a? Module }.uniq
+  # currently loaded top-level modules
+  CORE = (Module.constants - [:Config]).
+    map { |c| Object.const_get(c) }.
+    select { |m| m.is_a? Module }.uniq
 
   class << self
 
+    # wrapper to create a namebox only to protect modules when requiring
+    def require resource, *modules_to_protect
+
+      new(*modules_to_protect) do
+
+        # need to refer to top-level binding, which is lost inside this def.
+        TOPLEVEL_BINDING.eval("require '#{resource}'")
+
+      end
+
+    end
+
+    # set and get the default modules to protect, for the caller file.
+    def default_modules
+      (@default_modules ||= {})[caller_info[:file]] || []
+    end
+
+    def default_modules= modules_to_protect
+      (@default_modules ||= {})[caller_info[:file]] = [modules_to_protect].flatten
+    end
+
     # Get the caller info in a structured way (hash)
     def caller_info
+
       # search for last reference to this file in caller and take the next one
       cr = caller.reverse
-      c = cr[cr.find_index { |s| s.start_with? __FILE__ } - 1]
+      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 it
       {:file => m[1], :line => m[2].to_i, :method => m[4]}
+
     end
 
-    def require resource, *modules_to_protect
-      new(*modules_to_protect) { TOPLEVEL_BINDING.eval("require '#{resource}'") }
+    # 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
 
-    def all_modules
-      unless @all_modules
-        @all_modules = [Object, Module, Class]
-        @all_modules << BasicObject if RUBY_VERSION >= '1.9'
-        # must run twice to get all modules correctly
-        all_modules
+    # get the instance method from superclass of ancestor
+    # in the base_class' ancestors list
+    #
+    def super_method(name, base_class, ancestor = base_class)
+
+      super_class = super_ancestor(base_class, ancestor)
+
+      # no super_class!
+      raise NameError unless super_class
+
+      # get the super method (can throw NameError if it doesn't exist)
+      super_class.instance_method(name)
+    end
+
+    def super_owner(name, base_class, ancestor)
+      begin
+        super_method(name, base_class, ancestor).owner
+      rescue NameError
       end
-      if RUBY_VERSION >= "1.9"
-        get_modules19 Object
-      else
-        get_modules18 Object
+    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|
+
+        # 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
-      @all_modules.uniq!
-      @all_modules.dup
+
+      # reverse to the correct order
+      list.reverse
     end
 
-    # set and get the default modules to protect, for the caller file.
-    def default_modules
-      (@default_modules ||= {})[caller_info[:file]] || []
+    def class_owner(mtd)
+      owner = mtd.owner
+      return owner if owner.instance_of? Module
+      ObjectSpace.each_object(owner).to_a.last
     end
 
-    def default_modules= modules_to_protect
-      (@default_modules ||= {})[caller_info[:file]] = [modules_to_protect].flatten
+    # 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
 
-    private
+    # get the class method from superclass of ancestor
+    # in the base_class' ancestors list
+    #
+    def class_super_method(name, base_class, ancestor = base_class)
 
-    # get modules in use (differs from 1.8 to 1.9)
-    def get_modules18 base
-      new_mods = base.constants.map { |m| base.const_get(m) }.
-        select { |m| m.is_a?(Module) && !@all_modules.include?(m)}
-      unless new_mods.length == 0
-        @all_modules.push *new_mods
-        new_mods.each { |m| get_modules18(m) }
-      end
+      super_class = class_super_ancestor(base_class, ancestor)
+
+      # no super_class!
+      raise NameError unless super_class
+
+      # get the super method (can throw NameError if it doesn't exist)
+      super_class.method(name)
     end
 
-    def get_modules19 base
-      new_mods = (base.constants - [:Config]).map { |m| base.const_get(m) }.
-        select { |m| m.is_a?(Module) && !@all_modules.include?(m)}
-      unless new_mods.length == 0
-        @all_modules.push *new_mods
-        new_mods.each { |m| get_modules19(m) }
+    def class_super_owner(name, base_class, ancestor)
+      begin
+        class_owner(class_super_method(name, base_class, ancestor))
+      rescue NameError
       end
     end
 
   end
 
-  # +modules+ are modules to protect.
-  # Must be the classes themselves, e.g., String, Symbol,
+  # +modules_to_protect+ must be the classes themselves, e.g., String, Symbol,
   # not their names ("String" or :Symbol).
   # Special names are:
-  # :all => protect all known modules and submodules. It's safer but slower.
+  # :all => protect all known modules and submodules. It's safer but slooow.
   # :core => protect the known top-level modules.
-  # :default => protect the modules defined in Namebox.default_modules for the caller file.
+  # :default => protect the modules defined in Namebox.default_modules.
   # Obs.: :core and :default can be used together and/or with other classes,
   # but :all must be the only parameter if it is used.
+  #
   def initialize *modules_to_protect, &blk
 
     # initialize
@@ -98,32 +163,63 @@ class Namebox
 
     # by default, get Namebox.default_modules
     modules_to_protect = Namebox.default_modules if modules_to_protect.empty?
+
+    # check for :all modules
     if modules_to_protect.include? :all
-      raise "If :all is used in Namebox.new, :all must be the only parameter!" if modules_to_protect.length > 1
-      @modules = Namebox.all_modules
+
+      # :all must be the only parameter
+      if modules_to_protect.length > 1
+        raise "If :all is used in Namebox.new, :all must be the only parameter!"
+      end
+
+      # get all modules
+      @modules = ObjectSpace.each_object(Module).to_a
+
     else
+
+      # take off the symbols
       @modules = modules_to_protect.select { |m| m.is_a? Module }
+
+      # include default modules if wanted
       @modules += Namebox.default_modules if modules_to_protect.include? :default
+
+      # include core modules if wanted
       @modules += CORE if modules_to_protect.include? :core
+
+      # avoid redundancy
       @modules.uniq!
+
     end
 
-    raise "Modules to protect were not given and there's no Namebox.default_modules defined for file #{Namebox.caller_info[:file]}" if @modules.empty?
+    # modules must be given or Namebox.default_modules must be set
+    if @modules.empty?
+      raise ("Modules to protect were not given and there's no " +
+            "Namebox.default_modules defined for file " +
+            Namebox.caller_info[:file])
+    end
 
-    # update modules list and save preexisting data
+    # save preexisting methods
     methods_before = get_methods
 
+    # ###############################################################
+    # RUN THE CODE, which can change the methods of protected modules
+    #
     blk.call
+    #
+    # ###############################################################
 
-    # compare with preexisting data to discover affected methods
+    # get methods after changes
     methods_after = get_methods
 
-    # refine the new methods!
+    # 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
         info_old = methods_before[fullname] || {}
         new_m = info[:method]
         old_m = info_old[:method]
@@ -131,75 +227,187 @@ class Namebox
         # don't touch unmodified methods
         next if new_m == old_m
 
-        # avoid reprotecting a method
-        owner = new_m.owner
-        protected_method = "#{owner}.#{info[:name]}"
-        next if @protected_methods.include? protected_method
-        @protected_methods << protected_method
+        # method was modified! take some info
+        name = info[:name]
+        klass = info[:class]
 
-        if info[:type] == :instance
-          owner.send :define_method, info[:name] do |*args, &blk|
+        # instance and class methods are managed differently
+        if info[:instance]
+
+          ##########################################################
+          #
+          # PROTECT INSTANCE METHODS
+          #
+          ##########################################################
+
+          # 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)
+          end
+
+          ## print "#{klass}##{name}: "; p new_owners;
+
+          # redefine the method, which will check namebox visibility dinamically
+          klass.send :define_method, name do |*args, &blk|
+
+            # check namebox visibility
             if this_nb.open?
+
+              # call the protected (by namebox) method
+              # instance methods are unbound; must bind to self
               new_m.bind(self).call(*args, &blk)
+
             else
-              # try previous method or super
+
+              # search a different method to call
+              # must be dynamic because it can change anytime
+              # (someone can attach a new definition to some ancestor)
+
               begin
-                old_m ? old_m.bind(self).call(*args, &blk) : super(*args, &blk)
-              rescue NoMethodError
+                # 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
+
+              rescue NameError
+
+                # didn't find a different method; raise NoMethodError
+
+                # if inspect is too big, shorten it
                 obj = self.inspect.to_s
                 obj = obj[0..45] + '...' + obj[-1] if obj.length > 50
-                raise NoMethodError.new("Undefined instance method `#{info[:name]}' for #{obj}:#{self.class}")
+
+                raise NoMethodError.new("Undefined instance method `#{name}' " +
+                                        "for #{obj}:#{self.class}")
               end
+
+              # play as self
+              m.bind(self).call(*args, &blk)
             end
           end
+
         else
-          # class methods
-          owner.send :define_method, info[:name] do |*args, &blk|
+
+          ##########################################################
+          #
+          # PROTECT CLASS METHODS
+          #
+          ##########################################################
+
+          # 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)
+          end
+
+          ## print "#{klass.inspect}.#{name}: "; p new_owners;
+
+          # redefine class method thru eigenclass
+          class << klass; self; end.send :define_method, name do |*args, &blk|
+
+            # check namebox visibility
             if this_nb.open?
+
+              # call the protected (by namebox) method
+              # new_m is already bound to self; just call it
               new_m.call(*args, &blk)
+
             else
-              # try previous method or super
+
+              # search a different method to call
+              # must be dynamic because it can change anytime
+              # (someone can extend an ancestor with some module)
+
               begin
-                old_m ? old_m.call(*args, &blk) : super(*args, &blk)
-              rescue NoMethodError
-                raise NoMethodError.new("Undefined class method `#{info[:name]}' for #{self}:#{self.class}")
+                # try before owner (after klass - this method)
+                m = Namebox.class_super_method(name, klass)
+
+                # skip new owners
+                while new_owners.include?(m_owner = Namebox.class_owner(m))
+                  m = Namebox.class_super_method(name, klass, m_owner)
+                end
+
+                # bind to self (can throw TypeError in 1.8.7)
+                m = m.unbind.bind(self)
+
+              rescue NameError
+
+                # didn't find a different method
+                raise NoMethodError.new("Undefined class method `#{name}' " +
+                                        "for #{self}:#{self.class}")
+
+              rescue TypeError
+
+                # Ruby 1.8.7 does not bind singleton methods to descendant class;
+                # use current m anyway
+
               end
+
+              # run!
+              m.call(*args, &blk)
+
             end
           end
         end
       end
     end
-
   end
 
+
+  # open a namebox region for visibility in the caller file at caller line
   def open
     info = ranges_info
 
     # there must be no open range
-    raise "Namebox was already opened in #{info[:file]}:#{info[:last]}" if info[:last]
+    if info[:last]
+      raise "Namebox was already opened in #{info[:file]}:#{info[:last]}"
+    end
 
     # range in progress
     info[:ranges] << info[:line]
   end
 
+
+  # close the namebox region in the caller file
   def close
     info = ranges_info
 
     # there must be an open range in progress
-    raise "Namebox was not opened in #{info[:file]} before line #{info[:line]}" unless info[:last]
+    unless info[:last]
+      raise "Namebox was not opened in #{info[:file]} before line #{info[:line]}"
+    end
 
     # begin of range must be before end
     r_beg = info[:last]
     r_end = info[:line]
-    raise "Namebox#close in #{info[:file]}:#{r_end} should be after Namebox#open (line #{r_beg})" unless r_end >= r_beg
-    r = Range.new(r_beg, r_end)
+    unless r_end >= r_beg
+      raise ("Namebox#close in #{info[:file]}:#{r_end} should be after " +
+            "Namebox#open (line #{r_beg})")
+    end
 
     # replace the single initial line with the range, making sure it's unique
+    r = Range.new(r_beg, r_end)
     info[:ranges].pop
     info[:ranges] << r unless info[:ranges].include? r
   end
 
+  # check namebox' visibility
   def open?
+
     # check file before checking ranges
     ci = Namebox.caller_info
     return true if @enabled_files.include? ci[:file]
@@ -209,14 +417,22 @@ class Namebox
     info[:ranges].each do |r|
       case r
       when Range
+
+        # check if caller is in an open range for this namebox
         return true if r.include?(info[:line])
+
       when Integer
+
+        # check if caller is after an initied range (Namebox#open)
         return true if info[:line] >= r
+
       end
     end
     false
   end
 
+
+  # open namebox in entire caller file (valid only after called!)
   def file_wide
     @enabled_files << Namebox.caller_info[:file]
   end
@@ -225,6 +441,7 @@ class Namebox
 
   # Get line ranges info for the caller file
   def ranges_info ci = Namebox.caller_info
+
     ranges = enabled_ranges[ci[:file]] ||= []
     ci[:ranges] = ranges
 
@@ -240,19 +457,25 @@ class Namebox
     @enabled_ranges ||= {}
   end
 
-  # get methods in use
+  # get methods in use thru modules to protect
   def get_methods
     gm = {}
+
     @modules.each do |c|
+
       c.instance_methods.each do |m|
         fullname = "#{c}##{m}"
-        gm[fullname] = {:type => :instance, :name => m, :method => c.instance_method(m) }
+        gm[fullname] = {:class => c, :instance => true, :name => m,
+                        :method => c.instance_method(m) }
       end
+
       c.methods.each do |m|
         fullname = "#{c}.#{m}"
-        gm[fullname] = {:type => :class, :name => m, :method => c.method(m) }
+        gm[fullname] = {:class => c, :name => m, :method => c.method(m) }
       end
+
     end
+
     gm
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namebox
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-05 00:00:00.000000000 Z
+date: 2013-01-11 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: sony.fermino@gmail.com