rdoba 0.0.3 → 0.1

data/lib/rdoba/numeric.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+require 'rdoba/common'
+require 'rdoba/strings'
+
+class String
+  alias :_rdoba_to_i :to_i
+  def to_i(base = 10, *opts)
+    v = parse_opts(opts)
+    if v[:be]
+      (str, sign, num) = (self.match /\s*(-?)([0-9a-fx]+)/u).to_a
+      if str
+	n = num.reverse._rdoba_to_i(base)
+	sign.empty? && n || -n
+      else
+	0
+      end
+    else
+      _rdoba_to_i(base)
+    end
+  end
+end
+
+class Fixnum
+  alias :_rdoba_to_s :to_s
+  def to_s(base = 10, *opts)
+    v = parse_opts(opts)
+
+    return _rdoba_to_s(base) unless v[:padding] or v[:style_formatting]
+
+    raise "Base of number can't be equal or less then zero" if base <= 0
+    raise "Padding count numberr can't be equal or less then zero" if v[:padding] <= 0
+    value = self
+    minus = if value < 0
+        value = -value
+        true
+      end
+    res = ''
+    while value != 0
+      value, rem = value.divmod(base)
+      rem += 0x40 - 0x39 if rem >= 10
+      res += (0x30 + rem).chr
+    end
+    res += "0" * (v[:padding].to_i - res.size) if res.size < v[:padding].to_i
+    res += 'x0' if v[:style_formatting] and base == 16
+    res += '-' if minus
+    res.reverse
+  end
+end
+
+class Numeric
+  def to_p(*opts)
+    v = parse_opts(opts)
+
+    value = self
+    minus = if value < 0
+        value = -value
+        true
+      end
+    res = ''
+    while value != 0
+      value, rem = value.divmod(256)
+      res += rem.chr
+    end
+
+    pad_char = if minus
+        negres += ''
+        over = 1
+        res.each_byte do |byte|
+          negbyte = 255 - byte + over
+          negres += if negbyte > 255
+              over = 1
+              0
+            else
+              over = 0
+              negbyte
+            end
+        end
+        res = negres
+        "\xFF"
+      else
+        "\0"
+      end
+
+    res += pad_char * (v[:padding].to_i - res.size) if res.size < v[:padding].to_i
+
+    plain = (v[:be] ? res.reverse(String::ByteByByte) : res).to_p
+    plain
+  end
+end
+
+

data/lib/rdoba/re.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+class String
+  def to_res
+    ostr = self.dup
+    res = ''
+    while true
+      m = ostr.match(/(?:([+\[\]\\().*?{}^$\/|])|«([^«]*)»)/u)
+      break unless m
+      res += m.pre_match + (m[2] || m[1] && ('\\' + m[1]))
+      ostr = m.post_match
+    end
+
+    res + ostr
+  end
+
+  def to_re
+    /#{to_res}/ui
+  end
+end
+

data/lib/rdoba/require.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+require 'rdoba/common'
+require 'rdoba/debug'
+
+module Kernel
+private
+  def require_dir(dir, name)
+    dbp11 "[require_dir] <<< dir = #{dir}, name = #{name}"
+    begin
+      rdir = File.join(dir, name)
+      return false unless File.directory?(rdir)
+      rdir = File.join(dir, name)
+      $: << rdir unless $:.include?(rdir)
+      dbp14 "[require_dir]> Found dir #{rdir}"
+      Dir.foreach(rdir) do |file|
+        next unless file =~ /(.*)\.(rb|so)$/
+        dbp14 "[require_dir]> Loading ... #{$1}"
+        require $1
+      end
+      true
+    rescue
+      false
+    end
+  end
+
+  def sub_require(name)
+    dbp11 "[sub_require] <<< name = #{name} "
+    $:.each do |dir|
+      begin
+        Dir.foreach(dir) do |file|
+          next unless file =~ /^#{name}\.(rb|so)$/
+          dbp14 "[sub_require]> Require Dir #{dir}/#{name} for #{file}"
+          r1 = require_dir(dir, name + '.modules')
+          r2 = require_dir(dir, name)
+          dbp14 "[sub_require]> Require Dir #{(r1 || r2) && 'passed' || 'failed'} ... #{name}"
+        end
+      rescue
+      end
+    end unless $".include?(name)
+    true
+  end
+
+public
+
+  alias :__require__ :require
+  def require(name, *opts)
+    v = parse_opts(opts)
+    dbp11 "[require] <<< name = #{name}"
+    begin
+      res = __require__ name
+    rescue => bang
+      puts "Lib internal error: #{$!.class} -> #{$!}\n\t#{$@.join("\n\t")}"
+      exit
+    end
+    dbp14 "[require]> Loaded? #{name}... #{res}"
+    res = sub_require(name) if res and v[:recursive]
+    res
+  end
+end
+

data/lib/rdoba/roman.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/ruby -KU
+
+class Numeric
+  Roman = { 1 => 'I', 4 => 'IV', 5 => 'V', 9 => 'IX', 10 => 'X', 40 => 'XL', 50 => 'L',
+      90 => 'XC', 100 => 'C', 400 => 'CD', 500 => 'D', 900 => 'CM', 1000 => 'M' }
+  Romani = Roman.keys.sort
+
+  def to_rom
+    res = ''
+    num = self
+    i = Romani.size - 1
+
+    while num > 0
+      if num >= Romani[i]
+        res << Roman[Romani[i]]
+        num -= Romani[i]
+      else
+        i -= 1
+      end
+    end
+    res
+  end
+
+end
+
+class String
+  def rom
+    h = Numeric::Roman.reverse
+    keys = h.keys.sort do |x,y| x.size < y.size ? 1 : x.size > y.size ? -1 : x <=> y end
+    str = self.upcase
+    res = 0
+    while str and not str.empty?
+    raise "Invalid roman number" if (keys.each do |key|
+      if str =~ /^#{key}(.*)/
+        str = $1
+        res += h[key]
+        break nil
+      end
+      end)
+    end
+    res
+  end
+end
+
+

data/lib/rdoba/strings.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/ruby -KU
+#<Encoding:UTF-8>
+
+class String
+
+  def self.upcase(char)
+      chr = char.class == String ? char.ord : char.to_i
+      if chr >= 0x430 and chr < 0x450
+        chr -= 0x20
+      elsif chr >= 0x410 and chr < 0x430
+      elsif chr >= 0x400 and chr < 0x410 or
+          chr >= 0x450 and chr < 0x482 or
+          chr >= 0x48A and chr < 0x524 or
+          chr >= 0xA642 and chr < 0xA668 or
+          chr >= 0xA680 and chr < 0xA698
+        chr -= 1 if (chr % 1) == 1
+      else
+        return chr.chr.__upcase__
+      end
+      chr.chr
+  end
+
+  def self.downcase(char)
+      chr = (char.class == String) ? char.ord : char.to_i
+      if chr >= 0x410 and chr < 0x430
+        chr += 0x20
+      elsif chr >= 0x430 and chr < 0x450
+      elsif chr >= 0x400 and chr < 0x410 or
+          chr >= 0x450 and chr < 0x482 or
+          chr >= 0x48A and chr < 0x524 or
+          chr >= 0xA642 and chr < 0xA668 or
+          chr >= 0xA680 and chr < 0xA698
+        chr += 1 if (chr % 1) == 0
+      else
+        return chr.chr.__downcase__
+      end
+      chr.chr
+  end
+
+  if RUBY_VERSION < '1.9'
+
+    alias :setbyte :[]=
+
+    def encoding
+      'UTF-8'
+    end
+
+    def force_encoding(*args)
+      self
+    end
+
+    def ord
+      a = nil
+      self.each_byte do |b|
+	c = b & 0xC0
+	case c
+	when 0xc0
+	  a = (b & 0x3F)
+	when 0x80
+	  return (a << 6) + (b & 0x3F)
+	else
+	  return b
+	end
+      end
+    end
+
+  end
+
+  FirstChar = 0
+  alias :__upcase__ :upcase
+  def upcase(option = nil)
+    if option == FirstChar
+      r = self.dup
+      r[0] = String.upcase(self.ord)
+      r
+    elsif self.match(/[Ѐ-ҁҊ-ԣꙀ-ꙧꚀꚗ]/u)
+      self.unpack('U*').map do |chr| String.upcase(chr) end.join
+    else; __upcase__ end
+  end
+
+  alias :__downcase__ :downcase
+  def downcase(option = nil)
+    if option == FirstChar
+      r = self.dup
+      r[0] = String.downcase(self.ord)
+      r
+    elsif self.match(/[Ѐ-ҁҊ-ԣꙀ-ꙧꚀꚗ]/u)
+      self.unpack('U*').map do |chr| String.downcase(chr) end.join
+    else; __downcase__ end
+  end
+
+  alias :to_p :to_s
+
+  ByteByByte = 0
+  alias :__reverse__ :reverse
+  def reverse(step = 1)
+      case step
+      when ByteByByte
+          arr = []
+          self.each_byte do |byte| arr << byte.chr end
+          arr.reverse.join
+      when 1
+          __reverse__
+      else
+          res = ''
+          offset = (self.size + 1) / step * step - step
+          (0..offset).step(step) do |shift|
+              res += self[offset - shift..offset - shift + 1]
+          end
+          res
+      end
+  end
+
+  def compare_to(value, opts = {} )
+    if opts == :ignore_diacritics or
+      (opts.class == Hash and opts.key? :ignore_diacritics)
+      # TODO verify composite range
+      def crop_diacritics(x)
+        (x < 0x300 or
+           x > 0x36f and x < 0x483 or
+           x > 0x487 and x < 0xa67c or
+           x > 0xa67d) && x || nil
+      end
+
+      (self.unpack('U*').map do |x| crop_diacritics(x)
+      end.compact) <=> (value.unpack('U*').map do |x| crop_diacritics(x)
+      end.compact)
+    else
+      self <=> value
+    end
+  end
+end
+
+class Fixnum
+  alias :__chr__ :chr
+  def chr
+    if self >= 256
+      num = self; s = "\0"; byte = 0x80; a = []
+      while num >= 0x40
+	s.setbyte(0, byte + (num & 0x3F))
+	a << s.dup; num >>= 6; byte = 0x40
+      end
+      s.setbyte(0, 0xC0 + (num & 0x3F))
+      a << s
+      a.reverse.join.force_encoding('UTF-8')
+    else; __chr__ end
+  end
+end
+

data/lib/rdoba/version.rb

@@ -0,0 +1,3 @@
+module Rdoba
+  VERSION = "0.1"
+end

data/lib/rdoba/yaml.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+
+require 'rdoba/common'
+
+class Object
+  def to_yml( o = {} )
+    level = o[:level] || 0
+    res = ''
+    res += '---' if level == 0
+    res += case self.class.to_sym
+      when :Hash
+        rs = ''
+        self.keys.sort do |x,y|
+          (ix, iy) = o[:order] ? [ o[:order].index(x), o[:order].index(y) ] : [ nil, nil ]
+          (ix and iy) ? ix <=> iy : (ix ? -1 : (iy ? 1 : x <=> y))
+        end.each do |key|
+          value = self[key]
+          rs += "\n" + ' ' * level * 2 + key.to_yml( { :level => level + 1, :order => o[:order] } )
+          rs += ': ' + value.to_yml( { :level => level + 1, :order => o[:order] } )
+        end
+        rs.empty? and "{}" or rs
+      when :Array
+        rs = ''
+        self.each do |value|
+          rs += "\n" + ' ' * level * 2 + '- ' + value.to_yml( { :level => level + 1, :order => o[:order] } )
+        end
+        rs.empty? and "[]" or rs
+      when :Fixnum
+        self.to_s
+      when :String
+        if self =~ /^["'\-:!#={}\[\]~]/ or self =~ /\s+$/ or self =~ /:\s/
+	  if self.count("'") < self.count('"')
+	    "'#{self.gsub("'","\\'")}'"
+	  else
+	    "\"#{self.gsub('"','\"')}\""
+	  end
+        else
+          self
+        end
+      when :NilClass
+        ''
+      else
+          $stderr.puts "Unsupported class #{self.class} to export to yml"; ''
+      end
+    res
+  end
+end
+