rdoba 0.9.1 → 0.9.4

data/features/step_definitions/mixin_steps.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+Допустим(/ꙇє примѣнена подпримѣсь \.([^\s]+) бисера рдоба/i) do |подпримѣсь|
+  require 'rdoba'
+  case подпримѣсь
+  when 'пуздро'
+    rdoba mixin: [:case]
+  when 'обратка'
+    rdoba mixin: [:reverse]
+  when 'ли_пущь'
+    rdoba mixin: [:empty]
+  when 'во_сл'
+    rdoba mixin: [:to_h]
+  when 'сравнена'
+    rdoba mixin: [:compare]
+  when 'режь_по'
+    rdoba mixin: [:split_by]
+  when 'жди_ьже'
+    rdoba mixin: [:wait_if]
+  when 'время'
+    rdoba mixin: [:time]
+  when 'пробь'
+    rdoba mixin: [:try]
+  else
+    raise
+  end
+end
+
+Допустим(/^у нас есть набор чисел$/) do
+  @набор = [1, 2, 3, 4, 5, 6, 7, 8]
+end
+
+Если(
+  /къ (кирилическу|латыньску) слову въ (верхнемъ|нижнемъ|смѣшанѣмъ) пуздрѣ ꙇє примѣненъ приꙇомъ :(ниспуздри|воспуздри)/
+) do |ꙇезикъ, пуздро, приꙇомъ|
+  стр =
+    if /кирилическу/.match?(ꙇезикъ)
+      if /верхнемъ/.match?(пуздро)
+        'КИРИЛИЧЕСКЫ БУКЫ ЗРИЙ СІИ: Ѡ И Ꙍ'
+      elsif /нижнемъ/.match?(пуздро)
+        'кирилическы букы зрий сіи: ѡ и ꙍ'
+      else
+        'КиРиЛиЧеСкЫ бУкЫ зРиЙ сІи: Ѡ и Ꙍ'
+      end
+    elsif /верхнемъ/.match?(пуздро)
+      'LATIN LETTERS SEE THE FOLLOWING: ÆǞ'
+    elsif /нижнемъ/.match?(пуздро)
+      'latin letters see the following: æǟ'
+    else
+      'LaTiN lEtTeRs SeE tHe FoLlOwInG: æǞ'
+    end
+
+  @плодъ = (приꙇомъ =~ /ниспуздри/) && стр.downcase || стр.upcase
+end
+
+Если(/^рассечём его на чётные и нечётные$/) do
+  @чётъ, @нечётъ = @набор.split_by { |x| x.even? }
+end
+
+Если(/^спробуем вызвать метод :qwer пущя$/) do
+  @плодъ = nil.try(:qwer)
+end
+
+То(/^(кирилическо|латыньско) слово имаꙇє буквы въ (нижнемъ|верхнемъ) пуздрѣ$/) do |ꙇезикъ, пуздро|
+  плодъ =
+    if /кирилическо/.match?(ꙇезикъ)
+      (пуздро =~ /верхнемъ/) && 'КИРИЛИЧЕСКЫ БУКЫ ЗРИЙ СІИ: Ѡ И Ꙍ' || 'кирилическы букы зрий сіи: ѡ и ꙍ'
+    else
+      (пуздро =~ /верхнемъ/) && 'LATIN LETTERS SEE THE FOLLOWING: ÆǞ' || 'latin letters see the following: æǟ'
+    end
+
+  if @плодъ != плодъ
+    raise "Плодна Страза со значенꙇемъ '#{@плодъ}' должна имѣти значенꙇе " \
+            "'#{плодъ}'"
+  end
+end
+
+То(/^Стразовъ приꙇомъ :обратка( сѫ кракомъ| сѫ доведомъ)? повратє обратну Стразу$/) do |доведъ|
+  требе =
+    case доведъ
+    when nil
+      'акортс'
+    when /кракомъ/u
+      "\xB0\xD0\xBA\xD0\xBE\xD0\x80\xD1\x82\xD1\x81\xD1"
+    when /доведомъ/u
+      'карост'
+    end
+
+  исходъ =
+    case доведъ
+    when nil
+      'строка'.reverse
+    when /кракомъ/u
+      'строка'.reverse :byte_by_byte
+    when /доведомъ/u
+      'строка'.reverse 2
+    end
+
+  if исходъ != требе
+    raise "Ложнъ исходъ '#{исходъ}' ꙇє повратнъ отъ приꙇома :обратка#{доведъ}, требуꙇє '#{требе}'"
+  end
+end
+
+То(/^приꙇомъ :ли_пущь рода (пущь|лжа|нове вещи) повратє (вѣрнъ|лжъ)$/) do |вещь, поврать|
+  поврать = (поврать == 'вѣрнъ') && true || false
+  исходъ =
+    case вещь
+    when 'пущь'
+      nil.empty? == поврать
+    when 'лжа'
+      false.empty? == поврать
+    when 'нове вещи'
+      Object.new.empty? == поврать
+    end
+  unless исходъ
+    raise "Ложнъ исходъ ꙇє повратнъ отъ приꙇома :ли_пущь рода #{вещь}"
+  end
+end
+
+Если(
+  /^(ровнъ|двуглубнъ|триглубнъ) наборъ( сѫ одинакыми частьми)? ꙇє пречиненъ во словникъ( приꙇомомъ :во_сл сѫ клѵчемъ :кромѣ_двоꙇниковъ)?$/
+) do |видъ, одинакъ, клѵчь|
+  @вещь =
+    case видъ
+    when 'ровнъ'
+      ['aa', 0, 'bb', 1].to_h
+    when 'двуглубнъ'
+      if одинакъ
+        if клѵчь
+          [['aa', 0], ['aa', 0]].to_h(save_unique: true)
+        else
+          [['aa', 0], ['aa', 0]].to_h
+        end
+      else
+        [['aa', 0], ['bb', 1]].to_h
+      end
+    when 'триглубнъ'
+      [['aa', 0, 1], ['bb', [1, 0]]].to_h
+    end
+end
+
+То(/^тъꙇи имѣꙇє ровнъ словникъ сѫ (пущими |ровнѣми |двуглубнѣми )?значѣми$/) do |видъ|
+  @схъ =
+    if /пущими/u.match?(видъ)
+      { 'aa' => nil, 0 => nil, 'bb' => nil, 1 => nil }
+    elsif /ровнѣми/u.match?(видъ)
+      { 'aa' => 0, 'bb' => 1 }
+    else
+      { 'aa' => [0, 1], 'bb' => [1, 0] }
+    end
+
+  if @вещь != @схъ
+    raise "Наборъ '#{@вещь}' требуꙇє быти '#{@схъ}'"
+  end
+end
+
+То(/^тъꙇи имѣꙇє ровнъ словникъ сѫ (однимъ|двами) двуглубн(?:ѣмъ|ѣмы) знач(?:ѣмъ|ѣмы)$/) do |видъ|
+  @схъ =
+    if /двами/.match?(видъ)
+      { 'aa' => [0, 0] }
+    else
+      { 'aa' => [0] }
+    end
+
+  if @вещь != @схъ
+    raise "Наборъ '#{@вещь}' требуꙇє быти '#{@схъ}'"
+  end
+end
+
+Если(/^имѣмы двѣ Стразы$/) do
+  @стры = %w[а҆́гнецъ а҆гкѵ́ра]
+end
+
+То(
+  /^приꙇомъ :сравнена двухъ Стразъ( сѫ презоромъ надъстрочниковъ( ꙇакъ словникъ)?)? повратє (безъ )?одна$/
+) do |доведъ, подобье, знакъ|
+  поврать = (знакъ =~ /безъ/u) && -1 || 1
+
+  исходъ =
+    if доведъ
+      if подобье
+        @стры[0].compare_to(@стры[1], ignore_diacritics: true) == поврать
+      else
+        @стры[0].compare_to(@стры[1], :ignore_diacritics) == поврать
+      end
+    else
+      @стры[0].compare_to(@стры[1]) == поврать
+    end
+
+  unless исходъ
+    raise "Приꙇомъ :сравнена двухъ Стразъ#{доведъ}#{подобье} требуꙇє повратъти '#{поврать}'"
+  end
+end
+
+То(/^получим два набора чётных и нечётных чисел$/) do
+  expect(@чётъ).to be_eql([2, 4, 6, 8])
+  expect(@нечётъ).to be_eql([1, 3, 5, 7])
+end
+
+То(/^той вернёт пущь$/) do
+  expect(@плодъ).to be_nil
+end
+
+Если(/^спробуем подождать мало, чтобы условие не выполнилось$/) do
+  @плодъ = wait_if(1) { false }
+end
+
+Если(/^спробуем подождать мало, чтобы условие выполнилось$/) do
+  @плодъ = wait_if(1) { true }
+end
+
+Если(/^спробуем подождать долго, чтобы условие выполнилось$/) do
+  @плодъ =
+    begin
+      Timeout.timeout(2) do
+        wait_if(10) { true }
+      end
+    rescue Timeout::Error
+      nil
+    end
+end
+
+То(/^недождёмся$/) do
+  expect(@плодъ).to be_nil
+end
+
+То(/^той вернёт ложно$/) do
+  expect(@плодъ).to be_falsey
+end
+
+То(/^той вернёт исте$/) do
+  expect(@плодъ).to be_truthy
+end
+
+Если(/^спробуем вызвать метод :mtime кута временного$/) do
+  @кут = tmpfile
+  @время = File.mtime(@кут)
+end
+
+Если(/^спробуем вызвать метод :atime кута временного$/) do
+  @кут = tmpfile
+  @время = File.atime(@кут)
+end
+
+Если(/^спробуем вызвать метод :ctime кута временного$/) do
+  @кут = tmpfile
+  @время = File.ctime(@кут)
+end
+
+То(/^той вернёт верно время/) do
+  время = @время.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+  expect(время).to be_eql(`stat -c %y #{@кут}`.strip)
+end
+
+Если(/^ꙇє примѣнена подпримѣсь невѣрна бисера рдоба$/) do
+  @проц = proc { rdoba mixin: [:false] }
+end
+
+То(/^исключение невѣрнѣ опции вызвано будетъ$/) do
+  expect { @проц.call }.to raise_error(Rdoba::Mixin::InvalidOption)
+end
+
+# #!/usr/bin/ruby -KU
+#
+# if $0 == __FILE__
+#     p s.to_res
+#     [1,2,3,4,5].each_comby do |c|
+# 	p c
+#     end
+#
+#     len = 4
+#     value = 100
+#     p sprintf("%.*X", len, value )
+#
+#     s = ' 1221 eeee 4564 wwww ' + 258.to_p
+#     ppp = s.scanf(' %d %s %d %s %.2+c')
+#     p ppp
+#     p 258.to_p.to_i(String::BE)
+#
+#     null = nil
+#     p null.class, null
+#     null <<= 'qweqweqweqwe'
+#     p null.class, null
+#     null << 'qweqweqweqwe'
+#     p null.class, null
+#     i = 12
+#     p sprintf("0x%X", i)
+#     p sprintf("%.3X", i)
+#
+#     p '----------'
+#
+#     str = <<STR
+# <font size="4" face="Irmologion Ucs">и3зhде
+# повелёніе t кeсарz ѓvгуста, написaти всю2
+# вселeнную</font>
+# STR
+#
+
+#
+#     str = '/font><font size="4">III</font><i>  </i>греч.<font size="4"><i></i>  </font><font size="4" face="Irmologion Ucs">Мёсzца ѓvгуста въ Gi-й дeнь. Слyжба с™и1телю и3 чудотв0рцу тЂхwну, є3пcкпу вор0нежскому.</font>13 августа, Тихона Воронежского, заголовок службы m_aug\13p.hip'
+#     re = /<font size="4" face="Irmologion Ucs">([ -"'-\?A-BD-HJ-\[\]`-hj-\}¤¦-§©«-®±µ-·»Ё-ЌЎ-яё-ќў-џҐ-ґ–-—‘-‚“-„†-•…‰‹-›€№™∙]+?)<\/font>/
+#
+#     p(str.match re)
+# end
+#

data/features/support/env.rb

@@ -1,161 +1,51 @@
+# frozen_string_literal: true
+
 require 'rdoba'
-require 'tempfile'
+require 'tmpdir'
 require 'open3'
 require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+require 'rspec/expectations'
 
-RdobaSimSimpleHead=<<HEAD
-#!/usr/bin/env ruby
-
-require 'rdoba'
-HEAD
-
-RdobaSimInHead=<<HEAD
-#!/usr/bin/env ruby
+# specific external test/development libraries
+#
+#
+Coveralls.wear!
+SimpleCov.start
+##############################################
 
-require 'rdoba'
-class Cls
-  def initialize
-    self > {:variable=>"value"}
-  end
-end
+RdobaSimSimpleHead = <<~HEAD
+  #!/usr/bin/env ruby
+  
+  require 'rdoba'
 HEAD
 
-RdobaSimClsHead=<<HEAD
-#!/usr/bin/env ruby
-
-require 'rdoba'
-class Cls
+RdobaSimClsHead = <<~HEAD
+  #!/usr/bin/env ruby
+  
+  require 'rdoba'
+  class Cls
 HEAD
 
-def format str
+def format(str)
   puts str
-  "   " * @deep + str + "\n" ; end
+  '   ' * @deep + str + "\n"
+end
 
 def store
-  file = @inithead + @init + @echo + ( "end\n" * @deep )
+  file = @inithead + @init + @echo + ("end\n" * @deep)
   puts file
-  File.open( 'tmp.rb', 'w+' ) do |f|
-    f.puts file ; end ; end
-
-def match_keywords keystr
-  keys = ( keystr || '' ).split( /[,:\s]/ ).map do |k|
-  [ :basic, :extended, :enter, :leave, :compat, :timestamp, :pid,
-      :function_name, :function_line ].include?( k.to_sym ) && k.to_sym || nil
-    end.compact ; end
-
-def rdoba_sim sub, cmd, *args
-  echo = nil
-  case sub
-  when :log, :debug
-    case cmd
-    when :init
-      opts = match_keywords args[ 1 ]
-      opts = opts.size > 1 && opts || opts.size > 0 && opts[ 0 ] || nil
-
-      if args[ 2 ] == 'class'
-        @deep = 1
-        @inithead = RdobaSimClsHead
-      else
-        @deep = 0
-        @inithead = RdobaSimSimpleHead ; end
-
-      param = case args[ 0 ]
-      when 'io'
-        { :io => "File.new( 'tmp.log', 'w+' )", :functions => :basic }
-      when 'as'
-        { :as => ":log", :functions => :basic }
-      when 'in'
-        @inithead = RdobaSimInHead
-        { :in => "Cls", :functions => :basic }
-      when 'prefix'
-#        basic|extended|enter|leave|compat
-        { args[ 0 ].to_sym => opts, :functions => :basic }
-      when 'functions'
-        { args[ 0 ].to_sym => opts }
-      else
-        { :functions => :basic }
-      end
-
-      param = "{" + ( param ).to_a.map do |v|
-        "#{v[ 0 ].inspect} => #{v[ 1 ].is_a?( String ) &&
-            v[ 1 ] || v[ 1 ].inspect}" end.join(',') + "}"
-      @init = "   " * @deep + "rdoba :#{sub} => #{param}\n"
-      puts @init
-      @echo = ''
-
-    when :func
-      call = case args[ 0 ]
-      when 'keyword'
-        'log'
-      when 'invalid keyword'
-        'errlog'
-      when /^db/
-        @echo << "self.dbgl = 0xff\n"
-        args[ 0 ]
-      else
-        'self'
-      end
-
-      sep = ( args[ 1 ] == :e ) && '.' || ' '
-      param = []
-      args[ 2..-1 ].each do |arg|
-        case arg
-        when NilClass
-        when Symbol
-          param << " #{arg}"
-        else
-          param << " #{arg.inspect}" ; end ; end
-      str = "#{call}#{sep}#{args[ 1 ]}#{param.join(',')}"
-      echo = format str
-      @echo << echo
-      while @deep > 0
-        @deep -= 1
-        @echo << ( format "end" ) ; end
-
-    when :create
-      @echo << ( format "Cls.new" )
-
-    when :call
-      @echo << ( format "Cls.singleton" )
-
-    when :def
-      if @inithead == RdobaSimClsHead
-        @deep = 1
-      else
-        @deep = 0 ; end
-      echo = case args[ 0 ]
-      when :init
-        format 'def initialize'
-      when :single
-        format 'def self.singleton'
-      end
-      @deep += 1
-      @echo << echo
-
-    when :exec
-      if !@echo.empty?
-        store
-        puts '-' * 15
-
-        File.chmod 0755, 'tmp.rb'
-        Open3.popen3( "./tmp.rb" ) do |stdin, stdout, stderr, wait_thr|
-          @out = stdout.read
-          @err = stderr.read
-        end
-        @echo = ''
-      end
-      res = case args[ 0 ]
-      when :file
-        File.new( 'tmp.log', 'r' ).read
-      when :stdout
-        @out
-      when :stderr
-        @err;
-      else return; end
-      puts res
-      res
-    end
+  File.open(@tmpfile, 'w+') do |f|
+    f.puts file
   end
 end
 
+def match_keywords(keystr)
+  keys =
+    (keystr || '').split(/[,:\s]/).map do |k|
+      %i[basic extended enter leave compat timestamp pid function_name function_line function].include?(k.to_sym) &&
+        k.to_sym || nil
+    end.compact
+end
+
+at_exit { $tmpdir && (FileUtils.remove_entry_secure $tmpdir) }

data/features/support/mixin_support.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MixinSupport
+  def random_string(count)
+    Random.new.bytes((count + 1) / 2).split('').map do |b| b.ord.to_s(16)end.join[0...count]
+  end
+
+  def tmpfile
+    filename = File.join(Dir.mktmpdir, random_string(20))
+    File.open(filename, 'w') do |f|
+      f.print(random_string(20))
+    end
+    filename
+  end
+end
+
+World(MixinSupport)

data/lib/rdoba/_version_.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rdoba
-  VERSION = "0.9.1"
+  VERSION = '0.9.4'
 end

data/lib/rdoba/a.rb

@@ -1,42 +1,42 @@
 #!/usr/bin/ruby -KU
-#coding:utf-8
+# frozen_string_literal: true
 
 require 'rdoba/debug'
 
 class Array
-  def geta(index, options = {}) #TODO => [] + class Index
-    dbp11 "[geta] <<< array = #{self.inspect}, index = #{index.inspect}, options = #{options.inspect}"
+  # TODO: => [] + class Index
+  def geta(index, options = {})
+    dbp11 "[geta] <<< array = #{inspect}, index = #{index.inspect}, options = #{options.inspect}"
     options[:сокр] ||= @сокр
 
-    if index.class == Array
-      return self if index == [] or index == ['']
+    if index.instance_of?(Array)
+      return self if [[], ['']].include?(index)
+
       index = index.clone
       value = self[index.shift]
-      (value.class == Hash or value.class == Array) ? value.geta(index, options) : value
+      (value.instance_of?(Hash) or value.instance_of?(Array)) ? value.geta(index, options) : value
     else
       geta_value(index, options)
     end
   end
-
 end
 
-
 class Hash
-
-protected
+  protected
 
   def geta_value(cid, options = {})
-    res = ((not cid) || cid.empty?) && self || self[cid] ||
+    res =
+      (!cid || cid.empty?) && self || self[cid] ||
         (options[:сокр] && (self[options[:сокр][cid]] || self[options[:сокр].reverse[cid]]))
 
-    if not res and options[:try_regexp]
-      self.keys.each do |key|
+    if !res and options[:try_regexp]
+      keys.each do |key|
         break res = self[key] if key.rmatch(cid)
-        if options[:сокр]
-          options[:сокр].each_pair do |val1, val2|
-            break res = self[key] if key.rmatch(cid.gsub(/#{val1}/, val2)) or
-                key.rmatch(cid.gsub(/#{val2}/, val1))
-          end
+
+        next unless options[:сокр]
+
+        options[:сокр].each_pair do |val1, val2|
+          break res = self[key] if key.rmatch(cid.gsub(/#{val1}/, val2)) or key.rmatch(cid.gsub(/#{val2}/, val1))
         end
       end
     end
@@ -44,47 +44,51 @@ protected
     res
   end
 
-public
+  public
 
-  def geta(index, options = {}) #TODO => [] + class Index
-    dbp11 "[geta] <<< hash = #{self.inspect}, index = #{index.inspect}, options = #{options.inspect}"
+  # TODO: => [] + class Index
+  def geta(index, options = {})
+    dbp11 "[geta] <<< hash = #{inspect}, index = #{index.inspect}, options = #{options.inspect}"
     options[:сокр] ||= @сокр
 
-    if index.class == Array
-      return self if index == [] or index == ['']
+    if index.instance_of?(Array)
+      return self if [[], ['']].include?(index)
+
       index = index.clone
       value = geta_value(index.shift, options)
-      (value.class == Hash or value.class == Array) ? value.geta(index, options) : value
+      (value.instance_of?(Hash) or value.instance_of?(Array)) ? value.geta(index, options) : value
     else
       geta_value(index, options)
     end
   end
 
-  def seta(index, value, options = {}) #TODO => [] + class Index
+  # TODO: => [] + class Index
+  def seta(index, value, options = {})
     dbp11 "[seta] <<< index: #{index.inspect}, value: #{value.inspect}, options: #{options.inspect}"
     options[:сокр] ||= @сокр
 
-    return self[index] = value if index.class != Array # TODO spec index
+    return self[index] = value if index.class != Array # TODO: spec index
 
     back = 0
-    index = index.reverse.map do |x|
-      if x.empty?
-        back += 1
-        nil
-      elsif back > 0
-        back -= 1
-        nil
-      else
-        x
-      end
-    end.compact.reverse
+    index =
+      index.reverse.map do |x|
+        if x.empty?
+          back += 1
+          nil
+        elsif back > 0
+          back -= 1
+          nil
+        else
+          x
+        end
+      end.compact.reverse
     dbp12 "[seta]> result index: #{index.inspect}"
 
     obj = nil
     o = self
     dbp14 "[seta]>> self: #{o.inspect}"
     set_idx = index.pop
-    par_class = set_idx =~ /^\d+$/ ? Array : Hash
+    par_class = /^\d+$/.match?(set_idx) ? Array : Hash
     par_idx = nil
     index.each do |idx|
       unless o
@@ -93,7 +97,7 @@ public
         obj[par_idx] = o
       end
       obj = o
-      o = (obj.class == Hash) ? obj.geta_value(idx, options) : obj[idx]
+      o = obj.instance_of?(Hash) ? obj.geta_value(idx, options) : obj[idx]
       dbp14 "[seta]>> cur idx: #{idx.inspect}, parent obj: #{obj.inspect}, obj: #{o.inspect}"
       unless o
         if idx == index.last
@@ -105,10 +109,8 @@ public
       end
     end
 
-    raise "Invalid path" unless o # TODO special exception
+    raise 'Invalid path' unless o # TODO: special exception
 
     o[set_idx] = value
   end
-
 end
-