rdoba 0.9.1 → 0.9.4

data/lib/rdoba/require.rb

@@ -1,56 +1,62 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 require 'rdoba/common'
 require 'rdoba/debug'
 
 module Kernel
-private
+  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
+
+        dbp14 "[require_dir]> Loading ... #{Regexp.last_match(1)}"
+        require Regexp.last_match(1)
       end
       true
-    rescue
+    rescue StandardError
       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}"
+    unless $".include?(name)
+      $:.each do |dir|
+        begin
+          Dir.foreach(dir) do |file|
+            next unless /^#{name}\.(rb|so)$/.match?(file)
+
+            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 StandardError
         end
-      rescue
       end
-    end unless $".include?(name)
+    end
     true
   end
 
-public
+  public
 
-  alias :__require__ :require
+  alias __require__ require
   def require(name, *opts)
     v = parse_opts(opts)
     dbp11 "[require] <<< name = #{name}"
     begin
       res = __require__ name
-    rescue => bang
+    rescue StandardError => e
       puts "Lib internal error: #{$!.class} -> #{$!}\n\t#{$@.join("\n\t")}"
       exit
     end
@@ -59,4 +65,3 @@ public
     res
   end
 end
-

data/lib/rdoba/roman.rb

@@ -1,45 +1,55 @@
 #!/usr/bin/ruby -KU
+# frozen_string_literal: true
 
 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
+  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'
+  }
+  RomanNumbers = Roman.keys.sort
+  RomanToInteger = Roman.invert
+  RomanDigits = RomanToInteger.keys.sort { |x, y| x.size < y.size ? 1 : x.size > y.size ? -1 : x <=> y }
 
   def to_rom
     res = ''
     num = self
-    i = Romani.size - 1
+    i = RomanNumbers.size - 1
 
     while num > 0
-      if num >= Romani[i]
-        res << Roman[Romani[i]]
-        num -= Romani[i]
+      if num >= RomanNumbers[i]
+        res << Roman[RomanNumbers[i]]
+        num -= RomanNumbers[i]
       else
         i -= 1
       end
     end
     res
   end
-
 end
 
 class String
+  RomanRe = /(#{Numeric::RomanDigits.join('|')})/
+
   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
+    numbers = upcase.scan(RomanRe).flatten.map { |x| Numeric::RomanToInteger[x] }
+    numbers.sort do |x, y|
+      if x < y
+        raise 'Invalid roman number'
       end
-      end)
+
+      0
     end
-    res
+    numbers.sum
   end
 end
-
-

data/lib/rdoba/strings.rb

@@ -1,149 +1,11 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
-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
+warn "Warning: the module 'string' has kept only for backward " \
+       "compatibility\nPlease use 'rdoba :mixin' form instead"
 
-  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
+class String
+  alias to_p to_s
 end
 
+rdoba mixin: %i[case reverse compare]

data/lib/rdoba/yaml.rb

@@ -1,48 +1,50 @@
 #!/usr/bin/ruby
+# frozen_string_literal: true
 
 require 'rdoba/common'
 
 class Object
-  def to_yml( o = {} )
+  def to_yml(o = {})
     level = o[:level] || 0
     res = ''
     res += '---' if level == 0
-    res += case self.class.to_sym
+    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 ]
+        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] } )
+          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
+        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] } )
+        each do |value|
+          rs += "\n" + ' ' * level * 2 + '- ' + value.to_yml({ level: level + 1, order: o[:order] })
         end
-        rs.empty? and "[]" or rs
+        rs.empty? and '[]' or rs
       when :Fixnum
-        self.to_s
+        to_s
       when :String
         if self =~ /^["'\-:!#={}\[\]~]/ or self =~ /\s+$/ or self =~ /:\s/
-	  if self.count("'") < self.count('"')
-	    "'#{self.gsub("'","\\'")}'"
-	  else
-	    "\"#{self.gsub('"','\"')}\""
-	  end
+          if count("'") < count('"')
+            "'#{gsub("'", "\\'")}'"
+          else
+            "\"#{gsub('"', '\"')}\""
+          end
         else
           self
         end
       when :NilClass
         ''
       else
-          $stderr.puts "Unsupported class #{self.class} to export to yml"; ''
+        warn "Unsupported class #{self.class} to export to yml"
+        ''
       end
     res
   end
 end
-

data/lib/rdoba.rb

@@ -1,57 +1,60 @@
-#encoding: utf-8
+# frozen_string_literal: true
 
 module Kernel
-  Modules = [ :bcd ]
+  Modules = %i[bcd mixin log debug]
 
-  def rdoba *options
+  def rdoba(*options)
     options.each do |option|
-      key, value = ( option.is_a?( Hash ) &&
-      [ ( k = option.keys.shift ).to_s.to_sym, option[ k ] ] ||
-      [ option.to_s.to_sym ] )
-      case key
-      when :mixin
-        require "rdoba/mixin"
-        Rdoba.mixin value
-      when :log, :debug
+      (option.is_a?(Hash) && option || { option.to_s.to_sym => {} }).each_pair do |key, value|
+        next unless Modules.include? key
+
         require "rdoba/#{key}"
-        Rdoba.log( { :in => self }.merge( value || {} ) ) # TODO move log method into module
-        # TODO and resolve some troubles with eval in main
-      else
-        Kernel.puts STDERR, "Unknown rdoba module named as '#{key.to_s}'"
-        nil; end ||
-      if Modules.include? key
-        require "rdoba/#{key}"; end; end; end; end
+        next unless Rdoba.methods.include? key
+
+        unless value.is_a? Hash
+          value = { value: value }
+        end
+        value.replace({ self: self }.merge(value))
+        Rdoba.send key, value
+      end
+    end
+  end
+end
 
 require 'rbconfig'
 
 module Rdoba
-   def self.gemroot name = nil, path = ''
-      if !gem( name )
-         raise "Invalid gem named as #{name.inspect}" ; end
-      g = Gem::Specification.find_by_name( name )
-      File.join g.full_gem_path, path
-   end
-
-   def self.os
-      @@os ||= (
-         host_os = RbConfig::CONFIG['host_os']
-         case host_os
-         when /(mswin|msys|mingw|cygwin|bccwin|wince|emc)/
-            plat = $1 == 'mswin' && 'native' || $1
-            out = `ver`.encode( 'US-ASCII',
-                  :invalid => :replace, :undef => :replace )
-            if out =~ /\[.* (\d+)\.([\d\.]+)\]/
-               "windows-#{plat}-#{$1 == '5' && 'xp' || 'vista'}-#{$1}.#{$2}"
-            else
-               "windows-#{plat}" ; end
-         when /darwin|mac os/
-            'macosx'
-         when /linux/
-            'linux'
-         when /(solaris|bsd)/
-            "unix-#{$1}"
-         else
-            raise "unknown os: #{host_os.inspect}"
-         end)
-   end ; end
+  def self.gemroot(name = nil, path = '')
+    unless gem(name)
+      raise "Invalid gem named as #{name.inspect}"
+    end
+
+    g = Gem::Specification.find_by_name(name)
+    File.join g.full_gem_path, path
+  end
 
+  def self.os
+    @@os ||=
+      begin
+        host_os = RbConfig::CONFIG['host_os']
+        case host_os
+        when /(mswin|msys|mingw|cygwin|bccwin|wince|emc)/
+          plat = Regexp.last_match(1) == 'mswin' && 'native' || Regexp.last_match(1)
+          out = `ver`.encode('US-ASCII', invalid: :replace, undef: :replace)
+          if out =~ /\[.* (\d+)\.([\d.]+)\]/
+            "windows-#{plat}-#{Regexp.last_match(1) == '5' && 'xp' || 'vista'}-#{Regexp.last_match(1)}.#{Regexp.last_match(2)}"
+          else
+            "windows-#{plat}"
+          end
+        when /darwin|mac os/
+          'macosx'
+        when /linux/
+          'linux'
+        when /(solaris|bsd)/
+          "unix-#{Regexp.last_match(1)}"
+        else
+          raise "unknown os: #{host_os.inspect}"
+        end
+      end
+  end
+end

data/rdoba.gemspec

@@ -1,32 +1,39 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+$:.push File.expand_path('lib', __dir__)
 require "rdoba/_version_"
 
 Gem::Specification.new do |s|
-  s.name        = "rdoba"
-  s.version     = Rdoba::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = [ 'Малъ Скрылёвъ (Malo Skrylevo)' ]
-  s.email       = [ '3aHyga@gmail.com' ]
-  s.homepage    = 'https://github.com/3aHyga/rdoba'
-  s.summary     = 'Ruby extension library (Ruby DOBAvka)'
-  s.description = 'Ruby extension library. It extends Kernel, Object, ' +
-		  'String, Hash, Array, and some other classes. Also allows ' +
-		  'to log application state with debug lines to an io'
-  s.license     = 'MIT'
+   s.name         = "rdoba"
+   s.version      = Rdoba::VERSION
+   s.platform     = Gem::Platform::RUBY
+   s.authors      = [ 'Малъ Скрылёвъ (Malo Skrylevo)' ]
+   s.email        = [ '3aHyga@gmail.com' ]
+   s.homepage     = 'https://github.com/3aHyga/rdoba'
+   s.summary      = 'Ruby extension library (Ruby DOBAvka)'
+   s.description  = 'Ruby extension library. It extends Kernel, Object, '       \
+                    'String, Hash, Array, and some other classes. Also allows ' \
+                    'to log application state with debug lines to an io'
+   s.license      = 'MIT'
 
-  s.rubyforge_project = "rdoba"
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = [ "lib" ]
-  s.extra_rdoc_files = [ 'README.md', 'LICENSE' ]
+   s.rubyforge_project = "rdoba"
+   s.files             = `git ls-files`.split("\n")
+   s.test_files        = `git ls-files -- {test,spec,features}/*`.split("\n")
+   s.executables       = `git ls-files -- bin/*`.split( "\n" ).map{ |f| File.basename(f) }
+   s.require_paths     = [ "lib" ]
+   s.extra_rdoc_files  = [ 'README.md', 'LICENSE', 'CHANGES.md' ] |
+                        `find html/`.split( "\n" )
 
-  s.required_rubygems_version = '>= 1.6.0'
-  s.required_ruby_version = '>= 1.9.0'
+   s.add_development_dependency 'bundler', '~> 2.0'
+   s.add_development_dependency 'coveralls'
+   s.add_development_dependency 'cucumber', '~> 1.3'
+   s.add_development_dependency 'ffi-stat', '~> 0.4'
+   s.add_development_dependency 'rake', '~> 12.0', '>= 12.3.3'
+   s.add_development_dependency 'rdiscount', '~> 2.1'
+   s.add_development_dependency 'rdoc', '~> 6.2'
+   s.add_development_dependency 'rspec-expectations', '~> 3.3'
+   s.add_development_dependency 'simplecov', '~> 0'
+   s.add_development_dependency 'tddium', '~> 1.25'
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'bundler', '~> 1.3'
-  s.add_development_dependency 'cucumber', '~> 1.3'
-  s.add_development_dependency 'coveralls'
-end
+   s.required_rubygems_version = '>= 1.6.0'
+   s.required_ruby_version = '>= 1.9.0' ; end

data/tddium.yml

@@ -0,0 +1,11 @@
+:tddium:
+   :ruby_version: ruby-1.9.3-p547
+   :bundler_version: '~> 1.6.5'
+   :test_pattern:
+      - features/\*.feature
+   :tests:
+      - bundle exec cucumber
+   :coverage: true
+   :postgresql: false
+   :mysql: false
+   :sqlite: false