rdoba 0.9.1 → 0.9.2

data/features/mixin.feature

@@ -0,0 +1,85 @@
+# language: ru
+Функционал: Примесь рдобы
+   Сценарий: Провѣрка подпримѣси .пуздро (case)
+      Допустим ꙇє примѣнена подпримѣсь .пуздро бисера рдоба
+      Если къ кирилическу слову въ верхнемъ пуздрѣ ꙇє примѣненъ приꙇомъ :ниспуздри
+      То кирилическо слово имаꙇє буквы въ нижнемъ пуздрѣ
+      Если къ кирилическу слову въ нижнемъ пуздрѣ ꙇє примѣненъ приꙇомъ :воспуздри
+      То кирилическо слово имаꙇє буквы въ верхнемъ пуздрѣ
+      Если къ кирилическу слову въ смѣшанѣмъ пуздрѣ ꙇє примѣненъ приꙇомъ :воспуздри
+      То кирилическо слово имаꙇє буквы въ верхнемъ пуздрѣ
+      Если къ латыньску слову въ верхнемъ пуздрѣ ꙇє примѣненъ приꙇомъ :ниспуздри
+      То латыньско слово имаꙇє буквы въ нижнемъ пуздрѣ
+      Если къ латыньску слову въ нижнемъ пуздрѣ ꙇє примѣненъ приꙇомъ :воспуздри
+      То латыньско слово имаꙇє буквы въ верхнемъ пуздрѣ
+      Если къ кирилическу слову въ смѣшанѣмъ пуздрѣ ꙇє примѣненъ приꙇомъ :ниспуздри
+      То кирилическо слово имаꙇє буквы въ нижнемъ пуздрѣ
+
+   Сценарий: Провѣрка подпримѣси .обратка (reverse)
+      Допустим ꙇє примѣнена подпримѣсь .обратка бисера рдоба
+      То Стразовъ приꙇомъ :обратка повратє обратну Стразу
+      И Стразовъ приꙇомъ :обратка сѫ кракомъ повратє обратну Стразу
+      И Стразовъ приꙇомъ :обратка сѫ доведомъ повратє обратну Стразу
+
+   Сценарий: Провѣрка подпримѣси .ли_пущь (empty)
+      Допустим ꙇє примѣнена подпримѣсь .ли_пущь бисера рдоба
+      То приꙇомъ :ли_пущь рода пущь повратє вѣрнъ
+      И приꙇомъ :ли_пущь рода лжа повратє лжъ
+      И приꙇомъ :ли_пущь рода нове вещи повратє лжъ
+
+   Сценарий: Провѣрка подпримѣси .во_сл (to_h)
+      Допустим ꙇє примѣнена подпримѣсь .во_сл бисера рдоба
+      Если ровнъ наборъ ꙇє пречиненъ во словникъ
+      То тъꙇи имѣꙇє ровнъ словникъ сѫ пущими значѣми
+      Если двуглубнъ наборъ ꙇє пречиненъ во словникъ
+      То тъꙇи имѣꙇє ровнъ словникъ сѫ ровнѣми значѣми
+      Если триглубнъ наборъ ꙇє пречиненъ во словникъ
+      То тъꙇи имѣꙇє ровнъ словникъ сѫ двуглубнѣми значѣми
+      Если двуглубнъ наборъ сѫ одинакыми частьми ꙇє пречиненъ во словникъ
+      То тъꙇи имѣꙇє ровнъ словникъ сѫ двами двуглубнѣмы значѣмы
+      Если двуглубнъ наборъ сѫ одинакыми частьми ꙇє пречиненъ во словникъ приꙇомомъ :во_сл сѫ клѵчемъ :кромѣ_двоꙇниковъ
+      То тъꙇи имѣꙇє ровнъ словникъ сѫ однимъ двуглубнѣмъ значѣмъ
+
+   Сценарий: Провѣрка подпримѣси .режь_по (split_by)
+      Допустим ꙇє примѣнена подпримѣсь .режь_по бисера рдоба
+      И у нас есть набор чисел
+      Если рассечём его на чётные и нечётные
+      То получим два набора чётных и нечётных чисел
+
+   Сценарий: Провѣрка подпримѣси .пробь (try)
+      Допустим ꙇє примѣнена подпримѣсь .пробь бисера рдоба
+      Если спробуем вызвать метод :qwer пущя
+      То той вернёт пущь
+
+   Сценарий: Провѣрка подпримѣси .жди_ьже (wait_if)
+      Допустим ꙇє примѣнена подпримѣсь .жди_ьже бисера рдоба
+      Если спробуем подождать мало, чтобы условие выполнилось
+      То той вернёт ложно
+
+      Если спробуем подождать мало, чтобы условие не выполнилось
+      То той вернёт исте
+
+      Если спробуем подождать долго, чтобы условие выполнилось
+      То недождёмся
+
+   Сценарий: Провѣрка подпримѣси .время (time)
+      Допустим ꙇє примѣнена подпримѣсь .время бисера рдоба
+      Если спробуем вызвать метод :mtime кута временного
+      То той вернёт верно время изменения
+
+      Если спробуем вызвать метод :atime кута временного
+      То той вернёт верно время доступа
+
+      Если спробуем вызвать метод :ctime кута временного
+      То той вернёт верно время создания
+
+   Сценарий: Провѣрка подпримѣси .сравнена (compare)
+      Допустим ꙇє примѣнена подпримѣсь .сравнена бисера рдоба
+      Если имѣмы двѣ Стразы
+      То приꙇомъ :сравнена двухъ Стразъ повратє безъ одна
+      И приꙇомъ :сравнена двухъ Стразъ сѫ презоромъ надъстрочниковъ повратє одна
+      И приꙇомъ :сравнена двухъ Стразъ сѫ презоромъ надъстрочниковъ ꙇакъ словникъ повратє одна
+
+   Сценарий: Провѣрка невѣрной подпримѣси
+      Если ꙇє примѣнена подпримѣсь невѣрна бисера рдоба
+      То исключение невѣрнѣ опции вызвано будетъ

data/features/step_definitions/log_steps.rb

@@ -1,5 +1,8 @@
-When /appl(?:y|ied) Rdoba (Log|Debug) module(?: with set([\w\s,:]+ keywords?| a file name) for :(io|as|in|functions|prefix) option| with an (invalid) :io option value)?(?: inside a (class))?/ do |kind, subs, opt, invalid, cls|
-  rdoba_sim kind.downcase.to_sym, :init, opt, subs, cls
+When /appl(y|ied) Rdoba (Log|Debug) module(?: with set([\w\s,:]+ keywords?| a file name) for :(io|as|in|functions|prefix) options?| with an (invalid) :io option value)?(?: inside a (class))?(?:, and :as option pointing to (self|log))?/ do |var, kind, subs, opt, invalid, cls, as |
+  if var == 'ied'
+    rdoba_sim kind.downcase.to_sym, :init, subs, cls
+  end
+  rdoba_sim kind.downcase.to_sym, :apply, opt, subs, as
 end
 
 When /issue a call to the function/ do
@@ -10,13 +13,19 @@ When /issue a creation of the class/ do
   rdoba_sim :log, :create
 end
 
+When /declare the (Cls) class/ do| cls |
+  rdoba_sim :log, :declare, cls
+end
+
 When /(issue|define) an output of an? (variable|number|string|array)(?: inside an? (initializer|singleton function))?(?: using (?:the|an?) (keyword|invalid keyword|class))?/ do |issue, subject, inside, cond|
 
   case inside
   when 'initializer'
     rdoba_sim :log, :def, :init
   when 'singleton function'
-    rdoba_sim :log, :def, :single ; end
+    rdoba_sim :log, :def, :single
+  else
+    rdoba_sim :log, :def ; end
 
   func = :func
   case subject
@@ -27,36 +36,41 @@ When /(issue|define) an output of an? (variable|number|string|array)(?: inside a
   when 'string'
     rdoba_sim :log, func, cond, :>, "string"
   when 'array'
-    rdoba_sim :log, func, cond, :>, [ 'array value1', 'array value2' ] ; end ; end
+    rdoba_sim :log, func, cond, :>, [ 'array value1', 'array value2' ] ; end
 
-When /issue an? :(extended|info|warn|enter|leave|compat) output of a variable/ do |key|
+  if issue == 'issue'
+    rdoba_sim :log, :close ; end ; end
+
+When /issue an? :(extended|info|warn|enter|leave|compat) output of a variable?/ do |key|
   case key
   when 'extended'
-    rdoba_sim :log, :func, :self, :>>, { variable: 'value' }
+    rdoba_sim :log, :func, :log, :>>, { variable: 'value' }
   when 'info'
-    rdoba_sim :log, :func, :self, :*, { variable: 'value' }
+    rdoba_sim :log, :func, :log, :*, { variable: 'value' }
   when 'warn'
-    rdoba_sim :log, :func, :self, :%, { variable: 'value' }
+    rdoba_sim :log, :func, :log, :%, { variable: 'value' }
   when 'enter'
-    rdoba_sim :log, :func, :self, :+, { variable: 'value' }
+    rdoba_sim :log, :func, :log, :+, { variable: 'value' }
   when 'leave'
-    rdoba_sim :log, :func, :self, :-, true # TODO check return
+    rdoba_sim :log, :func, :log, :-, true # TODO check return
   when 'compat'
-    rdoba_sim :log, :func, :dbp11, "'variable: \"value\"'" ; end ; end
+    rdoba_sim :log, :func, :dbp11, "'variable: \"value\"'" ; end
+
+  rdoba_sim :log, :close ; end
 
 When /issue an output of the thrown (exception|standard error)(.*)/ do |type, note|
   case type
   when 'exception'
     if note =~ /out/
-      rdoba_sim :log, :func, :self, :e, :'Exception.new', :$stdout
+      rdoba_sim :log, :func, :log, :e, :'Exception.new', :$stdout
     else
-      rdoba_sim :log, :func, :self, :e, :'Exception.new' ; end
+      rdoba_sim :log, :func, :log, :e, :'Exception.new' ; end
   when 'standard error'
     if note =~ /notification/
-      rdoba_sim :log, :func, :self, :e, :'StandardError.new',
+      rdoba_sim :log, :func, :log, :e, :'StandardError.new',
           [ 'standard error extended info' ]
     else
-      rdoba_sim :log, :func, :self, :e, :'StandardError.new' ; end ; end ; end
+      rdoba_sim :log, :func, :log, :e, :'StandardError.new' ; end ; end ; end
 
 When /look into(?: the)? (stdout|stderr|file|IO)/ do |ioname|
   @res = case ioname
@@ -69,14 +83,14 @@ When /look into(?: the)? (stdout|stderr|file|IO)/ do |ioname|
   when 'stderr'
     rdoba_sim :log, :exec, :stderr; end ; end
 
-When /(remove|add) :(basic|extended|info|warn|enter|leave|compat) keyword.* :(functions) option/ do |act, key, opt|
+When /(remove|add) :(basic|extended|info|warn|enter|leave|compat) keyword.* :(functions) option(?: to the (self) object)?/ do |act, key, opt, obj|
   if act == 'remove'
-    rdoba_sim :log, :func, :self, :>=, [ key.to_sym ]
+    rdoba_sim :log, :func, obj, :>=, [ key.to_sym ]
   else
-    rdoba_sim :log, :func, :self, :<=, [ key.to_sym ] ; end ; end
+    rdoba_sim :log, :func, obj, :<=, [ key.to_sym ] ; end ; end
 
 When /clear the :(functions) option/ do |opt|
-  rdoba_sim :log, :func, :self, :>=, [ :* ]
+  rdoba_sim :log, :func, :log, :>=, [ :* ]
 end
 
 Then /see the (variable|string|number|array|'true' value) output(?: with the :(basic|extended|info|warn|enter|leave) notice)?(?: preficed with the :(.*))?/ do |subject, notice, prefices|
@@ -104,9 +118,11 @@ Then /see the (variable|string|number|array|'true' value) output(?: with the :(b
           raise "Invalid answer: #{@res.chomp}, must be like " +
               "[00:00:00.000000000]{0000}(name)#{sym} variable: \"value\"" ; end
       when [:timestamp, :pid, :function_name, :function_line]
-        if @res !~ /\[\d\d:\d\d:\d\d\.\d{9}\]\{\d+\}\([^:]+:\d+\)#{symr} variable: "value"/
+        if @res !~ /\[\d\d:\d\d:\d\d\.\d{9}\]\{\d+\}\([^\.]+\.\d+\)#{symr} variable: "value"/
           raise "Invalid answer: #{@res.chomp}, must be like " +
-              "[00:00:00.000000000]{0000}(name:0)#{sym} variable: \"value\"" ; end
+              "[00:00:00.000000000]{0000}(name.0)#{sym} variable: \"value\"" ; end
+      when [:timestamp, :pid, :function]
+        expect( @res ).to match( /\[\d\d:\d\d:\d\d\.\d{9}\]\{\d+\}\([^:]+:[^\.]+\.\d+\)#{symr} variable: "value"/ )
       else
         raise "Invalid answer: #{@res}"
       end
@@ -156,9 +172,29 @@ Then /see(?: a| the)? (nothing|warning|.* error exception)/ do |subject|
       raise "Invalid answer: #{@res.inspect}, must notify" +
           " that the interpreter has not found the specified method" ; end
   when /name error/
-    if @res !~ /undefined local variable or method .* \(NameError\)/
+    if @res !~ /.* \(NameError\)/
       raise "Invalid answer: #{@res.inspect}, must notify" +
           " that the the specified name isn't declared" ; end
   else
     raise "Invalid answer: #{@res.inspect}" ; end ; end
 
+
+Given(/^selected full Rdoba Log test plan( with self keyword)?$/) do |slf|
+   @testplan = 'features/support/' +
+   if slf
+      'fulltest_as_self.rb.in'
+   else
+      'fulltest_as_log.rb.in' ; end
+   if !File.exist? @testplan
+      raise "Invalid file #{@testplan} for the specified full test plan" ; end
+      end
+
+When(/^we run the test plan$/) do
+   Open3.popen3( @testplan ) do |stdin, stdout, stderr, wait_thr|
+      @out = stdout.read
+      @err = stderr.read ; end ; end
+
+Then(/^we see no error on its output$/) do
+   if !@err.empty?
+      raise "Error found: #{@err}" ; end ; end
+

data/features/step_definitions/mixin_steps.rb

@@ -0,0 +1,266 @@
+#coding: utf-8
+Допустим( /ꙇє примѣнена подпримѣсь \.([^\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 ꙇезикъ =~ /кирилическу/
+            if пуздро =~ /верхнемъ/
+               'КИРИЛИЧЕСКЫ БУКЫ ЗРИЙ СІИ: Ѡ И Ꙍ'
+            elsif пуздро =~ /нижнемъ/
+               'кирилическы букы зрий сіи: ѡ и ꙍ'
+            else
+               'КиРиЛиЧеСкЫ бУкЫ зРиЙ сІи: Ѡ и Ꙍ' ; end
+         else
+            if пуздро =~ /верхнемъ/
+               'LATIN LETTERS SEE THE FOLLOWING: ÆǞ'
+            elsif пуздро =~ /нижнемъ/
+               'latin letters see the following: æǟ'
+            else
+               'LaTiN lEtTeRs SeE tHe FoLlOwInG: æǞ' ; end ; end
+
+   @плодъ = ( приꙇомъ =~ /ниспуздри/ ) && стр.downcase || стр.upcase ; end
+
+Если(/^рассечём его на чётные и нечётные$/) do
+   ( @чётъ, @нечётъ ) = @набор.split_by { |x| x % 2 == 0 } ; end
+
+Если(/^спробуем вызвать метод :qwer пущя$/) do
+   @плодъ = nil.try( :qwer ) ; end
+
+То(/^(кирилическо|латыньско) слово имаꙇє буквы въ (нижнемъ|верхнемъ) пуздрѣ$/) do | ꙇезикъ, пуздро |
+   плодъ = if ꙇезикъ =~ /кирилическо/
+              ( пуздро =~ /верхнемъ/ ) &&
+                  'КИРИЛИЧЕСКЫ БУКЫ ЗРИЙ СІИ: Ѡ И Ꙍ'||
+                  'кирилическы букы зрий сіи: ѡ и ꙍ'
+           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
+   if !исходъ
+      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
+      { "aa" => nil, 0 => nil, "bb" => nil, 1 => nil }
+   elsif видъ =~ /ровнѣми/u
+      { "aa" => 0, "bb" => 1 }
+   else
+      { "aa" => [ 0, 1 ], "bb" => [ 1, 0 ] } ; end
+
+   if @вещь != @схъ
+      raise "Наборъ '#{@вещь}' требуꙇє быти '#{@схъ}'" ; end
+end
+
+То(/^тъꙇи имѣꙇє ровнъ словникъ сѫ (однимъ|двами) двуглубн(?:ѣмъ|ѣмы) знач(?:ѣмъ|ѣмы)$/) do | видъ |
+   @схъ =
+   if видъ =~ /двами/
+      { "aa" => [ 0, 0 ] }
+   else
+      { "aa" => [ 0 ] } ; end
+
+   if @вещь != @схъ
+      raise "Наборъ '#{@вещь}' требуꙇє быти '#{@схъ}'" ; end
+end
+
+Если(/^имѣмы двѣ Стразы$/) do
+   @стры = [ 'а҆́гнецъ', 'а҆гкѵ́ра' ] ; 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
+
+   if !исходъ
+      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.new { rdoba :mixin => [ :false ] } ; end
+
+То(/^исключение невѣрнѣ опции вызвано будетъ$/) do
+   expect{ @проц.call }.to raise_error( Rdoba::Mixin::InvalidOption ) ; end
+
+
+=begin
+#!/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
+
+=end

data/features/support/env.rb

@@ -1,8 +1,18 @@
 require 'rdoba'
-require 'tempfile'
+require 'tmpdir'
 require 'open3'
 require 'coveralls'
+require "codeclimate-test-reporter"
+require 'simplecov'
+require 'rspec/expectations'
+
+# specific external test/development libraries
+#
+#
 Coveralls.wear!
+CodeClimate::TestReporter.start
+SimpleCov.start
+##############################################
 
 RdobaSimSimpleHead=<<HEAD
 #!/usr/bin/env ruby
@@ -10,13 +20,10 @@ RdobaSimSimpleHead=<<HEAD
 require 'rdoba'
 HEAD
 
-RdobaSimInHead=<<HEAD
-#!/usr/bin/env ruby
-
-require 'rdoba'
+RdobaCodeClassDeclaration=<<HEAD
 class Cls
   def initialize
-    self > {:variable=>"value"}
+    log > {:variable=>"value"}
   end
 end
 HEAD
@@ -35,13 +42,13 @@ def format str
 def store
   file = @inithead + @init + @echo + ( "end\n" * @deep )
   puts file
-  File.open( 'tmp.rb', 'w+' ) do |f|
+  File.open( @tmpfile, '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
+      :function_name, :function_line, :function ].include?( k.to_sym ) && k.to_sym || nil
     end.compact ; end
 
 def rdoba_sim sub, cmd, *args
@@ -50,24 +57,31 @@ def rdoba_sim sub, cmd, *args
   when :log, :debug
     case cmd
     when :init
-      opts = match_keywords args[ 1 ]
-      opts = opts.size > 1 && opts || opts.size > 0 && opts[ 0 ] || nil
+      $tmpdir ||= Dir.mktmpdir
+      @tmpfile ||= File.join( $tmpdir, 'tmp.log' )
 
-      if args[ 2 ] == 'class'
+      if args[ 1 ] == 'class'
         @deep = 1
         @inithead = RdobaSimClsHead
       else
         @deep = 0
         @inithead = RdobaSimSimpleHead ; end
+      @echo = ''
+      @init = ''
+      puts @inithead
 
+    when :apply
+      opts = match_keywords args[ 1 ]
+#      opts = opts.size > 2 && opts || opts.size > 0 && opts[ 1 ] || nil
       param = case args[ 0 ]
       when 'io'
-        { :io => "File.new( 'tmp.log', 'w+' )", :functions => :basic }
+        { :io => "File.new( File.join( '#{@tmpfile}' ), 'w+' )", :functions => :basic }
       when 'as'
-        { :as => ":log", :functions => :basic }
+        { :as => ":self", :functions => :basic }
       when 'in'
-        @inithead = RdobaSimInHead
         { :in => "Cls", :functions => :basic }
+#      when /in.*as/
+#        { :in => "Cls", :as => args[ 2 ].to_sym, :functions => :basic }
       when 'prefix'
 #        basic|extended|enter|leave|compat
         { args[ 0 ].to_sym => opts, :functions => :basic }
@@ -77,24 +91,26 @@ def rdoba_sim sub, cmd, *args
         { :functions => :basic }
       end
 
+      if args[ 2 ]
+         param.merge!( :as => args[ 2 ].to_sym ) ; 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 = ''
+
+      @echo << "   " * @deep + "rdoba :#{sub} => #{param}\n"
 
     when :func
       call = case args[ 0 ]
       when 'keyword'
-        'log'
+        'self'
       when 'invalid keyword'
         'errlog'
       when /^db/
         @echo << "self.dbgl = 0xff\n"
         args[ 0 ]
       else
-        'self'
+        ( args[ 0 ] || :log ).to_sym
       end
 
       sep = ( args[ 1 ] == :e ) && '.' || ' '
@@ -109,10 +125,15 @@ def rdoba_sim sub, cmd, *args
       str = "#{call}#{sep}#{args[ 1 ]}#{param.join(',')}"
       echo = format str
       @echo << echo
+
+   when :close
       while @deep > 0
         @deep -= 1
         @echo << ( format "end" ) ; end
 
+    when :declare
+      @echo << ( format RdobaCodeClassDeclaration )
+
     when :create
       @echo << ( format "Cls.new" )
 
@@ -126,11 +147,13 @@ def rdoba_sim sub, cmd, *args
         @deep = 0 ; end
       echo = case args[ 0 ]
       when :init
+        @deep += 1
         format 'def initialize'
       when :single
+        @deep += 1
         format 'def self.singleton'
-      end
-      @deep += 1
+      else;
+        '' ; end
       @echo << echo
 
     when :exec
@@ -138,8 +161,8 @@ def rdoba_sim sub, cmd, *args
         store
         puts '-' * 15
 
-        File.chmod 0755, 'tmp.rb'
-        Open3.popen3( "./tmp.rb" ) do |stdin, stdout, stderr, wait_thr|
+        File.chmod 0755, @tmpfile
+        Open3.popen3( @tmpfile ) do |stdin, stdout, stderr, wait_thr|
           @out = stdout.read
           @err = stderr.read
         end
@@ -147,7 +170,7 @@ def rdoba_sim sub, cmd, *args
       end
       res = case args[ 0 ]
       when :file
-        File.new( 'tmp.log', 'r' ).read
+        File.new( @tmpfile, 'r' ).read
       when :stdout
         @out
       when :stderr
@@ -159,3 +182,4 @@ def rdoba_sim sub, cmd, *args
   end
 end
 
+at_exit { $tmpdir && ( FileUtils.remove_entry_secure $tmpdir ) }