rdoba 0.9.3 → 0.9.4

data/lib/rdoba/numeric.rb

@@ -1,20 +1,20 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 require 'rdoba/common'
 require 'rdoba/strings'
 
 class String
-  alias :_rdoba_to_i :to_i
+  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
+      str, sign, num = (match /\s*(-?)([0-9a-fx]+)/u).to_a
       if str
-	n = num.reverse._rdoba_to_i(base)
-	sign.empty? && n || -n
+        n = num.reverse._rdoba_to_i(base)
+        sign.empty? && n || -n
       else
-	0
+        0
       end
     else
       _rdoba_to_i(base)
@@ -22,8 +22,8 @@ class String
   end
 end
 
-class Fixnum
-  alias :_rdoba_to_s :to_s
+class Integer
+  alias _rdoba_to_s to_s
   def to_s(base = 10, *opts)
     v = parse_opts(opts)
 
@@ -31,8 +31,10 @@ class Fixnum
 
     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
+    minus =
+      if value < 0
         value = -value
         true
       end
@@ -42,7 +44,7 @@ class Fixnum
       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 += '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
@@ -54,7 +56,8 @@ class Numeric
     v = parse_opts(opts)
 
     value = self
-    minus = if value < 0
+    minus =
+      if value < 0
         value = -value
         true
       end
@@ -64,12 +67,14 @@ class Numeric
       res += rem.chr
     end
 
-    pad_char = if minus
+    pad_char =
+      if minus
         negres += ''
         over = 1
         res.each_byte do |byte|
           negbyte = 255 - byte + over
-          negres += if negbyte > 255
+          negres +=
+            if negbyte > 255
               over = 1
               0
             else
@@ -85,9 +90,6 @@ class Numeric
 
     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
+    (v[:be] ? res.reverse(String::ByteByByte) : res).to_p
   end
 end
-
-

data/lib/rdoba/os.rb

@@ -0,0 +1,127 @@
+require 'ostruct'
+
+require 'rdoba/blank'
+
+class Object
+   def to_os
+      OpenStruct.new(self.to_h.map {|(x, y)| [x.to_s, [Hash, Array].include?(y.class) && y.to_os || y] }.to_h)
+   end
+end
+
+class Array
+   def to_os
+      OpenStruct.new(self.map.with_index {|y, x| [x.to_s, [Hash, Array].include?(y.class) && y.to_os || y] }.to_h)
+   end
+end
+
+class Integer
+   def to_sym
+      to_s.to_sym
+   end
+end
+
+class OpenStruct
+   def merge_to other
+      OpenStruct.new(other.to_h.merge(self.to_h))
+   end
+
+   def merge other
+      OpenStruct.new(self.to_h.merge(other.to_h))
+   end
+
+   def map *args, &block
+      res = self.class.new
+
+      self.each_pair do |key, value|
+         res[key] = block[key, value]
+      end
+
+      res
+   end
+
+   def select &block
+      res = self.class.new
+
+      self.each_pair do |key, value|
+         res[key] = value if block[key, value]
+      end
+
+      res
+   end
+
+   def compact
+      select { |_, value| !value.blank? }
+   end
+
+   def each *args, &block
+      self.each_pair(*args, &block)
+   end
+
+   def reduce default = nil, &block
+      res = default
+
+      self.each_pair do |key, value|
+         res = block[res, key, value]
+      end
+
+      res
+   end
+
+   # +deep_merge+ deeply merges the Open Struct hash structure with the +other_in+ enumerating it key by key.
+   # +options+ are the options to change behaviour of the method. It allows two keys: :mode, and :dedup
+   # :mode key can be :append, :prepend, or :replace, defaulting to :append, when mode is to append, it combines duplicated
+   # keys' values into an array, when :prepend it prepends an other value before previously stored one unlike for :append mode,
+   # when :replace it replace duplicate values with a last ones.
+   # :dedup key can be true, or false. It allows to deduplicate values when appending or prepending values.
+   # Examples:
+   #    open_struct.deep_merge(other_open_struct)
+   #    open_struct.deep_merge(other_open_struct, :prepend)
+   #
+   def deep_merge other_in, options_in = {}
+      return self if other_in.nil? or other_in.blank?
+
+      options = { mode: :append }.merge(options_in)
+
+      other =
+         if other_in.is_a?(OpenStruct)
+            other_in.dup
+         elsif other_in.is_a?(Hash)
+            other_in.to_os
+         else
+            OpenStruct.new(nil => other_in)
+         end
+
+      self.reduce(other) do |res, key, value|
+         res[key] =
+            if res.table.keys.include?(key)
+               case value
+               when Hash, OpenStruct
+                  value.deep_merge(res[key], options)
+               when Array
+                  value.concat([res[key]].compact.flatten(1))
+               when NilClass
+                  res[key]
+               else
+                  value_out =
+                     if options[:mode] == :append
+                        [res[key], value].compact.flatten(1)
+                     elsif options[:mode] == :prepend
+                        [value, res[key]].compact.flatten(1)
+                     else
+                        value
+                     end
+
+                  if value_out.is_a?(Array) && options[:dedup]
+                     value_out.uniq
+                  else
+                     value_out
+                  end
+               end
+            else
+               value
+            end
+
+         res
+      end
+   end
+end

data/lib/rdoba/re.rb

@@ -1,13 +1,14 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 class String
   def to_res
-    ostr = self.dup
+    ostr = dup
     res = ''
     while true
-      m = ostr.match(/(?:([+\[\]\\().*?{}^$\/|])|«([^«]*)»)/u)
+      m = ostr.match(%r{(?:([+\[\]\\().*?{}^$/|])|«([^«]*)»)}u)
       break unless m
+
       res += m.pre_match + (m[2] || m[1] && ('\\' + m[1]))
       ostr = m.post_match
     end
@@ -19,4 +20,3 @@ class String
     /#{to_res}/ui
   end
 end
-

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,43 +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' }
-   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 }
+  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 = RomanNumbers.size - 1
+  def to_rom
+    res = ''
+    num = self
+    i = RomanNumbers.size - 1
 
-      while num > 0
-         if num >= RomanNumbers[ i ]
-            res << Roman[ RomanNumbers[ i ] ]
-            num -= RomanNumbers[ i ]
-         else
-            i -= 1 ;end;end
-      res ;end;end
+    while num > 0
+      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("|")})/
+  RomanRe = /(#{Numeric::RomanDigits.join('|')})/
 
-   def rom
-      numbers = self.upcase.scan(RomanRe).flatten.map { |x| Numeric::RomanToInteger[x] }
-      numbers.sort do |x, y|
-         if x < y
-            raise "Invalid roman number" ;end
-         0 ;end
-      numbers.sum ;end;end
+  def rom
+    numbers = upcase.scan(RomanRe).flatten.map { |x| Numeric::RomanToInteger[x] }
+    numbers.sort do |x, y|
+      if x < y
+        raise 'Invalid roman number'
+      end
+
+      0
+    end
+    numbers.sum
+  end
+end

data/lib/rdoba/strings.rb

@@ -1,12 +1,11 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
-STDERR.puts "Warning: the module 'string' has kept only for backward " \
-            "compatibility\nPlease use 'rdoba :mixin' form instead"
+warn "Warning: the module 'string' has kept only for backward " \
+       "compatibility\nPlease use 'rdoba :mixin' form instead"
 
 class String
-  alias :to_p :to_s
+  alias to_p to_s
 end
 
-rdoba :mixin => [ :case, :reverse, :compare ]
-
+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,51 +1,60 @@
-#encoding: utf-8
+# frozen_string_literal: true
 
 module Kernel
-   Modules = [ :bcd, :mixin, :log, :debug ]
-
-   def rdoba *options
-      options.each do |option|
-         ( option.is_a?( Hash ) &&
-               option || { option.to_s.to_sym => {} }
-         ).each_pair do |key, value|
-            if Modules.include? key
-               require "rdoba/#{key}"
-               if Rdoba.methods.include? key
-                  if !value.is_a? Hash
-                     value = { :value => value } ; end
-                  value.replace( { :self => self }.merge value )
-                  Rdoba.send key, value ; end ; end ; end; end ; end ; end
+  Modules = %i[bcd mixin log debug]
+
+  def rdoba(*options)
+    options.each do |option|
+      (option.is_a?(Hash) && option || { option.to_s.to_sym => {} }).each_pair do |key, value|
+        next unless Modules.include? key
+
+        require "rdoba/#{key}"
+        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,5 +1,6 @@
-# -*- 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|
@@ -23,16 +24,16 @@ Gem::Specification.new do |s|
    s.extra_rdoc_files  = [ 'README.md', 'LICENSE', 'CHANGES.md' ] |
                         `find html/`.split( "\n" )
 
-   s.add_development_dependency 'simplecov', '~> 0'
-   s.add_development_dependency 'tddium', '~> 0'
-   s.add_development_dependency 'rake', '~> 0'
-   s.add_development_dependency 'bundler', '~> 1.5'
+   s.add_development_dependency 'bundler', '~> 2.0'
+   s.add_development_dependency 'coveralls'
    s.add_development_dependency 'cucumber', '~> 1.3'
-   s.add_development_dependency 'coveralls', '~> 0'
+   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', '~> 4.2'
+   s.add_development_dependency 'rdoc', '~> 6.2'
    s.add_development_dependency 'rspec-expectations', '~> 3.3'
-   s.add_development_dependency 'ffi-stat', '~> 0.4'
+   s.add_development_dependency 'simplecov', '~> 0'
+   s.add_development_dependency 'tddium', '~> 1.25'
 
    s.required_rubygems_version = '>= 1.6.0'
    s.required_ruby_version = '>= 1.9.0' ; end