rdoba 0.0.3 → 0.1

data/lib/rdoba/combinations.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+class Array
+
+private
+
+  def __comby(i, size)
+    s = "0#{sprintf("%.*b", size, i)}0"
+    v = { :res => [], :c0 => 0, :c1 => 0, :j => 0}
+
+    def up1(v)
+      sub_j = v[:j] + v[:c1] + 1
+      v[:res] << self[v[:j]...sub_j]
+      v[:j] = sub_j
+      v[:c1] = 0
+    end
+
+    def up0(v)
+      sub_j = v[:j] + v[:c0] - 1
+      self[v[:j]...sub_j].each do |x| v[:res] << [x] end
+      v[:j] = sub_j
+    end
+
+    s.each_char do |c|
+      if c == '1'
+        v[:c1] += 1
+        up0(v) if v[:c0] > 1
+        v[:c0] = 0
+      else
+        v[:c0] += 1
+        up1(v) if v[:c1] > 0
+      end
+    end
+    up0(v) if v[:c0] > 1
+    v[:res]
+  end
+
+public
+
+  def each_comby(*args)
+    return self if self.empty? or not block_given?
+    if args.include?(:backward)
+      yield [ self.dup ]
+      ((1 << (self.size - 1)) - 2).downto(0) do |i|
+        c = __comby(i, self.size - 1)
+        yield c
+      end
+    else
+      0.upto((1 << (self.size - 1)) - 2) do |i|
+        c = __comby(i, self.size - 1)
+        yield c
+      end
+      yield [ self.dup ]
+    end
+
+    return self
+  end
+end
+

data/lib/rdoba/common.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+class Object
+  def xor(val1)
+    val0 = (not not self)
+    ((val0) and (not val1)) or ((not val0) and (val1))
+  end
+
+  def co(method, *args) #calls any method
+    eval "#{method}(*args)"
+  end
+
+  def to_sym
+    to_s.to_sym
+  end
+
+  def parse_opts(opts)
+    v = {}
+    opts.each do |opt|
+      case opt.class.to_s.to_sym
+      when :Hash
+	opt.each do |x,y| v[x] = y end
+      when :Array
+	opt.each do |x| v[x] = true end
+      when :Symbol
+	v[opt] = true
+      end
+    end
+    v
+  end
+
+  def apply_opts(opts)
+    parse_opts(opts).each do |x,y|
+      self.instance_variable_set("@#{x}".to_sym, y)
+    end
+  end
+end
+
+module Kernel
+  def wait_if(timeout = 30)
+    require 'timeout'
+
+    begin
+      Timeout::timeout(timeout) do
+        while yield(); end
+      end
+      true
+    rescue Timeout::Error
+      false
+    end
+  end
+end
+
+class NilClass
+  def =~(value)
+    value == nil
+  end
+
+  def +(value)
+    value
+  end
+
+  def <<(value)
+    [ value ]
+  end
+
+  def empty?
+    true
+  end
+
+  def to_i
+    0
+  end
+  alias :ord :to_i
+
+  def size
+    0
+  end
+
+  def <=>(value)
+    -1
+  end
+end
+
+
+class Array
+  def purge
+    self.compact.delete_if {|x| x.empty? }
+  end
+
+  def >>(value = nil)
+    value ? delete(value) : shift
+  end
+
+  alias :__get__ :[]
+  def [](index, *args)
+    return __get__(index.to_i, *args) if index.class == String and index =~ /^\d+$/
+    __get__(index, *args)
+  end
+
+  alias :__set__ :[]=
+  def []=(index, value, *args)
+    return __set__(index.to_i, value, *args) if index.class == String and index =~ /^\d+$/
+    __set__(index, value, *args)
+  end
+end
+
+class String
+  def -(str)
+    #TODO make smart search for match in the 'str', when only last subpart matched to 'self'
+    len = self.size
+    bc = ec = nil
+    (0...len).each do |idx|
+      break bc = idx if self[idx] == str[0]
+    end
+    ((bc + 1)...len).each do |idx|
+      break ec = idx if self[idx] != str[idx - bc]
+    end if bc
+    (not bc) ? self.clone : (not ec) ? self[0, bc] : self[0, bc] + self[ec, len - ec]
+  end
+
+  alias :__match__ :=~
+  def =~(value)
+    if value.class == String
+      self == value
+    elsif value.class == Regexp
+      value =~ self
+    else
+      __match__(value)
+    end
+  end
+
+  def rmatch(value)
+    self == value || self =~ /^\/([^\/]+)/ && value =~ /#{$1}/
+  end
+
+  def hexdump
+    res= ''
+    i = 0
+    self.each_byte do |byte|
+      res << sprintf("%.2X ", byte)
+      i += 1
+      res << "\n" if i % 16 == 0
+    end
+    res
+  end
+end
+
+class Hash
+  def |(inval)
+    res = self.dup
+    inval.each_pair do |key, val|
+      if val.class == res[key].class
+        if val.class == Hash
+          res[key] |= inval[key]
+        elsif val.class == Array
+          res[key].concat val
+        else
+          res[key] = val
+        end
+      else
+        res[key] = val
+      end
+    end
+    res
+  end
+
+  def reverse!
+    replace(reverse)
+  end
+
+  def reverse
+    h = {}
+    self.each_pair do |key, value|
+      if h.key? value
+	if h[value].class == Array
+	  h[value] << key
+	else
+	  h[value] = [ h[value], key ]
+	end
+      else
+	h[value] = key
+      end
+    end
+    h
+  end
+end
+
+

data/lib/rdoba/debug.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+
+class Object
+  attr_reader :debug
+
+  @debug = nil
+  eval "$debug_#{self.class} = 0"
+
+public
+
+  def debug=(level)
+    @debug = level
+  end
+
+  def dbc(level)
+    level = level.to_i
+    if level > 0
+      clevel = @debug || begin; eval "$debug_#{self.class}"; rescue; nil; end
+      clevel ? (clevel.to_i & level) == level : false
+    else
+      false
+    end
+  end
+
+  def dbp(level, text)
+    Kernel.puts text if dbc(level)
+  end
+
+  def dbg(level, code, vars = {})
+    if dbc(level)
+      if vars
+        vars.each_pair do |var, value|
+          instance_variable_set(var, value)
+        end
+      end
+      eval code
+    end
+  end
+
+  (1..0xF).each do |x|
+    (1..0xF).each do |y|
+      idx = sprintf "%x%x", x, y
+      eval "def dbp#{idx}(text); dbp(0x#{idx},text); end"
+      eval "def dbg#{idx}(text); dbg(0x#{idx},text); end"
+    end
+  end
+end
+

data/lib/rdoba/deploy.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+require 'rdoba/common'
+
+class Hash
+
+  def deploy!(vars = {})
+    self.replace deploy(vars)
+    # TODO add variable copy
+  end
+
+  def deploy(vars = {})
+    res = {}
+
+    self.keys.sort do |x,y|
+      if x =~ /=$/
+	y =~ /=$/ ? x <=> y : -1
+      else
+	y !~ /=$/ ? x <=> y : 1
+      end
+    end.each do |key|
+
+      if key =~ /(.*)=$/
+	vars[$1] = self[key]
+	next
+
+      elsif key =~ /(.*)@$/
+	sym = $1
+	eval "res.class.co( :attr_accessor, :#{sym})"
+	eval "res.#{sym} = self[key]"
+	next
+
+      elsif key =~ /^%([^%].*)/
+        next $stderr.puts "Warning: undefined variable " +
+	    "#{$1.inspect} found. Ignoring..." unless vars.key?($1)
+	var = vars[$1].dup
+	if var.class == Hash
+	  res |= var.deploy(vars)
+	elsif var.class == String
+	  res[var] = nil
+	else
+          raise "Undeployable hash #{$1} value class #{var.class}"
+	end
+	next
+
+      elsif key =~ /^%%(.*)/
+	key.replace $1.to_s
+      end
+
+      def deploy_value(value, vars)
+	case value.class.to_sym
+	when :String
+	  if value =~ /^%([^%].*)/
+	    begin; vars[$1].deploy(vars); rescue; nil end
+	  elsif value =~ /(.*)%([A-Za-z0-9_А-я]+)(.*)/
+	    a = [ $1.to_s, $2.to_s, $3.to_s ]
+	    a[1] = begin; vars[a[1]].deploy(vars).to_s; rescue; vars[a[1]] end
+	    a.join
+	  else
+	    value
+	  end
+	when :Hash
+	  value.deploy(vars)
+	when :Array
+	  value.map do |sub|
+	    deploy_value(sub, vars)
+	  end
+	else
+	  value
+	end
+      end
+
+      value = self[key]
+      res[key] = deploy_value(value, vars)
+    end
+    res
+  end
+end
+

data/lib/rdoba/dup.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+class Array
+  alias :__dup__ :dup
+  def dup(opts = {})
+    if (opts.class == Hash ? opts.key?(:recursive) : opts.to_s.to_sym == :recursive)
+      res = []
+
+      def sub_dup(value)
+	if value.class.to_s =~ /(Hash|Array)/
+	  value.dup(:recursive)
+	else
+	  begin
+	    value.dup
+	  rescue
+	    new = value
+	  end
+	end
+      end
+
+      self.each do |value| res << sub_dup(value) end
+
+      res
+    elsif opts.empty?
+      __dup__
+    else
+      raise "Unsupported option(s): #{opts.class == Hash ? opts.keys.join(', ') : opts}"
+    end
+  end
+
+end
+
+class Hash
+  alias :__dup__ :dup
+  def dup(opts = {})
+    if (opts.class == Hash ? opts.key?(:recursive) : opts.to_s.to_sym == :recursive)
+      res = {}
+
+      def sub_dup(value)
+	if value.class.to_s =~ /(Hash|Array)/
+	  value.dup(:recursive)
+	else
+	  begin
+	    value.dup
+	  rescue
+	    new = value
+	  end
+	end
+      end
+
+      self.each do |key, value| res[ sub_dup(key) ] = sub_dup(value) end
+
+      res
+    elsif opts.empty?
+      __dup__
+    else
+      raise "Unsupported option(s): #{opts.class == Hash ? opts.keys.join(', ') : opts}"
+    end
+  end
+
+end
+
+

data/lib/rdoba/fenc.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -KU
+
+class String
+  def fenc
+    if RUBY_VERSION < '1.9'
+      self
+    else
+      return self unless Encoding.default_internal
+      if self.frozen?
+	self.dup.force_encoding(Encoding.default_internal || 'UTF-8').freeze
+      else
+	self.force_encoding(Encoding.default_internal || 'UTF-8')
+      end
+    end
+  end
+end
+

data/lib/rdoba/hashorder.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/ruby
+
+class Hash
+  attr_reader :order
+
+  class Each
+    General = 0
+    Pair    = 1
+    Key	    = 2
+    Value   = 3
+  end
+
+private
+
+  def each_special(spec)
+    (@order | self.keys).each do |key|
+      if self.has_key? key
+	case spec
+	when Hash::Each::General
+	  yield key, self[key]
+	when Hash::Each::Pair
+	  yield key, self[key]
+	when Hash::Each::Key
+	  yield key
+	when Hash::Each::Value
+	  yield self[key]
+	end
+      end
+    end
+  end
+
+public
+
+  def order=(order)
+    return nil if order.class != Array
+
+    @order = order
+  end
+
+  def disorder
+    @order = nil; self
+  end
+
+  alias :__each__ :each
+  alias :__each_pair__ :each_pair
+  alias :__each_key__ :each_key
+  alias :__each_value__ :each_value
+
+  def each(&block)
+    @order ? each_special(Hash::Each::General, &block) : __each__(&block)
+  end
+
+  def each_pair(&block)
+    @order ? each_special(Hash::Each::Pair, &block) : __each_pair__(&block)
+  end
+
+  def each_key(&block)
+    @order ? each_special(Hash::Each::Key, &block) : __each_key__(&block)
+  end
+
+  def each_value(&block)
+    @order ? each_special(Hash::Each::Value, &block) : __each_value__(&block)
+  end
+
+end
+

data/lib/rdoba/io.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+require 'strscan'
+require 'rdoba/re'
+require 'rdoba/roman'
+require 'rdoba/numeric'
+
+module Kernel
+  alias :__sprintf__ :sprintf
+  def sprintf(format, *args)
+    nargs = []
+    nformat = ''
+
+    fmt = format.split('%')
+    nformat = fmt.shift
+
+    while (not fmt.empty?)
+      part = fmt.shift
+      part = '%' + fmt.shift unless part
+      if part =~ /([0-9 #+\-*.]*)([bcdEefGgiopsuXxP])(.*)/ and $2 == 'P'
+        keys = $1 || ''
+        str = $3 || ''
+        if keys =~ /(-)?([0-9*]*)\.?([0-9\*]*)(\+?)/
+          value = args.shift
+          indent = ' ' * ($2 == '*' ? args.shift : $2).to_i
+          plain = value && value.to_p(
+	      :padding => ($3 == '*' ? args.shift : $3.empty? ? 1 : $3).to_i,
+	      :be => $4.empty? ? nil : true) || ''
+          nformat += ($1 ? plain + indent : indent + plain) + str
+        else
+          nformat += '%' + keys + 'c' + str
+          nargs.push args.shift
+        end
+      else
+        nformat += '%' + part
+        l = $1 =~ /\*/ ? 2 : 1
+        while l > 0
+          nargs.push args.shift
+          l -= 1
+        end
+      end
+    end
+    __sprintf__(nformat, *nargs).to_p
+  end
+
+end
+
+class String
+  def scanf_re(format)
+    fss = StringScanner.new(format) # TODO remove scanner in favor of match
+    nformat = ''
+
+    pos = 0
+    argfs = []
+    while fss.scan_until(/%([0-9 #+\-*]*)(?:\.([0-9]+)(\+)?)?([bcdefgiosuxr])/)
+      argfs << [ fss[1], fss[2], fss[3], fss[4] ]
+      # TODO add performing the special case in fss[1]
+      nformat += fss.pre_match[pos..-1].to_res + case fss[4]
+      when 'x'
+        '(?:0[xX])?([a-fA-F0-9]+)'
+      when 'i'
+        '([+\-]?[0-9]+)'
+      when 'u'
+        '([0-9]+)'
+      when 'e'
+        '([+\-]?[0-9]+[eE][+\-]?[0-9]+)'
+      when 'f'
+        '([+\-]?[0-9]+\.[0-9]*)'
+      when 'g'
+        '([+\-]?[0-9]+(?:[eE][+\-]?[0-9]+|\.[0-9]*))'
+      when 'c'
+        fss[2] ? "(.{1,#{fss[2]}})" : "(.)"
+      when 'b'
+        '([01]+)b?'
+      when 'o'
+        '0([0-9]+)'
+      when 'd'
+        '([+\-]?(?:0X)?[A-F0-9.+]+)'
+      when 's'
+        '(.+)'
+      when 'r'
+        '([IVXLCDMivxlcdm]+)'
+      end
+
+      pos = fss.pos
+    end
+
+    nformat += fss.rest
+
+    [ /#{nformat}/, argfs ]
+  end
+
+  (alias :__scanf__ :scanf) if self.instance_methods(false).include?(:scanf)
+  def scanf(format, &block)
+    (re, argfs) = scanf_re(format)
+
+    ss = StringScanner.new(self)
+    res = []
+    rline = []
+    while ss.scan_until(re)
+      argfs.each_index do |i|
+        argf = argfs[i]
+        value = ss[i + 1]
+        rline << case argf[3]
+        when 'x'
+          value.to_i(16)
+        when /[diu]/
+          value.to_i
+        when /[efg]/
+          value.to_f
+        when 'c'
+	  argf[2] ? value.to_i(:be) : value.to_i
+        when 'b'
+          value.to_i(2)
+        when 'o'
+          value.to_i(8)
+        when 's'
+          value
+        when 'r'
+          value.rom
+        end
+      end
+
+      if block_given?
+        pass = []
+        (1..block.arity).each do |i| pass << "rline[#{i}]" end
+        eval "yield(#{pass.join(', ')})"
+      end
+
+      res << rline
+    end
+
+    res
+  end
+
+  def consolize
+    ss = StringScanner.new(self)
+    res = ''
+    ostr = ''
+    pos = 0
+
+    while ss.scan_until(/\r/)
+      ostr[0...ss.pre_match.size - pos] = ss.pre_match[pos..-1]
+      pos = ss.pos
+
+      if ss.post_match[0] == "\n"[0]
+        res = ostr
+        pos += 1
+        ostr = ''
+      end
+
+    end
+
+    ostr[0...ss.rest.size] = ss.rest
+    res + ostr
+  end
+end
+
+