rdoba 0.1 → 0.9

data/features/step_definitions/bcd_steps.rb

@@ -0,0 +1,69 @@
+#encoding: utf-8
+
+require 'test/unit/assertions'
+
+World( Test::Unit::Assertions )
+
+Given 'Apply Rdoba bcd module' do
+  require 'rdoba'
+end
+
+When  'Rdoba applied in a code' do
+  rdoba :bcd
+end
+
+Then 'Create a new simple BCD string' do
+  @bcd = BCDString.new 12345
+  assert @bcd == "\x45\x23\x01",
+  "The BCD, which has been converted from an integer, has invalid value"
+end
+
+Then 'Parse an integer' do
+  @bcd = BCD.parse 12345
+  assert @bcd == "\x45\x23\x01",
+  "The BCD, which has been converted from an integer, has invalid value"
+end
+
+Then 'Parse a negative integer' do
+  begin
+    assert BCD.parse( -12345 ),
+    "A negative integer has been parse, that is wrong"
+  rescue BCD::ParseError
+  end
+end
+
+Then 'Check class to BCD of parsed integer' do
+  assert @bcd.class == BCDString,
+  "BCD of parsed integer has invalid class #{@bcd.class}"
+end
+
+Then 'Convert the simple BCD to an integer' do
+  assert @bcd.to_i == 12345,
+  "The integer that has been converted from BCD has invalid value"
+end
+
+Then 'Create a new bignum BCD string' do
+  @bcd = BCDString.new 12345098761029384756
+  assert @bcd == "\x56\x47\x38\x29\x10\x76\x98\x50\x34\x12"
+  .force_encoding( 'ASCII-8BIT' ),
+  "The BCD, which has been converted from Bignum integer, has invalid value"
+end
+
+Then 'Convert the BCD to a Bignum integer' do
+  bignum = @bcd.to_i
+  assert bignum.class == Bignum,
+  "BCD number converted has invalid class value '#{bignum.class}'"
+  assert bignum == 12345098761029384756,
+  "BCD number converted to integer has invalid value"
+end
+
+Then 'Try to create a BCD class with an erroneous argument' do
+  bcd_string = "\x56\x47\x38\x29\x10\x76\x98\x50\x34\xA2"
+  bcd_string.extend BCD
+  begin
+    assert bcd_string.to_i == 0,
+    "BCD string has been converted into an integer, that is wrong"
+  rescue BCD::ConvertError
+  end
+end
+

data/features/step_definitions/log_steps.rb

@@ -0,0 +1,164 @@
+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
+end
+
+When /issue a call to the function/ do
+  rdoba_sim :log, :call
+end
+
+When /issue a creation of the class/ do
+  rdoba_sim :log, :create
+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
+
+  func = :func
+  case subject
+  when 'variable'
+    rdoba_sim :log, func, cond, :>, { variable: 'value' }
+  when 'number'
+    rdoba_sim :log, func, cond, :>, 1
+  when 'string'
+    rdoba_sim :log, func, cond, :>, "string"
+  when 'array'
+    rdoba_sim :log, func, cond, :>, [ 'array value1', 'array value2' ] ; 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' }
+  when 'info'
+    rdoba_sim :log, :func, :self, :*, { variable: 'value' }
+  when 'warn'
+    rdoba_sim :log, :func, :self, :%, { variable: 'value' }
+  when 'enter'
+    rdoba_sim :log, :func, :self, :+, { variable: 'value' }
+  when 'leave'
+    rdoba_sim :log, :func, :self, :-, true # TODO check return
+  when 'compat'
+    rdoba_sim :log, :func, :dbp11, "'variable: \"value\"'" ; end ; 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
+    else
+      rdoba_sim :log, :func, :self, :e, :'Exception.new' ; end
+  when 'standard error'
+    if note =~ /notification/
+      rdoba_sim :log, :func, :self, :e, :'StandardError.new',
+          [ 'standard error extended info' ]
+    else
+      rdoba_sim :log, :func, :self, :e, :'StandardError.new' ; end ; end ; end
+
+When /look into(?: the)? (stdout|stderr|file|IO)/ do |ioname|
+  @res = case ioname
+  when 'file'
+    rdoba_sim :log, :exec, :file
+  when 'IO'
+    rdoba_sim :log, :exec, :io
+  when 'stdout'
+    rdoba_sim :log, :exec, :stdout
+  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|
+  if act == 'remove'
+    rdoba_sim :log, :func, :self, :>=, [ key.to_sym ]
+  else
+    rdoba_sim :log, :func, :self, :<=, [ key.to_sym ] ; end ; end
+
+When /clear the :(functions) option/ do |opt|
+  rdoba_sim :log, :func, :self, :>=, [ :* ]
+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|
+  case subject
+  when 'variable'
+    sym = notice && { 'basic' => '>', 'extended' => '>>', 'info' => '***',
+        'warn' => '%%%', 'enter' => '<<<', 'leave' => '>>>' }[ notice ] || '>'
+    symr = sym.to_s.gsub ( '*' ) do |x| "\\#{x}" end
+    prefices = match_keywords prefices
+    if prefices.empty?
+      if @res !~ /variable: "value"/
+        raise "Invalid answer: #{@res}, must be \"variable: \"value\"" ; end
+    else
+      case prefices
+      when [:timestamp]
+        if @res !~ /\[\d\d:\d\d:\d\d\.\d{9}\]#{symr} variable: "value"/
+          raise "Invalid answer: #{@res.chomp}, must be like " +
+              "[00:00:00.000000000]#{sym} variable: \"value\"" ; end
+      when [:timestamp, :pid]
+        if @res !~ /\[\d\d:\d\d:\d\d\.\d{9}\]\{\d+\}#{symr} variable: "value"/
+          raise "Invalid answer: #{@res.chomp}, must be like " +
+              "[00:00:00.000000000]{0000}#{sym} variable: \"value\"" ; end
+      when [:timestamp, :pid, :function_name]
+        if @res !~ /\[\d\d:\d\d:\d\d\.\d{9}\]\{\d+\}\(.+\)#{symr} variable: "value"/
+          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"/
+          raise "Invalid answer: #{@res.chomp}, must be like " +
+              "[00:00:00.000000000]{0000}(name:0)#{sym} variable: \"value\"" ; end
+      else
+        raise "Invalid answer: #{@res}"
+      end
+    end
+  when 'string'
+    if @res !~ /string/
+      raise "Invalid answer: #{@res}, must be \"string\"" ; end
+  when 'number'
+    if @res !~ /1/
+      raise "Invalid answer: #{@res.inspect}, must be \"1\"" ; end
+  when "'true' value"
+    if @res !~ /true/
+      raise "Invalid answer: #{@res.inspect}, must be \"true\"" ; end
+  when 'array'
+    if @res !~ /array value1, array value2/
+      raise "Invalid answer: #{@res.inspect}, must be an enum: \"array value1, array value2\"" ; end ; end ; end
+
+Then /see the (standard error|exception) info(.*)/ do |subject, notice|
+  case subject
+  when 'exception'
+    if @res !~/Exception:%> Exception/
+      raise "Invalid answer: #{@res.inspect}, must be like " +
+          "'Exception:%> Exception'" ; end
+  when 'standard error'
+    if notice =~ /notification/
+      if @res !~ /StandardError:%> StandardError\n\tstandard error extended info/
+        raise "Invalid answer: #{@res.inspect}, must be like " +
+            "'StandardError:%> StandardError\n\tstandard error " +
+            "extended info'" ; end
+    else
+      if @res !~ /StandardError:%> StandardError/
+        raise "Invalid answer: #{@res.inspect}, must be like " +
+            "'StandardError:%> StandardError'" ; end ; end ; end ; end
+
+Then /see(?: a| the)? (nothing|warning|.* error exception)/ do |subject|
+  case subject
+  when 'nothing'
+    if !@res.empty?
+      raise "Invalid answer: #{@res.inspect}, must be empty" ; end
+  when 'warning'
+    if @res !~ /Warning:/
+      raise "Invalid answer: #{@res.inspect}, must be a warning " +
+          "with the description" ; end
+    'log\': main is not a class/module (TypeError)'
+  when /no method error/
+    if @res !~ /undefined method .* \(NoMethodError\)/
+      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\)/
+      raise "Invalid answer: #{@res.inspect}, must notify" +
+          " that the the specified name isn't declared" ; end
+  else
+    raise "Invalid answer: #{@res.inspect}" ; end ; end
+

data/features/support/env.rb

@@ -0,0 +1,159 @@
+require 'rdoba'
+require 'tempfile'
+require 'open3'
+
+RdobaSimSimpleHead=<<HEAD
+#!/usr/bin/env ruby
+
+require 'rdoba'
+HEAD
+
+RdobaSimInHead=<<HEAD
+#!/usr/bin/env ruby
+
+require 'rdoba'
+class Cls
+  def initialize
+    self > {:variable=>"value"}
+  end
+end
+HEAD
+
+RdobaSimClsHead=<<HEAD
+#!/usr/bin/env ruby
+
+require 'rdoba'
+class Cls
+HEAD
+
+def format str
+  puts str
+  "   " * @deep + str + "\n" ; end
+
+def store
+  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
+  end
+end
+

data/lib/rdoba.rb

@@ -1,17 +1,33 @@
-#!/usr/bin/ruby -KU
-#<Encoding:UTF-8>
+#encoding: utf-8
 
-require 'rdoba/a'
-require 'rdoba/io'
-require 'rdoba/dup'
-require 'rdoba/require'
-require 'rdoba/common'
-require 'rdoba/debug'
-require 'rdoba/yaml'
-require 'rdoba/strings'
-require 'rdoba/deploy'
-require 'rdoba/roman'
-require 'rdoba/combinations'
-require 'rdoba/hashorder'
-require 'rdoba/fenc'
+#require 'rdoba/a'
+#require 'rdoba/dup'
+#require 'rdoba/require'
+#require 'rdoba/common'
+#require 'rdoba/debug'
+#require 'rdoba/yaml'
+#require 'rdoba/strings'
+#require 'rdoba/deploy'
+#require 'rdoba/roman'
+#require 'rdoba/combinations'
+#require 'rdoba/hashorder'
+#require 'rdoba/fenc'
 
+module Kernel
+  Modules = [ :io, :seqnum, :version, :bcd ]
+
+  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 :log, :debug
+        require "rdoba/#{key}"
+        Rdoba.log( { :in => self }.merge( value || {} ) ) # TODO move log method into module
+        # and resolve some troubles with eval in main
+      when :classmatch
+        require 'rdoba/classmatch'
+        self.extend Rdoba::ClassMatch
+      else nil; end || if Modules.include? key
+        require "rdoba/#{key}"; end; end; end; end

data/lib/rdoba/_version_.rb

@@ -0,0 +1,3 @@
+module Rdoba
+  VERSION = "0.9"
+end