rdoba 0.9.1 → 0.9.4

data/lib/rdoba/bcd.rb

@@ -1,61 +1,78 @@
-#encoding: utf-8
-#
+# frozen_string_literal: true
 
 module BCD
-  class ParseError < Exception
-    def initialize msg = "Invalid positive integer value"; end; end
+  class ParseError < RuntimeError
+    def initialize(msg = 'Invalid positive integer value'); end
+  end
 
-  class ConvertError < Exception
-    def initialize msg = "Invalid number has given"; end; end
+  class ConvertError < RuntimeError
+    def initialize(msg = 'Invalid number has given'); end
+  end
 
   def to_i
     res = 0
     mul = 1
-    self.each_byte do |c|
-      def pow value, mul
+    each_byte do |c|
+      def pow(value, mul)
         if value >= 10
-          raise ConvertError; end
+          raise ConvertError
+        end
+
         value * mul
       end
-      res += pow( c.ord & 0xF,  mul )
+      res += pow(c.ord & 0xF, mul)
       mul *= 10
-      res += pow( c.ord >> 4, mul )
+      res += pow(c.ord >> 4, mul)
       mul *= 10
     end
-    res; end
+    res
+  end
 
-  def self.parse value
+  def self.parse(value)
     if value < 0
-      raise ParseError; end
+      raise ParseError
+    end
+
     res = BCDString.new
     if res.respond_to? :force_encoding
-      res.force_encoding( 'ASCII-8BIT' ); end
+      res.force_encoding('ASCII-8BIT')
+    end
     if value > 0
       part = nil
       while value > 0
-        ( value, mod ) = value.divmod 10
+        value, mod = value.divmod 10
         if part
-          res << ( ( mod << 4 ) | part ).chr
+          res << ((mod << 4) | part).chr
           part = nil
         else
-          part = mod; end; end
+          part = mod
+        end
+      end
       if part
-        res << part.chr; end
+        res << part.chr
+      end
     else
-      res << 0.chr; end
-    res; end; end
+      res << 0.chr
+    end
+    res
+  end
+end
 
 class BCDString < String
   include BCD
 
-  def initialize value = nil
+  def initialize(value = nil)
     if value.is_a? Numeric
-      self.replace BCD.parse( value )
+      replace BCD.parse(value)
     else
-      super value.to_s; end; end; end
+      super value.to_s
+    end
+  end
+end
 
 class Numeric
   def to_bcd
     # NOTE: return as plain LSB string
-    BCD.parse value; end; end
-
+    BCD.parse value
+  end
+end

data/lib/rdoba/blank.rb

@@ -0,0 +1,14 @@
+class Object
+   def blank?
+      case self
+      when NilClass, FalseClass
+         true
+      when TrueClass
+         false
+      when Hash, Array
+         !self.any?
+      else
+         self.to_s == ""
+      end
+   end
+end

data/lib/rdoba/combinations.rb

@@ -1,12 +1,12 @@
 #!/usr/bin/ruby
+# frozen_string_literal: true
 
 class Array
-
-private
+  private
 
   def __comby(i, size)
-    s = "0#{sprintf("%.*b", size, i)}0"
-    v = { :res => [], :c0 => 0, :c1 => 0, :j => 0}
+    s = "0#{format('%.*b', size, i)}0"
+    v = { res: [], c0: 0, c1: 0, j: 0 }
 
     def up1(v)
       sub_j = v[:j] + v[:c1] + 1
@@ -17,7 +17,9 @@ private
 
     def up0(v)
       sub_j = v[:j] + v[:c0] - 1
-      self[v[:j]...sub_j].each do |x| v[:res] << [x] end
+      self[v[:j]...sub_j].each do |x|
+        v[:res] << [x]
+      end
       v[:j] = sub_j
     end
 
@@ -35,25 +37,25 @@ private
     v[:res]
   end
 
-public
+  public
 
   def each_comby(*args)
-    return self if self.empty? or not block_given?
+    return self if empty? or !block_given?
+
     if args.include?(:backward)
-      yield [ self.dup ]
-      ((1 << (self.size - 1)) - 2).downto(0) do |i|
-        c = __comby(i, self.size - 1)
+      yield [dup]
+      ((1 << (size - 1)) - 2).downto(0) do |i|
+        c = __comby(i, size - 1)
         yield c
       end
     else
-      0.upto((1 << (self.size - 1)) - 2) do |i|
-        c = __comby(i, self.size - 1)
+      0.upto((1 << (size - 1)) - 2) do |i|
+        c = __comby(i, size - 1)
         yield c
       end
-      yield [ self.dup ]
+      yield [dup]
     end
 
-    return self
+    self
   end
 end
-

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,49 +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
-  end
-end
-
-module Kernel
-  def wait_if(timeout = 30)
-    require 'timeout'
-
-    begin
-      Timeout::timeout(timeout) do
-        while yield(); end
-      end
-      true
-    rescue Timeout::Error
-      false
-    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?
@@ -72,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)
@@ -132,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
@@ -148,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
@@ -172,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,6 +1,12 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+warn "Warning: the module has kept only for backward compatibility\n" \
+       "Please use 'rdoba :log' form instead"
 
-STDERR.puts "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

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
-