rdoba 0.9.1 → 0.9.4

data/lib/rdoba/gem.rb

@@ -1,36 +1,40 @@
 #!/usr/bin/ruby -KU
-#encoding:utf-8
+# frozen_string_literal: true
 
 require 'rbconfig'
 
 module Rdoba
-   def self.gemroot gemname = nil, path = ''
-      if !gem
-         raise "Undefined gem name" ; end
-      g = Gem::Specification.find_by_name( gemname )
-      File.join g.full_gem_path, 'share', 'settings.yaml'
-   end
+  def self.gemroot(gemname = nil, _path = '')
+    unless gem
+      raise 'Undefined gem name'
+    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
+    g = Gem::Specification.find_by_name(gemname)
+    File.join g.full_gem_path, 'share', 'settings.yaml'
+  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/lib/rdoba/hashorder.rb

@@ -1,35 +1,36 @@
 #!/usr/bin/ruby
+# frozen_string_literal: true
 
 class Hash
   attr_reader :order
 
   class Each
     General = 0
-    Pair    = 1
-    Key	    = 2
-    Value   = 3
+    Pair = 1
+    Key = 2
+    Value = 3
   end
 
-private
+  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
+    (@order | keys).each do |key|
+      next unless 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
 
-public
+  public
 
   def order=(order)
     return nil if order.class != Array
@@ -38,13 +39,14 @@ public
   end
 
   def disorder
-    @order = nil; self
+    @order = nil
+    self
   end
 
-  alias :__each__ :each
-  alias :__each_pair__ :each_pair
-  alias :__each_key__ :each_key
-  alias :__each_value__ :each_value
+  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)
@@ -61,6 +63,4 @@ public
   def each_value(&block)
     @order ? each_special(Hash::Each::Value, &block) : __each_value__(&block)
   end
-
 end
-

data/lib/rdoba/io.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 require 'strscan'
 require 'rdoba/re'
@@ -7,7 +7,7 @@ require 'rdoba/roman'
 require 'rdoba/numeric'
 
 module Kernel
-  alias :__sprintf__ :sprintf
+  alias __sprintf__ sprintf
   def sprintf(format, *args)
     nargs = []
     nformat = ''
@@ -15,26 +15,31 @@ module Kernel
     fmt = format.split('%')
     nformat = fmt.shift
 
-    while (not fmt.empty?)
+    until 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\*]*)(\+?)/
+      part ||= '%' + fmt.shift
+      if part =~ /([0-9 #+\-*.]*)([bcdEefGgiopsuXxP])(.*)/ and Regexp.last_match(2) == 'P'
+        keys = Regexp.last_match(1) || ''
+        str = Regexp.last_match(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
+          indent = ' ' * (Regexp.last_match(2) == '*' ? args.shift : Regexp.last_match(2)).to_i
+          plain =
+            value &&
+              value.to_p(
+                padding:
+                  (Regexp.last_match(3) == '*' ? args.shift : Regexp.last_match(3).empty? ? 1 : Regexp.last_match(3))
+                    .to_i,
+                be: Regexp.last_match(4).empty? ? nil : true
+              ) || ''
+          nformat += (Regexp.last_match(1) ? plain + indent : indent + plain) + str
         else
           nformat += '%' + keys + 'c' + str
           nargs.push args.shift
         end
       else
         nformat += '%' + part
-        l = $1 =~ /\*/ ? 2 : 1
+        l = Regexp.last_match(1) =~ /\*/ ? 2 : 1
         while l > 0
           nargs.push args.shift
           l -= 1
@@ -43,57 +48,59 @@ module Kernel
     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
+    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
+      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 ]
+    [/#{nformat}/, argfs]
   end
 
-  (alias :__scanf__ :scanf) if self.instance_methods(false).include?(:scanf)
+  (alias __scanf__ scanf) if instance_methods(false).include?(:scanf)
   def scanf(format, &block)
-    (re, argfs) = scanf_re(format)
+    re, argfs = scanf_re(format)
 
     ss = StringScanner.new(self)
     res = []
@@ -102,29 +109,32 @@ class String
       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
+        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?
+      if block
         pass = []
-        (1..block.arity).each do |i| pass << "rline[#{i}]" end
+        (1..block.arity).each do |i|
+          pass << "rline[#{i}]"
+        end
         eval "yield(#{pass.join(', ')})"
       end
 
@@ -144,17 +154,14 @@ class String
       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
+      next unless ss.post_match[0] == "\n"[0]
 
+      res = ostr
+      pos += 1
+      ostr = ''
     end
 
     ostr[0...ss.rest.size] = ss.rest
     res + ostr
   end
 end
-
-

data/lib/rdoba/merge.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rdoba::Merge
+  TARGET = :Hash
+
+  def deep_merge(source, dest)
+    dup = dest.dup
+    source.each do |key, value|
+      newvalue = dup.delete key
+      case newvalue
+      when Hash
+        value.deep_merge newvalue
+      when Array
+        value |= newvalue
+      when NilClass
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/rdoba/mixin/time.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rdoba::Mixin::Time
+  require 'ffi/stat'
+
+  def mtime(file)
+    FFI::Stat.stat(file)[:st_mtimespec].to_time
+  end
+
+  def atime(file)
+    FFI::Stat.stat(file)[:st_atimespec].to_time
+  end
+
+  def ctime(file)
+    FFI::Stat.stat(file)[:st_ctimespec].to_time
+  end
+end

data/lib/rdoba/mixin/try.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rdoba::Mixin::TryObject
+  def try(method, *args, default: nil)
+    if respond_to?(method)
+      send(method, *args)
+    else
+      default
+    end
+  end
+end

data/lib/rdoba/mixin/try_1_9_0.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rdoba::Mixin::TryObject
+  def try(method, *args)
+    if respond_to?(method)
+      send(method, *args)
+    end
+  end
+end

data/lib/rdoba/mixin/wait_if.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Rdoba::Mixin::Wait_ifKernel
+  ##
+  # +wait_if+ waits for +timeout+ second to the condition passed via block,
+  # and in case if it failed, returns false, otherwise true. +timeout+ can
+  # be a float or integer number of seconds, but if passed 0 or nil it waits
+  # forever. Default value is 6 seconds. Example:
+  #
+  #     wait_if(5) { sleep 2; true } # => true
+  #     wait_if(5) { sleep 10; true } # => false
+  #
+  def wait_if(timeout = 6)
+    begin
+      Timeout.timeout(timeout) do
+        while yield()
+          sleep(0.1)
+        end
+      end
+      true
+    rescue Timeout::Error
+      false
+    end
+  end
+end