rdoba 0.1 → 0.9

data/lib/rdoba/log.rb

@@ -0,0 +1,248 @@
+# 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/lib/rdoba/numeric.rb

@@ -4,65 +4,48 @@
 require 'rdoba/common'
 require 'rdoba/strings'
 
-class String
-  alias :_rdoba_to_i :to_i
-  def to_i(base = 10, *opts)
-    v = parse_opts(opts)
-    if v[:be]
-      (str, sign, num) = (self.match /\s*(-?)([0-9a-fx]+)/u).to_a
-      if str
-	n = num.reverse._rdoba_to_i(base)
-	sign.empty? && n || -n
-      else
-	0
-      end
-    else
-      _rdoba_to_i(base)
-    end
-  end
-end
-
 class Fixnum
+  NativeEndian = 0
+  LittleEndian = -1
+  BigEndian = -2
+
   alias :_rdoba_to_s :to_s
-  def to_s(base = 10, *opts)
-    v = parse_opts(opts)
+  def to_s( base = 10, opts = {} )
+    if !opts[ :padding ] && !opts[ :style_formatting ]
+      return _rdoba_to_s( base ); end
 
-    return _rdoba_to_s(base) unless v[:padding] or v[:style_formatting]
+    if base <= 0
+      raise "Base of number can't be equal or less then zero"; end
+    if opts[ :padding ] <= 0
+      raise "Padding count numberr can't be equal or less then zero"; end
 
-    raise "Base of number can't be equal or less then zero" if base <= 0
-    raise "Padding count numberr can't be equal or less then zero" if v[:padding] <= 0
     value = self
-    minus = if value < 0
-        value = -value
-        true
-      end
+    minus = value < 0 && ( value = -value; true )
     res = ''
     while value != 0
       value, rem = value.divmod(base)
       rem += 0x40 - 0x39 if rem >= 10
-      res += (0x30 + rem).chr
-    end
-    res += "0" * (v[:padding].to_i - res.size) if res.size < v[:padding].to_i
-    res += 'x0' if v[:style_formatting] and base == 16
-    res += '-' if minus
+      res += (0x30 + rem).chr; end
+
+    if res.size < ( padding = opts[ :padding ].to_i )
+      res += "0" * ( padding - res.size ); end
+    if opts[ :style_formatting ] and base == 16
+      res += 'x0'; end
+    if minus
+      res += '-';end
+
     res.reverse
   end
 end
 
 class Numeric
-  def to_p(*opts)
-    v = parse_opts(opts)
-
+  def to_p( opts = {} )
     value = self
-    minus = if value < 0
-        value = -value
-        true
-      end
+    minus = value < 0 && ( value = -value; true )
     res = ''
     while value != 0
       value, rem = value.divmod(256)
-      res += rem.chr
-    end
+      res += rem.chr; end
 
     pad_char = if minus
         negres += ''
@@ -74,19 +57,46 @@ class Numeric
               0
             else
               over = 0
-              negbyte
-            end
-        end
+              negbyte; end; end
         res = negres
         "\xFF"
       else
-        "\0"
-      end
+        "\0"; end
+
+    if res.size < ( padding = opts[ :padding ].to_i )
+      res += pad_char * ( padding - res.size ); end
 
-    res += pad_char * (v[:padding].to_i - res.size) if res.size < v[:padding].to_i
+    #TODO add detection of endianness of current system
+    if ( endian = opts[ :endian ] || Fixnum::NativeEndian ) ==
+    Fixnum::NativeEndian
+      endian = Fixnum::LittleEndian; end
+    ( ( endian == Fixnum::LittleEndian ) && res ||
+        res.reverse( String::ByteByByte ) ).to_p; end; end
 
-    plain = (v[:be] ? res.reverse(String::ByteByByte) : res).to_p
-    plain
+class String
+  alias :_rdoba_to_i :to_i
+  def to_i( base = 10 )
+    return 0 if self.empty?
+
+    #TODO add detection of endianness of current system
+    if base == Fixnum::NativeEndian
+      base = Fixnum::LittleEndian; end
+    res = 0
+    if base == Fixnum::BigEndian
+      self.each_byte do |b|
+        res = ( res << 8 ) | b
+      end
+      res
+    elsif base == Fixnum::LittleEndian
+      size = self.size
+      (1..size).each do |i|
+        b = self.getbyte( size - i )
+        res = ( res << 8 ) | b
+      end
+      res
+    else
+      _rdoba_to_i base
+    end
   end
 end
 

data/lib/rdoba/strings.rb

@@ -92,15 +92,16 @@ class String
   alias :to_p :to_s
 
   ByteByByte = 0
-  alias :__reverse__ :reverse
-  def reverse(step = 1)
+  alias :of_rdoba_reverse :reverse
+  def reverse( step = 1 )
+      # of Plain
       case step
       when ByteByByte
           arr = []
           self.each_byte do |byte| arr << byte.chr end
           arr.reverse.join
       when 1
-          __reverse__
+          of_rdoba_reverse
       else
           res = ''
           offset = (self.size + 1) / step * step - step

data/lib/rdoba/version.rb

@@ -1,3 +1,51 @@
-module Rdoba
-  VERSION = "0.1"
-end
+#encoding: utf-8
+
+class Version
+  attr_reader :subminor, :minor, :major
+
+  def self.parse value
+    case version.is_a?
+    when self
+      value
+    when Array
+      Version.new version[ 0 ].to_i, version[ 1 ].to_i, version[ 2 ].to_i
+    when Numeric
+      Version.new version >> 8, ( version >> 4 ) & 0xF, version & 0xF
+    else
+      if version.to_s =~ /(\d+)\.(\d+)(?:\.(\d+))?/
+        Version.new $1.to_i, $2.to_i, $3.to_i
+      elsif version.to_s =~ /([\da-z][\da-z])([\da-z])([\da-z])/i
+        Version.new $1.to_i( 16 ), $2.to_i( 16 ), $3.to_i( 16 )
+      else
+        Version.new 0, 0, 0; end; end; end
+
+  def == value
+    v = self.parse value
+    @major == v.major && @minor == v.minor && @subminor == v.subminor
+  end
+
+  def < value
+    v = self.parse value
+    @major < v.major || @major == v.major &&
+    ( @minor < v.minor || @minor == v.minor &&
+    @subminor < v.subminor ); end
+
+  def > value
+    v = self.parse value
+    @major > v.major || @major == v.major &&
+    ( @minor > v.minor || @minor == v.minor &&
+    @subminor > v.subminor ); end
+
+  def to_a
+    [ @major, @minor, @subminor ]; end
+
+  def to_s
+    "#{@major}.#{@minor}.#{@subminor}"; end
+
+  private
+
+  def initialize major, minor = 0, subminor = 0
+    @subminor = subminor
+    @minor = minor
+    @major = major; end; end
+