arpie 0.0.5 → 0.0.6

data/BINARY_SPEC

@@ -79,7 +79,29 @@ Most field types take :sizeof OR :length as an argument.
 ==== :length
 Tell Binary to expect exactly :length items of the given type. Think of it as a fixed-size array.
 
-=== :sizeof
+You can actually specify a field or virtual that was defined before the currently-defining field.
+Example:
+
+  class Inner < Arpie::Binary
+    field :sz, :uint8
+    field :ls, :list, :of => :uint8, :length => :sz
+  end
+
+  class Outer < Arpie::Binary
+    field :totalsz, :uint8
+
+    field :bytes, :bytes, :length => :totalsz do
+      field :content, :list, :of => Inner,
+        :length => :all
+    end
+
+    field :end, :uint8
+  end
+
+Note that fields defined this way will NOT update their "length referral" - you will have to
+do that manually.
+
+==== :sizeof
 This includes a prefixed "non-visible" field, which will be used to determine the
 actual expected length of the data. Example:
 
@@ -90,7 +112,7 @@ Will expect a network-order short (16 bits), followed by the amout of bytes the
 If the field type given in :sizeof requires additional parameters, you can pass them with
 :sizeof_opts (just like with :list - :of).
 
-== :list
+=== :list
 
 A :list is an array of arbitary, same-type elements. The element type is given in the :list-specific
 :of parameter:
@@ -105,7 +127,7 @@ If your :of requires additional argument (a list of lists, for example), you can
   field :my_list_2, :list, :sizeof => :uint8, :of => :string,
     :of_opts => { :sizeof, :nint16 }
 
-== :bitfield
+=== :bitfield
 
 The bitfield type unpacks one or more bytes into their bit values, for individual addressing:
 
@@ -128,13 +150,15 @@ The bitfield type unpacks one or more bytes into their bit values, for individua
 
 This is pretty much all that you can do with it, for now.
 
-== :fixed
+== static values / :fixed
 
 The fixed type allows defining fixed strings that are always the same, both acting as a filler
 and a safeguard (it will complain if it does not match):
 
   field :blah, :fixed, :value => "FIXED"
 
+The alias Binary.static does this for you.
+
 == Nested Classes
 
 Instead of pre-registered primitive data fiels you can pass in class names:
@@ -186,7 +210,7 @@ As you get to parse complex data structures, you might encounter the following c
 
     field :middle, :something
 
-    field :matrix, :list, :of => :uint8, :sizeof => (value of :len_a * :len_b)
+    field :matrix, :list, :of => :uint8, :length => (value of :len_a * :len_b)
   end
 
 In this case, you will need to use a virtual attribute:
@@ -197,8 +221,8 @@ In this case, you will need to use a virtual attribute:
 
     field :middle, :something
 
-    virtual :v_len do |o| o.len_a * o.len_b end
-    field :hah, :list, :of => Nested, :sizeof => :v_len
+    virtual :v_len, :uint16 do |o| o.len_a * o.len_b end
+    field :hah, :list, :of => Nested, :length => :v_len
 
     pre_to do |o|
       o.len_a = 4

data/Rakefile

@@ -1,7 +1,11 @@
 require "rake"
 require "rake/clean"
 require "rake/gempackagetask"
-require "rake/rdoctask"
+begin
+  require "hanna/rdoctask"
+rescue LoadError
+  require "rake/rdoctask"
+end
 require "fileutils"
 include FileUtils
 
@@ -9,7 +13,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "arpie"
-VERS = "0.0.5"
+VERS = "0.0.6"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   "#{NAME}: A high-performing layered networking protocol framework. Simple to use, simple to extend.", \
@@ -44,7 +48,7 @@ spec = Gem::Specification.new do |s|
   s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib,tools,scripts,data}/**/*")
   s.require_path = "lib"
   s.bindir = "bin"
-  s.add_dependency('uuidtools', '>= 1.0.7')
+  s.add_dependency('uuidtools', '>= 2.0.0')
 end
 
 Rake::GemPackageTask.new(spec) do |p|

data/lib/arpie.rb

@@ -1,6 +1,7 @@
 require 'arpie/error'
 require 'arpie/protocol'
 require 'arpie/binary'
+require 'arpie/binary_types'
 require 'arpie/xmlrpc'
 require 'arpie/server'
 require 'arpie/client'

data/lib/arpie/binary.rb

@@ -34,7 +34,7 @@ module Arpie
   # Do not use +Kernel+ methods as field names. It'll confuse method_missing.
   # Example:
   #  field :test, :uint8
-  # => in `test': wrong number of arguments (ArgumentError)
+  #  => in `test': wrong number of arguments (ArgumentError)
   #
   # In fact, this is the reason while Binary will not let you define fields with
   # with names like existing instance methods.
@@ -62,6 +62,7 @@ module Arpie
 
     def initialize
       @fields = {}
+      @@fields[self.class] ||= []
 
       # set up our own class handlers, create anon classes, set up default values
       @@fields[self.class].each {|field|
@@ -87,7 +88,13 @@ module Arpie
         "Anon#{self.class.__anonymous.inspect}" :
         self.class.to_s
 
-      "#<#{klass}#{desc} #{@fields.inspect}>"
+      fields = []
+      @@fields[self.class].each {|field|
+        fields << "%s=>%s" % [field.name.inspect, @fields[field.name].inspect]
+      }
+      fields = '{' + fields.join(", ") + '}'
+
+      "#<#{klass}#{desc} #{fields}>"
     end
 
     def method_missing m, *a
@@ -269,6 +276,11 @@ module Arpie
       @@fields[self] << Field.new(name.to_sym, type, opts, inline_handler)
     end
 
+    # Alias for +field+.
+    def self.f *va, &b
+      field *va, &b
+    end
+
     # Set up a new virtual field
     def self.virtual name, type, opts = {}, &handler
       raise ArgumentError, "You need to pass a block with virtuals" unless block_given?
@@ -282,12 +294,18 @@ module Arpie
       @@virtuals[self] << Virtual.new(name.to_sym, type, opts, handler)
     end
 
+    # Alias for +virtual+.
+    def self.v *va, &b
+      virtual *va, &b
+    end
 
     def self.binary_size opts = {}
       @@fields[self] ||= []
       total = @@fields[self].inject(0) {|sum, field|
         klass = get_type_handler(field.type)
-        sum + klass.binary_size(field.opts)
+        sz = klass.binary_size(field.opts)
+        sz or raise "cannot binary_size dynamic Binary definitions"
+        sum + sz
       }
 
       total
@@ -418,337 +436,4 @@ module Arpie
       self.add_hook(:post_from, handler)
     end
   end
-
-  class BinaryType
-    include Arpie
-
-    def binary_size opts
-      nil
-    end
-
-    def required_opts
-      {}
-    end
-
-    # Return [object, len]
-    def from binary, opts
-      raise NotImplementedError
-    end
-
-    # Return [binary]
-    def to object, opts
-      raise NotImplementedError
-    end
-
-    def check_limit value, limit
-      case limit
-        when nil
-          true
-        when Range, Array
-          limit.include?(value)
-        else
-          raise ArgumentError, "unknown limit definition: #{limit.inspect}"
-      end or bogon! nil, "not in :limit => #{limit.inspect}"
-    end
-
-  end
-
-  class PackBinaryType < BinaryType
-    attr_reader :pack_string
-
-    def binary_size opts
-      opts = @force_opts.merge(opts || {})
-      PackBinaryType.length_of(@pack_string + (opts[:length] || 1).to_s)
-    end
-
-    def self.length_of format
-      length = 0
-      format.scan(/(\S_?)\s*(\d*)/).each do |directive, count|
-        count = count.to_i
-        count = 1 if count == 0
-
-        length += case directive
-        when 'A', 'a', 'C', 'c', 'Z', 'x' : count
-        when 'B', 'b' : (count / 8.0).ceil
-        when 'D', 'd', 'E', 'G' : count * 8
-        when 'e', 'F', 'f', 'g' : count * 4
-        when 'H', 'h' : (count / 2.0).ceil
-        when 'I', 'i', 'L', 'l', 'N', 'V' : count * 4
-        when 'n', 'S', 's', 'v' : count * 2
-        when 'Q', 'q' : count * 8
-        when 'X' : count * -1
-        else raise ArgumentError, "#{directive} is not supported"
-        end
-      end
-
-      length
-    end
-
-    def initialize pack_string, force_opts = {}
-      @pack_string = pack_string
-      @force_opts = force_opts
-    end
-
-    def from binary, opts
-      opts = @force_opts.merge(opts || {})
-      binary && binary.size >= binary_size(opts) or incomplete!
-      len = opts[:length] || 1
-      pack_string = @pack_string + len.to_s
-      value = binary.unpack(pack_string)[0]
-      value += opts[:mod] if opts[:mod]
-      check_limit value, opts[:limit]
-
-      [value, binary_size(opts)]
-    end
-
-    def to object, opts
-      opts = @force_opts.merge(opts || {})
-      object.nil? and bogon! nil,"nil object given"
-      object -= opts[:mod] if opts[:mod]
-      len = opts[:length] || 1
-      pack_string = @pack_string + len.to_s
-      [object].pack(pack_string)
-    end
-
-  end
-
-  Binary.register_type(PackBinaryType.new('c'), :uint8)
-  Binary.register_type(PackBinaryType.new("c"), :int8)
-  Binary.register_type(PackBinaryType.new("C"), :uint8)
-  Binary.register_type(PackBinaryType.new("s"), :int16)
-  Binary.register_type(PackBinaryType.new("S"), :uint16)
-  Binary.register_type(PackBinaryType.new("i"), :int32)
-  Binary.register_type(PackBinaryType.new("I"), :uint32)
-  Binary.register_type(PackBinaryType.new("q"), :int64)
-  Binary.register_type(PackBinaryType.new("Q"), :uint64)
-
-  Binary.register_type(PackBinaryType.new("l"), :long32)
-  Binary.register_type(PackBinaryType.new("L"), :ulong32)
-
-  Binary.register_type(PackBinaryType.new("n"), :nint16)
-  Binary.register_type(PackBinaryType.new("N"), :nint32)
-  Binary.register_type(PackBinaryType.new("v"), :lint16)
-  Binary.register_type(PackBinaryType.new("V"), :lint32)
-
-  Binary.register_type(PackBinaryType.new("d"), :double)
-  Binary.register_type(PackBinaryType.new("E"), :ldouble)
-  Binary.register_type(PackBinaryType.new("G"), :ndouble)
-
-  Binary.register_type(PackBinaryType.new("f"), :float)
-  Binary.register_type(PackBinaryType.new("e"), :lfloat)
-  Binary.register_type(PackBinaryType.new("g"), :nfloat)
-
-  Binary.register_type(PackBinaryType.new("B"), :msb_bitfield)
-  Binary.register_type(PackBinaryType.new("b"), :lsb_bitfield)
-
-  class BitBinaryType < Arpie::BinaryType
-    def from binary, opts
-      len = opts[:length] || 1
-      binary.size >= len or incomplete!
-      b = binary.split("")[0,len].map {|x|
-        x == "1"
-      }
-      b = b[0] if b.size == 1
-      [b, len]
-    end
-
-    def to object, opts
-      object = [object] if object.is_a?(TrueClass) || object.is_a?(FalseClass)
-      object.map {|x| x == true ? "1" : "0" }.join("")
-    end
-  end
-  Arpie::Binary.register_type(BitBinaryType.new, :bit)
-
-  class BytesBinaryType < BinaryType
-    def all_opts; [:sizeof, :length] end
-
-    def initialize pack_string, force_opts = {}
-      @pack_string = pack_string
-      @force_opts = force_opts
-    end
-
-    def binary_size opts
-      opts = @force_opts.merge(opts || {})
-      if opts[:sizeof]
-        len_handler = Binary.get_type_handler(opts[:sizeof])
-        len_handler.binary_size(opts[:sizeof_opts])
-      elsif opts[:length]
-        opts[:length]
-      else
-        nil
-      end
-    end
-
-    def from binary, opts
-      opts = (opts || {}).merge(@force_opts)
-      if opts[:sizeof]
-        len_handler = Binary.get_type_handler(opts[:sizeof])
-        len, len_size = len_handler.from(binary, opts[:sizeof_opts])
-        binary.size >= len_size + len or incomplete!
-
-        [binary.unpack("x#{len_size} #{@pack_string}#{len}")[0], len_size + len]
-
-      elsif opts[:length]
-        len = case opts[:length]
-          when :all
-            binary.size
-          else
-            opts[:length]
-          end
-        binary.size >= len or incomplete!
-        [binary.unpack("#{@pack_string}#{len}")[0], len]
-
-      else
-        raise ArgumentError, "need one of [:sizeof, :length]"
-      end
-
-    end
-
-    def to object, opts
-      opts = (opts || {}).merge(@force_opts)
-      if opts[:sizeof]
-        len_handler = Binary.get_type_handler(opts[:sizeof])
-        len_handler.respond_to?(:pack_string) or raise ArgumentError,
-          "#{self.class}#to: needs a PackStringType parameter for length"
-
-        [object.size, object].pack("#{len_handler.pack_string} #{@pack_string}*")
-
-      elsif opts[:length]
-        len = case opts[:length]
-          when :all
-            "*"
-          when Symbol
-            opts[:object].send(opts[:length])
-          else
-            opts[:length]
-        end
-        [object].pack("#{@pack_string}#{len}")
-
-      else
-        raise ArgumentError, "need one of [:sizeof, :length]"
-      end
-
-    end
-  end
-
-  Binary.register_type(BytesBinaryType.new("a", :length => 1), :char)
-  Binary.register_type(BytesBinaryType.new("a"), :bytes)
-  Binary.register_type(BytesBinaryType.new("A"), :string)
-  Binary.register_type(BytesBinaryType.new("Z"), :nstring)
-
-  Binary.register_type(BytesBinaryType.new("M"), :quoted_printable)
-  Binary.register_type(BytesBinaryType.new("m"), :base64)
-  Binary.register_type(BytesBinaryType.new("u"), :uuencoded)
-
-
-  class ListBinaryType < BinaryType
-
-    def binary_size opts
-      if opts[:sizeof]
-        len_handler = Binary.get_type_handler(opts[:sizeof])
-        len_handler.binary_size(opts[:sizeof_opts])
-      elsif opts[:length]
-        case opts[:length]
-          when Symbol
-            opts[:object] ? opts[:object].send(opts[:length]) : nil
-          else
-            opts[:length]
-        end
-      else
-        nil
-      end
-    end
-
-    def from binary, opts
-      type_of = Binary.get_type_handler(opts[:of])
-      type_of.respond_to?(:binary_size) &&
-        type_of_binary_size = type_of.binary_size(opts[:of_opts]) or raise ArgumentError,
-        "can only encode known-width fields"
-
-      list = []
-      consumed = 0
-      length = nil
-
-      if opts[:sizeof]
-        len_handler = Binary.get_type_handler(opts[:sizeof])
-        length, ate = len_handler.from(binary, opts[:sizeof_opts])
-        consumed += ate
-
-      elsif opts[:length]
-        length = case opts[:length]
-          when :all
-            binary.size / type_of_binary_size
-          when Symbol
-            opts[:object].send(opts[:length])
-          else
-            opts[:length]
-          end
-      else
-        raise ArgumentError, "need one of [:sizeof, :length]"
-      end
-
-      cc, ate = nil, nil
-      for i in 0...length do
-        cc, ate = type_of.from(binary[consumed .. -1], opts[:of_opts])
-        list << cc
-        consumed += ate
-      end
-
-      [list, consumed]
-    end
-
-    def to object, opts
-      object.is_a?(Array) or bogon! object, "require Array"
-
-      type_of = Binary.get_type_handler(opts[:of])
-
-      if opts[:sizeof]
-        len_handler = Binary.get_type_handler(opts[:sizeof])
-        ([len_handler.to(object.size, opts[:sizeof_opts])] + object.map {|o|
-          type_of.to(o, opts[:of_opts])
-        }).join('')
-
-      elsif opts[:length]
-        length = case opts[:length]
-          when Symbol
-            opts[:object].send(opts[:length])
-          else
-            opts[:length]
-        end
-
-        object.size == length or bogon! object,
-          "Array#size does not match required fixed width: " +
-          "have #{object.size}, require #{length.inspect}"
-
-        object.map {|o|
-          type_of.to(o, opts[:of_opts])
-        }.join('')
-
-      else
-        raise ArgumentError, "need one of [:sizeof, :length]"
-      end
-
-    end
-  end
-  Binary.register_type(ListBinaryType.new, :list)
-
-  class FixedBinaryType < BinaryType
-    def required_opts ; {:value => proc {|v| v.is_a?(String)}} end
-    def binary_size opts
-      opts[:value].size
-    end
-
-    def from binary, opts
-      sz = opts[:value].size
-      existing = binary.unpack("a#{sz}")[0]
-      existing == opts[:value] or bogon! nil, ":fixed did not match data in packet"
-
-      [opts[:value], opts[:value].size]
-    end
-
-    def to object, opts
-      opts[:value]
-    end
-  end
-  Binary.register_type(FixedBinaryType.new, :fixed)
 end

data/lib/arpie/binary/bytes_type.rb

@@ -0,0 +1,82 @@
+module Arpie
+  class BytesBinaryType < BinaryType
+    def initialize pack_string, force_opts = {}
+      @pack_string = pack_string
+      @force_opts = force_opts
+    end
+
+    def binary_size opts
+      opts = @force_opts.merge(opts || {})
+      if opts[:sizeof]
+        len_handler = Binary.get_type_handler(opts[:sizeof])
+        len_handler.binary_size(opts[:sizeof_opts])
+      elsif opts[:length]
+        opts[:length]
+      else
+        nil
+      end
+    end
+
+    def from binary, opts
+      opts = (opts || {}).merge(@force_opts)
+      if opts[:sizeof]
+        len_handler = Binary.get_type_handler(opts[:sizeof])
+        len, len_size = len_handler.from(binary, opts[:sizeof_opts])
+        binary.size >= len_size + len or incomplete!
+
+        [binary.unpack("x#{len_size} #{@pack_string}#{len}")[0], len_size + len]
+
+      elsif opts[:length]
+        len = case opts[:length]
+          when :all
+            binary.size
+          when Symbol
+            opts[:object].send(opts[:length])
+          else
+            opts[:length]
+          end
+        binary.size >= len or incomplete!
+        [binary.unpack("#{@pack_string}#{len}")[0], len]
+
+      else
+        raise ArgumentError, "need one of [:sizeof, :length]"
+      end
+
+    end
+
+    def to object, opts
+      opts = (opts || {}).merge(@force_opts)
+      if opts[:sizeof]
+        len_handler = Binary.get_type_handler(opts[:sizeof])
+        len_handler.respond_to?(:pack_string) or raise ArgumentError,
+          "#{self.class}#to: needs a PackStringType parameter for length"
+
+        [object.size, object].pack("#{len_handler.pack_string} #{@pack_string}*")
+
+      elsif opts[:length]
+        len = case opts[:length]
+          when :all
+            "*"
+          when Symbol
+            "*"
+          else
+            opts[:length]
+        end
+        [object].pack("#{@pack_string}#{len}")
+
+      else
+        raise ArgumentError, "need one of [:sizeof, :length]"
+      end
+
+    end
+  end
+
+  Binary.register_type(BytesBinaryType.new("a", :length => 1), :char)
+  Binary.register_type(BytesBinaryType.new("a"), :bytes)
+  Binary.register_type(BytesBinaryType.new("A"), :string)
+  Binary.register_type(BytesBinaryType.new("Z"), :nstring)
+
+  Binary.register_type(BytesBinaryType.new("M"), :quoted_printable)
+  Binary.register_type(BytesBinaryType.new("m"), :base64)
+  Binary.register_type(BytesBinaryType.new("u"), :uuencoded)
+end

data/lib/arpie/binary/fixed_type.rb

@@ -0,0 +1,42 @@
+module Arpie
+  class FixedBinaryType < BinaryType
+    def binary_size opts
+      opts[:value].size
+    end
+
+    def from binary, opts
+      opts[:value] or raise ArgumentError, "Requires option :value"
+      sz = opts[:value].size
+      existing = binary.unpack("a#{sz}")[0]
+      existing == opts[:value] or bogon! nil, ":fixed did not match data in packet"
+
+      [opts[:value], opts[:value].size]
+    end
+
+    def to object, opts
+      opts[:value] or raise ArgumentError, "Requires option :value"
+      object == opts[:value] or bogon! nil, ":fixed did not match data in structure"
+      opts[:value]
+    end
+  end
+
+  class Binary
+    # Create a static field.
+    # This is an alias for:
+    #  field :name, :fixed, :value => content
+    #
+    # If no name is specified, it is assumed that the user will
+    # never want to access it and a suitable one is autogenerated.
+    def self.static content, name = nil
+      name ||= "static-%x" % content.hash
+      field name, :fixed, :value => content
+    end
+
+    # An alias for +static+.
+    def self.s *va, &b
+      static *va, &b
+    end
+  end
+
+  Binary.register_type(FixedBinaryType.new, :fixed)
+end

data/lib/arpie/binary/list_type.rb

@@ -0,0 +1,117 @@
+module Arpie
+  class ListBinaryType < BinaryType
+
+    def binary_size opts
+      if opts[:sizeof]
+        len_handler = Binary.get_type_handler(opts[:sizeof])
+        len_handler.binary_size(opts[:sizeof_opts])
+      elsif opts[:length]
+        case opts[:length]
+          when Symbol
+            opts[:object] ? opts[:object].send(opts[:length]) : nil
+          else
+            opts[:length]
+        end
+      else
+        nil
+      end
+    end
+
+    def from binary, opts
+      type_of = Binary.get_type_handler(opts[:of])
+      type_of_binary_size = nil
+      if type_of.respond_to?(:binary_size)
+        type_of_binary_size = type_of.binary_size(opts[:of_opts]) rescue nil
+      end
+
+      list = []
+      consumed = 0
+      length = nil
+
+      if opts[:sizeof]
+        len_handler = Binary.get_type_handler(opts[:sizeof])
+        length, ate = len_handler.from(binary, opts[:sizeof_opts])
+        consumed += ate
+
+      elsif opts[:length]
+        length = case opts[:length]
+          when :all
+            if type_of_binary_size
+              binary.size / type_of_binary_size
+            else
+              nil
+            end
+
+          when Symbol
+            opts[:object].send(opts[:length])
+
+          else
+            opts[:length]
+
+          end
+      else
+        raise ArgumentError, "need one of [:sizeof, :length]"
+      end
+
+      cc, ate = nil, nil
+
+
+
+      if length.nil?
+        loop do
+          nextdata = binary[consumed .. -1]
+          break if !nextdata || nextdata == ""
+          cc, ate = type_of.from(binary[consumed .. -1], opts[:of_opts])
+          list << cc
+          consumed += ate
+        end
+
+      else
+        for i in 0...length do
+          cc, ate = type_of.from(binary[consumed .. -1], opts[:of_opts])
+          list << cc
+          consumed += ate
+        end
+      end
+
+      [list, consumed]
+    end
+
+    def to object, opts
+      object.is_a?(Array) or bogon! object, "require Array"
+
+      type_of = Binary.get_type_handler(opts[:of])
+
+      if opts[:sizeof]
+        len_handler = Binary.get_type_handler(opts[:sizeof])
+        ([len_handler.to(object.size, opts[:sizeof_opts])] + object.map {|o|
+          type_of.to(o, opts[:of_opts])
+        }).join('')
+
+      elsif opts[:length]
+        length = case opts[:length]
+          when :all
+            object.size
+          when Symbol
+            object.size
+          else
+            opts[:length]
+        end
+
+        object.size == length or bogon! object,
+          "Array#size does not match required fixed width: " +
+          "have #{object.size}, require #{length.inspect}"
+
+        object.map {|o|
+          type_of.to(o, opts[:of_opts])
+        }.join('')
+
+      else
+        raise ArgumentError, "need one of [:sizeof, :length]"
+      end
+
+    end
+  end
+
+  Binary.register_type(ListBinaryType.new, :list)
+end

data/lib/arpie/binary/pack_type.rb

@@ -0,0 +1,109 @@
+module Arpie
+  class PackBinaryType < BinaryType
+    attr_reader :pack_string
+
+    def binary_size opts
+      opts = @force_opts.merge(opts || {})
+      PackBinaryType.length_of(@pack_string + (opts[:length] || 1).to_s)
+    end
+
+    def self.length_of format
+      length = 0
+      format.scan(/(\S_?)\s*(\d*)/).each do |directive, count|
+        count = count.to_i
+        count = 1 if count == 0
+
+        length += case directive
+        when 'A', 'a', 'C', 'c', 'Z', 'x' : count
+        when 'B', 'b' : (count / 8.0).ceil
+        when 'D', 'd', 'E', 'G' : count * 8
+        when 'e', 'F', 'f', 'g' : count * 4
+        when 'H', 'h' : (count / 2.0).ceil
+        when 'I', 'i', 'L', 'l', 'N', 'V' : count * 4
+        when 'n', 'S', 's', 'v' : count * 2
+        when 'Q', 'q' : count * 8
+        when 'X' : count * -1
+        else raise ArgumentError, "#{directive} is not supported"
+        end
+      end
+
+      length
+    end
+
+    def initialize pack_string, force_opts = {}
+      @pack_string = pack_string
+      @force_opts = force_opts
+    end
+
+    def from binary, opts
+      opts = @force_opts.merge(opts || {})
+      binary && binary.size >= binary_size(opts) or incomplete!
+      len = opts[:length] || 1
+      pack_string = @pack_string + len.to_s
+      value = binary.unpack(pack_string)[0]
+      value += opts[:mod] if opts[:mod]
+      check_limit value, opts[:limit]
+
+      [value, binary_size(opts)]
+    end
+
+    def to object, opts
+      opts = @force_opts.merge(opts || {})
+      object.nil? and bogon! nil,"nil object given"
+      object -= opts[:mod] if opts[:mod]
+      len = opts[:length] || 1
+      pack_string = @pack_string + len.to_s
+      [object].pack(pack_string)
+    end
+
+  end
+
+  Binary.register_type(PackBinaryType.new('c'), :uint8)
+  Binary.register_type(PackBinaryType.new("c"), :int8)
+  Binary.register_type(PackBinaryType.new("C"), :uint8)
+  Binary.register_type(PackBinaryType.new("s"), :int16)
+  Binary.register_type(PackBinaryType.new("S"), :uint16)
+  Binary.register_type(PackBinaryType.new("i"), :int32)
+  Binary.register_type(PackBinaryType.new("I"), :uint32)
+  Binary.register_type(PackBinaryType.new("q"), :int64)
+  Binary.register_type(PackBinaryType.new("Q"), :uint64)
+
+  Binary.register_type(PackBinaryType.new("l"), :long32)
+  Binary.register_type(PackBinaryType.new("L"), :ulong32)
+
+  Binary.register_type(PackBinaryType.new("n"), :nint16)
+  Binary.register_type(PackBinaryType.new("N"), :nint32)
+  Binary.register_type(PackBinaryType.new("v"), :lint16)
+  Binary.register_type(PackBinaryType.new("V"), :lint32)
+
+  Binary.register_type(PackBinaryType.new("d"), :double)
+  Binary.register_type(PackBinaryType.new("E"), :ldouble)
+  Binary.register_type(PackBinaryType.new("G"), :ndouble)
+
+  Binary.register_type(PackBinaryType.new("f"), :float)
+  Binary.register_type(PackBinaryType.new("e"), :lfloat)
+  Binary.register_type(PackBinaryType.new("g"), :nfloat)
+
+  Binary.register_type(PackBinaryType.new("B"), :msb_bitfield)
+  Binary.register_type(PackBinaryType.new("b"), :lsb_bitfield)
+
+  class BitBinaryType < Arpie::BinaryType
+    def from binary, opts
+      len = opts[:length] || 1
+      len = binary.size if len == :all
+      binary.size >= len or incomplete!
+      b = binary.split("")[0,len].map {|x|
+        x == "1"
+      }
+      b = b[0] if b.size == 1
+      [b, len]
+    end
+
+    def to object, opts
+      object = [object] if object.is_a?(TrueClass) || object.is_a?(FalseClass)
+      object.map {|x| x == true ? "1" : "0" }.join("")
+    end
+  end
+
+  Arpie::Binary.register_type(BitBinaryType.new, :bit)
+end

data/lib/arpie/binary_types.rb

@@ -0,0 +1,39 @@
+module Arpie
+  class BinaryType
+    include Arpie
+
+    def binary_size opts
+      nil
+    end
+
+    def required_opts
+      {}
+    end
+
+    # Return [object, len]
+    def from binary, opts
+      raise NotImplementedError
+    end
+
+    # Return [binary]
+    def to object, opts
+      raise NotImplementedError
+    end
+
+    def check_limit value, limit
+      case limit
+        when nil
+          true
+        when Range, Array
+          limit.include?(value)
+        else
+          raise ArgumentError, "unknown limit definition: #{limit.inspect}"
+      end or bogon! nil, "not in :limit => #{limit.inspect}"
+    end
+  end
+end
+
+require 'arpie/binary/pack_type'
+require 'arpie/binary/bytes_type'
+require 'arpie/binary/fixed_type'
+require 'arpie/binary/list_type'

data/lib/arpie/proxy.rb

@@ -51,8 +51,16 @@ module Arpie
 
       begin
         # Prune old serials. This can probably be optimized, but works well enough for now.
-        if @uuid_tracking && message.uuid && message.uuid.is_a?(Numeric)
-          message.uuid &= 0xffffffffffffffff
+        if @uuid_tracking && message.uuid
+          uuid, serial = * message.uuid
+
+          raise ArgumentError,
+            "Invalid UUID given, expect [uuid/64bit, serial/numeric]." unless
+              uuid.is_a?(Integer) && serial.is_a?(Integer)
+
+          # Limit to sane values.
+          uuid   &= 0xffffffffffffffff
+          serial &= 0xffffffffffffffff
 
           timestamps = @uuids.values.map {|v| v[0] }.sort
           latest_timestamp = timestamps[-@max_uuids]
@@ -82,31 +90,47 @@ module Arpie
   class ProxyClient < RPCClient
     attr_accessor :namespace
 
+    # Set to false to disable replay protection.
+    # Default is true.
+    attr_accessor :replay_protection
+
+    # The current serial for this transport.
+    attr_accessor :serial
+
+    # The generated uuid for this Client.
+    # nil if no call has been made yet.
+    attr_accessor :uuid
+
     def initialize *protocols
       super
       @protocol, @namespace = protocol, ""
+      @serial = 0
       @uuid_generator = lambda {|client, method, argv|
-        UUID.random_create.to_i
+        UUIDTools::UUID.random_create.to_i
       }
+      @replay_protection = true
     end
 
     # Set up a new UUID generator for this proxy client.
     # Make sure that this yields really random numbers.
     # The default uses the uuidtools gem and is usually okay.
-    # You can simply set this to nil (by calling it without
-    # a block).
     #
-    # Note that disabling this disables replay protection.
+    # This gets called exactly once for each created ProxyClient.
     def uuid_generator &handler #:yields: client, method, argv
       @uuid_generator = handler
       self
     end
 
     def method_missing meth, *argv # :nodoc:
-      uuid = @uuid_generator ?
-        @uuid_generator.call(self, meth, argv) : nil
+      serial = nil
+      if @replay_protection
+        serial = [
+          @uuid ||= @uuid_generator.call(self, meth, argv),
+          @serial += 1
+        ]
+      end
 
-      call = Arpie::RPCall.new(@namespace, meth, argv, uuid)
+      call = Arpie::RPCall.new(@namespace, meth, argv, serial)
       ret = self.request(call)
       case ret
         when Exception

data/spec/binary_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Binary" do
+
+  describe "empty:" do subject {
+    [
+      Class.new(Binary) do
+      end,
+      ""
+    ]
+  }
+    it_should_behave_like "Binary Tests"
+  end
+
+  describe "basic sanity:" do subject {
+    [
+      Class.new(Binary) do
+        field :a, :uint32
+        field :b, :uint32
+        field :c, :uint64
+        field :s, :string, :length => 4
+      end,
+      [1, 2, 3, "abcd"].pack("I I Q a4")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+  end
+
+  describe ".virtual:" do subject {
+    [
+      Class.new(Binary) do
+        field :a, :uint8
+        field :b, :uint8
+        virtual :c, :uint8 do |o| o.a * o.b end
+      end,
+      [1, 2].pack("CC")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+
+    it "evaluates the block given" do
+      b, co = @c.from(@d)
+      b.c.should == b.a * b.b
+    end
+  end
+
+  describe ".aliases:" do subject {
+    [
+      Class.new(Binary) do
+        f :a, :uint8
+        f :b, :uint8
+        s "hio!"
+        v :c, :uint8 do |o| o.a * o.b end
+      end,
+      [1, 2, "hio!"].pack("CCa4")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+  end
+
+  describe ":default:" do subject {
+    [
+      Class.new(Binary) do
+        field :a, :uint8
+        field :b, :uint8, :default => 5, :optional => true
+        v :c, :uint8 do |o| o.a * o.b end
+      end,
+      [1, 2].pack("CC")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+
+    it "does not use the default when a value was read" do
+      b, con = @c.from([1, 2].pack("CC"))
+      b.a.should == 1
+      b.b.should == 2
+    end
+
+    it "uses the default when no value is present" do
+      b, con = @c.from([1].pack("C"))
+      b.a.should == 1
+      b.b.should == 5
+    end
+
+  end
+
+
+end

data/spec/bytes_binary_type_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "BytesBinaryType" do
+  describe "sizeof and length" do subject {
+    [
+      Class.new(Arpie::Binary) do
+        field :s, :string, :sizeof => :uint8
+        field :d, :string, :length => 5
+      end,
+      [4, "abcd", "12345"].pack("C a4 a5")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+  end
+
+  describe "virtual length" do subject {
+    [
+      Class.new(Arpie::Binary) do
+        field :v, :uint8
+        field :d, :string, :length => :v
+      end,
+      [4, "abcd"].pack("C a4")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+  end
+
+  describe "length as virtual should not update the virtual" do subject {
+    [
+      Class.new(Arpie::Binary) do
+        field :data_length, :uint8
+        field :data, :bytes, :length => :data_length
+      end,
+      [4, "abcd"].pack("C a4")
+    ]
+  }
+
+    it_should_behave_like "Binary Tests with data"
+
+    it "does not change virtuals on data change" do
+      dd, b = @c.from(@d + "xxyzz")
+      dd.data += "a"
+      expect = [4, "abcda"].pack("Ca*")
+      dd.to.should == expect
+    end
+  end
+end

data/spec/client_server_spec.rb

@@ -94,7 +94,7 @@ describe "ProxyServer" do
   it "should not re-evaluate for already-seen uuids" do
     @client.evaluate_calls
     @client.evaluate_calls
-    @client.uuid_generator do 100 end
+    @client.serial -= 1
     @client.evaluate_calls
     @client.evaluate_calls
     $evaluate_calls.should == 3

data/spec/fixed_binary_type_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe FixedBinaryType do
+
+  it "always returns the fixed size" do
+    subject.from("aaaa", :value => "aaaa").should == ["aaaa", 4]
+  end
+
+  it "always encodes to fixed size" do
+    subject.to("aaaa", :value => "aaaa").should == "aaaa"
+  end
+
+  it "returns the proper binary size" do
+    subject.binary_size(:value => "aaaa").should == 4
+  end
+
+  it "should raise error on mismatch in #from" do
+    proc { subject.from("aaa", :value => "aaaa") }.should raise_error StreamError
+  end
+
+  it "raises error on mismatch in #to" do
+    proc { subject.to("aaa", :value => "aaaa") }.should raise_error StreamError
+  end
+
+  it "raiseserror on missing option" do
+    proc { subject.from("aaa", {}) }.should raise_error ArgumentError
+    proc { subject.to("aaa", {}) }.should raise_error ArgumentError
+  end
+end

data/spec/list_binary_type_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "ListBinaryType" do
+  describe "length as virtual" do
+    class Inner < Arpie::Binary
+      field :sz, :uint8
+      field :ls, :list, :of => :uint8, :length => :sz
+    end
+
+    class Outer < Arpie::Binary
+      field :totalsz, :uint8
+
+      field :bytes, :bytes, :length => :totalsz do
+        field :content, :list, :of => Inner,
+          :length => :all
+      end
+
+      field :end, :uint8
+    end
+
+    it "reads correctly when all bytes are eaten" do
+      c, consumed = Outer.from [8,   2, 0, 1,   4, 0, 1, 2, 3, 0xff].pack("C*")
+      consumed.should == 10
+      c.bytes.content.size.should == 2
+      c.bytes.content[0].ls.should == [0, 1]
+      c.bytes.content[1].ls.should == [0, 1, 2, 3]
+      c.end.should == 0xff
+    end
+
+    it "raises EIncomplete when partial data remains" do
+      proc { Outer.from [8, 0, 1, 2, 3, 4, 5, 6, 7,  4, 1, 2 ].pack("C*") }.should raise_error Arpie::EIncomplete
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ unless Object.const_defined?('Arpie')
   $:.unshift(File.join(File.dirname(__FILE__), "../lib/"))
   require 'arpie'
 end
+include Arpie
 
 describe "IO Mockup", :shared => true do
   before do
@@ -56,3 +57,35 @@ describe "RPCProtocolChainSetup", :shared => true do
   end
 end
 
+
+
+describe "Binary Setup", :shared => true do
+  before do
+    @c = subject[0]
+    @d = subject[1]
+  end
+end
+
+describe "Binary Tests", :shared => true do
+  it_should_behave_like "Binary Setup"
+
+  it "reads and packs the given example binary" do
+    dd, b = @c.from(@d)
+    dd.to.should == @d
+  end
+end
+
+describe "Binary Tests with data", :shared => true do
+  it_should_behave_like "Binary Tests"
+
+  it "should raise EIncomplete when not enough data is available" do
+    proc { @c.from("")}.should raise_error Arpie::EIncomplete
+  end
+
+  it "returns the proper cutoff position" do
+    dd, b = @c.from(@d + "xxyzz")
+    b.should == @d.size
+  end
+
+  it "returns a valid binary size"
+end

data/tools/benchmark.rb

@@ -46,7 +46,7 @@ Benchmark.bm {|b|
 
   puts ""
   puts "Arpie: proxied MarshalProtocol without replay protection"
-  $proxy.uuid_generator
+  $proxy.replay_protection = false
   b.report("   1") {    1.times { $proxy.reverse "benchmark" } }
   b.report("1000") { 1000.times { $proxy.reverse "benchmark" } }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: arpie
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Bernhard Stoeckner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-24 00:00:00 +01:00
+date: 2009-08-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.7
+        version: 2.0.0
     version: 
 description: A high-performing layered networking protocol framework. Simple to use, simple to extend.
 email: elven@swordcoast.net
@@ -36,26 +36,36 @@ files:
 - COPYING
 - README
 - Rakefile
+- spec/protocol_merge_and_split_spec.rb
 - spec/protocol_spec.rb
+- spec/bytes_binary_type_spec.rb
+- spec/fixed_binary_type_spec.rb
+- spec/list_binary_type_spec.rb
 - spec/spec.opts
-- spec/spec_helper.rb
-- spec/protocol_merge_and_split_spec.rb
 - spec/rcov.opts
+- spec/spec_helper.rb
+- spec/binary_spec.rb
 - spec/client_server_spec.rb
-- lib/arpie.rb
-- lib/arpie
-- lib/arpie/client.rb
-- lib/arpie/error.rb
-- lib/arpie/protocol.rb
-- lib/arpie/binary.rb
-- lib/arpie/proxy.rb
 - lib/arpie/xmlrpc.rb
+- lib/arpie/proxy.rb
 - lib/arpie/server.rb
-- tools/benchmark.rb
+- lib/arpie/binary.rb
+- lib/arpie/protocol.rb
+- lib/arpie/error.rb
+- lib/arpie/client.rb
+- lib/arpie/binary_types.rb
+- lib/arpie/binary/bytes_type.rb
+- lib/arpie/binary/fixed_type.rb
+- lib/arpie/binary/list_type.rb
+- lib/arpie/binary/pack_type.rb
+- lib/arpie.rb
 - tools/protocol_benchmark.rb
+- tools/benchmark.rb
 - BINARY_SPEC
 has_rdoc: true
 homepage: http://arpie.elv.es
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --quiet
@@ -84,9 +94,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: arpie
-rubygems_version: 1.3.0
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A high-performing layered networking protocol framework. Simple to use, simple to extend.
 test_files: []