namebox 0.0.0

data/lib/namebox.rb

@@ -0,0 +1,258 @@
+# Namebox for Ruby
+#
+# (c) 2012 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
+
+  class << self
+
+    # 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]
+      raise "Unable to find a valid caller file in #{caller.inspect}" unless c
+
+      m = c.match(/^(.*?):(\d+)(:in `(.*)')?$/)
+      raise "Unexpected caller syntax in \"#{c}\"" unless m
+
+      {: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}'") }
+    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
+      end
+      if RUBY_VERSION >= "1.9"
+        get_modules19 Object
+      else
+        get_modules18 Object
+      end
+      @all_modules.uniq!
+      @all_modules.dup
+    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
+
+    private
+
+    # 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
+    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) }
+      end
+    end
+
+  end
+
+  # +modules+ are 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.
+  # :core => protect the known top-level modules.
+  # :default => protect the modules defined in Namebox.default_modules for the caller file.
+  # 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
+    @enabled_files = []
+    @protected_methods = []
+
+    # by default, get Namebox.default_modules
+    modules_to_protect = Namebox.default_modules if modules_to_protect.empty?
+    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
+    else
+      @modules = modules_to_protect.select { |m| m.is_a? Module }
+      @modules += Namebox.default_modules if modules_to_protect.include? :default
+      @modules += CORE if modules_to_protect.include? :core
+      @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?
+
+    # update modules list and save preexisting data
+    methods_before = get_methods
+
+    blk.call
+
+    # compare with preexisting data to discover affected methods
+    methods_after = get_methods
+
+    # refine the new methods!
+    unless methods_after == methods_before
+
+      this_nb = self
+      methods_after.each do |fullname, info|
+
+        info_old = methods_before[fullname] || {}
+        new_m = info[:method]
+        old_m = info_old[:method]
+
+        # 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
+
+        if info[:type] == :instance
+          owner.send :define_method, info[:name] do |*args, &blk|
+            if this_nb.open?
+              new_m.bind(self).call(*args, &blk)
+            else
+              # try previous method or super
+              begin
+                old_m ? old_m.bind(self).call(*args, &blk) : super(*args, &blk)
+              rescue NoMethodError
+                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}")
+              end
+            end
+          end
+        else
+          # class methods
+          owner.send :define_method, info[:name] do |*args, &blk|
+            if this_nb.open?
+              new_m.call(*args, &blk)
+            else
+              # try previous method or super
+              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}")
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+  def open
+    info = ranges_info
+
+    # there must be no open range
+    raise "Namebox was already opened in #{info[:file]}:#{info[:last]}" if info[:last]
+
+    # range in progress
+    info[:ranges] << info[:line]
+  end
+
+  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]
+
+    # 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)
+
+    # replace the single initial line with the range, making sure it's unique
+    info[:ranges].pop
+    info[:ranges] << r unless info[:ranges].include? r
+  end
+
+  def open?
+    # check file before checking ranges
+    ci = Namebox.caller_info
+    return true if @enabled_files.include? ci[:file]
+
+    # check ranges for this file
+    info = ranges_info ci
+    info[:ranges].each do |r|
+      case r
+      when Range
+        return true if r.include?(info[:line])
+      when Integer
+        return true if info[:line] >= r
+      end
+    end
+    false
+  end
+
+  def file_wide
+    @enabled_files << Namebox.caller_info[:file]
+  end
+
+  private
+
+  # Get line ranges info for the caller file
+  def ranges_info ci = Namebox.caller_info
+    ranges = enabled_ranges[ci[:file]] ||= []
+    ci[:ranges] = ranges
+
+    # check whether there is an opened range in progress for the caller file
+    last = ranges[-1]
+    ci[:last] = last if last.is_a? Integer
+
+    ci
+  end
+
+  # Stores enabled line ranges of caller files for this module
+  def enabled_ranges
+    @enabled_ranges ||= {}
+  end
+
+  # get methods in use
+  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) }
+      end
+      c.methods.each do |m|
+        fullname = "#{c}.#{m}"
+        gm[fullname] = {:type => :class, :name => m, :method => c.method(m) }
+      end
+    end
+    gm
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: namebox
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sony Santos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-05 00:00:00.000000000 Z
+dependencies: []
+description: A simple hello world gem
+email: sony.fermino@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/namebox.rb
+homepage: http://rubychallenger.blogspot.com.br/2013/01/namebox.html
+licenses:
+- Public Domain
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Create namespace boxes to protect the core classes' methods from changes,
+  like refinements
+test_files: []