rmtools 1.0.0 → 1.1.0

data/lib/rmtools/core/kernel.rb

@@ -0,0 +1,28 @@
+module Kernel
+  
+  # re-require
+  def require!(file)
+    %w{.rb .so .dll}.each {|ext| $".delete "#{file}#{ext}"}
+    require file
+  end
+
+  def obtained(obj, &func)
+    if obj.is Proc
+      if obj.arity == 0
+        func.call obj.call
+      else # obj is a function receiving another function
+        obj.call &func
+      end
+    else func.call obj
+    end
+  end
+  
+  def TypeError! given, *expected
+    "invalid argument type #{given.class.name}, expected #{expected*' or '}"
+  end
+    
+  def executing? file=$0
+    caller(0)[0] =~ /^#{file}:/
+  end
+  
+end

data/lib/rmtools/{module.rb → core/module.rb}

@@ -70,44 +70,3 @@ private
   
 end
 
-class Class
-  
-  # define python-like initializer form
-  def __init__
-    modname, classname = name.rsplit('::', 2)
-    classname ||= modname
-    mod = '::'.in(name) ? eval(modname) : RMTools
-    mod.module_eval "def #{classname} *args; #{name}.new *args end
-                  module_function :#{classname}"
-    if mod != RMTools
-      mod.each_child {|c| c.class_eval "include #{mod}; extend #{mod}" if !c.in c.children}
-    end
-  end 
-  
-  def method_proxy *vars
-    buffered_missing = instance_methods.grep(/method_missing/).sort.last || 'method_missing'
-    # next arg overrides previous
-    vars.each {|v|
-      class_eval "
-      alias #{buffered_missing.bump! '_'} method_missing
-      def method_missing *args, &block
-        #{v}.send *args, &block
-      rescue NoMethodError
-        #{buffered_missing} *args, &block
-      end"
-    }
-  end
-  
-  def personal_methods filter=//
-    (self.singleton_methods - self.superclass.singleton_methods).sort!.grep(filter)
-  end
-  
-  def my_instance_methods filter=//
-    (self.public_instance_methods - Object.public_instance_methods).sort!.grep(filter)
-  end
-  
-  def personal_instance_methods filter=//
-    (self.public_instance_methods - self.superclass.public_instance_methods).sort!.grep(filter)
-  end
-  
-end

data/lib/rmtools/core/numeric.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+class Numeric
+  
+  def ceil_to(i)
+    self + i - self%i 
+  end
+  
+  def floor_to(i)
+    self - self%i
+  end
+  
+  def round_to(i)
+    [ceil_to(i), floor_to(i)].max
+  end
+  
+  def between(min, max)
+    min < self and self < max
+  end
+  
+  def mult_of(subj)
+    self%subj == 0
+  end
+  
+  def hex
+    sprintf "%x", self
+  end
+  
+end
+
+module Math
+
+  def logb(b, x) log(x)/log(b) end
+
+end
+    

data/lib/rmtools/{object.rb → core/object.rb}

@@ -1,11 +1,7 @@
 # encoding: utf-8
 class Object
   alias :resto :respond_to?
-  
-  def requrie file
-    require file
-  end
-  #alias :requrie :require # most frequent typo, lol
+  alias :requrie :require # most frequent typo, lol
   
   def is klass
     if Array === klass
@@ -50,25 +46,8 @@ class Object
     self
   end
   
-  def in *container
+  def in(*container)
     container.size == 1 ? container[0].include?(self) : container.include?(self)
   end
   
-  def require! file
-    %w{.rb .so .dll}.each {|ext| $".delete "#{file}#{ext}"}
-    require file
-  end
-
-  def b; self end
-  
-end
-
-class BlackHole
-
-  # Think twice before use it. It may devour your code!
-  def method_missing *args
-    BlackHole.new
-  end
-  
 end
-  

data/lib/rmtools/core/proc.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+class Proc
+  NULL = lambda {} unless defined? Proc::NULL
+  attr_accessor :string
+  
+  def when
+    Thread.new do
+      sleep 0.001 until yield
+      call
+    end
+  end
+  
+  def self.eval string, binding=nil
+    (proc = (binding || Kernel).eval "lambda {#{string}}").string = string
+    proc
+  end
+  
+end

data/lib/rmtools/core/regexp.rb

@@ -0,0 +1,11 @@
+class Regexp
+  
+  def | re
+    Regexp.new(source+'|'+re.source, options | re.options)
+  end
+  
+  def in string
+    string =~ self
+  end
+  
+end

data/lib/rmtools/core/string_compliance.rb

@@ -0,0 +1,31 @@
+class String
+
+  if RUBY_VERSION < "1.9"
+    def ord; self[0] end
+  else
+    # BUGFIX?
+    alias :sub19 :sub
+    alias :sub19! :sub!
+    alias :gsub19 :gsub
+    alias :gsub19! :gsub!
+    
+    def sub! a,b=nil,&c
+      if b
+        if b=~/\\\d/
+          b = b.sub19!(/\\\d/) {|m| "\#{$#{m[1,1]}}"}
+          sub19!(a) {eval "\"#{b}\""}
+        else sub19!(a) {b} end
+      else sub19! a,&c end
+    end
+
+    def sub a,b=nil,&c
+      if b
+        if b=~/\\\d/
+          b = b.sub19(/\\\d/) {|m| "\#{$#{m[1,1]}}"}
+          sub19(a) {eval "\"#{b}\""}
+        else sub19(a) {b} end
+      else sub19 a,&c end
+    end
+  end
+
+end

data/lib/rmtools/core.rb

@@ -0,0 +1 @@
+require_with_path __FILE__, '*'

data/lib/rmtools/db/active_record.rb

@@ -0,0 +1,54 @@
+require 'active_record'
+
+module ActiveRecord
+
+  def self.establish_connection_with config
+    c = case config
+            when String
+              c = if config.inline
+                      if c = RMTools.read(config) then c
+                      else return; nil
+                      end
+                    else config
+                    end
+              YAML.load c
+            when IO then YAML.load config
+            else config
+          end
+    Base.establish_connection(c) rescue(false)
+  end
+
+  class Base
+    
+    def self.establish_connection_with config
+      ActiveRecord.establish_connection_with config
+    end
+    
+    def to_hash
+      serializer = Serializer.new(self)
+      serializer.respond_to?(:attributes_hash) ?
+        serializer.attributes_hash : 
+        serializer.serializable_record
+    end
+    
+    alias :delete_with_id :delete
+    # a problem was: model.delete() won't work if it has no id. Just delete() it if has
+    def delete
+      id ? delete_with_id : self.class.delete_all(attributes)
+    end
+    
+    def self.merge_conditions(*conditions)
+      segments = conditions.map {|condition| 
+        sanitize_sql condition
+      }.reject {|condition|
+        condition.blank?
+      }
+      "(#{segments.join(') AND (')})" unless segments.empty?
+    end
+    
+  end
+    
+end
+    
+    
+    

data/lib/rmtools/db.rb

@@ -0,0 +1,7 @@
+begin
+  require 'active_record'
+  ActiveRecord::Base
+  require_with_path __FILE__, 'active_record'
+rescue
+  nil
+end

data/lib/rmtools/debug/binding.rb

@@ -0,0 +1,56 @@
+class Binding
+  
+  def inspect_local_variables
+    vars = self.eval('local_variables') # ['a', 'b']
+    values = self.eval "[#{vars * ','}]" # ["a's value", "b's value"]
+    Hash[vars.zip(values)]
+  end
+  
+  def inspect_instance_variables
+    vars = self.eval('instance_variables') # ['@a', '@b']
+    values = self.eval "[#{vars * ','}]" # ["@a's value", "@b's value"]
+    Hash[vars.zip(values)]
+  end
+  
+  def inspect_env
+    self.eval("{'self' => self}").merge(inspect_local_variables).merge(inspect_instance_variables)
+  end
+  
+  def valid_types(pattern_ary)
+    self.eval("[#{self.eval('local_variables')*','}]").valid_types(pattern_ary)
+  end
+  
+  def report(obj)
+    if Array === obj
+      obj.map {|s| self.eval "\"#{s.gsub('"'){'\"'}} = \#{(#{s}).inspect}\""} * '; '
+    else
+      obj.to_s.split(' ').map {|s| self.eval "\"#{s.gsub('"'){'\"'}} = \#{(#{s}).inspect}\""} * '; '
+    end
+  end
+  
+  # it's supposed to be called during TDD in an IRB session
+  # $__MAIN__ must be `self' or root IRB session, i.e. `main' object
+  # def tested_function
+  #   blah blah blah
+  # rescue => err
+  #   binding.start_interaction
+  #   raise err
+  # end
+  def start_interaction(sandbox=true)
+    $__env__ = inspect_env
+    Kernel.puts RMTools.format_trace(caller(2)).join("\n")
+    $env.present
+    $__binding__ = self
+    
+    $log << "entering irb"
+    $__MAIN__.irb
+    # Now input "irb_change_binding$__binding__" and have fun with debug
+    $log << "exiting irb"
+    
+    if sandbox
+      self.eval($env.keys.map {|k, v| "#{k} = $env[#{k.inspect}]"} * '; ')
+    end
+    $__env__ = nil
+  end
+  
+end

data/lib/rmtools/debug/highlight.rb

@@ -0,0 +1,23 @@
+require_with_path 'console/coloring'
+
+module RMTools
+    
+  def highlighted_line(file, line)
+    if defined? SCRIPT_LINES__
+      "   >>  #{Painter.green SCRIPT_LINES__[file][line.to_i - 1].chop}" if SCRIPT_LINES__[file]
+    else
+      file = Readline::TEMPLOG if file == '(irb)' and defined? Readline::TEMPLOG
+      "   >>  #{Painter.green read_lines(file, line.to_i).chop}" if File.file? file
+    end
+  end
+    
+  module_function :highlighted_line
+end
+  
+class Proc
+  
+  def inspect
+    "#{str=to_s}: #{@string ? Painter.green(@string) : "\n"+RMTools.highlighted_line(*str.match(/([^@]+):(\d+)>$/)[1..2])}"
+  end
+  
+end

data/lib/rmtools/debug/logging.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+require_with_path 'console/coloring'
+require_with_path 'text/string_parse'
+
+module RMTools
+
+  # lazy logger
+  # with caller processing and highlighting
+  class RMLogger
+    __init__
+    attr_accessor :mute_info, :mute_warn, :mute_log, :mute_debug
+    attr_reader :default_format
+        
+    Modes = %w{debug log info warn}.to_syms
+    NOPRINT = 4
+    NOLOG = 2
+    INLINE = 1
+  
+    def initialize format={}
+      @clr = Coloring.new
+      @highlight = {
+          :warn => @clr.red_bold("WARN"),
+          :log => @clr.cyan("INFO"),
+          :info => @clr.cyan_bold("INFO"),
+          :debug => @clr.gray_bold("DEBUG")
+      }
+      @file_formats = Hash.new(@default_format = {})
+      set_format :global, format
+    end
+          
+    def _set_format file, format
+      file.print = !format.q
+      file.out = format.out
+                
+      file.path_format = '%'.in file.out if file.out
+      file.tf   = format.time.to_a
+      file.cf0 = format.caller
+      file.cf = file.cf0.sub('%p'){'\1'}.sub('%f'){'\2'}.sub('%l'){'\3'}.sub('%m'){'\4'}
+      file.fmt = format.format
+      file._time, file._caller = '%time'.in(file.fmt), '%caller'.in(file.fmt)
+    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 => "#{@clr.gray('%f:%l')} #{@clr.red_bold(':%m')}", # file:line :method
+            :format => "%time %mode [%caller]: %text" # no comments} 
+    end
+          
+    # set any needed params, the rest will be set by default
+    def set_format *args
+      global, format = args.fetch_opts [nil], 
+                            :time => ["%H:%M:%S", "%03d"], 
+                            :caller => "#{@clr.gray('%f:%l')} #{@clr.red_bold(':%m')}", 
+                            :format => "%time %mode [%caller]: %text"
+      if global
+        _set_format @default_format, format
+      else
+        _set_format(file_format={}, format)
+        @file_formats[File.expand_path(caller[0].till ':')] = file_format
+      end
+    end
+          
+    def get_format file=nil
+      cfg = @file_formats[file && File.expand_path(file)]
+      modes = Modes.reject {|m| send :"mute_#{m}"}
+      %{<Logger #{cfg.fmt.sub('%time', "%time(#{cfg.tf*'.'})").sub('%caller', "%caller(#{cfg.cf0})")}#{' -> '+cfg.out if cfg.out} #{modes.b ? modes.inspect : 'muted'}>}
+    end
+            
+    def _print mode, text, opts, caler, bind, cfg
+      log_ = opts&NOLOG==0
+      print_ = opts&NOPRINT==0
+      str = cfg.fmt.dup
+      str.sub! "%mode", @highlight[mode]
+      if bind
+        text = bind.report text
+      elsif !text.is String
+        text = text.inspect
+      end
+      str.sub! "%text", text
+      str << "\n" if opts&INLINE==0
+      out = cfg.out
+      if cfg._time or cfg.path_format
+        now = Time.now
+        if cfg._time
+          time = now.strftime cfg.tf[0]
+          time << ".#{cfg.tf[1]%[now.usec/1000]}" if cfg.tf[1]
+          str.sub! "%time", time
+        end
+        out = now.strftime cfg.out if cfg.path_format
+      end
+      str.sub! "%caller", caler.sub(String::CALLER_RE, cfg.cf) if caler
+      log_str = @clr.clean str
+      RMTools.write out, log_str if log_
+      Kernel.print str if print_
+    end
+          
+    def check_binding a
+      a[0].is(Binding) ? [a[0], a[1] || 0] : [nil, a[0] || 0]
+    end
+        
+    def get_config!
+      @file_formats.empty? ? @default_format : @file_formats[File.expand_path(caller(2)[0].till ':')]
+    end
+        
+    # controllers:
+    # - $panic: print debug messages
+    # - $verbose: print log messages
+    # - $quiet: print only warn messages regardless of other globals
+    # - @mute_warn, @mute_info, @mute_log: do not print
+    #                       this messages regardless of any globals
+    # - @out_all: write to file any messages
+        
+    def warn text="\b\b ", *a
+      cfg = get_config!
+      if (cfg.out or cfg.print) && !@mute_warn
+        bind, opts = check_binding a
+        opts |= NOLOG if !cfg.out
+        opts |= NOPRINT if !cfg.print
+        text ||= yield if block_given?
+        _print(:warn, text, opts, cfg._caller && caller[0], bind, cfg)
+      end  
+    end
+        
+    def log text="\b\b ", *a
+      cfg = get_config!
+      if (cfg.out or cfg.print && !$quiet && $verbose) && !@mute_log
+        bind, opts = check_binding a
+        opts |= NOLOG if !cfg.out
+        opts |= NOPRINT if !(cfg.print && !$quiet && $verbose)
+        text ||= yield if block_given?
+        _print(:log, text, opts, cfg._caller && caller[0], bind, cfg)
+      end
+    end
+            
+    def info text="\b\b ", *a
+      cfg = get_config!
+      if (cfg.print && !$quiet or cfg.out && cfg.out_all) && !@mute_info
+        bind, opts = check_binding a
+        opts |= NOLOG if !(cfg.out && cfg.out_all)
+        opts |= NOPRINT if !(cfg.print && !$quiet)
+        text ||= yield if block_given?
+        _print(:info, text, opts, cfg._caller && caller[0], bind, cfg)
+      end 
+    end
+          
+    def debug text="\b\b ", *a
+      cfg = get_config!
+      if (cfg.print && $panic && !$quiet or cfg.out && cfg.out_all) && !@mute_debug
+        bind, opts = check_binding a
+        opts |= NOLOG if !(cfg.out && cfg.out_all)
+        opts |= NOPRINT if !(cfg.print && $panic && !$quiet)
+        text ||= yield if block_given?
+        _print(:debug, text, opts, cfg._caller && caller[0], bind, cfg)
+      end 
+    end
+          
+    alias << info
+    alias <   warn
+        
+    Modes.each {|m| define_method("#{m}=") {|mute| send :"mute_#{m}=", !mute}}
+          
+    def outall=(x) @default_format.out_all = x end
+    def print=(x) @default_format.print = x end  
+    def out=(x) @default_format.out = x end
+        
+    def out_all() @default_format.out_all end
+    def print() @default_format.print end  
+    def out() @default_format.out end
+        
+    def inspect() get_format end
+          
+  end
+  
+end

data/lib/rmtools/debug/present.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+class Object
+  
+  def present
+    Hash[readable_variables.map {|v| [":#{v}", __send__(v)]}].present
+  end
+  
+end
+
+class Array
+  
+  def present(inspect_string=nil)
+    res = "[ "
+    indent = (size-1).to_s.size
+    res << map_with_index {|k,i|
+      "#{i.to_s.rjust(indent)}: #{(k.is String and !inspect_string) ? k : k.inspect}"
+    }*"\n  "
+    res << "]"
+    puts res
+  end
+  
+end
+
+class Hash
+  
+  def present(inspect_string=nil)
+    str = "{ "
+    sorted = sort rescue to_a.sort_by_to_s
+    str << sorted.map {|k,v|
+      "#{(k.is String and !inspect_string) ? k : k.inspect} => #{(v.is String and !inspect_string) ? v : v.inspect},"
+    }*"\n  "
+    str << "}"
+    puts str
+  end
+  
+end
+
+

data/lib/rmtools/debug/timer.rb

@@ -0,0 +1,19 @@
+require_with_path 'console/coloring'
+
+module RMTools
+
+  def timer(ts=1, output=true)
+    timez = ts - 1
+    panic, verbose = $panic, $verbose
+    $panic = $verbose = false
+    t1 = Time.now
+    timez.times {yield}
+    res = yield
+    t2 = (Time.now.to_f*1000).round
+    t1 = (t1.to_f*1000).round
+    $panic, $verbose = panic, verbose
+    res = res.inspect
+    puts "#{output ? "res: #{res.size > 1000 ? res[0...1000]+"…" : res}\n" : "size of res string: #{res.to_s.size}, "}one: #{Painter.gray '%0.4fms'%[(t2-t1).to_f/ts]}, total: #{Painter.gray "#{(t2-t1).to_f}ms"}"
+  end
+  
+end

data/lib/rmtools/debug/traceback.rb

@@ -0,0 +1,92 @@
+require_with_path 'debug/highlight'
+module Kernel
+
+	# Python-like traceback for exceptions; uses ANSI coloring.
+  # In case of any low-level ruby error it may hang up interpreter
+  # (although you must have done creepy things for that). If you find 
+  # interpreter in hanging up, require 'rmtools_notrace' instead of 'rmtools'
+  # or run "Exception.trace_format false" right after require
+  #
+  # 1:0> def divbyzero
+  # 2:1< 10/0 end
+  # => nil
+  # 3:0> divbyzero
+  # ZeroDivisionError: divided by 0
+  #        from (irb):2:in `divbyzero' <- `/'
+  #   >>  10/0 end
+  #        from (irb):3
+  #   >>  divbyzero
+  def format_trace a
+    bt, calls, i = [], [], 0
+  #  $log.info 'a.size', binding
+    m = a[0].parse:caller
+    while i < a.size
+  #    $log.info i
+      m2 = a[i+1] && a[i+1].parse(:caller)
+  #    $log.info 'm', binding
+  #    $log.info 'm2', binding
+  #    $log.info 'm[3] m[1..2]==m2[1..2]', binding if m and m2
+  #    $log.info 'm[1] m[2]', binding if m
+  #    $log.info highlighted_line(*m[1..2]) if m
+      if m and m.func and m2 and [m.path, m.line] == [m2.path, m2.line]
+        calls << "`#{m.func}' -> "
+      elsif m and m.line != 0 and line = highlighted_line(m.path, m.line)
+        bt << "#{a[i]}#{calls.join}\n#{line}"
+        calls = []
+      else bt << a[i]
+      end
+      i += 1
+      m = m2
+    end
+  #  $log << Painter.r("FORMAT DONE! #{bt.size} lines formatted")
+    bt
+  end
+  
+end
+
+class Class
+    
+  def trace_format method
+    if Exception.in ancestors
+      class_eval(method ? %{
+    def set_backtrace src
+      src = #{method} src
+      set_bt src
+    end
+    } : %{
+    def set_backtrace src
+      set_bt src
+    end
+    })
+    else
+      raise NoMethodError, "undefined method `trace_format' for class #{self}"
+    end
+  end
+  
+end
+
+    # 1.9 may hung up processing IO while generating traceback
+if RUBY_VERSION < '1.9'
+  class Exception
+    alias :set_bt :set_backtrace
+    
+    # to use trace formatting ensure that you have SCRIPT_LINES__ constant set
+    # SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+    #
+    # 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 get the lines entered in IRB
+    # else it reads only ordinal require'd files
+    
+    trace_format :format_trace
+  end
+  
+  SystemStackError.trace_format false
+end

data/lib/rmtools/debug.rb

@@ -0,0 +1 @@
+require_with_path __FILE__, '*'

data/lib/rmtools/debug_notrace.rb

@@ -0,0 +1 @@
+require_with_path 'debug', '{binding,logging,present,timer}'