rmtools 1.0.0 → 1.1.0

data/lib/rmtools/time/russian.rb

@@ -0,0 +1,47 @@
+class String
+  
+    def digit_date
+      gsub(/jan|[яЯ][нН][вВ]([аА][рР][яЯьЬ]?)?/i, '01').
+      gsub(/feb|[фФ][еЕ][вВ]([рР][аА][лЛ][яЯьЬ]?)?/i, '02').
+      gsub(/mar|[мМ][аА][рР]([тТ][аА]?)?/i, '03').
+      gsub(/apr|[аА][пП][рР]([еЕ][лЛ][яЯьЬ]?)?/i, '04').
+      gsub(/may|[мМ][аА][яЯйЙ]?/i, '05').
+      gsub(/june?|[иИ][юЮ][нН][яЯьЬ]?/i, '06').
+      gsub(/july?|[иИ][юЮ][лЛ][яЯьЬ]?/i, '07').
+      gsub(/aug|[аА][вВ][гГ]([уУ][сС][тТ][аА]?)?/i, '08').
+      gsub(/sep|[сС][еЕ][нН]([тТ][яЯ][бБ][рР][яЯьЬ]?)?/i, '09').
+      gsub(/oct|[оО][кК][тТ]([яЯ][бБ][рР][яЯьЬ]?)?/i, '10').
+      gsub(/nov|[нН][оО][яЯ]([бБ][рР][яЯьЬ]?)?/i, '11').
+      gsub(/dec|[дД][еЕ][кК]([аА][бБ][рР][яЯьЬ]?)?/i, '12')
+    end
+    alias :digitize :digit_date
+    
+    def tr_date
+      gsub(/[яЯ][нН][вВ]([аА][рР][яЯьЬ]?)?/, 'jan').
+      gsub(/[фФ][еЕ][вВ]([рР][аА][лЛ][яЯьЬ]?)?/, 'feb').
+      gsub(/[мМ][аА][рР]([тТ][аА]?)?/, 'mar').
+      gsub(/[аА][пП][рР]([еЕ][лЛ][яЯьЬ]?)?/, 'apr').
+      gsub(/[мМ][аА][яЯйЙ]?/, 'may').
+      gsub(/[иИ][юЮ][нН][яЯьЬ]?/, 'jun').
+      gsub(/[иИ][юЮ][лЛ][яЯьЬ]?/, 'jul').
+      gsub(/[аА][вВ][гГ]([уУ][сС][тТ][аА]?)?/, 'aug').
+      gsub(/[сС][еЕ][нН]([тТ][яЯ][бБ][рР][яЯьЬ]?)?/, 'sep').
+      gsub(/[оО][кК][тТ]([яЯ][бБ][рР][яЯьЬ]?)?/, 'oct').
+      gsub(/[нН][оО][яЯ]([бБ][рР][яЯьЬ]?)?/, 'nov').
+      gsub(/[дД][еЕ][кК]([аА][бБ][рР][яЯьЬ]?)?/, 'dec')
+    end
+    
+    def digit_nums
+      gsub(/[оО][дД][иИ][нН]|[еЕ][дД][иИ][нН][иИ][цЦ][аА]/, '1').
+      gsub(/[дД][вВ]([оО][йЙ][кК])?[аА]/, '2').
+      gsub(/[тТ][рР]([иИ]|[оО][йЙ][кК][аА])/, '3').
+      gsub(/[чЧ][еЕ][тТ]([ыЫ][рР][еЕ]|[вВ][еЕёЁ][рР][кК][аА])/, '4').
+      gsub(/[пП][яЯ][тТ]([ьЬ]|[еЕёЁ][рР][кК][аА])/, '5').
+      gsub(/[шШ][еЕ][сС][тТ]([ьЬ]|[еЕёЁ][рР][кК][аА])/, '6').
+      gsub(/[сС][еЕ][мМ]([ьЬ]|[еЕёЁ][рР][кК][аА])/, '7').
+      gsub(/[вВ][оО][сС]([еЕ][мМ][ьЬ]|[ьЬ][мМ][еЕёЁ][рР][кК][аА])/i, '8').
+      gsub(/[дД][еЕ][вВ][яЯ][тТ]([ьЬ]|[кК][аА])/, '9').
+      gsub(/[нН][оОуУ][лЛ][ьЬ]/, '0')
+    end
+
+end

data/lib/rmtools/time.rb

@@ -1,32 +1 @@
-# encoding: utf-8
-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: #{(t2-t1).to_f/ts}ms, total: #{(t2-t1).to_f}ms"
-  end
-    
-  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
+require_with_path __FILE__, '*'

data/lib/rmtools/xml/document.rb

@@ -0,0 +1,28 @@
+module LibXML::XML
+
+  class Document
+      
+    def title
+      (a = context(nil).find('head//title')[0]) && a.content.strip
+    end
+    
+    def body
+      context(nil).find('body')[0] || root
+    end
+      
+    def to_xhtml
+      html = to_s
+      html.sub! "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n", ''
+      html.gsub! %r{<a name(=\"\S+\")\s+id\1(\s*[a-z0-9="]*\s*>)}, '<a name\1\2'
+      html.gsub! %r{\n?<!\[CDATA\[\s*(.+?)\s*\]\]>\n?}m, '\1'
+      html.gsub! %r{<html( +xmlns=\"http://\S+\")\1}, '<html\1'
+      html
+    end
+    
+    def inspect
+      "<#XMLDocument #{title && "«#{title}» "}(#{to_xhtml.size.bytes})>"
+    end
+      
+  end
+    
+end

data/lib/rmtools/xml/finders.rb

@@ -0,0 +1,84 @@
+require_with_path 'text/string_scanner'
+
+module LibXML::XML
+  DefaultNS = {}
+
+  FindByIndex = lambda {|node, ns, ss|
+    node = node.is(Array) ?
+      node.sum {|n| n.__find(nil, ns, ss)[ss.matched[1..-2].to_i].to_a} : 
+                      node.__find(nil, ns, ss)[ss.matched[1..-2].to_i]
+    node.is(Array) && node.size == 1 ? node[0] : node
+  }
+  FindByProc = lambda {|node, ns, ss|
+    node = node.is(Array) ?
+      node.sum {|n| n.__find(nil, ns, ss).select(&ss.matched[1..-2]).to_a} : 
+                      node.__find(nil, ns, ss).select(&ss.matched[1..-2])
+    node.is(Array) && node.size == 1 ? node[0] : node
+  }
+    
+  class Node
+    undef :find if method_defined? :find
+    undef :at   if method_defined? :at
+      
+    def __find(xp=nil, ns=nil, ss=nil)
+      xp ||= ss.head
+      context(ns).find(XPath.filter xp)
+    end
+      
+    def find(xpath, nslist=DefaultNS)
+      node = self
+      ss = StringScanner.new xpath
+      ss.each %r{\[-?\d+\]|\{[^\}]+\}}, 
+        ?[ => lambda {|ss| 
+          if node; node = FindByIndex[node, nslist, ss]
+          else     return []     end  }, 
+        ?{ => lambda {|ss| 
+          if node; node = FindByProc[node, nslist, ss]
+          else     return []     end  },
+        nil => lambda {|str|
+          node = node.is(Array) ?
+            node.sum {|n| n.__find(str, nslist).to_a} : node.__find(str, nslist) 
+        }
+      node ? (!ss.eos? || node.is(Array)) ? node : [node] :  []
+    end
+      
+    def at(xpath, nslist=DefaultNS)
+      find(xpath, nslist)[0]
+    end
+    
+  end
+  
+  class Document
+    undef :find if method_defined? :find
+    undef :at   if method_defined? :at
+      
+    def __find(xp=nil, ns=nil, ss=nil)
+      xp ||= ss.head
+      context(ns).find(XPath.filter xp)
+    end
+      
+    def find(xpath, nslist=DefaultNS)
+      xpath.sub!(/^([\w*])/, '//\1')
+      node = self
+      ss = StringScanner.new xpath
+      ss.each %r{\[-?\d+\]|\{[^\}]+\}}, 
+        ?[ => lambda {|ss|
+          if node; node = FindByIndex[node, nslist, ss]
+          else     return []     end  }, 
+        ?{ => lambda {|ss|
+          if node; node = FindByProc[node, nslist, ss]
+          else     return []     end  },
+        nil => lambda {|str|
+          node = node.is(Array) ?
+            node.sum {|n| n.__find(str, nslist).to_a} : node.__find(str, nslist) 
+        }
+      node ? (!ss.eos? || node.is(Array)) ? node : [node] :  []
+    end
+      
+    def at(xpath, nslist=DefaultNS)
+      find(xpath, nslist)[0]
+    end
+    
+  end
+    
+end

data/lib/rmtools/xml/libxml.rb

@@ -0,0 +1,11 @@
+require 'xml'
+require_with_path 'xml/{xpath,finders,node,document,string}'
+require_with_path 'enumerable/common'
+
+module LibXML::XML
+  Error.reset_handler
+  
+  class XPath::Object
+    include Enumerable            
+  end
+end

data/lib/rmtools/xml/node.rb

@@ -0,0 +1,196 @@
+module LibXML::XML
+    
+    class Node
+      __init__
+    
+      alias :get :[]
+      alias :root? :parent?
+      alias :root :parent
+      
+      def [](*item)
+        if item[0].is String
+          get item[0]
+        else to_a[*item]
+        end
+      end
+      
+    # JQUERY-LIKE MANIPULATION
+      def self.build(str, copy=true)
+        nodes = Document.string("<html>#{str}</html>", :options=>97).root.to_a
+        copy ? nodes.copies(true) : nodes
+      end
+      
+      def self.from(str, copy=true) 
+        build(str, copy)[0] 
+      end
+      
+      def append(obj)
+        case obj
+          when Node then self << obj
+          when Array then obj.each {|n| append n}
+          else append Node.build obj.to_s
+        end
+        self
+      end
+      
+      def after(obj)
+        case obj
+          when Node then self.next = obj
+          when Array then obj.reverse_each {|n| after n}
+          else after Node.build obj.to_s
+        end
+        self
+      end
+      
+      def before(obj)
+        case obj
+          when Node then self.prev = obj
+          when Array then obj.each {|n| before n}
+          else before Node.build obj.to_s
+        end
+        self
+      end
+      
+      def prepend obj
+        first ? first.before(obj) : append(obj)
+      end
+      
+      def html(str=nil)
+        if str
+          self.content = ''
+          append str
+        else to_a.join
+        end
+      end
+      
+      def text(str=nil)
+        if str
+          self.content = str
+          self
+        else
+          self.content
+        end
+      end
+      
+      
+    # FETCH CONTENT
+      def text_nodes(lvl=0) # 0 => nevermind
+        nodes = []
+        xp = "*"
+        loop {
+          ary = find(xp).to_a
+          break if ary.empty?
+          nodes.concat(ary.childrens.flatten.find_all {|e| 
+            e.text? && e.text[/[a-zA-Zа-яА-Я]/]
+          })
+          xp << "/*"
+          break if (lvl -= 1) == 0
+        }
+        nodes
+      end
+      
+      
+    # FORM
+      InputsMapper = lambda {|i| [i['name'], i.name == 'select' ?
+        (i.at('option[selected]') || i.at('option')) : 
+        (i.value || i.checked)]
+      }
+      def inputs
+        [Hash[find("input[name][type=hidden]").map(&InputsMapper)],
+         Hash[
+            ["input[name][type!=hidden]", "textarea[name]", "select[name]"].sum {|s|
+              find(s).map &InputsMapper
+            }
+        ]]
+      end
+      
+      def inputs_all
+        Hash[["input[name]", "textarea[name]", "select[name]"].sum {|s|
+                  find(s).map &InputsMapper
+        }]
+      end
+      
+      
+    # ATTRIBUTES
+      def to_hash
+        attributes.to_hash
+      end
+      
+      %w{style id width height onclick ondbclick onmousedown onmousemove onmouseout onmouseover onmouseup src onerror onload href type value size onchange onselect onblur onfocus onfocusin onfocusout onkeydown onkeypress onkeyup action target enctype onsubmit checked selected}.each {|name|
+        define_method(name) {self[name]}
+        define_method(name+'=') {|value| self[name] = value}
+      }
+      def klass() self['class'] end
+      def klass=(name) self['class'] = name end
+      def metod() self['method'] end
+      def metod=(name) self['method'] = name end
+      
+      
+    # RELATED FINDERS
+      alias :prevNode :prev
+      alias :nextNode :next
+      
+      def prev(*args) getNode :prevNode, *args end
+      def next(*args) getNode :nextNode, *args end
+      def closest(*args) getNode :parent, *args end
+      
+    private
+      Searches = {}
+      def getNode meth, filter=nil, skip=true
+        unless filter
+          send meth
+        else
+          return unless el = skip ? send(meth) : self
+          unless nil;cond = Searches[filter]
+            m = filter.match %r{(\w+)?#{         #   span
+                   }(?:\.(\w+))?(?:#([\-\w]+))?#{#   .class #id
+                   }(\[((\w+)#{                         # [name
+                   }(([!^$~]?)=([\-\w]+))?)?\])#{#           ^= name-beg]
+                   }?}
+            cond = []
+            cond << "_.name == '#{m[1]}'" if m[1]
+            cond << "_['class'] == '#{m[2]}'" if m[2]
+            cond << "_['id'] == '#{m[3]}'" if m[3]
+            if m[4]
+              if m[5]
+                attr = m[6]
+                attr_cond = m[7]
+                if attr_cond
+                  cond_op = m[8]
+                  attr_value = m[9]
+                  cond << case cond_op
+                      when '!'; "_['#{attr}'] !=  '#{attr_value}' "
+                      when '^'; "_['#{attr}'] =~ /^#{attr_value}/ "
+                      when '$'; "_['#{attr}'] =~  /#{attr_value}$/"
+                      when '~'; "_['#{attr}'] =~  /#{attr_value}/ "
+                      else   "_['#{attr}'] == '#{attr_value}'"
+                    end
+                else
+                  cond << "_['#{attr}']"
+                end
+              elsif !(m[2] or m[3])
+                cond << "!_.attributes?"
+              end
+            end
+            cond = Searches[filter] = Proc.eval("|_| #{cond*' && '}")
+          end
+          if cond[el]
+            el
+          else
+            while el = el.send(meth) and el.kinda Node and !cond[el]; end
+            el if el and el.kinda Node and cond[el]
+          end
+        end
+      end
+      
+    end
+   
+    class Attributes
+      
+      def to_hash
+        Hash[map {|a| [a.name,a.value]}]
+      end
+      
+    end
+    
+end

data/lib/rmtools/xml/string.rb

@@ -0,0 +1,43 @@
+require_with_path 'lang/shortcuts'
+
+class String
+  
+  def xml_charset
+    charset = (charset = self[0,2000].match(/(?:encoding|charset)=(.+?)"/)) ? 
+      charset[1].upcase : 'UTF8'
+    if charset and charset != 'UTF-8'
+      utf!(charset) rescue(charset = nil) 
+    end
+    charset
+  end
+  
+  def xml_to_utf
+    charset = (charset = self[0,2000].match(/(?:encoding|charset)=(.+?)"/)) ? 
+      charset[1].upcase : 'UTF8'
+    if charset and charset != 'UTF-8'
+      utf!(charset) rescue() 
+    end
+    self
+  end
+  
+  def to_doc(forceutf=nil)
+    str = b || "<html/>"
+    doc = if forceutf
+        XML::HTMLParser.string(str.xml_to_utf, :options => 97,
+                                        :encoding => XML::Encoding::UTF_8).parse
+      else
+        begin
+          XML::HTMLParser.string(str, :options => 97).parse
+        rescue
+          if enc = xml_charset
+            XML::HTMLParser.string(str, :options => 97, 
+                           :encoding => eval('XML::Encoding::'+enc.upcase.tr('-','_'))).parse
+          else to_doc :force
+          end
+        end   
+      end
+    doc.order_elements!
+    doc
+  end
+  
+end

data/lib/rmtools/xml/xpath.rb

@@ -0,0 +1,32 @@
+module LibXML
+
+  module XML::XPath
+      Finders = {}
+      
+      def self.filter(xpath)
+        return xpath if xpath.ord == ?!
+        if x = Finders[xpath]; return x end
+        if xpath[%r{\[@?\w+([^\w!]=).+?\]}]
+          raise XML::Error, "can't process '#{$1}' operator"
+        end
+        x = xpath.dup
+        x.gsub! %r{\.([\w-]+)([\[\{/]|\Z)}, '[@class="\1"]\2'
+        x.gsub! %r{#([\w-]+)([\[\{/]|\Z)}, '[@id="\1"]\2'
+        x.gsub! %r{(^|/)([^.#\w*/'"])}, '\1*\2'
+        x.gsub! %r{\[([a-z]+)}, '[@\1'
+        x.gsub! %r{(\[(?:@\w+!?=)?)['"]?([^'"\]@]+)['"]?\]}, '\1"\2"]'
+        if x !~%r{^(#{
+                        }(\./|\.//|/|//)?#{
+                        }(\w+:)?(\w+|\*)#{                         #  [ns:]name
+                        }(\[(@\w+(!?="[^"]+")?|"[^"]+")\])*#{#  attributes [@href!="pics/xynta.jpeg"]
+                        }(\[-?\d+\]|\{[^\}]+\})?#{               #  inruby-filters (see finder functions ^)
+                        })+$}
+          raise XML::Error, "can't process `#{xpath}`" 
+        end
+        x = '//'+x if x !~ %r{^[./]}
+        x.sub! %r{^/}, './'
+        Finders[xpath] = x
+      end
+      
+  end
+end

data/lib/rmtools/xml.rb

@@ -0,0 +1,7 @@
+begin
+  require 'xml'
+  LibXML::XML
+  require_with_path __FILE__, 'libxml'
+rescue
+  nil
+end

data/lib/rmtools.rb

@@ -1,51 +1,15 @@
-require 'fileutils'
-require 'iconv'
-require 'cgi'
-require 'set'
-require 'strscan'
-
-# why did I put it in here?
-# require "bundler/setup"
-
-# being required *after* rmtools/random it overrides some of a functions and then whine about they are "deprecated", huh
-require 'activesupport' rescue nil
+require 'active_support'
 
 module RMTools
-  rmtools = File.expand_path(__FILE__)[0..-4]
-  require "#{rmtools}/string_to_proc"
-  [ 'string_to_proc',
-    'string', 'object', 'module', 'enum', 'array', 'hash',
-    'numeric',  'stringscanner',  'proc',  'io',  'range',
-      
-    'js',	        #  js hash getter/setter and string concat logic
-    
-    'boolean',	  # {obj.b -> self or false} with python logic
-                  # and native boolean #to_i and #<=>
-                  # Since 2.3.8 active_support has analogue: #presence
-                  # BTW, why so slow?
-                        
-    'logging',  'coloring', # lazy logger
-                            # with caller processing and highlighting
-  #  'traceback',	# python-like traceback for exceptions 
-                  # uses ANSI coloring; kinda buggy, so better
-                  # require 'rmtools/traceback' separately
-      
-                                       
-    'printing', # transparent print: print text (or object info) and erase it
-    'limited_string',       # for compact string inspecting
-    
-    'binding',       # binding inspect
-    'arguments',    # arguments parsing and types validation
-    
-    'cyrilic',  'cyr-time', # String & Regexp methods for Russian processing
-    
-    # some bicycles just for convenience
-    'dumps',  'time',  'random'
-  ].each {|f| require "#{rmtools}/#{f}"}
+  require File.expand_path('require', __FILE__[0..-4])
+  [ 'core', 'enumerable', 'text', 'b', 'time', 'functional', 
+    'conversions', 'ip', 'lang', 'rand',
+    'console', 'fs', 'debug', 
+    'db', 'xml',
+    '../rmtools.so'
+  ].each {|file| require_with_path file}
 end
 
-require "#{rmtools}/rmtools.so" rescue nil
-
 $log = RMTools::RMLogger.new
 
 # Comment out in case of any method conflicts