rdoba 0.9.1 → 0.9.4

data/features/step_definitions/log_steps.rb

@@ -1,164 +0,0 @@
-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/lib/rdoba/log.rb

@@ -1,248 +0,0 @@
-# encoding: utf-8
-
-module Rdoba
-  def self.log options = {}
-    # options: {
-    #   :as - name of method to apply the log functions, default: self
-    #   :in - name of class or namespace to implement to the log, default: Kernel
-    #   :functions = [
-    #     :basic
-    #     :warn
-    #     :info
-    #     :enter
-    #     :leave
-    #     :extended
-    #     :compat - enable old style log strings dbgXX
-    #   ]
-    #   :prefix = [
-    #     :timestamp
-    #     :pid
-    #     :function_name
-    #     :function_line
-    #   ]
-    #   :io - An IO object to send log output to, default is $stdout
-    # }
-    # if empty the default value (enter, leave) is applied
-    # format of log message is the following:
-    # [<timestamp>]{pid}(<function name>)<log type> <debug text>"
-    # TODO add enum of options hash to convert values to symbols
-    # TODO make common format, and format for each of methods >, >>, +, -, %, *
-    # TODO add syntax redefinition ability for the methods >, >>, +, -, %, *
-    # TODO add multiple output (to more than only the IO)
-
-#    options[ :io ] = File.new('txt.log','w+')
-#    STDERR.puts options.inspect
-#    STDERR.puts options[ :io ].method( :puts ).inspect
-#    options.map
-    funcname = ( options[ :as ] || :self ).to_s.to_sym
-    pfx = ';if true;(Rdoba::Log::log @@rdoba_log_io_method,"' #TODO remove if
-    io = options[ :io ] || $stdout
-    io_m = io.method :puts
-    if prefix = ( options[ :prefix ].is_a?( Array ) && options[ :prefix ] ||
-          [ options[ :prefix ] ] )
-      if prefix.include?( :timestamp )
-        pfx << '[#{Time.now.strftime( "%H:%M:%S.%N" )}]'; end
-      if prefix.include?( :pid )
-        pfx << '{#{Process.pid}}'; end
-      if prefix.include?( :function_name )
-        if prefix.include?( :function_line )
-          pfx << '(#{m,f,l=get_stack_function_data_at_level(2);f+":"+l})'
-        else
-          pfx << '(#{get_stack_function_data_at_level(2)[1]})'; end ; end ; end
-
-    target = options[ :in ] || Kernel
-#    STDERR.puts "self: #{self.to_s}"
-#    STDERR.puts "funcname: #{funcname.inspect}"
-#    STDERR.puts "target: #{target.inspect}"
-
-    initfunc = Proc.new do
-      self.class_variable_set :@@rdoba_log_prefix, pfx
-      self.class_variable_set :@@rdoba_log_io_method, io_m
-      extend Rdoba::Log::ClassFunctions
-      include Rdoba::Log::Functions
-      self <= options[ :functions ] ; end
-
-    if funcname == :self
-      if target.to_s != 'main'
-        # CASE: class Cls; def method; self > end; end
-        target.instance_eval &initfunc ; end
-      # CASE: main { self > }
-      # CASE: class Cls; self > end
-      target.class.instance_eval &initfunc
-    else
-      host = ( target.to_s == 'main' && Kernel || target ) ## TODO check and remove
-      if target.to_s != 'main'
-        # CASE: class Cls; log > end
-        target.class.class_eval "class RdobaDebug;end"
-        target.class.send :class_eval, "def #{funcname};@#{funcname}||=RdobaDebug.new;end"
-        target.class::RdobaDebug.class_eval &initfunc ; end
-      # CASE: main { log > }
-      # CASE: class Cls; def method; log > end; end
-      host.class_eval "class RdobaDebug;end"
-      host.send :class_eval, "def #{funcname};@#{funcname}||=RdobaDebug.new;end"
-      host::RdobaDebug.class_eval &initfunc ; end
-
-#    STDERR.puts 2
-#    STDERR.puts target.inspect
-#    STDERR.puts target.class.methods.sort.inspect
-=begin
-    target.class.instance_eval do # main { self > }
-#    target.class_eval do # main { log > }
-      self.class_variable_set( :@@log_prefix, pfx )
-      self.class_variable_set( :@@log_io_method, io_m )
-      extend Rdoba::Log::ClassFunctions
-      include Rdoba::Log::Functions
-      STDERR.puts pfx
-      STDERR.puts io_m.inspect
-      self <= functions; end;
-=end
-      end; end
-
-module Rdoba
-  module Log
-    class Error < StandardError
-      def initialize options = {}
-        case options
-        when :compat
-          "Debug compatibility mode can't be enabled for " +
-          "the specified object"
-        when :main
-          "An :as option can't be default or set to 'self' value for " +
-          "a main application. Please set up it correctly"; end; end; end
-
-    module Functions
-      def <= functions = []
-        self.class <= functions; end
-
-      def >= functions = []
-        self.class >= functions; end
-
-      def e *args
-        io = case args.last
-             when IO
-               args.pop
-             else
-               $stderr ; end
-        e = $! || args.shift
-        dump = ( [ $@ || args.shift ] + args ).flatten.compact
-        io.send :puts, "#{e.class}:%> #{e}\n\t#{dump.join("\n\t")}"; end
-
-      def get_stack_function_data_at_level( level )
-        raise Exception
-      rescue Exception
-        #TODO check match a method containing '`'
-        $@[ level ] =~ /([^\/]+):(\d+):in `(.*?)'$/
-        [ $1, $3, $2 ]; end; end
-
-    module ClassFunctions
-      def <= functions
-        functions = Rdoba::Log::update_functions functions, self, :+
-        pfx = self.class_variable_get :@@rdoba_log_prefix
-        code = Rdoba::Log::make_code functions, pfx, self
-        self.class_eval code; end
-
-      def >= functions # TODO make check for instance log, not only for class
-        functions = Rdoba::Log::update_functions functions, self, :-
-        pfx = self.class_variable_get :@@rdoba_log_prefix
-        code = Rdoba::Log::make_code functions, pfx, self
-        self.class_eval code; end; end
-
-    def self.update_functions functions, obj, method
-      if functions.is_a?( Array ) && functions.include?( :* )
-        functions = [ :basic, :enter, :leave, :warn, :info, :extended, :compat ]
-        end
-      cf = begin
-          obj.class_variable_get :@@rdoba_log_functions
-        rescue NameError
-          [] ; end
-      functions = cf.send( method, functions.is_a?( Array ) && functions ||
-          functions.is_a?( NilClass) && [] || [ functions.to_s.to_sym ] )
-      obj.class_variable_set :@@rdoba_log_functions, functions
-      functions
-    end
-
-    def self.make_code functions, pfx, obj
-      code = ''
-      psfx = ' ",params);end;end;'
-      if functions.include?( :enter )
-        code << 'def + *params' + pfx + '<<<' + psfx
-      else
-        code << 'def + *params;end;'; end
-      if functions.include?( :leave )
-        code << 'def - ev' + pfx + '>>> ",[[ev.inspect]]);end;ev;end;'
-      else
-        code << 'def - ev;ev;end;'; end
-      if functions.include?( :basic )
-        code << "def > *params#{pfx}>#{psfx}"
-      else
-        code << 'def > *params;end;'; end
-      if functions.include?( :extended )
-        code << 'def >> *params' + pfx + '>>' + psfx
-      else
-        code << 'def >> *params;end;'; end
-      if functions.include?( :warn )
-        code << "def % *params#{pfx}%%%#{psfx}"
-      else
-        code << 'def % *params;end;'; end
-      if functions.include?( :info )
-        code << "def * *params#{pfx}***#{psfx}"
-      else
-        code << 'def * *params;end;'; end
-      if functions.include?( :compat )
-        obj.send :include, Rdoba::Log::DebugCompat
-        code << "$dbgl_#{self.class}=0;"
-        (1..0xF).each do |x|
-          (1..0xF).each do |y|
-            idx = sprintf "%x%x", x, y
-            code << "def dbp#{idx}(text); dbp(0x#{idx},text); end;"
-            code << "def dbg#{idx}(text); dbg(0x#{idx},text); end;"; end; end; end
-      code; end
-
-    def self.log io_m, prefix, params
-      text = prefix
-      text << params.map do |prm|
-          case prm
-          when Hash
-            r = []
-            prm.each do |key, value| r << "#{key}: #{value.inspect}" end
-            r.join(", ")
-          when Array
-            prm.join(', ')
-          when String
-            prm
-          else
-            prm.inspect
-          end
-        end.join(', ')
-      # NOTE: the shell over text id requires to proper output
-      # in multiprocess environment
-      io_m.call "#{text}\n"; end
-
-    module DebugCompat
-      def dbgl
-        @dbgl; end
-
-      def dbgl= level
-        @dbgl = level; end
-
-      def dbc level
-        level = level.to_i
-        if level > 0
-          clevel = @dbgl || begin
-            eval "$dbgl_#{self.class}"
-          rescue
-            nil; end
-          clevel || ( clevel.to_i & level ) == level
-        else
-          false; end; end
-
-      def dbp level, text
-        if dbc level
-          Kernel.puts text; end; end
-
-      def dbg level, code, vars = {}
-        if dbc level
-          if vars
-            vars.each_pair do |var, value|
-              instance_variable_set( var, value ); end; end
-          eval code; end; end; end ;end; end

data/test/helper.rb

@@ -1,18 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rdoba'
-
-class Test::Unit::TestCase
-end

data/test/rdoba_test.rb.stub

@@ -1,59 +0,0 @@
-#!/usr/bin/ruby -KU
-
-if $0 == __FILE__
-    s = 'АцWуУуqцууууЦ+-* | »«1«2+121»'
-    k = s.ord
-    p s
-    p s.downcase
-    p s.downcase(String::FirstChar)
-    p s.upcase
-    p s.upcase(String::FirstChar)
-    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)
-    lll = 3
-    lll.debug = 1
-    lll.dbgF2("puts(1)")
-    lll.debug = 0x2
-    lll.dbgF2("puts(2)")
-    lll.debug = 0xF3
-    lll.dbgF2("puts(3)")
-    lll.debug = 0xF2
-    lll.dbpF2("4")
-
-    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/test/test_rdoba.rb

@@ -1,7 +0,0 @@
-require 'helper'
-
-class TestRdoba < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
-end