rdoba 0.9.3 → 0.9.4

data/lib/rdoba/common.rb

@@ -1,13 +1,14 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 class Object
   def xor(val1)
-    val0 = (not not self)
-    ((val0) and (not val1)) or ((not val0) and (val1))
+    val0 = !!self
+    (val0 and !val1) or (!val0 and val1)
   end
 
-  def co(method, *args) #calls any method
+  # calls any method
+  def co(method, *_args)
     eval "#{method}(*args)"
   end
 
@@ -20,34 +21,36 @@ class Object
     opts.each do |opt|
       case opt.class.to_s.to_sym
       when :Hash
-	opt.each do |x,y| v[x] = y end
+        opt.each do |x, y|
+          v[x] = y
+        end
       when :Array
-	opt.each do |x| v[x] = true end
+        opt.each do |x|
+          v[x] = true
+        end
       when :Symbol
-	v[opt] = true
+        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
+    parse_opts(opts).each do |x, y| instance_variable_set("@#{x}".to_sym, y)end
   end
 end
 
 class NilClass
   def =~(value)
-    value == nil
+    value.nil?
   end
 
-  def +(value)
-    value
+  def +(other)
+    other
   end
 
   def <<(value)
-    [ value ]
+    [value]
   end
 
   def empty?
@@ -57,59 +60,58 @@ class NilClass
   def to_i
     0
   end
-  alias :ord :to_i
+  alias ord to_i
 
   def size
     0
   end
 
-  def <=>(value)
+  def <=>(_other)
     -1
   end
 end
 
-
 class Array
   def purge
-    self.compact.delete_if {|x| x.empty? }
+    compact.delete_if { |x| x.empty? }
   end
 
   def >>(value = nil)
     value ? delete(value) : shift
   end
 
-  alias :__get__ :[]
+  alias __get__ []
   def [](index, *args)
-    return __get__(index.to_i, *args) if index.class == String and index =~ /^\d+$/
+    return __get__(index.to_i, *args) if index.instance_of?(String) and index =~ /^\d+$/
+
     __get__(index, *args)
   end
 
-  alias :__set__ :[]=
+  alias __set__ []=
   def []=(index, value, *args)
-    return __set__(index.to_i, value, *args) if index.class == String and index =~ /^\d+$/
+    return __set__(index.to_i, value, *args) if index.instance_of?(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
+  def -(other)
+    # TODO: make smart search for match in the 'str', when only last subpart matched to 'self'
+    len = size
     bc = ec = nil
     (0...len).each do |idx|
-      break bc = idx if self[idx] == str[0]
+      break bc = idx if self[idx] == other[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]
+    ((bc + 1)...len).each do |idx| break ec = idx if self[idx] != other[idx - bc]end if bc
+    bc ? ec ? self[0, bc] + self[ec, len - ec] : self[0, bc] : clone
   end
 
-  alias :__match__ :=~
+  alias __match__ =~
   def =~(value)
-    if value.class == String
+    if value.instance_of?(String)
       self == value
-    elsif value.class == Regexp
+    elsif value.instance_of?(Regexp)
       value =~ self
     else
       __match__(value)
@@ -117,14 +119,14 @@ class String
   end
 
   def rmatch(value)
-    self == value || self =~ /^\/([^\/]+)/ && value =~ /#{$1}/
+    self == value || self =~ %r{^/([^/]+)} && value =~ /#{Regexp.last_match(1)}/
   end
 
   def hexdump
-    res= ''
+    res = ''
     i = 0
-    self.each_byte do |byte|
-      res << sprintf("%.2X ", byte)
+    each_byte do |byte|
+      res << format('%.2X ', byte)
       i += 1
       res << "\n" if i % 16 == 0
     end
@@ -133,13 +135,13 @@ class String
 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
+  def |(other)
+    res = dup
+    other.each_pair do |key, val|
+      if val.instance_of?(res[key].class)
+        if val.instance_of?(Hash)
+          res[key] |= other[key]
+        elsif val.instance_of?(Array)
           res[key].concat val
         else
           res[key] = val
@@ -157,19 +159,17 @@ class Hash
 
   def reverse
     h = {}
-    self.each_pair do |key, value|
+    each_pair do |key, value|
       if h.key? value
-	if h[value].class == Array
-	  h[value] << key
-	else
-	  h[value] = [ h[value], key ]
-	end
+        if h[value].instance_of?(Array)
+          h[value] << key
+        else
+          h[value] = [h[value], key]
+        end
       else
-	h[value] = key
+        h[value] = key
       end
     end
     h
   end
 end
-
-

data/lib/rdoba/debug.rb

@@ -1,10 +1,12 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-STDERR.puts "Warning: the module has kept only for backward compatibility\n" \
-"Please use 'rdoba :log' form instead"
+warn "Warning: the module has kept only for backward compatibility\n" \
+       "Please use 'rdoba :log' form instead"
 
 require 'rdoba/log'
 
 module Rdoba
-   def self.debug options = {}
-      Rdoba.log options ; end ; end
+  def self.debug(options = {})
+    Rdoba.log options
+  end
+end

data/lib/rdoba/deploy.rb

@@ -1,74 +1,80 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 require 'rdoba/common'
 
 class Hash
-
   def deploy!(vars = {})
-    self.replace deploy(vars)
-    # TODO add variable copy
+    replace deploy(vars)
+    # TODO: add variable copy
   end
 
   def deploy(vars = {})
     res = {}
 
-    self.keys.sort do |x,y|
-      if x =~ /=$/
-	y =~ /=$/ ? x <=> y : -1
+    keys.sort do |x, y|
+      if /=$/.match?(x)
+        /=$/.match?(y) ? x <=> y : -1
       else
-	y !~ /=$/ ? x <=> y : 1
+        /=$/.match?(y) ? 1 : x <=> y
       end
     end.each do |key|
-
       if key =~ /(.*)=$/
-	vars[$1] = self[key]
-	next
-
+        vars[Regexp.last_match(1)] = self[key]
+        next
       elsif key =~ /(.*)@$/
-	sym = $1
-	eval "res.class.co( :attr_accessor, :#{sym})"
-	eval "res.#{sym} = self[key]"
-	next
-
+        sym = Regexp.last_match(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
+        unless vars.key?(Regexp.last_match(1))
+          next warn 'Warning: undefined variable ' + "#{Regexp.last_match(1).inspect} found. Ignoring..."
+        end
 
+        var = vars[Regexp.last_match(1)].dup
+        if var.instance_of?(Hash)
+          res |= var.deploy(vars)
+        elsif var.instance_of?(String)
+          res[var] = nil
+        else
+          raise "Undeployable hash #{Regexp.last_match(1)} value class #{var.class}"
+        end
+        next
       elsif key =~ /^%%(.*)/
-	key.replace $1.to_s
+        key.replace Regexp.last_match(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
+        case value.class.to_sym
+        when :String
+          if value =~ /^%([^%].*)/
+            begin
+              vars[Regexp.last_match(1)].deploy(vars)
+            rescue StandardError
+              nil
+            end
+          elsif value =~ /(.*)%([A-Za-z0-9_А-я]+)(.*)/
+            a = [Regexp.last_match(1).to_s, Regexp.last_match(2).to_s, Regexp.last_match(3).to_s]
+            a[1] =
+              begin
+                vars[a[1]].deploy(vars).to_s
+              rescue StandardError
+                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]
@@ -77,4 +83,3 @@ class Hash
     res
   end
 end
-

data/lib/rdoba/dup.rb

@@ -1,64 +1,64 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 class Array
-  alias :__dup__ :dup
+  alias __dup__ dup
   def dup(opts = {})
-    if (opts.class == Hash ? opts.key?(:recursive) : opts.to_s.to_sym == :recursive)
+    if opts.instance_of?(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
+        if /(Hash|Array)/.match?(value.class.to_s)
+          value.dup(:recursive)
+        else
+          begin
+            value.dup
+          rescue StandardError
+            new = value
+          end
+        end
       end
 
-      self.each do |value| res << sub_dup(value) end
+      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}"
+      raise "Unsupported option(s): #{opts.instance_of?(Hash) ? opts.keys.join(', ') : opts}"
     end
   end
-
 end
 
 class Hash
-  alias :__dup__ :dup
+  alias __dup__ dup
   def dup(opts = {})
-    if (opts.class == Hash ? opts.key?(:recursive) : opts.to_s.to_sym == :recursive)
+    if opts.instance_of?(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
+        if /(Hash|Array)/.match?(value.class.to_s)
+          value.dup(:recursive)
+        else
+          begin
+            value.dup
+          rescue StandardError
+            new = value
+          end
+        end
       end
 
-      self.each do |key, value| res[ sub_dup(key) ] = sub_dup(value) end
+      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}"
+      raise "Unsupported option(s): #{opts.instance_of?(Hash) ? opts.keys.join(', ') : opts}"
     end
   end
-
 end
-
-

data/lib/rdoba/fe.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/ruby -KU
+# frozen_string_literal: true
 
 class String
   def fe
@@ -6,13 +7,13 @@ class String
       self
     else
       return self unless Encoding.default_internal
-      if self.frozen?
-	self.dup.force_encoding(Encoding.default_internal || 'UTF-8').freeze
+
+      if frozen?
+        dup.force_encoding(Encoding.default_internal || 'UTF-8').freeze
       else
-	self.force_encoding(Encoding.default_internal || 'UTF-8')
+        force_encoding(Encoding.default_internal || 'UTF-8')
       end
     end
   end
-  alias :fenc :fe
+  alias fenc fe
 end
-

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
-