rmtools 1.0.0

data/lib/rmtools/printing.rb

@@ -0,0 +1,41 @@
+module RMTools
+
+  class TempPrinter
+    __init__
+    
+    def initialize object=nil, format=nil
+      if @object = object
+        @format = '"' + format.gsub(/:([a-z_]\w*)/, '#{@\1.inspect}') + '"'
+      end
+    end
+    
+    def format_str
+      @object.instance_eval @format
+    end
+
+    def p(str=format_str)
+      STDOUT << @eraser if @eraser
+      cols = ENV['COLUMNS'].to_i
+      astr = RUBY_VERSION < '1.9' ? UTF2ANSI[str] : str
+      rows = astr.split("\n").sum {|line| 1 + line.size/cols}
+      eraser = "\b" + "\r\b"*rows + " "
+      @eraser = eraser + " "*cols*rows + eraser
+      puts str
+    end
+    
+    def end
+      @eraser = nil
+    end
+    
+    def clear
+      p ""
+    end
+    
+    def end!
+      clear
+      self.end
+    end
+    
+  end
+  
+end

data/lib/rmtools/proc.rb

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

@@ -0,0 +1,195 @@
+# encoding: utf-8
+module RMTools
+  begin
+    require 'securerandom'
+    SecureRandom.random_bytes
+    Urandom = true
+  rescue
+    Urandom = false
+  end
+  Numbers = '0123456789'
+  Chars = 'abcdefghijklmnopqrstuvwxyz'
+  Alphanum = Chars + Chars.upcase + Numbers
+  ASCII_readable = '!"#$%&\'()*+,-./[\]^_`{|}~:;<=>?@ ' + Alphanum
+  RuChars = UTF2ANSI[RU_LETTERS[0]]
+  RuAlphanum = UTF2ANSI[RU_LETTERS.join] + Numbers
+  
+  def randstr(len=8, what=:alphanum)
+    s = ''
+    res = case what
+      when :bytes, :binary
+        if Urandom
+          SecureRandom.random_bytes len
+        else
+          len.times {s.concat rand 256}; s
+        end
+      when :ascii
+        if Urandom
+          SecureRandom.random_bytes(len*3).tr("^ -~", '')[0...len]
+        else
+          len.times {s.concat ASCII_readable[rand 95].ord}; s
+        end
+      when :char
+        if Urandom
+          res = SecureRandom.base64(len*2).tr("^a-z", '')[0...len]
+        else
+          len.times {s.concat Chars[rand 26].ord}; s
+        end
+      when :alphanum
+        if Urandom
+          res = SecureRandom.base64(len).tr("+/=", '')[0...len]
+        else
+          len.times {s.concat Alphanum[rand 62].ord}; s
+        end
+      when :num, :digit
+        if Urandom
+          res = SecureRandom.hex(len).tr("^0-9", '')[0...len]
+        else
+          len.times {s.concat Numbers[rand 10].ord}; s
+        end
+      when :hex
+        if Urandom
+          res = SecureRandom.hex len/2
+        else
+          len.times {s.concat Numbers[rand 10].ord}; s
+        end
+      when :cyr, :cyrilic
+        if Urandom
+          res = ANSI2UTF[SecureRandom.random_bytes(len*8).tr("^\270\340-\377", '')[0...len]]
+        else
+          len.times {s.concat RuChars[rand 33].ord}; ANSI2UTF[s]
+        end
+      when :cyr_full, :cyr_alphanum
+        if Urandom
+          res = ANSI2UTF[SecureRandom.random_bytes(len*3.5).tr("^0-9\250\270\340-\377\300-\337", '')[0...len]]
+        else
+          len.times {s.concat RuAlphanum[rand 76].ord}; ANSI2UTF[s]
+        end
+        
+      when Symbol then raise ArgumentError, "invalid symbol :#{what}, valid symbols are
+        :bytes, :binary, :char, :alphanum, :num, :digit, :hex, :cyr, :cyrilic, :cyr_full, :cyr_alphanum"
+      when String then res = randstr(len*10, :bytes).tr("^#{what}", '')
+      else raise ArgumentError, "invalid argument #{what}, class #{(what.class)}"
+    end
+    res << randstr((len-res.size)*2, what) while res.size < len
+    res[0...len]
+  end
+  
+if RUBY_VERSION >= "1.8.7"
+  def randarr(len, &b)
+    a = (0...len).to_a.shuffle
+    block_given? ? a.map!(&b) : a
+  end
+else
+  def randarr(len, &b)
+    d = (0...len).to_a
+    a = Array.new(len) {d.rand!}
+    block_given? ? a.map!(&b) : a
+  end
+end
+
+  module_function :randstr, :randarr
+end
+
+module Enumerable
+  
+  def randsample(qty=Kernel.rand(size))
+    a, b = [], to_a.dup
+    qty.times {a << b.rand!}
+    a
+  end
+
+  def rand(&cond)
+    if cond
+      a, b, s = Set.new, to_a, size
+      loop {
+        i = Kernel.rand s
+        if i.in a
+          return if a.size == s
+        elsif !cond[e = b[i]]
+          a << i
+        else return e
+        end
+      }
+    else to_a[Kernel.rand(size)]
+    end
+  end
+
+end
+
+class Range
+  
+  def rand
+    self.begin + Kernel.rand(size)
+  end
+
+  def randseg
+    (a = rand) > (b = rand) ? b..a : a..b
+  end
+  
+end
+
+class Array
+  
+  def self.rand(len)
+    RMTools.randarr(len)
+  end
+
+  def rand(&cond)
+    if cond
+      a, s = [], size
+      loop {
+        i = Kernel.rand s
+        if i.in a
+          return if a.size == s
+        elsif !cond[e = self[i]]
+          a << i
+        else return e
+        end
+      }
+    else self[Kernel.rand(size)]
+    end
+  end
+  
+  def rand!
+    delete_at Kernel.rand size
+  end
+  
+  def randdiv(int)
+    len = 2*int.to_i+1
+    return [self] if len <= 1
+    newarr = []
+    arr = dup
+    while arr.size > 0
+      lenn = Kernel.rand(len)
+      next if lenn < 1
+      newarr << arr.slice!(0, lenn)
+    end
+    newarr
+  end
+  
+  def randdiv!(int)
+    len = 2*int.to_i+1
+    return [self] if len <= 1
+    newarr = []
+    while size > 0
+      lenn = Kernel.rand(len)
+      next if lenn < 1
+      newarr << slice!(0, lenn)
+    end
+    newarr
+  end
+
+end
+
+class String
+  
+  def self.rand(*args)        
+    RMTools.randstr(*args)
+  end
+
+  def rand(chsize=1)
+    self[Kernel.rand(size*chsize), chsize]
+  end
+  
+end

data/lib/rmtools/range.rb

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

data/lib/rmtools/setup.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+Dir.chdir(File.expand_path File.dirname __FILE__) {require 'io'; require 'boolean'}
+require 'digest/md5'
+
+def ext_files_not_modified(ext_name='rmtools')
+    return unless name = Gem.source_index.gems.keys.find {|n| 
+      n =~ /^#{ext_name}-\d/
+    }
+    gemspec = Gem.source_index.gems[name]
+    full_path  = gemspec.full_gem_path
+    ext_files  = gemspec.files.grep(/^ext\//)
+    ext_files.each {|f| 
+      insalled = File.join(full_path, f)
+      return unless File.file? insalled and Digest::SHA256.file(f) == Digest::SHA256.file(insalled)
+    }
+end
+  
+def compile_manifest(exc=['pkg'])
+    fs = Dir.new('.').recursive_content
+    RMTools.rw 'Manifest.txt', (exc ? fs.reject {|i| i[/^(#{exc*'|'})\//]} : fs)*"\n"
+end

data/lib/rmtools/string.rb

@@ -0,0 +1,276 @@
+# encoding: utf-8
+class String
+  if !method_defined? :/
+    alias :/ :split 
+  end
+  
+  def inline
+    count("\n") == 0
+  end
+  
+  def <<(str)
+    concat str.to_s
+  end
+  
+  # %{blah blah
+  #  wall of text in the interpreter
+  # oh shi~ may be we should
+  # save this into variable
+  # } >> (str='') 
+  # ok, easily saved to variable
+  def >>(str)
+    str.replace(self + str)
+  end
+  
+  def find_with_offsets text, offset
+    index = index(text)
+    start = [0, index - offset].max
+    _end = index + text.size
+    [self[start...index], text, self[_end, offset]]
+  end
+  
+  def div(dvsr, includesplitter=1, reportheaders=nil)
+    return lendiv dvsr if dvsr.kinda Fixnum
+    a = split(dvsr)
+    return a if !includesplitter and !reportheaders
+    skan = nil
+    case dvsr
+      when String
+        a = (1...a.size).map {|i| dvsr+a[i]}.unshift a[0] if includesplitter
+      when Regexp
+        skan = scan(dvsr).unshift ''
+        a = (0...a.size).map {|i| skan[i].to_s+a[i]} if includesplitter
+    end
+    (reportheaders and skan) ? [a, skan] : a
+  end
+  
+  def rdiv(dvsr, includesplitter=1, reportheaders=nil)
+    return lendiv dvsr if dvsr.kinda Fixnum
+    a = split(dvsr)
+    return a if !includesplitter and !reportheaders
+    skan = nil
+    case dvsr
+      when String
+        a = (0...a.size).map {|i| a[i]+dvsr} if includesplitter
+      when Regexp
+        skan = scan(dvsr)
+        a = (0...a.size).map {|i| a[i]+skan[i]} if includesplitter
+    end
+    (reportheaders and skan) ? [a, skan] : a
+  end
+  
+  def lendiv(len)
+    return [self] if len <= 0
+    str = dup
+    arr = []
+    while str.b
+      arr << str.slice!(0, len)
+    end
+    arr
+  end
+  
+  def split_to_lines(maxlen, charsize=nil, no_blanks=false, strips=true)  
+    raise Exception, "Can't break text with maxlen = #{maxlen}" if maxlen < 1
+    a = split("\n")
+    charsize ||= a[0].cyr? ? 2 : 1
+    a.map {|string| string.strip.split_to_blocks(maxlen*charsize, nil, false, no_blanks, strips)}.flatten*"\n"
+  end
+  
+  def split_to_blocks(maxlen, terminator=nil, strict_overhead=true, no_blanks=true, strips=false)
+    raise Exception, "Can't break text with maxlen = #{maxlen}" if maxlen < 1
+    blocks = []
+    term_re = /[^#{terminator}]+\z/ if terminator and terminator != :syntax
+    return [self] if size <= maxlen
+    words, buf = split(strips ? ' ' : / /), nil
+    while words.b or buf.b
+      if terminator and blocks.b and (buf_add = if terminator == :syntax
+               blocks[-1].split_by_syntax maxlen, buf.size
+        else blocks[-1][term_re]
+        end.b)
+        if buf_add == blocks[-1]
+               blocks.pop
+        else blocks[-1] = blocks[-1][0...-buf_add.size]
+        end
+        buf = buf_add + buf
+      end
+      blocks << ''
+      if buf
+        blocks[-1] << buf
+        buf = nil
+      end
+      while words.b
+        buf = words.shift + ' '
+        break if blocks[-1].size + buf.size - 1 > maxlen
+        blocks[-1] << buf
+        buf = nil
+      end
+    end
+    blocks.reject! &:empty? if no_blanks
+    blocks.strips! if strips
+    blocks.each {|b| raise Exception, "can't split string by #{terminator} to blocks with max length = #{maxlen}" if b.size > maxlen} if strict_overhead
+    blocks
+  end
+  
+  RMTools::URL_RE = %r{^((?:([^:]+)://)#{	              #  ( protocol
+                                   }([^/:]*(?::(\d+))?))?#{	    #  root[:port] )
+                                   }((/[^?#]*?(?:\.(\w+))?)#{	#  ( path[.fileext]
+                                   }(?:\?(.*?))?)?#{	              #  [?query params] )   
+                                   }(?:#(.+))?#{	                  #  [ #anchor ]
+                                 }$}	  unless defined? RMTools::URL_RE
+  def parseuri
+    m = match RMTools::URL_RE
+    !m || m[0].empty? ?
+      {  'href'	        => self  } : 
+      {	'href'	      => self,
+          'root'	      => m[1],
+          'protocol'	=> m[2],
+          'host'	      => m[3], 
+          'port'	      => m[4] ? m[4].to_i : 80,
+          'fullpath'	=> m[5] || '/',
+          'pathname'	=> m[5] || '/',
+          'path'	      => m[6] || '',
+          'ext'	        => m[7],
+          'query'	      => m[8] && m[8].to_hash(false),
+          'anchor'	    => m[9] }
+  end
+  
+  def utf(from_encoding)
+    Iconv.new('UTF-8', from_encoding).iconv(self)
+  end
+  
+  def utf!(from_encoding)
+    replace utf from_encoding
+  end
+  
+  def bytes
+    arr = []
+    each_byte {|b| arr << "\\x#{b.hex}"}
+    arr
+  end
+  
+  def to_re(esc=false)
+    Regexp.new(esc ? Regexp.escape(self) : self)
+  end
+
+  def lchomp(match)
+    if index(match) == 0
+      self[match.size..-1]
+    else
+      self.dup
+    end
+  end
+
+  def lchomp!(match)
+    if index(match) == 0
+      self[0...match.size] = ''
+      self
+    end
+  end
+  
+  def rsplit(splitter=$/, qty=0)
+    reverse.split(splitter, qty).reverse.reverses
+  end
+  
+  def until(splitter=$/)
+    split(splitter, 2)[0]
+  end
+  alias :till :until
+  
+  def after(splitter=$/)
+    split(splitter, 2)[1]
+  end
+  
+  def bump_version(splt='.')
+    re = /(?:(\d*)#{Regexp.escape splt})?/
+    s = File.split self
+    s[0] == '.' ?
+      s[1].reverse.sub(re) {$1?"#{$1.to_i+1}#{splt}":"1#{splt}"}.reverse :
+      File.join(s[0], s[1].reverse.sub(re)  {$1?"#{$1.to_i+1}#{splt}":"1#{splt}"}.reverse)
+  end
+  alias :next_version :bump_version
+  
+  def bump!(splt='.')
+    replace bump_version splt
+  end
+  
+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
+
+  def to_limited len=100
+    LimitedString.new self, len
+  end
+  
+protected
+  def split_by_syntax(maxlen, buflen=0)
+    len, add = maxlen - buflen, nil
+    [/[^.?!]+\z/, /[^;]+\z/, /[^\n]+/, /\S+\z/, /[^。]+z/, /[^、]+z/].each {|t|
+      if !(add = self[t]) or add.size <= len
+        return add
+      end
+    }
+    add
+  end
+    
+end
+  
+class Indent < String
+  attr_reader :indent
+
+  def initialize(indent='  ')
+    @indent = indent
+    super ''
+  end
+  
+  def +@
+    self << @indent
+  end
+  
+  def -@
+    self.chomp! @indent
+  end
+  
+  def i(&block)
+    +self
+    res = yield
+    -self
+    res
+  end
+
+end
+
+class Regexp
+  
+  def | re
+    Regexp.new(source+'|'+re.source, options | re.options)
+  end
+  
+  def in string
+    string =~ self
+  end
+  
+end