bindata 2.0.0 → 2.1.0

data/lib/bindata/string.rb

@@ -49,55 +49,27 @@ module BinData
   #                            from the end of the string.  The value will
   #                            not be trimmed when writing.
   class String < BinData::BasePrimitive
+    arg_processor :string
 
     optional_parameters :read_length, :length, :trim_padding, :pad_front, :pad_left
     default_parameters  :pad_byte => "\0"
     mutually_exclusive_parameters :read_length, :length
     mutually_exclusive_parameters :length, :value
 
-    class << self
-
-      def sanitize_parameters!(params) #:nodoc:
-        params.warn_replacement_parameter(:initial_length, :read_length)
-
-        params.warn_renamed_parameter(:pad_char, :pad_byte) # Remove this line in the future
-
-        if params.has_parameter?(:pad_left)
-          params[:pad_front] = params.delete(:pad_left)
-        end
-
-        if params.has_parameter?(:pad_byte)
-          byte = params[:pad_byte]
-          params[:pad_byte] = sanitized_pad_byte(byte)
-        end
-      end
-
-      #-------------
-      private
-
-      def sanitized_pad_byte(byte)
-        result = byte.is_a?(Integer) ? byte.chr : byte.to_s
-        len = result.respond_to?(:bytesize) ? result.bytesize : result.length
-        if len > 1
-          raise ArgumentError, ":pad_byte must not contain more than 1 byte"
-        end
-        result
-      end
-    end
-
     def assign(val)
       super(binary_string(val))
     end
 
     def snapshot
       # override to trim padding
-      result = super
-      result = clamp_to_length(result)
+      snap = super
+      snap = clamp_to_length(snap)
 
       if get_parameter(:trim_padding)
-        result = trim_padding(result)
+        trim_padding(snap)
+      else
+        snap
       end
-      result
     end
 
     #---------------
@@ -142,4 +114,31 @@ module BinData
       ""
     end
   end
+
+  class StringArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params)
+      params.warn_replacement_parameter(:initial_length, :read_length)
+      params.must_be_integer(:read_length, :length)
+
+      if params.has_parameter?(:pad_left)
+        params[:pad_front] = params.delete(:pad_left)
+      end
+
+      if params.has_parameter?(:pad_byte)
+        byte = params[:pad_byte]
+        params[:pad_byte] = sanitized_pad_byte(byte)
+      end
+    end
+
+    #-------------
+    private
+
+    def sanitized_pad_byte(byte)
+      pad_byte = byte.is_a?(Integer) ? byte.chr : byte.to_s
+      if pad_byte.bytesize > 1
+        raise ArgumentError, ":pad_byte must not contain more than 1 byte"
+      end
+      pad_byte
+    end
+  end
 end

data/lib/bindata/struct.rb

@@ -3,7 +3,7 @@ require 'bindata/base'
 module BinData
 
   class Base
-    optional_parameter :onlyif  # Used by Struct
+    optional_parameter :onlyif, :byte_align  # Used by Struct
   end
 
   # A Struct is an ordered collection of named data objects.
@@ -47,10 +47,13 @@ module BinData
   #
   # Fields may have have extra parameters as listed below:
   #
-  # [<tt>:onlyif</tt>]   Used to indicate a data object is optional.
-  #                      if +false+, this object will not be included in any
-  #                      calls to #read, #write, #num_bytes or #snapshot.
+  # [<tt>:onlyif</tt>]     Used to indicate a data object is optional.
+  #                        if +false+, this object will not be included in any
+  #                        calls to #read, #write, #num_bytes or #snapshot.
+  # [<tt>:byte_align</tt>] This field's rel_offset must be a multiple of
+  #                        <tt>:byte_align</tt>.
   class Struct < BinData::Base
+    arg_processor :struct
 
     mandatory_parameter :fields
     optional_parameters :endian, :hide
@@ -66,78 +69,11 @@ module BinData
                   uniq.collect { |key| [key, true] }.flatten
                ]
 
-    class << self
-
-      def sanitize_parameters!(params) #:nodoc:
-        sanitize_endian(params)
-        sanitize_fields(params)
-        sanitize_hide(params)
-      end
-
-      #-------------
-      private
-
-      def sanitize_endian(params)
-        if params.needs_sanitizing?(:endian)
-          endian = params.create_sanitized_endian(params[:endian])
-          params[:endian] = endian
-          params.endian   = endian # sync params[:endian] and params.endian
-        end
-      end
-
-      def sanitize_fields(params)
-        if params.needs_sanitizing?(:fields)
-          fields = params[:fields]
-
-          params[:fields] = params.create_sanitized_fields
-          fields.each do |ftype, fname, fparams|
-            params[:fields].add_field(ftype, fname, fparams)
-          end
-
-          field_names = sanitized_field_names(params[:fields])
-          ensure_field_names_are_valid(field_names)
-        end
-      end
-
-      def sanitize_hide(params)
-        if params.needs_sanitizing?(:hide) and params.has_parameter?(:fields)
-          field_names  = sanitized_field_names(params[:fields])
-          hfield_names = hidden_field_names(params[:hide])
-
-          params[:hide] = (hfield_names & field_names)
-        end
-      end
-
-      def sanitized_field_names(sanitized_fields)
-        sanitized_fields.field_names.compact
-      end
-
-      def hidden_field_names(hidden)
-        (hidden || []).collect { |h| h.to_sym }
-      end
-
-      def ensure_field_names_are_valid(field_names)
-        reserved_names = RESERVED
-
-        field_names.each do |name|
-          if self.class.method_defined?(name)
-            raise NameError.new("Rename field '#{name}' in #{self}, " +
-                                "as it shadows an existing method.", name)
-          end
-          if reserved_names.include?(name)
-            raise NameError.new("Rename field '#{name}' in #{self}, " +
-                                "as it is a reserved name.", name)
-          end
-          if field_names.count(name) != 1
-            raise NameError.new("field '#{name}' in #{self}, " +
-                                "is defined multiple times.", name)
-          end
-        end
-      end
-    end
-
     def initialize_shared_instance
-      @field_names = get_parameter(:fields).field_names.freeze
+      fields = get_parameter(:fields)
+      @field_names = fields.field_names.freeze
+      extend ByteAlignPlugin if fields.any_field_has_parameter?(:byte_align)
+      define_field_accessors
       super
     end
 
@@ -162,7 +98,7 @@ module BinData
       snapshot = Snapshot.new
       field_names.each do |name|
         obj = find_obj_for_name(name)
-        snapshot[name] = obj.snapshot if include_obj(obj)
+        snapshot[name] = obj.snapshot if include_obj?(obj)
       end
       snapshot
     end
@@ -179,19 +115,6 @@ module BinData
       end
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      @field_names.include?(base_field_name(symbol)) || super
-    end
-
-    def method_missing(symbol, *args, &block) #:nodoc:
-      obj = find_obj_for_name(symbol)
-      if obj
-        invoke_field(obj, symbol, args)
-      else
-        super
-      end
-    end
-
     def debug_name_of(child) #:nodoc:
       field_name = @field_names[find_index_of(child)]
       "#{debug_name}.#{field_name}"
@@ -205,12 +128,12 @@ module BinData
 
     def do_read(io) #:nodoc:
       instantiate_all_objs
-      @field_objs.each { |f| f.do_read(io) if include_obj(f) }
+      @field_objs.each { |f| f.do_read(io) if include_obj?(f) }
     end
 
     def do_write(io) #:nodoc
       instantiate_all_objs
-      @field_objs.each { |f| f.do_write(io) if include_obj(f) }
+      @field_objs.each { |f| f.do_write(io) if include_obj?(f) }
     end
 
     def do_num_bytes #:nodoc:
@@ -242,18 +165,25 @@ module BinData
     #---------------
     private
 
-    def base_field_name(name)
-      name.to_s.chomp("=").to_sym
+    def define_field_accessors
+      get_parameter(:fields).each_with_index do |field, i|
+        name = field.name_as_sym
+        define_field_accessors_for(name, i) if name
+      end
     end
 
-    def invoke_field(obj, symbol, args)
-      name = symbol.to_s
-      is_writer = (name[-1, 1] == "=")
-
-      if is_writer
-        obj.assign(*args)
-      else
-        obj
+    def define_field_accessors_for(name, index)
+      define_singleton_method(name) do
+        instantiate_obj_at(index) if @field_objs[index].nil?
+        @field_objs[index]
+      end
+      define_singleton_method("#{name}=") do |*vals|
+        instantiate_obj_at(index) if @field_objs[index].nil?
+        @field_objs[index].assign(*vals)
+      end
+      define_singleton_method("#{name}?") do
+        instantiate_obj_at(index) if @field_objs[index].nil?
+        include_obj?(@field_objs[index])
       end
     end
 
@@ -271,6 +201,10 @@ module BinData
       end
     end
 
+    def base_field_name(name)
+      name.to_s.sub(/(=|\?)\z/, "").to_sym
+    end
+
     def instantiate_all_objs
       @field_names.each_index { |i| instantiate_obj_at(i) }
     end
@@ -310,26 +244,25 @@ module BinData
     end
 
     def sum_num_bytes_below_index(index)
-      sum = 0
-      (0...index).each do |i|
+      (0...index).inject(0) do |sum, i|
         obj = @field_objs[i]
-        if include_obj(obj)
+        if include_obj?(obj)
           nbytes = obj.do_num_bytes
-          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+          (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+        else
+          sum
         end
       end
-
-      sum
     end
 
-    def include_obj(obj)
+    def include_obj?(obj)
       not obj.has_parameter?(:onlyif) or obj.eval_parameter(:onlyif)
     end
 
     # A hash that can be accessed via attributes.
     class Snapshot < ::Hash #:nodoc:
       def []=(key, value)
-        super(key, value) unless value.nil?
+        super unless value.nil?
       end
 
       def respond_to?(symbol, include_private = false)
@@ -341,4 +274,128 @@ module BinData
       end
     end
   end
+
+  # Align fields to a multiple of :byte_align
+  module ByteAlignPlugin
+    def do_read(io)
+      initial_offset = io.offset
+      instantiate_all_objs
+      @field_objs.each do |f|
+        if include_obj?(f)
+          if align_obj?(f)
+            io.seekbytes(bytes_to_align(f, io.offset - initial_offset))
+          end
+          f.do_read(io)
+        end
+      end
+    end
+
+    def do_write(io)
+      initial_offset = io.offset
+      instantiate_all_objs
+      @field_objs.each do |f|
+        if include_obj?(f)
+          if align_obj?(f)
+            io.writebytes("\x00" * bytes_to_align(f, io.offset - initial_offset))
+          end
+          f.do_write(io)
+        end
+      end
+    end
+
+    def sum_num_bytes_below_index(index)
+      sum = 0
+      (0...@field_objs.length).each do |i|
+        obj = @field_objs[i]
+        if include_obj?(obj)
+          sum = sum.ceil + bytes_to_align(obj, sum.ceil) if align_obj?(obj)
+
+          break if i >= index
+
+          nbytes = obj.do_num_bytes
+          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+        end
+      end
+
+      sum
+    end
+
+    def bytes_to_align(obj, rel_offset)
+      align = obj.eval_parameter(:byte_align)
+      (align - (rel_offset % align)) % align
+    end
+
+    def align_obj?(obj)
+      obj.has_parameter?(:byte_align)
+    end
+  end
+
+  class StructArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params)
+      sanitize_endian(params)
+      sanitize_fields(obj_class, params)
+      sanitize_hide(params)
+    end
+
+    #-------------
+    private
+
+    def sanitize_endian(params)
+      if params.needs_sanitizing?(:endian)
+        endian = params.create_sanitized_endian(params[:endian])
+        params[:endian] = endian
+        params.endian   = endian # sync params[:endian] and params.endian
+      end
+    end
+
+    def sanitize_fields(obj_class, params)
+      if params.needs_sanitizing?(:fields)
+        fields = params[:fields]
+
+        params[:fields] = params.create_sanitized_fields
+        fields.each do |ftype, fname, fparams|
+          params[:fields].add_field(ftype, fname, fparams)
+        end
+
+        field_names = sanitized_field_names(params[:fields])
+        ensure_field_names_are_valid(obj_class, field_names)
+      end
+    end
+
+    def sanitize_hide(params)
+      if params.needs_sanitizing?(:hide) and params.has_parameter?(:fields)
+        field_names  = sanitized_field_names(params[:fields])
+        hfield_names = hidden_field_names(params[:hide])
+
+        params[:hide] = (hfield_names & field_names)
+      end
+    end
+
+    def sanitized_field_names(sanitized_fields)
+      sanitized_fields.field_names.compact
+    end
+
+    def hidden_field_names(hidden)
+      (hidden || []).collect { |h| h.to_sym }
+    end
+
+    def ensure_field_names_are_valid(obj_class, field_names)
+      reserved_names = BinData::Struct::RESERVED
+
+      field_names.each do |name|
+        if obj_class.method_defined?(name)
+          raise NameError.new("Rename field '#{name}' in #{obj_class}, " +
+                              "as it shadows an existing method.", name)
+        end
+        if reserved_names.include?(name)
+          raise NameError.new("Rename field '#{name}' in #{obj_class}, " +
+                              "as it is a reserved name.", name)
+        end
+        if field_names.count(name) != 1
+          raise NameError.new("field '#{name}' in #{obj_class}, " +
+                              "is defined multiple times.", name)
+        end
+      end
+    end
+  end
 end