rdoba 0.9.1 → 0.9.2

data/lib/rdoba/mixin.rb

@@ -1,8 +1,209 @@
 #!/usr/bin/ruby -KU
 #encoding:utf-8
+         
+class String
+   # TODO obsolete
+   ByteByByte = 0
+   FirstChar = 1
+end
 
 module Rdoba
    module Mixin
+      class InvalidOption < StandardError ; end
+
+      module CompareString
+         def compare_to value, opts = {}
+            if ( opts == :ignore_diacritics ||
+               opts.class == 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
+
+               ( self.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 step == :byte_by_byte || step == String::ByteByByte
+               arr = []
+               self.each_byte do | byte |
+                  arr << byte.chr ; end
+               arr.reverse.join.force_encoding( self.encoding )
+            elsif step == 1
+               __rdoba_mixin_reverse_orig__
+            elsif step > 1
+               res = ''
+               offset = (self.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 = [ :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
+               if !c
+                  break range[ :change ].call ord ; end ; end
+
+            if !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
+               self.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 = {}
+            self.__rdoba_mixin_changecase__ :down, options ; end
+
+         def __rdoba_mixin_upcase__ options = {}
+            self.__rdoba_mixin_changecase__ :up, options ; end
+
+         def __rdoba_mixin_changecase__ reg, options = {}
+            if ![ :up, :down ].include? reg
+               return self ; end
+
+            re = Regexp.new '[\x80-\xFF]', nil, 'n'
+            if options == String::FirstChar || options.include?( :first_char )
+               r = self.dup
+               r[0] = CaseString.change_case_char reg, self.ord
+               r
+            elsif self.dup.force_encoding( 'ASCII-8BIT' ).match re
+               self.unpack('U*').map do | chr |
+                  CaseString.change_case_char reg, chr
+               end.join
+            elsif reg == :up
+               self.__rdoba_mixin_upcase_orig__
+            else
+               self.__rdoba_mixin_downcase_orig__ ; end ; end ; end
+
       module To_hArray
          def to_h options = {}
             h = {}
@@ -34,24 +235,87 @@ module Rdoba
 
             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 &block
+            idxs = []
+            rejected = self.reject.with_index do |v, i|
+               yield( v ) && ( idxs << i ) ; end
+               [ self.values_at(*idxs), rejected ] ; end ; end
+
       module EmptyObject
          def empty?
             false ; end ; end
 
       module EmptyNilClass
          def empty?
-            true ; end ; end ; end
+            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 || [] ).each do |value|
+      [ 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"
+            end # trap NameError
+            ::String.send :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"
+            end # trap NameError
+            String.send :include, Mixin::ReverseString
+         when :compare
+            String.send :include, Mixin::CompareString
          when :to_h
-            Array.send :include, Rdoba::Mixin::To_hArray
+            if [].respond_to?( :to_h )
+               m = Mixin::To_hArray.instance_method( :to_h )
+               Array.send( :define_method, :to_h, m )
+            else
+               Array.send( :include, Mixin::To_hArray ) ; end
+         when :time
+            require_relative 'mixin/time'
+            if File.respond_to?( :mtime )
+               [ :mtime, :atime, :ctime ].each do |name|
+                  m = Mixin::Time.instance_method( name )
+                  ::File.send( :define_singleton_method, name, m ) ; end
+            else
+               ::File.send( :extend, Mixin::Time ) ; end
+         when :wait_if
+            Object.send :include, Mixin::Wait_ifKernel
+         when :split_by
+            Array.send :include, Mixin::Split_byArray
+         when :try
+            Object.send :include, Mixin::TryObject
          when :empty
-            Object.send :include, Rdoba::Mixin::EmptyObject
-            NilClass.send :include, Rdoba::Mixin::EmptyNilClass
+            Object.send :include, Mixin::EmptyObject
+            NilClass.send :include, Mixin::EmptyNilClass
          else
-            Kernel.puts STDERR, "Invalid rdoba-mixin options key: #{value.to_s}"
+            raise( Mixin::InvalidOption, "Invalid rdoba-mixin options key: " +
+                  "#{value.to_s}" )
             end ; end ; end ; end
 
 

data/lib/rdoba/strings.rb

@@ -1,149 +1,12 @@
 #!/usr/bin/ruby -KU
 #coding:utf-8
 
-class String
-
-  def self.upcase(char)
-      chr = char.class == String ? char.ord : char.to_i
-      if chr >= 0x430 and chr < 0x450
-        chr -= 0x20
-      elsif chr >= 0x410 and chr < 0x430
-      elsif chr >= 0x400 and chr < 0x410 or
-          chr >= 0x450 and chr < 0x482 or
-          chr >= 0x48A and chr < 0x524 or
-          chr >= 0xA642 and chr < 0xA668 or
-          chr >= 0xA680 and chr < 0xA698
-        chr -= 1 if (chr % 1) == 1
-      else
-        return chr.chr.__upcase__
-      end
-      chr.chr
-  end
-
-  def self.downcase(char)
-      chr = (char.class == String) ? char.ord : char.to_i
-      if chr >= 0x410 and chr < 0x430
-        chr += 0x20
-      elsif chr >= 0x430 and chr < 0x450
-      elsif chr >= 0x400 and chr < 0x410 or
-          chr >= 0x450 and chr < 0x482 or
-          chr >= 0x48A and chr < 0x524 or
-          chr >= 0xA642 and chr < 0xA668 or
-          chr >= 0xA680 and chr < 0xA698
-        chr += 1 if (chr % 1) == 0
-      else
-        return chr.chr.__downcase__
-      end
-      chr.chr
-  end
-
-  if RUBY_VERSION < '1.9'
-
-    alias :setbyte :[]=
-
-    def encoding
-      'UTF-8'
-    end
-
-    def force_encoding(*args)
-      self
-    end
-
-    def ord
-      a = nil
-      self.each_byte do |b|
-	c = b & 0xC0
-	case c
-	when 0xc0
-	  a = (b & 0x3F)
-	when 0x80
-	  return (a << 6) + (b & 0x3F)
-	else
-	  return b
-	end
-      end
-    end
-
-  end
-
-  FirstChar = 0
-  alias :__upcase__ :upcase
-  def upcase(option = nil)
-    if option == FirstChar
-      r = self.dup
-      r[0] = String.upcase(self.ord)
-      r
-    elsif self.match(/[Ѐ-ҁҊ-ԣꙀ-ꙧꚀꚗ]/u)
-      self.unpack('U*').map do |chr| String.upcase(chr) end.join
-    else; __upcase__ end
-  end
-
-  alias :__downcase__ :downcase
-  def downcase(option = nil)
-    if option == FirstChar
-      r = self.dup
-      r[0] = String.downcase(self.ord)
-      r
-    elsif self.match(/[Ѐ-ҁҊ-ԣꙀ-ꙧꚀꚗ]/u)
-      self.unpack('U*').map do |chr| String.downcase(chr) end.join
-    else; __downcase__ end
-  end
+STDERR.puts "Warning: the module 'string' has kept only for backward " \
+            "compatibility\nPlease use 'rdoba :mixin' form instead"
 
+class String
   alias :to_p :to_s
-
-  ByteByByte = 0
-  alias :__reverse__ :reverse
-  def reverse(step = 1)
-      case step
-      when ByteByByte
-          arr = []
-          self.each_byte do |byte| arr << byte.chr end
-          arr.reverse.join
-      when 1
-          __reverse__
-      else
-          res = ''
-          offset = (self.size + 1) / step * step - step
-          (0..offset).step(step) do |shift|
-              res += self[offset - shift..offset - shift + 1]
-          end
-          res
-      end
-  end
-
-  def compare_to(value, opts = {} )
-    if opts == :ignore_diacritics or
-      (opts.class == Hash and opts.key? :ignore_diacritics)
-      # TODO verify composite range
-      def crop_diacritics(x)
-        (x < 0x300 or
-           x > 0x36f and x < 0x483 or
-           x > 0x487 and x < 0xa67c or
-           x > 0xa67d) && x || nil
-      end
-
-      (self.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
 
-class Fixnum
-  alias :__chr__ :chr
-  def chr
-    if self >= 256
-      num = self; s = "\0"; byte = 0x80; a = []
-      while num >= 0x40
-	s.setbyte(0, byte + (num & 0x3F))
-	a << s.dup; num >>= 6; byte = 0x40
-      end
-      s.setbyte(0, 0xC0 + (num & 0x3F))
-      a << s
-      a.reverse.join.force_encoding('UTF-8')
-    else; __chr__ end
-  end
-end
+rdoba :mixin => [ :case, :reverse, :compare ]
 

data/lib/rdoba.rb

@@ -1,26 +1,20 @@
 #encoding: utf-8
 
 module Kernel
-  Modules = [ :bcd ]
+   Modules = [ :bcd, :mixin, :log, :debug ]
 
-  def rdoba *options
-    options.each do |option|
-      key, value = ( option.is_a?( Hash ) &&
-      [ ( k = option.keys.shift ).to_s.to_sym, option[ k ] ] ||
-      [ option.to_s.to_sym ] )
-      case key
-      when :mixin
-        require "rdoba/mixin"
-        Rdoba.mixin value
-      when :log, :debug
-        require "rdoba/#{key}"
-        Rdoba.log( { :in => self }.merge( value || {} ) ) # TODO move log method into module
-        # TODO and resolve some troubles with eval in main
-      else
-        Kernel.puts STDERR, "Unknown rdoba module named as '#{key.to_s}'"
-        nil; end ||
-      if Modules.include? key
-        require "rdoba/#{key}"; end; end; end; end
+   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
 
 require 'rbconfig'
 

data/rdoba.gemspec

@@ -3,30 +3,36 @@ $:.push File.expand_path("../lib", __FILE__)
 require "rdoba/_version_"
 
 Gem::Specification.new do |s|
-  s.name        = "rdoba"
-  s.version     = Rdoba::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = [ 'Малъ Скрылёвъ (Malo Skrylevo)' ]
-  s.email       = [ '3aHyga@gmail.com' ]
-  s.homepage    = 'https://github.com/3aHyga/rdoba'
-  s.summary     = 'Ruby extension library (Ruby DOBAvka)'
-  s.description = 'Ruby extension library. It extends Kernel, Object, ' +
-		  'String, Hash, Array, and some other classes. Also allows ' +
-		  'to log application state with debug lines to an io'
-  s.license     = 'MIT'
+   s.name         = "rdoba"
+   s.version      = Rdoba::VERSION
+   s.platform     = Gem::Platform::RUBY
+   s.authors      = [ 'Малъ Скрылёвъ (Malo Skrylevo)' ]
+   s.email        = [ '3aHyga@gmail.com' ]
+   s.homepage     = 'https://github.com/3aHyga/rdoba'
+   s.summary      = 'Ruby extension library (Ruby DOBAvka)'
+   s.description  = 'Ruby extension library. It extends Kernel, Object, '       \
+                    'String, Hash, Array, and some other classes. Also allows ' \
+                    'to log application state with debug lines to an io'
+   s.license      = 'MIT'
 
-  s.rubyforge_project = "rdoba"
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = [ "lib" ]
-  s.extra_rdoc_files = [ 'README.md', 'LICENSE' ]
+   s.rubyforge_project = "rdoba"
+   s.files             = `git ls-files`.split("\n")
+   s.test_files        = `git ls-files -- {test,spec,features}/*`.split("\n")
+   s.executables       = `git ls-files -- bin/*`.split( "\n" ).map{ |f| File.basename(f) }
+   s.require_paths     = [ "lib" ]
+   s.extra_rdoc_files  = [ 'README.md', 'LICENSE', 'CHANGES.md' ] |
+                        `find html/`.split( "\n" )
 
-  s.required_rubygems_version = '>= 1.6.0'
-  s.required_ruby_version = '>= 1.9.0'
+   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 'cucumber', '~> 1.3'
+   s.add_development_dependency 'coveralls', '~> 0'
+   s.add_development_dependency 'rdiscount', '~> 2.1'
+   s.add_development_dependency 'rdoc', '~> 4.2'
+   s.add_development_dependency 'rspec-expectations', '~> 3.3'
+   s.add_development_dependency 'ffi-stat', '~> 0.4'
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'bundler', '~> 1.3'
-  s.add_development_dependency 'cucumber', '~> 1.3'
-  s.add_development_dependency 'coveralls'
-end
+   s.required_rubygems_version = '>= 1.6.0'
+   s.required_ruby_version = '>= 1.9.0' ; end

data/tddium.yml

@@ -0,0 +1,11 @@
+:tddium:
+   :ruby_version: ruby-1.9.3-p547
+   :bundler_version: '~> 1.6.5'
+   :test_pattern:
+      - features/\*.feature
+   :tests:
+      - bundle exec cucumber
+   :coverage: true
+   :postgresql: false
+   :mysql: false
+   :sqlite: false