rmtools 1.0.0

data/lib/rmtools/limited_string.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+class LimitedString < String
+  attr_reader :len
+  __init__
+  
+  def initialize str="", len=100
+    @len = len
+    super str
+  end
+  
+  def inspect
+    @len ||= 100
+    size > @len ? String.new(self[0...@len]+"…").inspect : super
+  end
+  
+end
+  

data/lib/rmtools/logging.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+module RMTools
+
+    class RMLogger
+        __init__
+        attr_accessor :mute_info, :mute_warn, :mute_log, :mute_debug
+        
+        RE = /^\(?(.*?([^\/\\]+?))\)?:(\d+)(?::in `([^']+)')?$/
+        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 format, :global
+        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 || ["%H:%M:%S", "%03d"]).to_a
+            file.cf0 = format.caller || "#{@clr.gray('%f:%l')} #{@clr.red_bold(':%m')}"
+            file.cf = file.cf0.sub('%F'){'\1'}.sub('%f'){'\2'}.sub('%l'){'\3'}.sub('%m'){'\4'}
+            file.fmt = format.format || "%time %mode [%caller]: %text"
+            file._time, file._caller = '%time'.in(file.fmt), '%caller'.in(file.fmt)
+        end
+          
+        def set_format format={}, global=nil
+            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 = text.reports bind
+            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(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[1].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=nil, *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=nil, *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=nil, *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=nil, *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}=") {|b| send :"mute_#{m}=", !b}}
+          
+        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/module.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+class Module # :nodoc:
+                
+  def children
+    constants.map! {|c| module_eval c}.find_all {|c| c.kinda Module rescue()}
+  end
+                
+  def each_child
+    constants.map! {|c| module_eval c}.each {|c| yield c if c.kinda Module}
+    constants
+  end
+  
+  def self_name
+    @self_name ||= name.rsplit('::', 2)[1] || name
+  end
+  
+  def my_methods filter=//
+    self.singleton_methods.sort!.grep(filter)
+  end
+  alias personal_methods my_methods
+  
+private
+  #   example:
+  #
+  #   def divide_ten_by x
+  #       10 / x
+  #   end
+  #
+  #   def maybe(*args)
+  #       yield *args rescue(puts $!) 
+  #   end
+  #    ...
+  #  
+  #   decorate :divide_ten_by, :maybe  #  =>
+  #   def divide_ten_by x
+  #       10 / x rescue(puts $!)
+  #   end
+  def decorate f1, f2
+    f1_clone = f1.to_s.dup
+    f1_clone.bump! '_' while method_defined? f1_clone.to_sym
+    class_eval do
+      alias :"#{f1_clone}" :"#{f1}"
+      define_method(f1) {|*args| send(f2, *args, &method(f1_clone))}
+    end
+  end
+  
+  #   some FP, example:
+  #
+  #   def divide_ten_by x
+  #       10 / x
+  #   end
+  #
+  #   def maybe
+  #       lambda {|*args| yield *args rescue(puts $!)} 
+  #   end
+  #    ...
+  #  
+  #   decorated_fof :divide_ten_by, :maybe  #  =>
+  #   def divide_ten_by
+  #       lambda {|x| 10 / x rescue(puts $!)}
+  #   end
+  def decorated_fof f1, f2
+    f1_clone = f1.to_s.dup
+    f1_clone.bump! '_' while method_defined? f1_clone
+    class_eval do
+      alias :"#{f1_clone}" :"#{f1}"
+      define_method(f1) {send(f2, &method(f1_clone))}
+    end
+  end
+  
+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/numeric.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+class Integer
+  
+  def digits
+    nums = []
+    while (int ||= self) > 0
+      nums << int%10
+      int /= 10
+    end
+    nums
+  end
+  
+  def mult_of(subj) # allready implemented in ActiveSupport though
+    self%subj == 0
+  end
+  
+  def each_bit # descending order
+    to_s(2).each_byte {|b| yield(b == 49)}
+  end
+  
+  def blur_bm
+    to_s(2).gsub(/.?1.?/) {|m| m.size==3?'111':'11'}.to_i(2)
+  end
+  
+  def hex
+    sprintf "%x", self
+  end
+  
+  def to_array(base=10)
+    int = self
+    ary = []
+    begin
+      a = int.divmod base
+      ary << a[1]
+      int = a[0]
+    end while int != 0
+    ary.reverse!
+  end
+  
+end
+
+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
+  
+end    
+
+class Float
+  
+  def partial(range=100)
+    return to_i.to_s if to_i == self
+    a = abs
+    (2..range-1).each {|i| (1..range).each {|j|
+        n = j.to_f/i
+        break if n > a
+        return "#{'-' if self != a}#{j}/#{i}" if n == a
+    } }
+    self
+  end
+      
+end
+
+module Math
+
+  def logb(b, x) log(x)/log(b) end
+
+end
+    

data/lib/rmtools/object.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+class Object
+  alias :resto :respond_to?
+  
+  def requrie file
+    require file
+  end
+  #alias :requrie :require # most frequent typo, lol
+  
+  def is klass
+    if Array === klass
+      instance_of?(Array) && self[0].instance_of?(klass[0])
+    else instance_of? klass
+    end
+  end
+  
+  def kinda klass
+    if Array === klass
+      kind_of?(Array) && self[0].kind_of?(klass[0])
+    else kind_of? klass
+    end
+  end
+  
+  def my_methods filter=//
+    (self.public_methods - Object.public_instance_methods).sort!.grep(filter)
+  end
+  
+  def personal_methods filter=//
+    (self.public_methods - self.class.superclass.public_instance_methods).sort!.grep(filter)
+  end
+  
+  def my_methods_with params
+    m = my_methods
+    params.each {|p,val| m.reject! {|_| ''.method(_).send(p) != val}}
+    m
+  end
+  
+  def personal_methods_with params
+    m = personal_methods
+    params.each {|p,val| m.reject! {|_| ''.method(_).send(p) != val}}
+    m
+  end
+  
+  def readable_variables
+    public_methods.to_ss & instance_variables.map(&'[1..-1]')
+  end
+  
+  def load_from(obj)
+    readable_variables.each {|v| instance_variable_set("@#{v}", obj.instance_variable_get("@#{v}"))}
+    self
+  end
+  
+  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
+