rmtools 1.0.0 → 1.1.0

data/lib/rmtools/lang/shortcuts.rb

@@ -0,0 +1,20 @@
+require_with_path 'lang/ansi'
+
+class String
+    # Actually, for short strings and 1251<->65001 it's much faster to use predefined ANSI2UTF and UTF2ANSI procs
+    def utf(from_encoding='WINDOWS-1251')
+      Iconv.new('UTF-8', from_encoding).iconv(self)
+    end
+    
+    def utf!(from_encoding='WINDOWS-1251')
+      replace utf from_encoding
+    end
+    
+    def ansi(from_encoding='UTF-8')
+      Iconv.new('WINDOWS-1251', from_encoding).iconv(self)
+    end
+    
+    def ansi!(from_encoding='UTF-8')
+      replace ansi from_encoding
+    end
+end

data/lib/rmtools/lang.rb

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

data/lib/rmtools/rand/array.rb

@@ -0,0 +1,39 @@
+require_with_path 'rand/enum'
+
+module RMTools
+  
+  def randarr(len, &b)
+    a = (0...len).to_a.shuffle
+    block_given? ? a.map!(&b) : a
+  end
+
+  module_function :randarr
+end
+
+class Array
+  
+  def self.rand(len)
+    RMTools.randarr(len)
+  end
+  
+  def rand!
+    delete_at Kernel.rand size
+  end
+  
+  def randdiv(int)
+    dup.randdiv!(int)
+  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

data/lib/rmtools/rand/enum.rb

@@ -0,0 +1,26 @@
+module Enumerable
+
+  def rand
+    if block_given?
+      h, ua = {}, to_a.uniq
+      size = ua.size
+      loop {
+        i = Kernel.rand size
+        if h[i]
+          return if h.size == s
+        elsif yield(e = ua[i])
+          return e
+        else h[i] = true
+        end
+      }
+    else to_a[Kernel.rand(size)]
+    end
+  end
+  
+  def randsample(qty=Kernel.rand(size))
+    a, b = [], to_a.dup
+    qty.times {a << b.rand!}
+    a
+  end
+
+end

data/lib/rmtools/rand/range.rb

@@ -0,0 +1,13 @@
+require_with_path 'rand/enum'
+
+class Range
+  
+  def rand
+    self.begin + Kernel.rand(size)
+  end
+
+  def randseg
+    (a = rand) > (b = rand) ? b..a : a..b
+  end
+  
+end

data/lib/rmtools/{random.rb → rand/string.rb}

@@ -1,4 +1,6 @@
 # encoding: utf-8
+require_with_path 'lang/ansi'
+
 module RMTools
   begin
     require 'securerandom'
@@ -11,8 +13,8 @@ module RMTools
   Chars = 'abcdefghijklmnopqrstuvwxyz'
   Alphanum = Chars + Chars.upcase + Numbers
   ASCII_readable = '!"#$%&\'()*+,-./[\]^_`{|}~:;<=>?@ ' + Alphanum
-  RuChars = UTF2ANSI[RU_LETTERS[0]]
-  RuAlphanum = UTF2ANSI[RU_LETTERS.join] + Numbers
+  RuChars = UTF2ANSI[Cyrillic::RU_LETTERS[0]]
+  RuAlphanum = UTF2ANSI[Cyrillic::RU_LETTERS.join] + Numbers
   
   def randstr(len=8, what=:alphanum)
     s = ''
@@ -75,111 +77,7 @@ module RMTools
     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
-
+  module_function :randstr
 end
 
 class String
@@ -191,5 +89,13 @@ class String
   def rand(chsize=1)
     self[Kernel.rand(size*chsize), chsize]
   end
+
+  def randsubstr(chsize=1)
+    (a = Kernel.rand(size*chsize)) > (b = Kernel.rand(size*chsize)) ? self[b..a] : self[a..b]
+  end
+
+  def randsample(qty=Kernel.rand(size))
+    split('').randsample(qty)
+  end
   
 end

data/lib/rmtools/rand.rb

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

data/lib/rmtools/require.rb

@@ -0,0 +1,13 @@
+module Kernel
+  # ` require_with_path __FILE__, "*" ' requires all ruby files from dir named as file
+  # ` require_with_path "folder", "file" ' requires file.rb from dir `folder' in working directory
+  # `require_with_path "file" ' requires 'file.rb' from working directory
+  def require_with_path(location, mask=nil)
+    if !mask
+      location, mask = File.dirname(__FILE__), location # /path/to/gems/rmtools
+    end
+    mask += '.rb' unless mask['.']
+    location = File.expand_path(location).chomp('.rb')
+    Dir.glob(File.join location, mask) {|file| require file}
+  end
+end

data/lib/rmtools/setup.rb

@@ -1,17 +1,18 @@
 # encoding: utf-8
-Dir.chdir(File.expand_path File.dirname __FILE__) {require 'io'; require 'boolean'}
+require File.expand_path('require', File.dirname(__FILE__))
+require_with_path 'fs'
 require 'digest/md5'
 
-def ext_files_not_modified(ext_name='rmtools')
+def ext_files_not_modified(ext_name='rmtools', version='\d')
     return unless name = Gem.source_index.gems.keys.find {|n| 
-      n =~ /^#{ext_name}-\d/
+      n =~ /^#{ext_name}-#{version}/
     }
     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)
+      installed = File.join(full_path, f)
+      return unless File.file? installed and Digest::SHA256.file(f) == Digest::SHA256.file(installed)
     }
 end
   

data/lib/rmtools/text/string_parse.rb

@@ -0,0 +1,60 @@
+require_with_path 'conversions/string'
+
+class String
+  CALLER_RE = %r{^\(?(.*?([^/\\]+?))#{	  # ( path ( file ) ) 
+                            }\)?:(\d+)(?::in #{	      # :( line )[ :in
+                            }[`<]([^'>]+)[>']#{	    # `( closure )' ]
+                      })?$}
+  URL_RE = %r{^((?:([^:]+)://)#{	            #  ( protocol
+                      }([^/:]*(?::(\d+))?))?#{	  #  root[:port] )
+                      }((/[^?#]*?(?:\.(\w+))?)#{	#  ( path[.( fileext )]
+                      }(?:\?(.*?))?)?#{	              #  [?( query params )] )   
+                      }(?:#(.+))?#{	                  #  [ #( anchor ) ]
+                    }$}
+  IP_RE           = /\d+\.\d+\.\d+\.\d+(?::\d+)?/
+  IP_RANGE_RE = /(\d+\.\d+\.\d+\.\d+)\s*-\s*(\d+\.\d+\.\d+\.\d+)/
+    
+    def parse(as)
+      case as
+        when :uri
+          m = match 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] }
+        when :caller
+          m = match CALLER_RE
+          m || m[0].empty? ? nil : 
+            {  'path' => m[1],
+                'file' => m[2],
+                'line' => m[3].to_i,
+                'func' => m[4],
+                'fullpath' => 
+                 m[1]['('] ? m[1] : 
+           File.expand_path(m[1])     }
+        when :ip;          self[IP_RE]
+        when :ip_range; (m = match IP_RANGE_RE) && m[1]..m[2]
+        else raise ArgumentError, "Incorrect flag. Correct flags: :uri, :caller, :ip, :ip_range"
+      end
+    end
+    
+    def parseuri
+      deprecation "Use String#parse(:uri) instead."
+      parse :uri
+    end
+    
+    def parseip(range=nil)
+      deprecation "Use String#parse(:ip#{'_range' if range}) instead."
+      parse :"ip#{'_range' if range}"
+    end
+    
+end

data/lib/rmtools/{stringscanner.rb → text/string_scanner.rb}

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require 'strscan'
 
 class StringScanner
   attr_reader :last
@@ -7,7 +8,7 @@ class StringScanner
     @last = 0
     res = scan_until re
     if cbs
-      if cbs[0].kinda Integer
+      if cbs.keys.compact[0].is Fixnum
         while res
           if cb = cbs[matched.ord]
             cb[self]
@@ -18,7 +19,7 @@ class StringScanner
         end
       else
         while res
-          if cb = cbs.find {|pattern, proc| pattern.in matched}
+          if cb = cbs.find {|pattern, proc| pattern and pattern.in matched}
             # patterns must be as explicit as possible
             cb[1][self]
             @last = pos

data/lib/rmtools/text/string_simple.rb

@@ -0,0 +1,75 @@
+class String
+  if !method_defined? :/
+    alias :/ :split 
+  end
+  
+  def inline
+    count("\n") == 0
+  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 until(splitter=$/)
+    split(splitter, 2)[0]
+  end
+  alias :till :until
+    
+  def after(splitter=$/)
+    split(splitter, 2)[1]
+  end
+    
+  # %{blah blah
+  #  wall of text in the interpreter
+  # oh it's too bulky; may be we should
+  # save this text into variable
+  # blah blah} >> (str='') 
+  # saved!
+  def >>(str)
+    str.replace(self + str)
+  end
+    
+  # Fast search for highlighting purposes
+  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
+    
+  # 'filename.txt'.bump!.bump!
+  # => "filename.txt.2"
+  # 'filename.txt'.bump!.bump!.bump!('_')
+  # => "filename.txt.2_1"
+  # 'filename.txt'.bump!.bump!.bump!('_').bump!
+  # => "filename.txt.2_1.1"
+  def bump!(splt='.')
+    replace bump_version splt
+  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 to_re(esc=false)
+    Regexp.new(esc ? Regexp.escape(self) : self)
+  end
+  
+end

data/lib/rmtools/text/string_split.rb

@@ -0,0 +1,148 @@
+require_with_path 'text/string_simple'
+require_with_path 'enumerable/array_iterators'
+
+class String
+    
+  def rsplit(splitter=$/, qty=0)
+    reverse.split(splitter, qty).reverse.reverses
+  end
+  
+  # Same as split, but without :reject_splitter option keeps splitters on the left of parts
+  # with :report_headers option collects all regexp'ed splitters along with result array
+    def sharp_split(splitter, *args)
+      count, opts = args.fetch_opts [0, :flags], :include_splitter => true
+      if !opts[:report_headers] and opts[:include_splitter] and splitter.is Regexp
+        return split(/(?=#{splitter.source})/, count)
+      end
+      a = split(splitter, count)
+      return a if !opts[:include_splitter] and !opts[:report_headers]
+      skan = nil
+      case splitter
+        when String
+          skan = ([splitter]*a.size).unshift ''
+          a = (1...a.size).map {|i| splitter+a[i]}.unshift a[0] if opts[:include_splitter]
+        when Regexp
+          skan = scan(splitter).unshift ''
+          a = (0...a.size).map {|i| skan[i].to_s+a[i]} if opts[:include_splitter]
+      end
+      opts[:report_headers] ? [a, skan] : a
+    end
+    
+    # Same as sharp_split, but without keeps splitters on the *right* of parts
+    def sharp_splitr(splitter, *args)
+      count, opts = args.fetch_opts [0, :flags], :include_splitter => true
+      a = split(splitter, count)
+      return a if !opts[:include_splitter] and !opts[:report_headers]
+      skan = nil
+      case splitter
+        when String
+          skan = [splitter]*a.size << ''
+          a = (0...a.size-1).map {|i| a[i]+splitter} << a[i] if opts[:include_splitter]
+        when Regexp
+          skan = scan(splitter) << ''
+          a = (0...a.size).map {|i| a[i]+skan[i]} if opts[:include_splitter]
+      end
+      opts[:report_headers] ? [a, skan] : a
+    end
+    
+    def div(len, *)
+      if !len.is Fixnum
+        deprecation "Use #sharp_split instead."
+        return sharp_split len
+      end
+      return [self] if len <= 0
+      str = dup
+      arr = []
+      while str.b
+        arr << str.slice!(0, len)
+      end
+      arr
+    end
+    
+  private
+    def split_by_syntax(str, maxlen, buflen=0)
+      len, add = maxlen - buflen, nil
+      [/[^.?!]+\z/, /[^;]+\z/, /[^\n]+/, /\S+\z/, /[^。]+z/, /[^、]+z/].each {|t|
+        if !(add = str[t]) or add.size <= len
+          return add
+        end
+      }
+      add
+    end
+    
+    def sanitize_blocks!(blocks, opts)
+      blocks.reject! {|b| b.empty?} if opts[:no_blanks]
+      blocks.strips! if opts[:strips]
+      blocks.each {|b| raise Exception, "can't split string by #{terminator} to blocks with max length = #{maxlen}" if b.size > maxlen} if opts[:strict_overhead]
+      blocks
+    end
+    
+  public
+  #   Base smart-split method
+  #   Keep in mind that cyrrilic in 1.8 is 2-byte long as method doesn't use cyrillic lib to not decrease speed.
+    def split_to_blocks(maxlen, *opts)
+      raise Exception, "Can't split text with maxlen = #{maxlen}" if maxlen < 1
+      return [self] if size <= maxlen
+      terminator, opts = opts.fetch_opts [nil, :flags], :strict_overhead => true, :no_blanks => true
+      blocks = []
+      term_re = /[^#{terminator}]+\z/ if terminator and terminator != :syntax
+      words, buf = split(opts[:strips] ? ' ' : / /), nil
+      while words.b or buf.b
+        if terminator and blocks.b and (
+          buf_add = if terminator == :syntax
+                          split_by_syntax blocks[-1], 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
+        if blocks.size == opts[:lines]
+          return sanitize_blocks! blocks, opts
+        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
+      sanitize_blocks! blocks, opts
+    end
+    
+    #   'An elegant way to factor duplication out of options passed to a series of method calls. Each method called in the block, with the block variable as the receiver, will have its options merged with the default options hash provided. '.cut_line 100
+    # => "An elegant way to factor duplication out of options passed to a series of method calls..."
+    def cut_line(maxlen, *opts)
+      terminator, opts = opts.fetch_opts [:syntax, :flags]
+      opts[:charsize] ||= RUBY_VERSION < '1.9' && a[0].cyr? ? 2 : 1
+      return self if size <= maxlen
+      maxlen -= 3
+      split_to_blocks(maxlen*opts[:charsize], terminator, :strips => true, :strict_overhead => false, :lines => 1)[0][0, maxlen].chomp('.') + '...'
+    end
+    
+    #   puts 'An elegant way to factor duplication out of options passed to a series of method calls. Each method called in the block, with the block variable as the receiver, will have its options merged with the default options hash provided.  '.split_to_lines 50
+    #    produces:
+    #   An elegant way to factor duplication out of
+    #   options passed to a series of method calls. Each
+    #   method called in the block, with the block
+    #   variable as the receiver, will have its options
+    #   merged with the default options hash provided.
+    #
+    # This method is use cyrillic lib only to detect char byte-length
+    # options: charsize, no_blanks, strips
+    def split_to_lines(maxlen, *opts)
+      raise Exception, "Can't break text with maxlen = #{maxlen}" if maxlen < 1
+      opts = opts.fetch_opts :flags, :strips=>true
+      a = split("\n")
+      opts[:charsize] ||= RUBY_VERSION < '1.9' && a[0].cyr? ? 2 : 1
+      a.map {|string| string.strip.split_to_blocks(maxlen*opts[:charsize], opts.merge(:strict_overhead => false))}.flatten*"\n"
+    end
+  
+end

data/lib/rmtools/text/textilize.rb

@@ -0,0 +1,44 @@
+module RMTools
+
+  def dump_recurse(obj, depth, maxdepth)
+    res = ''
+    case obj
+      when Hash
+        if depth <= maxdepth
+          res = "{\n"
+          obj.each { |i, j|
+            i = i.inspect unless i.is_a? String
+            childinfo = dump_recurse(j,depth+1,maxdepth)
+            res << "%s  %s => %s、\n"%[("  "*depth), i, childinfo]
+          }
+          res << "  "*depth+"  }"
+        else
+          res = obj.inspect
+        end
+        res
+      when Array
+        if depth <= maxdepth
+          res = "[\n"
+          obj.each_with_index { |j, i|
+            childinfo = dump_recurse(j,depth+1,maxdepth)
+            res << "%s  %0*d: %s、\n"%[("  "*depth), (obj.size-1).to_s.size, i, childinfo]
+          }
+          res << "  "*depth+"  ]"
+        else
+          res = obj.inspect
+        end
+        res
+      when String then obj
+      else obj.inspect
+    end
+  end
+  
+end
+  
+module Enumerable
+  
+    def dump(depth=5)
+      RMTools.dump_recurse self, 0, depth
+    end
+
+end

data/lib/rmtools/text.rb

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

data/lib/rmtools/time/global.rb

@@ -0,0 +1,17 @@
+module RMTools
+
+  def puttime(ms=nil)
+    t = Time.now
+    if ms
+      t.strftime("%H:%M:%S")+sprintf(".%03d ", t.usec/1000)
+    else
+      t.strftime("%d.%m.%y %H:%M:%S ")
+    end
+  end
+    
+  def putdate
+    Time.now.strftime("%d.%m.%y")
+  end
+  
+  module_function :puttime, :putdate
+end