rmtools 1.3.3 → 2.0.0.rc5

data/lib/rmtools/dev/logging.rb

@@ -34,6 +34,8 @@ module RMTools
       file.print = !format.q
       file.out = format.out || format.log_file
       file.color_out = format.color_out || format.color_log
+      file.detect_comments = !!format.detect_comments
+      file.precede_comments = format.precede_comments || "# "
                 
       file.path_format = '%'.in file.out if file.out
       file.tf   = format.time.to_a
@@ -44,21 +46,30 @@ module RMTools
     end
           
     def defaults
-      puts %{    #common options:
+      puts %{    # #{@c.y 'common options:'}
     :q => false,   # not print
     :out => false, # output to file, may contain strftime's %H%M%Y etc for filename
     :time => ["%H:%M:%S", "%03d"], # strftime, [msecs]
     :type => :console, # or :html
-    #console values:
+    # #{@c.y 'console values:'}
     :caller => "#{@c.gray('%f:%l')} #{@c.red_bold(':%m')}", # "file:line :method", %p is for fullpath
     :format => "%time %mode [%caller]: %text" # format of entire log string, %mode is {#{%w(debug log info warn).map {|i| @highlight[i.to_sym]}*', '}}
-    :color_out => false # do not clean control characters that make output to file colorful; set to true makes more readable output of `tail' but hardly readable by gui file output
-    #html options:
+    :color_out => false, # do not clean control characters that make output to file colorful; set to true makes more readable output of `tail' but hardly readable by gui file output
+    :detect_comments => false, # highlight and strip comments blocks
+    :precede_comments => "# ",
+    # :detect_comments with default :precede_comments allows comment blocks looking like:
+    $log<<<<-'#'
+    # ... comment string one ...
+    # ... comment string two ...
+    #
+    be logged like #{@c.green "\n# ... comment string one ...\n# ... comment string two ..."}
+    # #{@c.y 'html options:'}
     :caller => "<a class='l'>%f:%l</a> <a class='m'>:%m</a>",
     :format => "<div class='line'><a class='t'>%time</a> <a class='%mode'>%mode</m> [%caller]: <p>%text</p>%att</div>", # %att is for array of objects that should be formatted by the next option
     :att =>"<div class='att'><div class='hide'>+</div><pre>%s</pre></div>", # .hide should be scripted to work like a spoiler
     :serializer => RMTools::RMLogger::HTML # should respond to :render(obj); nil value means each object will be just #inspect'ed}
     end
+    alias :usage :defaults
           
     # set any needed params, the rest will be set by default
     def set_format *args
@@ -95,6 +106,8 @@ module RMTools
         text = bind.report text
       elsif !text.is String
         text = text.inspect
+      elsif cfg.detect_comments and text =~ /\A[ \t]*#[ \t]+\S/
+        text = "\n" + @c.green(text.gsub(/^([ \t]*#[ \t])?/, cfg.precede_comments).chop)
       end
       out = cfg.out
       if cfg._time or cfg.path_format

data/lib/rmtools/dev/timer.rb

@@ -7,7 +7,12 @@ module RMTools
     quiet, mute_warn = $quiet, $log.mute_warn
     $quiet = $log.mute_warn = true
     t1 = Time.now
-    timez.times {yield} if timez > 0
+    begin
+      timez.times {yield} if timez > 0
+    rescue
+      $quiet, $log.mute_warn = quiet, mute_warn
+      raise $!
+    end
     res = yield
     t2 = Time.now
     ts.times {}

data/lib/rmtools/dev/trace_format.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 RMTools::require 'dev/highlight'
 RMTools::require 'dev/logging'
+require 'active_support/core_ext/class/attribute'
 
 module RMTools
 
@@ -71,16 +72,46 @@ module RMTools
   module_function :format_trace, :format_trace_to_html
 end
 
-class Class
+# As for rmtools-1.1.0, 1.9.1 may hung up processing IO while generating traceback
+# As for 1.2.10 with 1.9.3 with readline support it isn't hung up anymore
+
+# Usage with Rails.
+# Rails raise and rescue a bunch of exceptions during a first load, a reload of code (e.g. in development env) and maybe even some exceptions for each request.
+# Thus, trace_format should be set only in a console environment *after* a code is loaded.
+# For a web-server environment use RMTools.format_trace for inspect backtrace *after* an exception was rescued.
+# Also note that Rails' autoreload of code won't rewrite SCRIPT_LINES__.
+class Exception
+  alias :set_bt :set_backtrace
+  class_attribute :trace_format
   
-private
-  def trace_format method
-    if Exception.in ancestors
-      class_attribute :__trace_format
-      self.__trace_format = method
-    else
-      raise NoMethodError, "undefined method `trace_format' for class #{self}"
+  # If you also set (e.g. in irbrc file) 
+  #   module Readline
+  #     alias :orig_readline :readline
+  #     def readline(*args)
+  #       ln = orig_readline(*args)
+  #       SCRIPT_LINES__['(irb)'] << "#{ln}\n"
+  #       ln
+  #     end
+  #   end
+  # it will be possible to fetch lines entered in IRB
+  # else format_trace would only read ordinally require'd files
+  def set_backtrace src
+    if format = self.class.trace_format
+      src = RMTools.__send__ format, src
     end
+    set_bt src
+  end
+end
+  
+# This is the most usable setting, I think. Set it in the irbrc, config/initializers or wherever
+<<-'example'
+if defined? IRB
+  class StandardError
+    self.trace_format = :format_trace
   end
   
-end
+  class SystemStackError
+    self.trace_format = nil
+  end
+end
+example

data/lib/rmtools/dev/{blackhole.rb → void.rb}

@@ -1,10 +1,10 @@
 # encoding: utf-8
-class BlackHole
+class Void
   __init__
 
-  # abc = BlackHole.new
+  # abc = Void.new
   # (abc.first.get {|_| !_}.something << 'blah blah')[123].raise!
-  # => #<BlackHole:0xb66367b0>
+  # => #<Void:0xb66367b0>
   # 
   # Think twice before use it. It may devour your code!
   def method_missing(m, *args)
@@ -21,4 +21,6 @@ class BlackHole
   if RUBY_VERSION < '1.9'
     undef id
   end
-end
+end
+
+BlackHole = Void

data/lib/rmtools/enumerable/array.rb

@@ -61,15 +61,20 @@ class Array
   end
   
   alias diff ^
+  
+  def intersects?(ary)
+    (self & ary).any?
+  end
+  alias :x? :intersects?
 
   # arithmetics
   def avg
-    sum.to_f/size
+    empty? ? 0 : sum.to_f/size
   end
   
   # for use with iterators
   def avg_by(&b)
-    sum(&b).to_f/size
+    empty? ? 0 : sum(&b).to_f/size
   end
   
   def scale(top)
@@ -252,4 +257,9 @@ class Array
     nil
   end
   
+  # rightmost #uniq
+  def runiq
+    reverse.uniq.reverse
+  end
+  
 end

data/lib/rmtools/enumerable/array_iterators.rb

@@ -1,57 +1,300 @@
 # encoding: utf-8
 RMTools::require 'enumerable/array'
 
-unless defined? RMTools::Iterators
+# [1, 2, 3].to_ss # => ['1', '2', '3']
+# [[1,2,3], [4,5,6], [7,8,9]].to_sss
+# => [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]]
+# [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]].subss!(/\d+/) {|m| (m.to_i % 3).to_s}
+# => [["1", "2", "0"], ["1", "2", "0"], ["1", "2", "0"]]
+# [[1, 2, 0], [1, 2, 0], [1, 2, 0]].sum_zeros?
+# => [false, false, true, false, false, true, false, false, true]
+# [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by_odds?
+# => [[1, 2, 3], [3, 4, 6]]
+class Array
+  alias :throw_no :method_missing
+  mattr_reader :iterators_names, :iterators_pattern
+  @@iterators_names = []
   
-  # [1, 2, 3].to_ss # => ['1', '2', '3']
-  # [[1,2,3], [4,5,6], [7,8,9]].to_sss
-  # => [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]]
-  # [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]].subss!(/\d+/) {|m| (m.to_i % 3).to_s}
-  # => [["1", "2", "0"], ["1", "2", "0"], ["1", "2", "0"]]
-  # [[1, 2, 0], [1, 2, 0], [1, 2, 0]].sum_zeros?
-  # => [false, false, true, false, false, true, false, false, true]
-  # [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by_odds?
-  # => [[1, 2, 3], [3, 4, 6]]
-  class Array
-    alias :throw_no :method_missing
-    RMTools::Iterators = %r{^(#{(instance_methods.grep(/_by$/)+%w{every no select reject partition find_all find sum foldr})*'|'})_([\w\d\_]+[!?]?)}
+  class << self
     
-    def method_missing(method, *args, &block)
-      if match = (meth = method.to_s).match(RMTools::Iterators)
-        iterator, meth = match[1].to_sym, match[2].to_sym
-        begin
-          case iterator
-          when :every then iterator = :every?
-          when :no     then iterator = :no?
+    def add_iterator_name(name_or_list)
+      name_or_list = [name_or_list] if !name_or_list.is Array
+      @@iterators_names |= name_or_list
+      @@iterators_pattern = %r{^(#{@@iterators_names*'|'})_([\w\d\_]+[!?]?)}
+    end
+  
+    def fallback_to_clean_iterators!
+      class_eval do
+        # Benchmark 1:
+        # # We take a simple methods like uniq_by (O(N)) and odd? (O(1)) to ensure that
+        # # penalty we would have in production would not be larger than that in bench
+        #
+        # # 1.1. Traditional calls:
+        # # 1.1.1: (9 x #odd? + 3 x #map + 1 x #uniq_by) * 10^6
+        # timer(1_000_000) { [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by {|i| i.map {|j| j.odd?}} }
+        # one: 0.0130ms, total: 13040.0ms
+        # # 1.1.2: (90_000 x #odd? + 300 x #map + 1 x #uniq_by) * 100
+        # timer(100) { a.uniq_by {|i| i.map {|j| j.odd?}} }
+        # one: 34.0000ms, total: 3400.0ms
+        #
+        # # 1.2. Meta calls:
+        # # 1.2.1: += (13 * 10^6 x #__send__) + (4 * 10^6 x #method_missing)
+        # timer(1_000_000) { [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by_odds? }
+        # one: 0.0354ms, total: 35440.0ms 
+        # # += 172% of time
+        # a = (0...300).to_a.map {Array.rand 300};
+        # # 1.2.2: += (9 * 10^6 x #__send__) + (30_100 x #method_missing)
+        # timer(100) { a.uniq_by_odds? }
+        # one: 39.3000ms, total: 3930.0ms
+        # # += 16% of time
+        #
+        # Conclusion:
+        # 
+        # 1. If we want to speed meta-calls up, we should sacrifice cleanness of Array namespace,
+        # I mean define missing methods inplace.
+        # 2. Most latency is given by #method_missing, but which are factor of #__send__?
+        def method_missing(method, *args, &block)
+          if match = (meth = method.to_s).match(@@iterators_pattern)
+            iterator, meth = match[1].to_sym, match[2].to_sym
+            
+            begin
+              case iterator
+              when :every then iterator = :every?
+              when :no     then iterator = :no?
+              end
+              
+              return case iterator
+                when :sum, :sort_along_by; __send__(iterator, args.shift) {|i| i.__send__ meth, *args, &block}
+                when :find_by, :select_by, :reject_by; __send__(iterator, meth, *args)
+                else __send__(iterator) {|i| i.__send__ meth, *args, &block}
+                end
+            rescue NoMethodError => e
+              e.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+              raise e
+            end
+            
+          elsif meth.sub!(/sses([=!?]?)$/, 'ss\1') or meth.sub!(/ies([=!?]?)$/, 'y\1') or meth.sub!(/s([=!?]?)$/, '\1')
+            assignment = meth =~ /=$/
+            meth = meth.to_sym
+            
+            begin 
+              if assignment
+                if Array === args
+                    each_with_index {|e,i| e.__send__ meth, args[i]}
+                else
+                    each {|e| e.__send__ meth, args}
+                end
+              else map {|e| e.__send__ meth, *args, &block}
+              end
+            rescue NoMethodError => e
+              e.message << " (`#{method}' interpreted as map-function `#{meth}')"
+              raise e
+            end
+            
+          else 
+            throw_no method
+          end      
+        end
+      end # class_eval
+    end # def fallback_to_clean_iterators!
+  
+  end # << self
+    
+  add_iterator_name(instance_methods.grep(/_by$/)+%w{every no select reject partition find_all find sum foldr foldl fold count rand_by})
+
+  # Benchmark 2:
+  #
+  # # 2.2. Meta calls:
+  # # 2.2.1: += (13 * 10^6 x #__send__)
+  # timer(1_000_000) { [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by_odds? }
+  # one: 0.0156ms, total: 15570.0ms
+  # # += 19% of time
+  # a = (0...300).to_a.map {Array.rand 300};
+  # # 2.2.2: += (9 * 10^6 x #__send__)
+  # timer(100) { a.uniq_by_odds? }
+  # one: 37.9000ms, total: 3790.0ms
+  # # += 11% of time
+  <<-'version 2'
+  def method_missing(method, *args, &block)
+    if match = (meth = method.to_s).match(@@iterators_pattern)
+      iterator, meth = match[1].to_sym, match[2].to_sym
+      case iterator
+      when :every then iterator = :every?
+      when :no     then iterator = :no?
+      end
+      
+      Array.class_eval do
+        case iterator
+        when :sum, :sort_along_by
+          define_method method do |*args, &block|
+            begin
+              # sum_posts_ids([], :all)  =>  
+              # sum([]) {|e| e.posts_ids(:all)}
+              __send__(iterator, args.shift) {|i| e.__send__ meth, *args, &block}
+            rescue NoMethodError => err
+              err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+              raise err
+            end
+          end
+        when :find_by, :select_by, :reject_by
+          define_method method do |*args, &block|
+            begin
+              # select_by_count(max_count)  =>  
+              # select {|e| e.count == max_count}
+              __send__(iterator, meth, *args)
+            rescue NoMethodError => err
+              err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+              raise err
+            end
           end
-          return case iterator
-            when :sum;     sum(args.shift) {|i| i.__send__ meth, *args, &block}
-            when :find_by, :select_by, :reject_by; __send__(iterator, meth, *args)
-            else __send__(iterator) {|i| i.__send__ meth, *args, &block}
+        else 
+          define_method method do |*args, &block|
+            begin
+              # uniq_by_sum(1) {|i| 1 / i.weight}  =>  
+              # uniq_by {|e| e.sum(1) {|i| 1 / i .weight}}
+              __send__(iterator) {|e| e.__send__ meth, *args, &block}
+            rescue NoMethodError => err
+              err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+              raise err
             end
-        rescue NoMethodError => e
-          e.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
-          raise e
+          end
         end
-      elsif meth.sub!(/sses([=!?]?)$/, 'ss\1') or meth.sub!(/ies([=!?]?)$/, 'y\1') or meth.sub!(/s([=!?]?)$/, '\1')
-        assignment = meth =~ /=$/
-        meth = meth.to_sym
-        begin 
-          if assignment
-            if Array === args
-                each_with_index {|e,i| e.__send__ meth, args[i]}
-            else
-                each {|e| e.__send__ meth, args}
+      end
+      
+    elsif meth.sub!(/sses([=!?]?)$/, 'ss\1') or meth.sub!(/ies([=!?]?)$/, 'y\1') or meth.sub!(/s([=!?]?)$/, '\1')
+      assignment = meth =~ /=$/
+      meth = meth.to_sym
+      
+      Array.class_eval do
+        if assignment
+          define_method method do |value|
+            begin
+              if Array === value
+                # owner_ids = users_ids  =>  
+                # each_with_index {|e, i| e.owner_id = users_ids[i]}
+                each_with_index {|e, i| e.__send__ meth, value[i]}
+              else
+                # owner_ids = user_id  =>  
+                # each {|e, i| e.owner_id = user_id}
+                each {|e| e.__send__ meth, value}
+              end
+            rescue NoMethodError => e
+              e.message << " (`#{method}' interpreted as map-function `#{meth}')"
+              raise e
+            end
+          end
+        else
+          define_method method do |*args, &block|
+            begin
+              # to_is(16)  =>  
+              # map {|e| e.to_i(16)}
+              map {|e| e.__send__ meth, *args, &block}
+            rescue NoMethodError => err
+              err.message << " (`#{method}' interpreted as map-function `#{meth}')"
+              raise err
             end
-          else map {|e| e.__send__ meth, *args, &block}
           end
-        rescue NoMethodError => e
-          e.message << " (`#{method}' interpreted as map-function `#{meth}')"
-          raise e
         end
-      else throw_no method
-      end      
-    end
+      end
+      
+    else 
+      return throw_no method
+    end      
+      
+    __send__(method, *args, &block)
   end
-
+  version 2
+  
+  # Benchmark 3:
+  #
+  # # 3.2. Meta calls:
+  # # 3.2.1: += (13 * 10^6 x #__send__)
+  # timer(1_000_000) { [[1, 2, 3], [3, 4, 6], [3, 8, 0]].uniq_by_odds? }
+  # one: 0.0145ms, total: 14520.0ms
+  # # += 11% of time
+  # a = (0...300).to_a.map {Array.rand 300};
+  # # 3.2.2: += (9 * 10^6 x #__send__)
+  # timer(100) { a.uniq_by_odds? }
+  # one: 36.1000ms, total: 3610.0ms
+  # # += 6% of time
+  def method_missing(method, *args, &block)
+    if match = (meth = method.to_s).match(@@iterators_pattern)
+      iterator, meth = match[1].to_sym, match[2].to_sym
+      case iterator
+      when :every then iterator = :every?
+      when :no     then iterator = :no?
+      end
+      
+      case iterator
+      when :sum, :sort_along_by
+        Array.class_eval %{
+      def #{method}(*args, &block)
+        # sum_posts_ids([], :all) =>
+        # sum([]) {|e| e.posts_ids(:all)}
+        #{iterator}(args.shift) {|e| e.#{meth}(*args, &block)}
+      rescue NoMethodError => err
+        err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+        raise err
+      end}
+      when :find_by, :select_by, :reject_by
+        Array.class_eval %{
+      def #{method}(val)
+        # select_by_count(max_count) =>
+        # select {|e| e.count == max_count}
+        #{iterator.to_s[0...-3]} {|e| e.#{meth} == val}
+      rescue NoMethodError => err
+        err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+        raise err
+      end}
+      else
+        Array.class_eval %{
+      def #{method}(*args, &block)
+        # uniq_by_sum(1) {|i| 1 / i.weight}  =>  
+        # uniq_by {|e| e.sum(1) {|i| 1 / i .weight}}
+        #{iterator} {|e| e.#{meth}(*args, &block)}
+      rescue NoMethodError => err
+        err.message << " (`#{method}' interpreted as decorator-function `#{meth}')"
+        raise err
+      end}
+      end
+      
+    elsif meth.sub!(/sses([=!?]?)$/, 'ss\1') or meth.sub!(/ies([=!?]?)$/, 'y\1') or meth.sub!(/s([=!?]?)$/, '\1')
+      assignment = meth =~ /=$/
+      meth = meth.to_sym
+      
+      if assignment
+        Array.class_eval %{
+      def #{method}(value)
+        if Array === value
+          # owner_ids = users_ids  =>  
+          # each_with_index {|e, i| e.owner_id = users_ids[i]}
+          each_with_index {|e, i| e.__send__ meth, value[i]}
+        else
+          # owner_ids = user_id  =>  
+          # each {|e, i| e.owner_id = user_id}
+          each {|e| e.__send__ meth, value}
+        end
+      rescue NoMethodError => err
+        err.message << " (`#{method}' interpreted as map-function `#{meth}')"
+        raise err
+      end}
+      else
+        Array.class_eval %{
+      def #{method}(*args, &block)
+        # to_is(16)  =>  
+        # map {|e| e.to_i(16)}
+        map {|e| e.#{meth}(*args, &block)}
+      rescue NoMethodError => err
+        err.message << " (`#{method}' interpreted as map-function `#{meth}')"
+        raise err
+      end}
+      end
+      
+    else 
+      return throw_no method
+    end      
+      
+    __send__(method, *args, &block)
+  end
+  
 end

data/lib/rmtools/enumerable/hash.rb

@@ -5,6 +5,7 @@ RMTools::require 'enumerable/traversal'
 class Hash
   include RMTools::KeyValueTraversal
   alias :>> :reverse_merge!
+  alias :<<  :merge!
   
   def to_traversable
     RMTools::KeyValueTraversable.new(self)