rdoba 0.9.1 → 0.9.4

data/lib/rdoba/mixin.rb

@@ -1,57 +1,378 @@
 #!/usr/bin/ruby -KU
-#encoding:utf-8
+# frozen_string_literal: true
+
+class String
+  # TODO: obsolete
+  ByteByByte = 0
+  FirstChar = 1
+end
 
 module Rdoba
-   module Mixin
-      module To_hArray
-         def to_h options = {}
-            h = {}
-            self.each do |v|
-               if v.is_a? Array
-                  if h.key? v[ 0 ]
-                     if !h[ v[ 0 ] ].is_a? Array
-                        h[ v[ 0 ] ] = [ h[ v[ 0 ] ] ] ; end
-
-                     if v.size > 2
-                        h[ v [ 0 ] ].concat v[ 1..-1 ]
-                     else
-                        h[ v [ 0 ] ] << v[ 1 ] ; end
-                  else
-                     h[ v[ 0 ] ] = v.size > 2 && v[ 1..-1] || v[ 1 ] ; end
-               else
-                  if h.key? v
-                     if !h[ v ].is_a? Array
-                        h[ v ] = [ h[ v ] ] ; end
-
-                     h[ v ] << v
-                  else
-                     h[ v ] = nil ; end ; end ; end
-
-            if options[ :save_unique ]
-               h.each_pair do |k,v|
-                  if v.is_a? Array
-                     v.uniq! ; end ; end ; end
-
-            h ; end ; end
-
-      module EmptyObject
-         def empty?
-            false ; end ; end
-
-      module EmptyNilClass
-         def empty?
-            true ; end ; end ; end
-
-   def self.mixin options
-      ( options || [] ).each do |value|
-         case value
-         when :to_h
-            Array.send :include, Rdoba::Mixin::To_hArray
-         when :empty
-            Object.send :include, Rdoba::Mixin::EmptyObject
-            NilClass.send :include, Rdoba::Mixin::EmptyNilClass
-         else
-            Kernel.puts STDERR, "Invalid rdoba-mixin options key: #{value.to_s}"
-            end ; end ; end ; end
+  module Mixin
+    class InvalidOption < StandardError
+    end
+
+    module CompareString
+      def compare_to(value, opts = {})
+        if opts == :ignore_diacritics || opts.instance_of?(Hash) && opts.key?(:ignore_diacritics)
+          # TODO: verify composite range
+          def crop_diacritics(x)
+            (x < 0x300 || x > 0x36f && x < 0x483 || x > 0x487 && x < 0xa67c || x > 0xa67d) && x || nil
+          end
+
+          (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
+
+    module ReverseString
+      Fixups = [:reverse]
+
+      Aliases = { __rdoba_mixin_reverse_orig__: :reverse }
+
+      def __rdoba_mixin_reverse__(step = 1)
+        if (!step.is_a?(Numeric) || step < 0) && step != :byte_by_byte
+          raise "Invalid step value #{step.inspect}"
+        end
+
+        if [:byte_by_byte, String::ByteByByte].include?(step)
+          arr = []
+          each_byte do |byte|
+            arr << byte.chr
+          end
+          arr.reverse.join.force_encoding(encoding)
+        elsif step == 1
+          __rdoba_mixin_reverse_orig__
+        elsif step > 1
+          res = ''
+          offset = (size + 1) / step * step - step
+          (0..offset).step(step) do |shift|
+            res += self[offset - shift..offset - shift + 1]
+          end
+          res
+        end
+      end
+    end
+
+    module CaseString
+      Fixups = %i[upcase downcase]
+
+      Aliases = { __rdoba_mixin_upcase_orig__: :upcase, __rdoba_mixin_downcase_orig__: :downcase }
+
+      ConvertTable = {
+        up: {
+          ranges: [
+            { ords: [(0xE0..0xFF), (0x3B1..0x3CB), (0x430..0x44F)], change: proc { |chr, _value| chr -= 0x20 } },
+            { ords: [(0x3AC..0x3AC)], change: proc { |ord| ord -= 0x26 } },
+            { ords: [(0x3AD..0x3AF)], change: proc { |ord| ord -= 0x25 } },
+            { ords: [(0x3B0..0x3B0)], change: proc { |ord| ord -= 0x22 } },
+            {
+              ords: [
+                (0x1F00..0x1F07),
+                (0x1F10..0x1F17),
+                (0x1F20..0x1F27),
+                (0x1F30..0x1F37),
+                (0x1F40..0x1F47),
+                (0x1F50..0x1F57),
+                (0x1F60..0x1F67),
+                (0x1F80..0x1F87),
+                (0x1F90..0x1F97),
+                (0x1Fa0..0x1Fa7),
+                (0x1Fb0..0x1Fb3)
+              ],
+              change: proc { |ord| ord += 0x8 }
+            },
+            { ords: [(0x450..0x45F)], change: proc { |ord| ord -= 0x50 } },
+            {
+              ords: [
+                (0x100..0x1B9),
+                (0x1C4..0x233),
+                (0x460..0x481),
+                (0x48A..0x523),
+                (0x1E00..0x1E95),
+                (0x1EA0..0x1EFF),
+                (0x0A642..0xA667),
+                (0x0A680..0x0A697),
+                (0xA722..0xA7A9)
+              ],
+              change: proc { |ord| ord.odd? && (ord - 1) || ord }
+            }
+          ],
+          default:
+            proc do |ord|
+              [ord].pack('U').__rdoba_mixin_upcase_orig__
+            end
+        },
+        down: {
+          ranges: [
+            { ords: [(0xC0..0xDF), (0x391..0x3AB), (0x410..0x42F)], change: proc { |chr, _value| chr += 0x20 } },
+            { ords: [(0x386..0x386)], change: proc { |ord| ord += 0x26 } },
+            { ords: [(0x388..0x38A)], change: proc { |ord| ord += 0x25 } },
+            { ords: [(0x38E..0x38E)], change: proc { |ord| ord += 0x22 } },
+            {
+              ords: [
+                (0x1F08..0x1F0F),
+                (0x1F18..0x1F1F),
+                (0x1F28..0x1F2F),
+                (0x1F38..0x1F3F),
+                (0x1F48..0x1F4F),
+                (0x1F58..0x1F5F),
+                (0x1F68..0x1F6F),
+                (0x1F88..0x1F8F),
+                (0x1F98..0x1F9F),
+                (0x1Fa8..0x1FaF),
+                (0x1Fb8..0x1FbA)
+              ],
+              change: proc { |ord| ord -= 0x8 }
+            },
+            { ords: [(0x400..0x40F)], change: proc { |ord| ord += 0x50 } },
+            {
+              ords: [
+                (0x100..0x1B9),
+                (0x1C4..0x233),
+                (0x450..0x481),
+                (0x48A..0x523),
+                (0x1E00..0x1E95),
+                (0x1EA0..0x1EFF),
+                (0x0A642..0xA667),
+                (0x0A680..0x0A697),
+                (0xA722..0xA7A9)
+              ],
+              change: proc { |ord| ord.even? && (ord + 1) || ord }
+            }
+          ],
+          default:
+            proc do |ord|
+              [ord].pack('U').__rdoba_mixin_downcase_orig__
+            end
+        }
+      }
+
+      def self.change_case_char(dest, char)
+        ord = char.is_a?(String) ? char.ord : char.to_i
+        table = ConvertTable[dest]
+        nord =
+          table[:ranges].each do |range|
+            c =
+              range[:ords].each do |r|
+                if r.include?(ord)
+                  break false
+                end
+              end
+            unless c
+              break range[:change].call ord
+            end
+          end
+
+        unless nord.is_a? Numeric
+          return table[:default].call ord
+        end
+
+        [nord].pack('U')
+      end
+
+      def self.up_char(char)
+        CaseString.change_case_char :up, char
+      end
+
+      def self.downcase_char(char)
+        CaseString.change_case_char :down, char
+      end
+
+      if RUBY_VERSION < '1.9'
+        alias setbyte []=
+
+        def encoding
+          'UTF-8'
+        end
 
+        def force_encoding(*_args)
+          self
+        end
 
+        def ord
+          a = nil
+          each_byte do |b|
+            case (b & 0xC0)
+            when 0xc0
+              a = (b & 0x3F)
+            when 0x80
+              return (a << 6) + (b & 0x3F)
+            else
+              return b
+            end
+          end
+        end
+      end
+
+      def __rdoba_mixin_downcase__(options = {})
+        __rdoba_mixin_changecase__ :down, options
+      end
+
+      def __rdoba_mixin_upcase__(options = {})
+        __rdoba_mixin_changecase__ :up, options
+      end
+
+      def __rdoba_mixin_changecase__(reg, options = {})
+        unless %i[up down].include? reg
+          return self
+        end
+
+        re = Regexp.new '[\x80-\xFF]', nil, 'n'
+        if options == String::FirstChar || options.include?(:first_char)
+          r = dup
+          r[0] = CaseString.change_case_char reg, ord
+          r
+        elsif dup.force_encoding('ASCII-8BIT').match re
+          unpack('U*').map do |chr|
+            CaseString.change_case_char reg, chr
+          end.join
+        elsif reg == :up
+          __rdoba_mixin_upcase_orig__
+        else
+          __rdoba_mixin_downcase_orig__
+        end
+      end
+    end
+
+    module To_hArray
+      def to_h(options = {})
+        h = {}
+        each do |v|
+          if v.is_a? Array
+            if h.key? v[0]
+              unless h[v[0]].is_a? Array
+                h[v[0]] = [h[v[0]]]
+              end
+
+              if v.size > 2
+                h[v[0]].concat v[1..-1]
+              else
+                h[v[0]] << v[1]
+              end
+            else
+              h[v[0]] = v.size > 2 && v[1..-1] || v[1]
+            end
+          elsif h.key? v
+            unless h[v].is_a? Array
+              h[v] = [h[v]]
+            end
+
+            h[v] << v
+          else
+            h[v] = nil
+          end
+        end
+
+        if options[:save_unique]
+          h.each_pair do |_k, v|
+            if v.is_a? Array
+              v.uniq!
+            end
+          end
+        end
+
+        h
+      end
+    end
+
+    module Split_byArray
+      #
+      # +split_by+ method splits the +self+ array by a condition,
+      # which is evaliated in a passed block, in two versions that are
+      # the return value. Usage:
+      #
+      # require 'rdoba'
+      #
+      # rdoba mixin: :split_by
+      #
+      # (first, second) = [0,1,2,3].split_by { |value| value % 2 == 0 }
+      # first # => [0,2]
+      # second # => [1,3]
+      #
+      def split_by
+        idxs = []
+        rejected = reject.with_index do |v, i| yield(v) && (idxs << i)end
+        [values_at(*idxs), rejected]
+      end
+    end
+
+    module EmptyObject
+      def empty?
+        false
+      end
+    end
+
+    module EmptyNilClass
+      def empty?
+        true
+      end
+    end
+  end
+end
+
+if RUBY_VERSION >= '2.0.0'
+  require_relative 'mixin/try'
+else
+  require_relative 'mixin/try_1_9_0'
+end
+
+require_relative 'mixin/wait_if'
+
+module Rdoba
+  def self.mixin(options)
+    [options[:value]].flatten.each do |value|
+      case value
+      when :case
+        Mixin::CaseString::Aliases.each do |k, v|
+          ::String.send :alias_method, k, v
+        end
+        Mixin::CaseString::Fixups.each do |e|
+          ::String.class_eval "def #{e}(*args);self.__rdoba_mixin_#{e}__(*args);end", __FILE__, __LINE__
+        end
+        ::String.include Mixin::CaseString
+      when :reverse
+        Mixin::ReverseString::Aliases.each do |k, v|
+          ::String.send :alias_method, k, v
+        end
+        Mixin::ReverseString::Fixups.each do |e|
+          ::String.class_eval "def #{e}(*args);self.__rdoba_mixin_#{e}__(*args);end", __FILE__, __LINE__
+        end
+        String.include Mixin::ReverseString
+      when :compare
+        String.include Mixin::CompareString
+      when :to_h
+        if [].respond_to?(:to_h)
+          m = Mixin::To_hArray.instance_method(:to_h)
+          Array.send(:define_method, :to_h, m)
+        else
+          Array.include Mixin::To_hArray
+        end
+      when :time
+        require_relative 'mixin/time'
+        if File.respond_to?(:mtime)
+          %i[mtime atime ctime].each do |name|
+            m = Mixin::Time.instance_method(name)
+            ::File.send(:define_singleton_method, name, m)
+          end
+        else
+          ::File.extend Mixin::Time
+        end
+      when :wait_if
+        Object.include Mixin::Wait_ifKernel
+      when :split_by
+        Array.include Mixin::Split_byArray
+      when :try
+        Object.include Mixin::TryObject
+      when :empty
+        Object.include Mixin::EmptyObject
+        NilClass.include Mixin::EmptyNilClass
+      else
+        raise(Mixin::InvalidOption, 'Invalid rdoba-mixin options key: ' + value.to_s)
+      end
+    end
+  end
+end

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
-