rmtools 1.0.0 → 1.1.0

data/lib/rmtools/io.rb

@@ -1,303 +0,0 @@
-# encoding: utf-8
-class Dir
-  
-  def include?(name)
-    #content.map {|f| File.split(f)[1]}.include? name
-    entries.include? name
-  end
-  
-  def recursive_content(flat=true)
-    list = []
-    cont = content.map {|f|
-      if File.directory?(f)
-             rc = Dir.new(f).recursive_content.map {|f| f.sub(/^\.\//, '')} 
-             flat ? list.concat(rc) : rc
-      else flat ? (list << f) : f 
-      end
-    }
-    (flat ? list : cont)
-  end
-  
-  def content
-    Dir["#{path}/**"].b || to_a[2..-1].sort.map {|c| File.join path, c}
-  end
-  
-  def parent
-    newpath = File.dirname(path)
-    Dir.new(newpath) if newpath != path 
-  end
-  
-  def child(idx)
-    df = content[idx]
-    if File.file?(df)
-      File.new(df)
-    elsif File.directory?(df)
-      Dir.new(df)
-    end
-  end
-  
-  def children
-    content.map {|df| 
-      if File.file?(df)
-        File.new(df)
-      elsif File.directory?(df)
-        Dir.new(df)
-      end                    
-    }
-  end
-  
-  def refresh
-    return if !File.directory?(path)
-    Dir.new(path)
-  end
-  
-  def inspect
-    displaypath = case path
-          when /^(\/|\w:)/ then path
-          when /^\./ then File.join(Dir.pwd, path[1..-1])
-          else File.join(Dir.pwd, path)
-        end
-    "<#Dir \"#{displaypath}\" #{to_a.size - 2} elements>"
-  end
-  
-  def name
-    File.basename(path)
-  end
-  
-  # Fixing windoze path problems
-  # requires amatch gem for better performance
-  def real_name
-    n, p, count = name, parent, []
-    return n if !p
-    pp, pc, sc = parent.path, parent.to_a[2..-1], to_a
-    if defined? Amatch
-      ms = pc.sizes.max
-      count = [:hamming_similar, :levenshtein_similar, :jaro_similar].sum {|m| pc.group_by {|_| _.upcase.ljust(ms).send(m, n)}.max[1]}.count.to_a
-      max = count.lasts.max
-      res = count.find {|c|
-        c[1] == max and File.directory?(df=File.join(pp, c[0])) and Dir.new(df).to_a == sc
-      }
-      return res[0] if res
-    end
-    (pc - count).find {|c|
-      File.directory?(df=File.join(pp, c)) and Dir.new(df).to_a == sc
-    }
-  end
-  
-end
-
-class File
-  
-  def inspect
-    "<#File \"#{path}\" #{closed? ? 'closed' : stat.size.bytes}>"
-  end
-  
-  def self.include?(name, str)
-    f = new name, 'r'
-    incl = f.include? str
-    f.close
-    incl
-  end
-  
-  def include?(str)
-    while s = gets do return true if s.include? str end
-  end
-  
-  def parent
-    newpath = File.dirname(path)
-    Dir.new(newpath) if newpath != path
-  end
-  
-  def name
-    File.basename(path)
-  end
-
-  def ext
-    name[/[^.]+$/]
-  end
-  
-  def refresh
-    return if !File.file?(path)
-    close
-    File.new(path,'r')
-  end  
-  
-  def self.modify(file, bak=true)
-    orig_text = read file
-    text = yield orig_text
-    rename file, file+'.bak' if bak
-    RMTools.rw(file, text.is(String) ? text : orig_text)
-  end
-  
-  def cp(df)
-    dir = File.dirname df
-    FileUtils.mkpath dir unless File.directory? dir
-    FileUtils.cp path, df
-  end
-
-  def mv(df)
-    dir = File.dirname df
-    FileUtils.mkpath dir unless File.directory? dir
-    rename df
-  end
-  
-  # Fixing windoze path problems
-  # requires amatch gem for better performance
-  def real_name
-    n, p, count = name, parent, []
-    pp, pc, ss = parent.path, parent.to_a[2..-1], stat
-    ms = pc.sizes.max
-    n, ext = n.rsplit('.', 2)
-    if ext
-      re = /\.#{ext}$/i
-      pc.reject! {|f| !f[re]}
-    end
-    if defined? Amatch
-      count = [:hamming_similar, :levenshtein_similar, :jaro_similar].sum {|m| pc.group_by {|f| (ext ? f[0..-(ext.size+2)] : f).upcase.ljust(ms).send(m, n)}.max[1]}.count.to_a
-      max = count.lasts.max
-      res = count.find {|c|
-        c[1] == max and File.file?(df=File.join(pp, c[0])) and File.stat(df) == ss
-      }
-      return res[0] if res
-    end
-    (pc - count).find {|c|
-      File.file?(df=File.join(pp, c)) and File.stat(df) == ss
-    }
-  end
-  
-  PathMemo = {} if !defined? PathMemo
-  def self.real_path path, memo=1
-    a = expand_path(path).split(/[\/\\]/)
-    a.each_index {|i|
-      if a[j=-(i+1)]['~']
-        n = i+2>a.size ? a[j] : join(a[0..-(i+2)], a[j])
-        a[j] = PathMemo[n] || real_name(n) 
-        PathMemo[n] = a[j] if memo
-      else break
-      end
-    }
-    a*'/'
-  end
-  
-  def self.real_name(df)
-    if file?(df)
-        new(df).real_name
-    elsif directory?(df)
-        Dir.new(df).real_name
-    end
-  end
-  
-end
-
-class IO
-  
-  def gets2
-    str = ''
-    str << (c = read 1) until c and "\r\n\b".include? c or eof?
-    str 
-  end
-  
-end
-
-module RMTools
-
-    def tick!
-      print %W{|\b /\b -\b \\\b +\b X\b}.rand
-    end
-    
-    def executing? file
-      caller(0)[0] =~ /^#{file}:/
-    end
-
-    def rw(df, value=nil)
-      return false if value.nil?
-      df.gsub!('\\', '/')
-      path = File.dirname(df)
-      FileUtils.mkpath(path) if !File.directory?(path)
-      mode = RUBY_VERSION > '1.9' ? :wb : 'wb'
-      File.open(df, mode) {|f| f << value}
-      value.size
-    end
-  
-    def write(df, value='', pos=0)
-      return false if value.nil?
-      df.gsub!('\\', '/')
-      path = File.dirname(df)
-      FileUtils.mkpath(path) if !File.directory?(path)
-      if pos == 0
-        mode = RUBY_VERSION > '1.9' ? :ab : 'ab'
-        File.open(df, mode) {|f| f << value}
-      else
-        if pos < 0
-          raise IndexError, "file #{df} does not exist, can't write from position #{pos}" if !File.file?(df)  
-          raise IndexError, "file #{df} is shorter than #{(-pos).bytes}, can't write from position #{pos}" if (size = File.size(df)) < -pos  
-          pos = size + pos
-        end
-        File.open(df, 'r+') {|f| f.pos = pos; f << value}
-      end
-      value.size
-    end
-  
-    def read(df, mode='rb')
-      df.gsub!('\\', '/')
-      if !File.file?(df)
-        $log.debug "#{df} is missed!"
-      else
-        File.open(df, mode) {|f| f.read}
-      end
-    end
-  
-    def read_lines(df, *lines)
-      return if !lines or lines.empty?
-      str = ""
-      last = lines.max
-      if !File.file?(df)
-        puts "#{df} is missed!"
-      else
-        File.open(df, 'r') {|f|
-          f.each {|line|
-              no = f.lineno
-              str << line if no.in lines
-              break if no == last
-        }}
-        str
-      end
-    end
-    
-    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
-    
-    def tail(file, bytes=1000)
-      if !File.file?(file)
-        puts "#{file} is missed!"
-      else
-        IO.read(file, bytes, File.size(file)-bytes)
-      end
-    end
-    
-    def tail_n(file, qty=10)
-      if !File.file?(file)
-        return puts "#{file} is missed!"
-      end
-      size = File.size(file)
-      lines = []
-      strlen = 0
-      step = qty*100
-      while qty > 0 and (offset = size-strlen-step) >= 0 and (str = IO.read(file, step, offset)).b
-        i = str.index("\n") || str.size
-        strlen += step - i
-        new_lines = str[i+1..-1]/"\n"
-        qty -= new_lines.size
-        lines = new_lines.concat(lines)
-      end
-      lines[-qty..-1]
-    end
-  
-  module_function :tick!, :executing?, :rw, :write, :read, :read_lines, :highlighted_line, :tail, :tail_n
-end

data/lib/rmtools/js.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-class Hash
-  
-  def method_missing(met, *args)
-    str = met.id2name
-    if str[/=$/]
-      self[str[0..-2]] = args[0]
-    else
-      raise NoMethodError, "undefined method `#{str}' for #{self}:#{(self.class)}" if !args.empty?
-      a = self[str]
-      (a == default) ? self[met] : a
-    end
-  end
-
-end
-
-class String
-  if !method_defined? :plus
-    alias :plus :+ end
-  
-  def +(str)
-    plus str.to_s
-  end
-  
-end

data/lib/rmtools/limited_string.rb

@@ -1,17 +0,0 @@
-# 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

@@ -1,158 +0,0 @@
-# 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/proc.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-class Proc
-  include RMTools
-  NULL = lambda {} unless defined? Proc::NULL
-  attr_accessor :string
-  
-  def inspect
-    "#{str=to_s}: #{@string ? Painter.green(@string) : "\n"+highlighted_line(*str.match(/([^@]+):(\d+)>$/)[1..2])}"
-  end
-  
-  def self.when condition
-    if condition.is String
-      sleep 0.001 until eval condition
-    else
-      sleep 0.001 until condition.call
-    end
-    yield
-  end
-  
-  def self.eval string, binding=nil
-    (proc = (binding || Kernel).eval "lambda {#{string}}").string = string
-    proc
-  end
-  
-end

data/lib/rmtools/range.rb

@@ -1,100 +0,0 @@
-# encoding: utf-8
-class Range
-  
-  def &(range)
-    return range&self if range.is XRange
-    beg = [self.begin, range.begin].max
-    end_ = [self.include_end.end, range.include_end.end].min
-    beg > end_ ? nil : beg..end_
-  end
-  
-  def |(range)
-    return range|self if range.is XRange
-    range = range.include_end
-    self_ = self.include_end
-    return XRange.new self, range if !x?(range)
-    [self.begin, range.begin].min..[self_.end, range.end].max
-  end
-  
-  def x?(range)
-    range_end = range.include_end.end
-    self_end = self.include_end.end
-    if self_end < range_end
-      self_end >= range.begin - (self_end.kinda Integer and range.begin.kinda Integer).to_i
-    else
-      range_end >= self.begin - (self.begin.kinda Integer and range_end.kinda Integer).to_i
-    end
-  end
-    
-  def <=>(range) (self.begin <=> range.begin).b || self.include_end.end <=> range.include_end.end end
-  
-  def include_end() exclude_end? ? self.begin..(self.end - 1) : self end
-  
-  def center() (first + last + (!exclude_end?).to_i)/2 end
-  
-  def part(i, j) first+(i-1)*size/j...first+i*size/j unless i < 1 or j < 1 or j < i end
-  
-  def size() last - first + (!exclude_end?).to_i end
-  
-  def /(i) first...size/i end
-  
-  def from(ary) ary[self] end
-  
-end
-
-class XRange
-  attr_accessor :ranges
-  __init__
-  
-  def initialize *args
-    if (str = args[0]).is String
-      str.scan(/([&|])?((-?\d+)\.\.(\.)?(-?\d+))/).each {|s|
-        s[2], s[4] = s[2].to_i, s[4].to_i
-        r = s[3] ? s[2]...s[4] : s[2]..s[4]
-        @ranges = case s[0]
-                          when '&', '^'; intersect r
-                          when '|', 'v'; union r
-                          else [r]
-                        end
-      }
-      @ranges.sort!
-    else
-      0.upto(args.sort!.size-2) {|i| args[i,2] = [nil, args[i]|args[i+1]] if args[i].x? args[i+1]}
-      @ranges = args.compact
-    end
-  end
-  
-  def &(range)
-    if range.is Range
-      XRange.new *intersect(range)
-    else
-      @ranges.map {|r| range & r}.foldl(:|)
-    end
-  end
-  
-  def |(range)
-    if range.is Range
-      XRange.new *union(range)
-    else
-      @ranges.each {|r| range |= r}
-      range
-    end
-  end
-  
-  def intersect(range)
-    @ranges.map {|r| r&range}.compact
-  end
-  
-  def union(range)
-    changed = (rs = @ranges.map {|r| (r.x?range) ? r|range : r}) != @ranges
-    changed ? rs : rs << range
-  end
-    
-  include Enumerable
-  
-  def each(&b) @ranges.each {|r| r.each &b} end
-  
-  def from(ary) @ranges.foldl(:+) {|r| ary[r]} end
-  
-end
-