rmtools 1.2.2b → 1.2.2c

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

data/Rakefile

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

data/lib/rmtools/console/coloring.rb

@@ -72,6 +72,7 @@ module RMTools
       ['sub', 'gsub', 'sub!', 'gsub!'].each {|m| 
         class_eval %{
       def #{m.sub'sub','hl'} str, pattern, color=:red_bold
+        pattern = pattern.to_s unless pattern.is Regexp
         str.#{m} pattern do |word|
           if str[/^\\e\\[(\\d+(;\\d+)?)/]
             "\\e[m\#{send(color, word)}\\e[\#$1m"
@@ -80,6 +81,12 @@ module RMTools
           end
         end
       end
+      }
+        String.class_eval %{
+      def #{m.sub'sub','hl'} pattern, color=:red_bold
+        Painter.#{m.sub'sub','hl'} self, pattern, color
+        self
+      end
       }
       }
       

data/lib/rmtools/db/active_record.rb

@@ -1,6 +1,4 @@
 # encoding: utf-8
-require 'active_record'
-
 module ActiveRecord
 
   def self.establish_connection_with config

data/lib/rmtools/dev/{code_reading.rb → code_reader.rb}

@@ -6,7 +6,7 @@ module RMTools
     attr_reader :MethodCache, :stack
     
     module Defaults
-      Leftop = leftop = '\[{(<=>~+\-*,;:^&\|'
+      Leftop = leftop = '\[{(<=>~+\-*,;^&\|'
       rightop = '\])}?!'
       sname = '\w<=>~+\-*/\]\[\^%!?@&\|'
       compname = "([\\.:#{sname}]+)"
@@ -17,8 +17,8 @@ module RMTools
       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*/}
+      heredoc = %{([\\s#{leftop}?]|[#{leftop}:\\w!?][ \t])\\s*#{heredoc_handle}}
+      re_sugar = %{(^|[#{leftop}\\n?;]|\W!|(^|[\{(,;\\s])(#{kw})[ \t]|[\\w#{rightop}]/)\\s*/}
       percent = '%([xwqrQW])?([\\/<({\[!\|])'
       simple = [re_sugar, percent, '[#\'"`]']*'|'
       mod_def = "module +#{mname}"
@@ -29,14 +29,18 @@ module RMTools
       
       StringParseRE = /#{heredoc}|#{simple}|[{}]|[^\w#{rightop}'"`\/\\]\?\\?\S/m
       HeredocParseRE = /\n|#{heredoc}|#{simple}/m
-      ArgumentsParseRE = /#{simple}|[{}()\[\]\n;,\|]| end\b|[:@$.\w!?]+(\b|[( ] *)| +[:?]\s+| *=>\s*/m
+      ArgumentsParseRE = /#{simple
+        }|(\d[\d.]+|:[@$_a-z]\w*|[@$]\w+) *#{
+        }|([@$_a-z][:.\w!?]+)([(`"' ] *|:['"]?)?#{
+        }| *( [:?]\s|=[>~]|[<!>]=|[+\-\|*%,])\s*#{
+        }|[{}()\[\]\n;,\|]| end\b/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}/
+      Include = /\s(include|extend)[( ] *#{mname}/
       AliasMethod = /\salias_method :#{name} *,\s*:#{name}/
       Beginners = /(([#{leftop}\n]?\s*)(if|unless|while|until))#{
         }|(.)?(?:(do|for)|begin|case)/
@@ -48,14 +52,14 @@ module RMTools
         }|#{call_}|[{}]#{
         }|(^|\n)=begin\b#{
         }|^\s*[;\(]? *(#{mod_def}|#{method_def})#{
-        }|:#{name}#{
+        }|:#{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
+        }|\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
@@ -65,8 +69,14 @@ module RMTools
       MethodDef = method_def.to_re
       AliasDef = alias_def.to_re
       
-      def self::Class(s, m)       
-        debug
+      def debug(s)
+        $log.debug(:caller=>1) {"#{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=>1)
+        $log.debug(:caller=>1) {Painter.g(s.head+s.matched)}
+      end
+      
+      def Class(s, m)       
+        debug(s)       
         _stack = clean_stack
         if _stack[-1] == [:block]
             stack << [:beginner]
@@ -88,40 +98,41 @@ module RMTools
             name = fix_module_name new, m[3] if m[3]
             new << '::' if new.b
             new << m[2]
-            MethodCache[new] ||= {}
+            @MethodCache[new] ||= {}
             inherit! new, name if m[3]
         end
       end
       
-      def self::Module(s, m)
-        debug
+      def Module(s, m)
+        debug(s)       
         stack << [:mod, m[1]]
-        MethodCache[clean_stack.lasts*'::'] = {}
+        @MethodCache[clean_stack.lasts*'::'] = {}
       end
       
-      def self::Method(s, m)
-        debug
+      def Method(s, m)
+        debug(s)
         _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 << [:beginner]
+        else
+          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]/
+          elsif name['.'] and name =~ /^[A-Z]/
             mod, name = name/'.'
             fix_module_name(_stack.lasts*'::', mod) >> '.' >> name
             stack << [:def, name, start]
-        else
+          else
             prefix = (_stack.any? && _stack[-1][0] == :singleton) ? _stack[-1][1]+'.' : _stack.lasts*'::'+'#'
             stack << [:def, prefix+name, start]
+          end
         end
       end
       
-      def self::Alias(s, m)
-        debug
+      def Alias(s, m)
+        debug(s)       
         _stack = clean_stack
         case _stack.any? && _stack[-1][0]
           when false, :def, :block
@@ -133,7 +144,7 @@ module RMTools
               prefix = _stack.lasts*'::'
               new, old = '#'+m[1], '#'+m[2]
         end
-        MethodCache[prefix][new] = MethodCache[prefix][old] || "def #{new}(*args)\n  #{old}(*args)\nend"
+        @MethodCache[prefix][new] = @MethodCache[prefix][old] || "def #{new}(*args)\n  #{old}(*args)\nend"
       end
       
     end if !defined? Defaults
@@ -143,43 +154,43 @@ module RMTools
     def init_instructions
       [
           [/^\#/, lambda {|s, m| s.scan_until(/\n/)}],
-          [@Processor::StringRE, method(:string)],
+          [StringRE, method(:string)],
           
           [/^\{$/, lambda {|s, m| 
-            debug
+            debug(s)
             $log.debug @curls_count
             @curls_count += 1
           }],
           
           [/^\}$/, method(:curl_close)],
-          [@Processor::Ord],
+          [Ord],
           
-          [@Processor::BlockOpen, lambda {|s, m| 
-            debug
+          [BlockOpen, lambda {|s, m| 
+            debug(s)
             $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)],
+          [ModDef, method(:Module)],
+          [ClassDef, method(:Class)],
+          [MethodDef, method(:Method)],
+          [AliasDef, method(:Alias)],
+          [Symbol],
+          [RERE, method(:string)],
+          [HeredocRE, method(:heredoc)],
           
           [/(^|\n)=begin/, lambda {|s, m| s.scan_until(/\n=end\s*\n/m)}],
           
-          [@Processor::Attrs, lambda {|s, m|
+          [Attrs, lambda {|s, m|
             attr_accessors s, m
             if s.matched =~ / end$/
               end!(s)
-            elsif s.matched =~ /[^\?]}$/
+            elsif s.matched =~ /[^\?]\}$/
               curl_close
             end
           }],
           
-          [@Processor::Include, lambda {|s, m|
+          [Include, lambda {|s, m|
             _stack = clean_stack
             if _stack.empty?
               if m[1] == 'include'
@@ -196,7 +207,7 @@ module RMTools
             end
           }],
           
-          [@Processor::AliasMethod, lambda {|s, m|
+          [AliasMethod, lambda {|s, m|
             _stack = clean_stack
             if _stack[-1][0] == :class
               new, old = m[1..2]
@@ -205,12 +216,12 @@ module RMTools
             end
           }],
           
-          [@Processor::Beginners, lambda {|s, m|
-            debug
+          [Beginners, lambda {|s, m|
+            debug(s)
             $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"
+              if m[3] == 'if' and @stack.empty? and s.check_until(EOF) and s.matched != "\n"
                 throw :EOF
               end
               @stack << [m[5] ? :block : :beginner]
@@ -221,20 +232,15 @@ module RMTools
           [/(^|[\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
+      #extend instructions_module
+      self.class.__send__(:include, instructions_module)
       @Instructions = init_instructions
-      @MainParseRE = @Processor::MainParseRE
-      add_method_seeker('get_opts') {|s, args| $log << args}
+      @MainParseRE = MainParseRE
+      add_method_seeker('.get_opts') {|s, args| $log << args}
     end
     
     def add_instruction(re, &callback)
@@ -243,8 +249,14 @@ module RMTools
     end
     
     def add_method_seeker(name, *args, &callback)
-      pattern = /(?:^|[\s#{@Processor::Leftop}])(#{name})[( ] */
+      if name.ord == ?.
+        pattern = /\w\.(#{name[1..-1]})([(`"' ] *|:['"]?)/
+      else
+        pattern = /(?:^|[\s#{Leftop}])(#{name})([(`"' ] *|:['"]?)/
+      end
+      $log<<pattern
       add_instruction(pattern) {|s, m|
+        $log << m
         yield s, arguments(s, m)
       }
     end
@@ -252,44 +264,64 @@ module RMTools
     # Parser methods
     
     def arguments(s, m)
+      $panic=true
+      debug(s)    
+      $panic=false
+      $log<<m
+      if m[2] =~ /['"`:]/
+        s.pos -= 1
+        s.matched_size -= 1
+        if m[2] =~ /:['"]/
+          s.pos -= 1
+          s.matched_size -= 1
+        end
+      end
       arg_list = [m[1]]
+      parens = m[2]=='('
       counts = {'}' => 0, ']' => 0, ')' => 0}
-      catch(:EOL) {s.each(@Processor::ArgumentsParseRE, [
-          [/^[{\[(]$/, lambda {|s, m| counts[Closers[m[0]]] += 1}],
+      eol = catch(:EOL) {s.each(ArgumentsParseRE, [
+          [/^[{\[(]$/, lambda {|s, m| $log<<m;arg_list << m[0];counts[Closers[m[0]]] += 1}],
           [/^[}\])]$/, lambda {|s, m| 
+          $log<<m;
             if counts[m[0]] > 0
               counts[m[0]] -= 1
             else
-              curl_close
-              throw :EOL
+              curl_close if m[0]=='}'
+              throw :EOL, :arguments
             end
           }],
-          [/^[,\|]$/, lambda {|s, m| s.scan_until(/\s*/m)}],
-          [/[#\n;]| end\b/, lambda {|s, m| 
+          [/[#\n;]| end\b/, lambda {|s, m| $log<<m;
             s.scan_until(/\n/) if m[0] == '#'
-            heredoc_list.each {|opener| string(s, [nil]*4+opener)}
             throw :EOL
           }],
-          [@Processor::StringRE, lambda {|s, m| 
+          [StringRE, lambda {|s, m| $log<<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| 
+          [RERE, lambda {|s, m| $log<<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]
+          [/^ *(?:( [:?]\s|=[>~]|[<!>]=|[+\-\|*%])|,)\s*$/, lambda {|s, m| $log<<m;arg_list << m[1] if m[1]}],
+          [/^(\d[\d.]+|:[@$_a-z]\w*|[@$]\w+) *$/, lambda {|s, m| $log<<m;arg_list << m[1]}],
+          [/^([@$_a-z][:.\w!?]+)([(`"' ] *|:['"]?)?$/, lambda {|s, m| $log<<m;
+            str_beg = s.pos-s.matched_size
+            a, eol = arguments(s, m)
+            if a
+              $log << [a, s.string[str_beg...s.pos]]
+              arg_list << s.string[str_beg...s.pos]
+            end
+            if eol == :arguments
+              throw :EOL
+            end
           }]
       ])}
-      arg_list
+      $log << [arg_list, eol]
+      [arg_list, eol]
     end
     
     def string(s, m)
-      debug
+      debug(s)
       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}"}
@@ -305,7 +337,7 @@ module RMTools
       backslash = false
       quote_re |= /#\{/ if (m[5] and m[5].ord != ?') or closer =~ /[\/"`]/ or (m[2] =~ /[xrQW]/ or m[3])
       instructions = [
-        [@Processor::Ord],
+        [Ord],
         [/\s*#{Regexp.escape closer}$/, lambda {|s, m|
           if backslash
             backslash = false
@@ -341,7 +373,7 @@ module RMTools
           end
         $log.log "entering curls"
           inner_curls_count += 1
-          catch(:inner_out) {s.each(@Processor::StringParseRE, [
+          catch(:inner_out) {s.each(StringParseRE, [
               [/^\#$/, lambda {|s, m| 
               $log.log 'reading comment'
              s.scan_until(/\n/)}],
@@ -355,9 +387,9 @@ module RMTools
               else
                 $log.log "decreasing curls count"
               end}],
-              [@Processor::HeredocRE, method(:heredoc)],
-              [@Processor::StringRE, method(:string)],
-              [@Processor::RERE, method(:string)]
+              [HeredocRE, method(:heredoc)],
+              [StringRE, method(:string)],
+              [RERE, method(:string)]
           ])}
         }]
       ]
@@ -378,17 +410,17 @@ module RMTools
       s.pos
     end
     
-    def heredoc(s=nil, m)
+    def heredoc(s, m)
       heredoc_list = [m[1..2]]
-      catch(:EOL) {s.each(@Processor::HeredocParseRE, [
+      catch(:EOL) {s.each(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)]
+          [HeredocRE, lambda {|s, m| heredoc_list << m[1..2]}],
+          [StringRE, method(:string)],
+          [RERE, method(:string)]
       ])}
     end
     
@@ -401,7 +433,7 @@ module RMTools
     end
     
     def end!(s, *)
-      debug
+      debug(s)
       if s.+ !~ /[?!(]/
         exit = @stack.pop
         case exit[0]
@@ -411,7 +443,7 @@ module RMTools
               prefix, name = 'Object', prefix
             end
             if @MethodCache[prefix]
-              (@MethodCache[prefix][name] ||= []) << (path.inline ? [path, exit[2]...s.pos] : s.string[exit[2]...s.pos])
+              (@MethodCache[prefix][name] ||= []) << (@path.inline ? [@path, exit[2]...s.pos] : s.string[exit[2]...s.pos])
             end
         end
       end
@@ -433,6 +465,7 @@ module RMTools
 
     def parse_file(path)
       @stack = []
+      @path = path
       
       if path.inline
         return if @ReadPaths[path]
@@ -449,7 +482,7 @@ module RMTools
       
       @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?
+      raise "Can't parse: #{@stack.inspect}, #{ss.string[ss.last..ss.pos].inspect}\nfile:#{path}" if @stack.any?
       ss
     end
 
@@ -507,36 +540,42 @@ module RMTools
       end
       if path.is String
         prefix, name = path.sharp_split(/[.#]/, 2)
-      elsif Class === path
+        raise "If first parameter is a string then it must be of Module{#|.}method form" if !name
+      elsif Module === 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}:"
+      if SCRIPT_LINES__.size == @ReadPaths.size and (SCRIPT_LINES__.keys - @ReadPaths.keys).empty?
+        puts "nothing was found for #{prefix}#{name}"
+      else
+        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
-        else  puts ''
         end
-      else
-        puts "code for #{prefix}#{name}:"
-        print_lines prefix, name, all
       end
     end
 
   end  
-  
+  if !defined? Reader
   Reader = CodeReader.new
+  end
 end
 
 module Kernel

data/lib/rmtools/dev/logging.rb

@@ -44,11 +44,12 @@ module RMTools
     end
           
     def defaults
-      puts %{            :q => false,   # not print
-            :out => false, # output to file, may have strftime's %H%M%Y for filename
-            :time => ["%H:%M:%S", "%03d"], # strftime, [msecs]
-            :caller => "#{@c.gray('%f:%l')} #{@c.red_bold(':%m')}", # file:line :method
-            :format => "%time %mode [%caller]: %text" # no comments} 
+      puts %{    :q => false,   # not print
+    :out => false, # output to file, may contain strftime's %H%M%Y etc for filename
+    :color_out => false # do not clean control characters that make output to file colorful (set to true makes more readable out of tail -n/-f but hardly readable file as text by gui)
+    :time => ["%H:%M:%S", "%03d"], # strftime, [msecs]
+    :caller => "#{@c.gray('%f:%l')} #{@c.red_bold(':%m')}", # file:line :method
+    :format => "%time %mode [%caller]: %text" # format of entire log string, %mode is {#{%w(debug log info warn).map {|i| @highlight[i.to_sym]}*', '}}} 
     end
           
     # set any needed params, the rest will be set by default
@@ -96,7 +97,7 @@ module RMTools
       if caler
         str.sub! "%caller", caler.sub(String::CALLER_RE, cfg.cf)
       end
-      log_str = @c.clean str if !cfg.color_out
+      log_str = cfg.color_out ? str : @c.clean(str)
       RMTools.write out, log_str if log_
       Kernel.print str if print_
     end

data/lib/rmtools/dev/timer.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 RMTools::require 'console/coloring'
-
 module RMTools
 
   def timer(ts=1, output=true)

data/lib/rmtools/dev/traceback.rb

@@ -20,7 +20,7 @@ if RUBY_VERSION < '1.9'
     # it will be possible to get the lines entered in IRB
     # else it reads only ordinal require'd files
     def set_backtrace src
-      message.hl! self.class
+      #message.hl! self.class
       if format = self.class.__trace_format
         src = RMTools.__send__ format, src
       end

data/lib/rmtools_dev.rb

@@ -3,4 +3,4 @@ $__MAIN__ = self
 require 'rmtools/init'
 RMTools::require 'dev'
 
-unless defined? Rails; class Object; include RMTools end end
+unless defined? Rails; class Object; include RMTools end end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rmtools
 version: !ruby/object:Gem::Version 
-  hash: 35
+  hash: 32
   prerelease: 5
   segments: 
   - 1
   - 2
   - 2
-  - b
-  version: 1.2.2b
+  - c
+  version: 1.2.2c
 platform: ruby
 authors: 
 - Shinku
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-16 00:00:00 +03:00
+date: 2011-11-17 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,14 +57,13 @@ dependencies:
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 43
+        hash: 27
         segments: 
         - 2
-        - 9
-        - 0
-        version: 2.9.0
+        - 12
+        version: "2.12"
   type: :development
   version_requirements: *id003
 description: Applied framework primarily for debug and text/arrays/files operation.
@@ -98,8 +97,8 @@ files:
 - 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