rmtools 1.2.0 → 1.2.2b

data/Manifest.txt

@@ -17,8 +17,8 @@ lib/rmtools/dev/binding.rb
 lib/rmtools/dev/logging.rb
 lib/rmtools/dev/trace_format.rb
 lib/rmtools/dev/highlight.rb
+lib/rmtools/dev/code_reading.rb
 lib/rmtools/dev/timer.rb
-lib/rmtools/dev/code_reader.rb
 lib/rmtools/xml/xpath.rb
 lib/rmtools/xml/string.rb
 lib/rmtools/xml/libxml.rb
@@ -33,6 +33,7 @@ lib/rmtools/core/string_compliance.rb
 lib/rmtools/core/kernel.rb
 lib/rmtools/core/boolean.rb
 lib/rmtools/core/aliases.rb
+lib/rmtools/core/threadify.rb
 lib/rmtools/core/module.rb
 lib/rmtools/core/object.rb
 lib/rmtools/core/deprecation.rb
@@ -66,7 +67,6 @@ lib/rmtools/fs.rb
 lib/rmtools/ip.rb
 lib/rmtools/lang.rb
 lib/rmtools/functional.rb
-lib/rmtools/load.rb
 lib/rmtools/install.rb
 lib/rmtools/functional/decorate.rb
 lib/rmtools/functional/fold.rb
@@ -88,6 +88,7 @@ lib/rmtools/conversions/string.rb
 lib/rmtools/conversions/enum.rb
 lib/rmtools/conversions/int.rb
 lib/rmtools/enumerable.rb
+lib/rmtools/init.rb
 lib/rmtools/dev_min.rb
 lib/rmtools_dev.rb
 ./Rakefile

data/README.txt

@@ -14,7 +14,7 @@ Methods for basic classes addon collection.
 * Slightly extended StringScanner
 * Proof of concept: Regexp reverse (wonder if someone did it earlier in Ruby)
 * Kernel#whose? to find classes and/or modules knowing some method
-* Method code lookup over all loaded libs (it can't handle evals yet), see dev/code_lookup.rb
+* Method code lookup over all loaded libs (it can't handle evals yet), see dev/code_reading.rb
 * Coloring is now made by singleton `Painter' and have option for transparent coloring
 
 === Version 1.1.14

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake'
 require 'lib/rmtools/install'
 compile_manifest
 
-RMTOOLS_VERSION = '1.2.0'
+RMTOOLS_VERSION = '1.2.2b'
 begin
     require 'hoe'
     config = Hoe.spec 'rmtools' do

data/ext/rmtools.cpp

@@ -20,15 +20,17 @@ using namespace std;
 static VALUE object_define_new_value(VALUE self, VALUE new_obj)
 {
     if (FIXNUM_P(self) || self == Qnil || self == Qfalse || self == Qtrue || self == Qundef) {
-        const char* msg = STR2CSTR(rb_mod_name(rb_obj_class(self)));
+        VALUE tmp = rb_mod_name(rb_obj_class(self));
+        const char* msg = StringValuePtr(tmp);
         rb_raise(rb_eTypeError, "can't redefine %s", msg);
     }
     if (FIXNUM_P(new_obj) || new_obj == Qnil || new_obj == Qfalse || new_obj == Qtrue  || new_obj == Qundef) {
-        const char* msg = STR2CSTR(rb_mod_name(rb_obj_class(new_obj)));
+        VALUE tmp = rb_mod_name(rb_obj_class(self));
+        const char* msg = StringValuePtr(tmp);
         rb_raise(rb_eTypeError, "can't define object as %s", msg);
     }
     // Place the definition of the new object in the slot of self
-    memcpy(reinterpret_cast<void*>(self), reinterpret_cast<void*>(new_obj), SLOT_SIZE);
+    memcpy(reinterpret_cast<void*>(self), reinterpret_cast<void*>(rb_funcall(new_obj, rb_intern("clone"), 0)), SLOT_SIZE);
     return self;
 }
 

data/lib/rmtools.rb

@@ -1,2 +1,2 @@
-require 'rmtools/load'
+require 'rmtools/init'
 RMTools::require 'dev_min'

data/lib/rmtools/core/arguments.rb

@@ -12,7 +12,7 @@ class Array
     if Hash === defaults
       opts, defaults = defaults, []
       return_hash = true
-      $log.warn "fetch_opts(<hash>) now changed, if you want to jsut fetch hash options, use `opts = <hash>.merge(opts||{})' construction"
+      $log.warn "fetch_opts(<hash>) now changed, if you want to jsut fetch hash options, use `opts = <hash>.merge(opts||{})' construction", :caller => 2
     else
       return_hash = false
     end

data/lib/rmtools/core/class.rb

@@ -46,4 +46,4 @@ class Class
   
 end
 
-[Hash, Regexp, File, Dir].each {|klass| klass.__init__}
+[Hash, Regexp, File, Dir, Range, Class, Module].each {|klass| klass.__init__}

data/lib/rmtools/core/kernel.rb

@@ -3,6 +3,8 @@ module Kernel
   
   # re-require
   def require!(file)
+    ['.rb', '.so', '.dll', ''].each {|ext| $".delete "#{file}#{ext}"}
+    file = File.expand_path file
     ['.rb', '.so', '.dll', ''].each {|ext| $".delete "#{file}#{ext}"}
     require file
   end
@@ -23,12 +25,13 @@ module Kernel
   end
     
   def executing? file=$0
-    caller(0)[0] =~ /^#{file}:/
+    caller[0] =~ /^#{file}:/
   end
   
   def whose?(method, *opts)
-    opts = opts.get_opts [:flags], :ns => :public
-    checker = :"#{ns}_method_defined?"
+    opts = *opts.get_opts([:flags], :ns => :public)
+    opts[:modules] ||= opts[:mod]
+    checker = :"#{opts[:ns]}_method_defined?"
     if Array === method
       methods = method.to_syms
     else 

data/lib/rmtools/core/object.rb

@@ -46,6 +46,27 @@ class Object
   
   def in(*container)
     container.size == 1 ? container[0].include?(self) : container.include?(self)
+  end  
+  
+  def deep_clone
+    _deep_clone({})
+  end
+
+protected
+  def _deep_clone(cloning_map)
+    return cloning_map[self] if cloning_map.key? self
+    cloning_obj = clone
+    cloning_map[self] = cloning_obj
+    cloning_obj.instance_variables.each do |var|
+      val = cloning_obj.instance_variable_get(var)
+      begin
+        val = val._deep_clone(cloning_map)
+      rescue TypeError
+        next
+      end
+      cloning_obj.instance_variable_set(var, val)
+    end
+    cloning_obj
   end
   
 end

data/lib/rmtools/core/threadify.rb

@@ -0,0 +1,17 @@
+module RMTools
+
+  def threadify(ary, max_threads=4)
+    forks = []
+    ary.each do |e|
+      if max_threads > forks.size
+        forks << fork { yield e }
+      end
+      if max_threads == forks.size
+        forks.delete Process.wait
+      end
+    end
+    Process.waitall
+  end
+
+  module_function:threadify
+end

data/lib/rmtools/db/active_record.rb

@@ -76,6 +76,33 @@ module ActiveRecord
       find_by_sql(["SELECT * FROM #{quoted_table_name} WHERE #{primary_key} = ?", id])[0]
     end
     
+    # values must be 2-tuple array [[column1, value1], [column2, value2], ...] and columns must be in order they've been created
+    def self.insert_unless_exist(table, values)
+      table = connection.quote_table_name table
+      if execute_sanitized(["SELECT COUNT(*) FROM #{table} WHERE #{vaues.firsts.map {|v| "#{connection.quote_column_name v}=?"}*' AND '} LIMIT 1", *values.lasts]).to_a.flatten > 0
+        false
+      else
+        execute_sanitized ["INSERT INTO #{table} VALUES (#{['?']*values.size*','})", *values.lasts]
+        true
+      end
+    end
+    
+    def resource_path
+      "#{self.class.name.tableize}/#{id}"
+    end
+    
+  end
+  
+  class Relation
+    
+    def any?
+      limit(1).count != 0
+    end
+    
+    def empty?
+      limit(1).count == 0
+    end
+    
   end
     
 end

data/lib/rmtools/dev/code_reading.rb

@@ -0,0 +1,556 @@
+# encoding: utf-8
+RMTools::require 'text/string_scanner'
+
+module RMTools
+  class CodeReader
+    attr_reader :MethodCache, :stack
+    
+    module Defaults
+      Leftop = leftop = '\[{(<=>~+\-*,;:^&\|'
+      rightop = '\])}?!'
+      sname = '\w<=>~+\-*/\]\[\^%!?@&\|'
+      compname = "([\\.:#{sname}]+)"
+      name = "([#{sname}]+)"
+      mname = '([:\w]+)'
+      call_ = '(\{s*\||([\w][?!]?|\)|\.((\[\]|[<=>])?=[=~]?|[<>*\-+/%^&\|]+))[ \t]*\{)'
+      space = '[ \t]+'
+      space_ = '[ \t]*'
+      kw = 'if|elsif|else|unless|while|until|case|begin|rescue|when|then|or|and|not'
+      heredoc_handle = %q{<<(-)?(\w+|`[^`]+`|'[^']+'|"[^"]+")}
+      heredoc = %{([\\s#{leftop}?]|[#{leftop}\\w!?][ \t])\\s*#{heredoc_handle}}
+      re_sugar = %{(^|[#{leftop}\\n?;]|\W!|\\b(#{kw})[ \t]|[\\w#{rightop}]/)\\s*/}
+      percent = '%([xwqrQW])?([\\/<({\[!\|])'
+      simple = [re_sugar, percent, '[#\'"`]']*'|'
+      mod_def = "module +#{mname}"
+      class_def = "class(?: *(<<) *| +)([$@:\\w]+)(?: *< *#{mname})?"
+      method_def = "def +#{compname}"
+      alias_def = "alias +:?#{name} +:?#{name}"
+      Ender = '\s*\)? *(?:end\b|[\n;})\]])'
+      
+      StringParseRE = /#{heredoc}|#{simple}|[{}]|[^\w#{rightop}'"`\/\\]\?\\?\S/m
+      HeredocParseRE = /\n|#{heredoc}|#{simple}/m
+      ArgumentsParseRE = /#{simple}|[{}()\[\]\n;,\|]| end\b|[:@$.\w!?]+(\b|[( ] *)| +[:?]\s+| *=>\s*/m
+      
+      StringRE = /(^['"`]$)|^#{percent}$/
+      RERE = %r{(?:^|[#{leftop}\w!\s/])\s*(/)}
+      HeredocRE = heredoc_handle.to_re
+      Symbol = /^:#{name}$/
+      Attrs = /\s(c)?(?:attr_(reader|writer|accessor))[( ] *((?::\w+ *,\s*)*:\w+)#{Ender}/
+      Include = /\s(include|extend) +#{mname}/
+      AliasMethod = /\salias_method :#{name} *,\s*:#{name}/
+      Beginners = /(([#{leftop}\n]?\s*)(if|unless|while|until))#{
+        }|(.)?(?:(do|for)|begin|case)/
+      EOF = /($0\s*==\s*__FILE__\s*|__FILE__\s*==\s*\$0\s*)?\n/
+      BlockOpen = /(?:^\{\s*\||.\{)$/
+      Ord = /^\W\?\\?\S$/
+      
+      MainParseRE = /#{simple
+        }|#{call_}|[{}]#{
+        }|(^|\n)=begin\b#{
+        }|^\s*[;\(]? *(#{mod_def}|#{method_def})#{
+        }|:#{name}#{
+        }|[^\w#{rightop}'"`\/\\]\?\\?\S#{
+        }|#{heredoc
+        }|(^|[#{leftop}\n])\s*((if|unless)\b|#{
+                                                    }[;\(]? *#{class_def})#{
+        }|(^|[\n;])\s*(while|until)\b#{
+        }|(^|[#{leftop}\s?])(do|case|begin|for)\b#{
+        }\s(c)?(?:attr_(reader|writer|accessor))[( ] *((?::\w+ *,\s*)*:\w+)#{Ender
+        }|\salias_method +:#{name} *,\s*:#{name
+        }|\s(include|extend)[( ] *#{mname
+        }|(^|[;\s])(#{alias_def}|end|__END__)\b/m
+        
+      ModDef = mod_def.to_re
+      ClassDef = class_def.to_re
+      MethodDef = method_def.to_re
+      AliasDef = alias_def.to_re
+      
+      def self::Class(s, m)       
+        debug
+        _stack = clean_stack
+        if _stack[-1] == [:block]
+            stack << [:beginner]
+        elsif m[1]
+            if m[2] =~ /^[@$]/
+                stack << [:beginner]
+            elsif _stack.any? and _stack[-1][0] == :def
+                stack << [:beginner]
+            else
+                slf = _stack.lasts*'::'
+                name = m[2].sub 'self.', ''
+                name.sub! 'self', slf
+                name = fix_module_name slf, name
+                stack << [:singleton, name]
+            end
+        else
+            new = clean_stack.lasts*'::'
+            stack << [:class, m[2]]
+            name = fix_module_name new, m[3] if m[3]
+            new << '::' if new.b
+            new << m[2]
+            MethodCache[new] ||= {}
+            inherit! new, name if m[3]
+        end
+      end
+      
+      def self::Module(s, m)
+        debug
+        stack << [:mod, m[1]]
+        MethodCache[clean_stack.lasts*'::'] = {}
+      end
+      
+      def self::Method(s, m)
+        debug
+        _stack = clean_stack(true)
+        if _stack[-1] == [:block]
+            stack << [:beginner]
+        end
+        start = s.pos - s.matched[/[^\n]+$/].size
+        name = m[1].sub(/::([^:.]+)$/, '.\1')
+        name.sub!(/#{_stack.last[1]}\./, 'self.') if _stack.any?
+        if name[/^self\.(.+)/]
+            stack << [:def, "#{_stack.lasts*'::'}.#$1", start]
+        elsif name['.'] and name =~ /^[A-Z]/
+            mod, name = name/'.'
+            fix_module_name(_stack.lasts*'::', mod) >> '.' >> name
+            stack << [:def, name, start]
+        else
+            prefix = (_stack.any? && _stack[-1][0] == :singleton) ? _stack[-1][1]+'.' : _stack.lasts*'::'+'#'
+            stack << [:def, prefix+name, start]
+        end
+      end
+      
+      def self::Alias(s, m)
+        debug
+        _stack = clean_stack
+        case _stack.any? && _stack[-1][0]
+          when false, :def, :block
+              return
+          when :singleton
+              prefix = _stack[-1][1]
+              new, old = '.'+m[1], '.'+m[2]
+          else
+              prefix = _stack.lasts*'::'
+              new, old = '#'+m[1], '#'+m[2]
+        end
+        MethodCache[prefix][new] = MethodCache[prefix][old] || "def #{new}(*args)\n  #{old}(*args)\nend"
+      end
+      
+    end if !defined? Defaults
+      
+    Closers = {'<' => '>', '{' => '}', '[' => ']', '(' => ')'}
+    
+    def init_instructions
+      [
+          [/^\#/, lambda {|s, m| s.scan_until(/\n/)}],
+          [@Processor::StringRE, method(:string)],
+          
+          [/^\{$/, lambda {|s, m| 
+            debug
+            $log.debug @curls_count
+            @curls_count += 1
+          }],
+          
+          [/^\}$/, method(:curl_close)],
+          [@Processor::Ord],
+          
+          [@Processor::BlockOpen, lambda {|s, m| 
+            debug
+            $log.debug @curls_count
+            @stack << [:block]
+          }],
+          
+          [@Processor::ModDef, @Processor.method(:Module)],
+          [@Processor::ClassDef, @Processor.method(:Class)],
+          [@Processor::MethodDef, @Processor.method(:Method)],
+          [@Processor::AliasDef, @Processor.method(:Alias)],
+          [@Processor::Symbol],
+          [@Processor::RERE, method(:string)],
+          [@Processor::HeredocRE, method(:heredoc)],
+          
+          [/(^|\n)=begin/, lambda {|s, m| s.scan_until(/\n=end\s*\n/m)}],
+          
+          [@Processor::Attrs, lambda {|s, m|
+            attr_accessors s, m
+            if s.matched =~ / end$/
+              end!(s)
+            elsif s.matched =~ /[^\?]}$/
+              curl_close
+            end
+          }],
+          
+          [@Processor::Include, lambda {|s, m|
+            _stack = clean_stack
+            if _stack.empty?
+              if m[1] == 'include'
+                inherit! 'Object', m[2] 
+              else
+                inherit_singletons! 'Object', m[2] 
+              end
+            elsif !_stack[-1][0].in([:def, :block]) and m[2] =~ /^[A-Z]/
+              if m[1] == 'include'
+                inherit! _stack.lasts*'::', m[2] 
+              else
+                inherit_singletons! _stack.lasts*'::', m[2] 
+              end
+            end
+          }],
+          
+          [@Processor::AliasMethod, lambda {|s, m|
+            _stack = clean_stack
+            if _stack[-1][0] == :class
+              new, old = m[1..2]
+              prefix = _stack.lasts*'::'
+              @MethodCache[prefix][new] = @MethodCache[prefix][old] || "def #{new}(*args)\n  #{old}(*args)\nend"
+            end
+          }],
+          
+          [@Processor::Beginners, lambda {|s, m|
+            debug
+            $log.debug [m, s.last, s.string[s.last-1,1].to_s]
+            if (m[2] and s.last != 0 and m[2].tr(' \t', '').empty? and !(s.string[s.last-1,1].to_s)[/[\n;({\[]/])
+            else
+              if m[3] == 'if' and @stack.empty? and s.check_until(@Processor::EOF) and s.matched != "\n"
+                throw :EOF
+              end
+              @stack << [m[5] ? :block : :beginner]
+            end
+          }],
+          
+          [/(^|[\s;])end.?/, method(:end!)],
+          [/(^|[\s;])__END__/, lambda {|s, m| throw :EOF}]
+      ].dup
+    end
+      
+    def debug(s,m)
+      $log.debug(:caller=>2) {"#{s.string[0, s.pos].count("\n")+1}:#{s.head.size + s.matched_size - ((s.head+s.matched).reverse.index("\n") || 0)}"}
+      $log.debug(@stack, :caller=>2)
+      $log.debug(:caller=>2) {Painter.g(s.head+s.matched)}
+    end
+    
+    def initialize(instructions_module=Defaults)
+      @MethodCache = {'Object' => {}}
+      @ReadPaths = {}
+      @Processor = instructions_module
+      @Instructions = init_instructions
+      @MainParseRE = @Processor::MainParseRE
+      add_method_seeker('get_opts') {|s, args| $log << args}
+    end
+    
+    def add_instruction(re, &callback)
+      @MainParseRE |= re 
+      @Instructions << [re, callback]
+    end
+    
+    def add_method_seeker(name, *args, &callback)
+      pattern = /(?:^|[\s#{@Processor::Leftop}])(#{name})[( ] */
+      add_instruction(pattern) {|s, m|
+        yield s, arguments(s, m)
+      }
+    end
+    
+    # Parser methods
+    
+    def arguments(s, m)
+      arg_list = [m[1]]
+      counts = {'}' => 0, ']' => 0, ')' => 0}
+      catch(:EOL) {s.each(@Processor::ArgumentsParseRE, [
+          [/^[{\[(]$/, lambda {|s, m| counts[Closers[m[0]]] += 1}],
+          [/^[}\])]$/, lambda {|s, m| 
+            if counts[m[0]] > 0
+              counts[m[0]] -= 1
+            else
+              curl_close
+              throw :EOL
+            end
+          }],
+          [/^[,\|]$/, lambda {|s, m| s.scan_until(/\s*/m)}],
+          [/[#\n;]| end\b/, lambda {|s, m| 
+            s.scan_until(/\n/) if m[0] == '#'
+            heredoc_list.each {|opener| string(s, [nil]*4+opener)}
+            throw :EOL
+          }],
+          [@Processor::StringRE, lambda {|s, m| 
+            str = [s.pos-1, string(s, m)]
+            str[1] ? arg_list << s.string[str[0]...str[1]] : arg_list << s.string[str[0]-1..str[0]]
+          }],
+          [@Processor::RERE, lambda {|s, m| 
+            str = [s.pos-1, string(s, m)]
+            arg_list << s.string[str[0]...str[1]]
+          }],
+          [/^ +[:?]\s+$/],
+          [/^ *=>\s*$/, lambda {|s, m| arg_list << '=>'}],
+          [/^[:@$.\w!?]+([( ] *)?$/, lambda {|s, m| 
+            str = [s.pos-s.matched_size, arguments(s, m) && s.pos]
+            arg_list << s.string[str[0]...str[1]] if str[1]
+          }]
+      ])}
+      arg_list
+    end
+    
+    def string(s, m)
+      debug
+      return if m[1] and s.- == '$'
+      opener = m[1] || m[3] || m[5]
+      $log.log {"entering #{opener}-quotes, matched as '#{Painter.g s.matched}' at #{s.string[0..s.pos].count("\n")+1}"}
+      if opener == m[5]
+        closer = opener = m[5].tr('`\'"', '')
+        quote_re = /\\|\n#{'\s*' if m[4]}#{closer}/
+      else
+        closer = Closers[opener] || opener
+        quote_re = /\\|#{Regexp.escape closer}/
+      end
+      openers_cnt = 1
+      inner_curls_count = 0
+      backslash = false
+      quote_re |= /#\{/ if (m[5] and m[5].ord != ?') or closer =~ /[\/"`]/ or (m[2] =~ /[xrQW]/ or m[3])
+      instructions = [
+        [@Processor::Ord],
+        [/\s*#{Regexp.escape closer}$/, lambda {|s, m|
+          if backslash
+            backslash = false
+            break if s.- == '\\' and m[0] == closer
+          end
+          if (openers_cnt -= 1) == 0
+            $log.log {"exiting through #{closer}-quotes at #{s.string[0...s.pos].count("\n")+1}"}
+            throw :EOS 
+        else
+            $log.log 'decreasing openers count'
+          end
+        }],
+        [/\\/, lambda {|s, m|
+          prev = s.-
+          backslash = true
+          if prev == '\\'
+            i = 2
+            while prev == '\\'
+              prev = s.prev_in i
+              i += 1
+              backslash = !backslash
+            end
+          end
+        $log.log {"#{!backslash ? 'closed' : 'found'} \\ in #{opener}-quotes at #{s.string[0, s.pos].count("\n")+1}"}
+        }],
+        [/\#\{/, lambda {|s, m| 
+          if backslash
+            backslash = false
+            if s.- == '\\'
+              openers_cnt += 1 if closer == '}'
+              break
+            end
+          end
+        $log.log "entering curls"
+          inner_curls_count += 1
+          catch(:inner_out) {s.each(@Processor::StringParseRE, [
+              [/^\#$/, lambda {|s, m| 
+              $log.log 'reading comment'
+             s.scan_until(/\n/)}],
+              [/^\{$/, lambda {|s, m| 
+              $log.log "increasing curls count"
+              inner_curls_count += 1}],
+              [/^\}$/, lambda {|s, m| 
+              if (inner_curls_count -= 1) == 0
+                $log.log "exiting curls"
+                throw :inner_out
+              else
+                $log.log "decreasing curls count"
+              end}],
+              [@Processor::HeredocRE, method(:heredoc)],
+              [@Processor::StringRE, method(:string)],
+              [@Processor::RERE, method(:string)]
+          ])}
+        }]
+      ]
+      if closer != opener
+        quote_re |= /#{Regexp.escape opener}/
+        instructions << [/#{Regexp.escape opener}$/, lambda {|s, m|
+          if backslash
+            backslash = false
+            break if s.- == '\\'
+          end
+        $log.log 'increasing openers count'
+          openers_cnt += 1
+        }]
+        $log.debug [quote_re,instructions]
+      end
+        
+      catch(:EOS) {s.each(quote_re, instructions)}
+      s.pos
+    end
+    
+    def heredoc(s=nil, m)
+      heredoc_list = [m[1..2]]
+      catch(:EOL) {s.each(@Processor::HeredocParseRE, [
+          [/[#\n]/, lambda {|s, m| 
+            s.scan_until(/\n/) if m[0] == '#'
+            heredoc_list.each {|opener| string(s, [nil]*4+opener)}
+            throw :EOL
+          }],
+          [@Processor::HeredocRE, lambda {|s, m| heredoc_list << m[1..2]}],
+          [@Processor::StringRE, method(:string)],
+          [@Processor::RERE, method(:string)]
+      ])}
+    end
+    
+    def curl_close(*)
+      if @curls_count == 0
+        @stack.pop
+      else
+        @curls_count -= 1
+      end
+    end
+    
+    def end!(s, *)
+      debug
+      if s.+ !~ /[?!(]/
+        exit = @stack.pop
+        case exit[0]
+          when :def
+            prefix, name = exit[1].sharp_split(/[.@#]/, 2)
+            if !name
+              prefix, name = 'Object', prefix
+            end
+            if @MethodCache[prefix]
+              (@MethodCache[prefix][name] ||= []) << (path.inline ? [path, exit[2]...s.pos] : s.string[exit[2]...s.pos])
+            end
+        end
+      end
+    end
+    
+    def attr_accessors(s, m)
+      _stack = clean_stack
+      if _stack[-1][0] == :class
+        prefix = _stack.lasts*'::'
+        attrs = (m[3]/',').map {|attr| (m[1] ? '.' : '#')+attr.strip[1..-1]}
+        if m[2].in %w(reader accessor)
+          attrs.each {|attr| (@MethodCache[prefix][attr] ||= []) << "def #{'self.' if m[1]}#{attr}\n  #{'@' if m[1]}@#{attr}\nend"}
+        end
+        if m[2].in %w(writer accessor)
+          attrs.each {|attr| (@MethodCache[prefix][attr] ||= []) << "def #{'self.' if m[1]}#{attr}=value\n  #{'@' if m[1]}@#{attr} = value\nend"}
+        end
+      end
+    end
+
+    def parse_file(path)
+      @stack = []
+      
+      if path.inline
+        return if @ReadPaths[path]
+        lines = get_lines(path)[0]
+        @ReadPaths[path] = true
+      else
+        lines = path.sharp_split(/\n/)
+      end
+      if RUBY_VERSION > '1.9'
+        ss = StringScanner lines.join.force_encoding('UTF-8')
+      else
+        ss = StringScanner lines.join
+      end
+      
+      @curls_count = 0
+      catch(:EOF) { ss.each @MainParseRE, @Instructions }
+      raise "Can't parse: #{@stack.inspect}, #{ss.string[ss.last..ss.pos].inspect}" if @stack.any?
+      ss
+    end
+
+    def clean_stack(no_def=false)
+      @stack.select {|e| e[0] != :beginner and !no_def || e[0] != :def}
+    end
+
+    def inherit!(descendant, ancestor)
+      @MethodCache[descendant].reverse_merge((
+        @MethodCache[fix_module_name(descendant, ancestor)] ||= {}
+      ).map_values {|defs| defs.dup})
+    end
+
+    def inherit_singletons!(descendant, ancestor)
+      (@MethodCache[fix_module_name(descendant, ancestor)] ||= {}).each {|name, defs|
+        @MethodCache[descendant][name.sub('#', '.')] = defs.dup if name.ord == ?#
+      }
+    end
+
+    def fix_module_name(current, name)
+      if name =~ /^::/ or current == ''
+        current+name
+      elsif name == current or name == 'self'
+        current
+      elsif name !~ /^[A-Z]/
+        current+'#'+name
+      else 
+        path = current+'::'+name
+        if @MethodCache[path]
+          path
+        else 
+          @MethodCache[name] ||= {}
+          name
+        end
+      end
+    end
+
+    def get_lines(path)
+      SCRIPT_LINES__.to_a.select {|d, f| d[path]}.to_a.lasts
+    end
+    
+    def print_lines(prefix, name, all)
+      map = lambda {|lines|
+          if lines.is Array
+            lines = SCRIPT_LINES__[lines[0]].join[lines[1]]
+          end
+          lines           }
+      methods = all ? @MethodCache[prefix][name].map(&map) : map.call(@MethodCache[prefix][name].last)
+      puts methods
+    end
+
+    def code_of(path, name=nil, all=false)
+      if name.in [true, :all]
+        all = true
+      end
+      if path.is String
+        prefix, name = path.sharp_split(/[.#]/, 2)
+      elsif Class === path
+        prefix = path.name
+        name = ".#{name}"
+      else
+        prefix = path.class.name
+        name = "##{name}"
+      end
+      if !(@MethodCache[prefix]||{})[name]
+        puts "looking up script lines, please wait..."
+        SCRIPT_LINES__.each_key {|k| parse_file k
+                                                    break if (@MethodCache[prefix]||{})[name]
+        }
+      end
+      if !(@MethodCache[prefix]||{})[name]
+        print "nothing was found for #{prefix}#{name}"
+        name = name.tr('#.', '.#')
+        if (@MethodCache[prefix]||{})[name]
+          puts ", but found for #{name}:"
+          print_lines prefix, name, all
+        else  puts ''
+        end
+      else
+        puts "code for #{prefix}#{name}:"
+        print_lines prefix, name, all
+      end
+    end
+
+  end  
+  
+  Reader = CodeReader.new
+end
+
+module Kernel
+  
+  def code_of(*args)
+    RMTools::Reader.code_of(*args)
+  end
+
+end
+
+class Method
+  
+  def code(all=false)
+    RMTools::Reader.code_of(receiver, name, all)
+  end
+  
+end