bindata 2.0.0 → 2.1.0

data/lib/bindata/buffer.rb

@@ -51,32 +51,18 @@ module BinData
   # <tt>:type</tt>::     The single type inside the buffer.  Use a struct if
   #                      multiple fields are required.
   class Buffer < BinData::Base
-    include DSLMixin
+    extend DSLMixin
 
-    dsl_parser :buffer
+    dsl_parser    :buffer
+    arg_processor :buffer
 
     mandatory_parameters :length, :type
 
-    class << self
-      def arg_extractor
-        MultiFieldArgExtractor
-      end
-
-      def sanitize_parameters!(params) #:nodoc:
-        params.merge!(dsl_params)
-
-        if params.needs_sanitizing?(:type)
-          el_type, el_params = params[:type]
-          params[:type] = params.create_sanitized_object_prototype(el_type, el_params)
-        end
-      end
-    end
-
     def initialize_instance
       @type = get_parameter(:type).instantiate(nil, self)
     end
 
-    def clear? #:nodoc:
+    def clear?
       @type.clear?
     end
 
@@ -116,4 +102,19 @@ module BinData
       eval_parameter(:length)
     end
   end
+
+  class BufferArgProcessor < BaseArgProcessor
+    include MultiFieldArgSeparator
+
+    def sanitize_parameters!(obj_class, params)
+      params.merge!(obj_class.dsl_params)
+
+      params.must_be_integer(:length)
+
+      if params.needs_sanitizing?(:type)
+        el_type, el_params = params[:type]
+        params[:type] = params.create_sanitized_object_prototype(el_type, el_params)
+      end
+    end
+  end
 end

data/lib/bindata/choice.rb

@@ -58,54 +58,14 @@ module BinData
   #                            selection to the current selection whenever the
   #                            selection changes.  Default is false.
   class Choice < BinData::Base
-    include DSLMixin
+    extend DSLMixin
 
-    dsl_parser :choice
+    dsl_parser    :choice
+    arg_processor :choice
 
     mandatory_parameters :choices, :selection
     optional_parameter   :copy_on_change
 
-    class << self
-
-      def sanitize_parameters!(params) #:nodoc:
-        params.merge!(dsl_params)
-
-        if params.needs_sanitizing?(:choices)
-          choices = choices_as_hash(params[:choices])
-          ensure_valid_keys(choices)
-          params[:choices] = params.create_sanitized_choices(choices)
-        end
-      end
-
-      #-------------
-      private
-
-      def choices_as_hash(choices)
-        if choices.respond_to?(:to_ary)
-          key_array_by_index(choices.to_ary)
-        else
-          choices
-        end
-      end
-
-      def key_array_by_index(array)
-        result = {}
-        array.each_with_index do |el, i|
-          result[i] = el unless el.nil?
-        end
-        result
-      end
-
-      def ensure_valid_keys(choices)
-        if choices.has_key?(nil)
-          raise ArgumentError, ":choices hash may not have nil key"
-        end
-        if choices.keys.detect { |key| key.is_a?(Symbol) and key != :default }
-          raise ArgumentError, ":choices hash may not have symbols for keys"
-        end
-      end
-    end
-
     def initialize_shared_instance
       extend CopyOnChangePlugin if eval_parameter(:copy_on_change) == true
       super
@@ -125,40 +85,24 @@ module BinData
       selection
     end
 
-    def clear? #:nodoc:
-      current_choice.clear?
-    end
-
-    def assign(val)
-      current_choice.assign(val)
-    end
-
-    def snapshot
-      current_choice.snapshot
+    def safe_respond_to?(symbol, include_private = false) #:nodoc:
+      base_respond_to?(symbol, include_private)
     end
 
     def respond_to?(symbol, include_private = false) #:nodoc:
       current_choice.respond_to?(symbol, include_private) || super
     end
 
-    def safe_respond_to?(symbol, include_private = false) #:nodoc:
-      base_respond_to?(symbol, include_private)
-    end
-
     def method_missing(symbol, *args, &block) #:nodoc:
       current_choice.__send__(symbol, *args, &block)
     end
 
-    def do_read(io) #:nodoc:
-      current_choice.do_read(io)
-    end
-
-    def do_write(io) #:nodoc:
-      current_choice.do_write(io)
-    end
-
-    def do_num_bytes #:nodoc:
-      current_choice.do_num_bytes
+    %w(clear? assign snapshot do_read do_write do_num_bytes).each do |m|
+      self.module_eval <<-END
+        def #{m}(*args)
+          current_choice.#{m}(*args)
+        end
+      END
     end
 
     #---------------
@@ -178,6 +122,46 @@ module BinData
     end
   end
 
+  class ChoiceArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params) #:nodoc:
+      params.merge!(obj_class.dsl_params)
+
+      if params.needs_sanitizing?(:choices)
+        choices = choices_as_hash(params[:choices])
+        ensure_valid_keys(choices)
+        params[:choices] = params.create_sanitized_choices(choices)
+      end
+    end
+
+    #-------------
+    private
+
+    def choices_as_hash(choices)
+      if choices.respond_to?(:to_ary)
+        key_array_by_index(choices.to_ary)
+      else
+        choices
+      end
+    end
+
+    def key_array_by_index(array)
+      result = {}
+      array.each_with_index do |el, i|
+        result[i] = el unless el.nil?
+      end
+      result
+    end
+
+    def ensure_valid_keys(choices)
+      if choices.has_key?(nil)
+        raise ArgumentError, ":choices hash may not have nil key"
+      end
+      if choices.keys.detect { |key| key.is_a?(Symbol) and key != :default }
+        raise ArgumentError, ":choices hash may not have symbols for keys"
+      end
+    end
+  end
+
   # Logic for the :copy_on_change parameter
   module CopyOnChangePlugin
     def current_choice

data/lib/bindata/dsl.rb

@@ -5,60 +5,52 @@ module BinData
   #
   # BaseArgExtractor always assumes :bar is parameter.  This extractor correctly
   # identifies it as value or parameter.
-  class MultiFieldArgExtractor
-    class << self
-      def extract(the_class, the_args)
-        value, parameters, parent = BaseArgExtractor.extract(the_class, the_args)
-
-        if parameters_is_value?(the_class, value, parameters)
-          value = parameters
-          parameters = {}
-        end
+  module MultiFieldArgSeparator
+    def separate_args(obj_class, obj_args)
+      value, parameters, parent = super(obj_class, obj_args)
 
-        [value, parameters, parent]
+      if parameters_is_value?(obj_class, value, parameters)
+        value = parameters
+        parameters = {}
       end
 
-      def parameters_is_value?(the_class, value, parameters)
-        if value.nil? and parameters.length > 0
-          field_names_in_parameters?(the_class, parameters)
-        else
-          false
-        end
+      [value, parameters, parent]
+    end
+
+    def parameters_is_value?(obj_class, value, parameters)
+      if value.nil? and parameters.length > 0
+        field_names_in_parameters?(obj_class, parameters)
+      else
+        false
       end
+    end
 
-      def field_names_in_parameters?(the_class, parameters)
-        field_names = the_class.fields.field_names
-        param_keys = parameters.keys
+    def field_names_in_parameters?(obj_class, parameters)
+      field_names = obj_class.fields.field_names
+      param_keys = parameters.keys
 
-        (field_names & param_keys).length > 0
-      end
+      (field_names & param_keys).length > 0
     end
   end
 
+  # BinData classes that are part of the DSL must be extended by this.
   module DSLMixin
-    def self.included(base) #:nodoc:
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-
-      def dsl_parser(parser_type = nil)
-        unless defined? @dsl_parser
-          parser_type = superclass.dsl_parser.parser_type if parser_type.nil?
-          @dsl_parser = DSLParser.new(self, parser_type)
-        end
-        @dsl_parser
-      end
-
-      def method_missing(symbol, *args, &block) #:nodoc:
-        dsl_parser.__send__(symbol, *args, &block)
+    def dsl_parser(parser_type = nil)
+      unless defined? @dsl_parser
+        parser_type = superclass.dsl_parser.parser_type if parser_type.nil?
+        @dsl_parser = DSLParser.new(self, parser_type)
       end
+      @dsl_parser
+    end
 
-      # Assert object is not an array or string.
-      def to_ary; nil; end
-      def to_str; nil; end
+    def method_missing(symbol, *args, &block) #:nodoc:
+      dsl_parser.__send__(symbol, *args, &block)
     end
 
+    # Assert object is not an array or string.
+    def to_ary; nil; end
+    def to_str; nil; end
+
     # A DSLParser parses and accumulates field definitions of the form
     #
     #   type name, params
@@ -70,21 +62,25 @@ module BinData
     #
     class DSLParser
       def initialize(the_class, parser_type)
-        @the_class   = the_class
-        @parser_type = parser_type
-        @endian      = parent_attribute(:endian, nil)
+        raise "unknown parser type #{parser_type}" unless parser_abilities[parser_type]
+
+        @the_class      = the_class
+        @parser_type    = parser_type
+        @validator      = DSLFieldValidator.new(the_class, self)
+        @endian_handler = DSLBigAndLittleEndianHandler.new(the_class)
+        @endian         = nil
       end
 
       attr_reader :parser_type
 
       def endian(endian = nil)
-        if endian.nil?
-          @endian
-        elsif endian == :big or endian == :little
-          @endian = endian
-        else
-          dsl_raise ArgumentError, "unknown value for endian '#{endian}'"
+        if endian
+          set_endian(endian)
+        elsif @endian.nil?
+          pendian = parent_attribute(:endian, nil)
+          set_endian(pendian) if pendian
         end
+        @endian
       end
 
       def hide(*args)
@@ -102,7 +98,7 @@ module BinData
 
       def fields
         unless defined? @fields
-          fields = parent_attribute(:fields, nil)
+          fields = @endian_handler.ancestor_fields || parent_attribute(:fields)
           @fields = SanitizedFields.new(endian)
           @fields.copy_fields(fields) if fields
         end
@@ -111,62 +107,217 @@ module BinData
       end
 
       def dsl_params
-        case @parser_type
-        when :struct
-          to_struct_params
-        when :array
-          to_array_params
-        when :buffer
-          to_array_params
-        when :choice
-          to_choice_params
-        when :primitive
-          to_struct_params
+        send(parser_abilities[@parser_type].at(0))
+      end
+
+      def method_missing(*args, &block)
+        if endian == :big_and_little
+          @endian_handler.forward_field_definition(*args, &block)
         else
-          raise "unknown parser type #{@parser_type}"
+          parse_and_append_field(*args, &block)
+        end
+      end
+
+      #-------------
+      private
+
+      def parser_abilities
+        @abilities ||= {
+          :struct    => [:to_struct_params, [:multiple_fields, :optional_fieldnames, :hidden_fields]],
+          :array     => [:to_array_params,  [:multiple_fields, :optional_fieldnames]],
+          :buffer    => [:to_array_params,  [:multiple_fields, :optional_fieldnames]],
+          :choice    => [:to_choice_params, [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]],
+          :primitive => [:to_struct_params, [:multiple_fields, :optional_fieldnames]]
+        }
+      end
+
+      def option?(opt)
+        parser_abilities[@parser_type].at(1).include?(opt)
+      end
+
+      def set_endian(endian)
+        if has_fields?
+          dsl_raise SyntaxError, "endian must not be called after defining fields"
         end
+        if not valid_endian?(endian)
+          dsl_raise ArgumentError, "unknown value for endian '#{endian}'"
+        end
+
+        if endian == :big_and_little
+          @endian_handler.prepare_subclasses
+        end
+
+        @endian = endian
       end
 
-      def method_missing(symbol, *args, &block) #:nodoc:
-        type   = symbol
-        name   = name_from_field_declaration(args)
-        params = params_from_field_declaration(type, args, &block)
+      def has_fields?
+        @fields && @fields.length > 0
+      end
 
-        append_field(type, name, params)
+      def valid_endian?(endian)
+        [:big, :little, :big_and_little].include?(endian)
+      end
+
+      def parent_attribute(attr, default = nil)
+        parent = @the_class.superclass
+        parser = parent.respond_to?(:dsl_parser) ? parent.dsl_parser : nil
+        if parser and parser.respond_to?(attr)
+          parser.send(attr)
+        else
+          default
+        end
+      end
+
+      def parse_and_append_field(*args, &block)
+        parser = DSLFieldParser.new(endian, *args, &block)
+        begin
+          @validator.validate_field(parser.name)
+          append_field(parser.type, parser.name, parser.params)
+        rescue Exception => err
+          dsl_raise err.class, err.message
+        end
+      end
+
+      def append_field(type, name, params)
+        fields.add_field(type, name, params)
+      rescue BinData::UnRegisteredTypeError => err
+        raise TypeError, "unknown type '#{err.message}'"
+      end
+
+      def dsl_raise(exception, message)
+        backtrace = caller
+        backtrace.shift while %r{bindata/dsl.rb} =~ backtrace.first
+
+        raise exception, message + " in #{@the_class}", backtrace
+      end
+
+      def to_array_params
+        case fields.length
+        when 0
+          {}
+        when 1
+          {:type => fields[0].prototype}
+        else
+          {:type => [:struct, to_struct_params]}
+        end
+      end
+
+      def to_choice_params
+        if fields.length == 0
+          {}
+        elsif fields.all_field_names_blank?
+          {:choices => fields.collect { |f| f.prototype }}
+        else
+          choices = {}
+          fields.each { |f| choices[f.name] = f.prototype }
+          {:choices => choices}
+        end
+      end
+
+      def to_struct_params
+        result = {:fields => fields}
+        if not endian.nil?
+          result[:endian] = endian
+        end
+        if option?(:hidden_fields) and not hide.empty?
+          result[:hide] = hide
+        end
+
+        result
+      end
+    end
+
+    # Handles the :big_and_little endian option.
+    # This option creates two subclasses, each handling
+    # :big or :little endian.
+    class DSLBigAndLittleEndianHandler
+      def initialize(the_class)
+        @the_class = the_class
+      end
+
+      def prepare_subclasses
+        create_subclasses_with_endian
+        make_class_abstract
+        override_new_in_class
+      end
+
+      def forward_field_definition(*args, &block)
+        class_with_endian(@the_class,    :big).send(*args, &block)
+        class_with_endian(@the_class, :little).send(*args, &block)
+      end
+
+      def ancestor_fields
+        if subclass_of_big_and_little_endian?
+          pparent = @the_class.superclass.superclass
+          ancestor_with_endian = class_with_endian(pparent, @the_class.endian)
+          obj_attribute(ancestor_with_endian, :fields)
+        else
+          nil
+        end
       end
 
       #-------------
       private
 
-      def option?(opt)
-        options.include?(opt)
-      end
-
-      def options
-        case @parser_type
-        when :struct
-          [:multiple_fields, :optional_fieldnames, :hidden_fields]
-        when :array
-          [:multiple_fields, :optional_fieldnames]
-        when :buffer
-          [:multiple_fields, :optional_fieldnames]
-        when :choice
-          [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]
-        when :primitive
-          [:multiple_fields, :optional_fieldnames]
-        else
-          raise "unknown parser type #{parser_type}"
+      def create_subclasses_with_endian
+        instance_eval "class ::#{@the_class}Be < ::#{@the_class}; endian :big; end"
+        instance_eval "class ::#{@the_class}Le < ::#{@the_class}; endian :little; end"
+      end
+
+      def make_class_abstract
+        @the_class.send(:unregister_self)
+      end
+
+      def override_new_in_class
+        saved_class = @the_class
+        endian_classes = {
+          :big => class_with_endian(saved_class, :big),
+          :little => class_with_endian(saved_class, :little),
+        }
+        @the_class.define_singleton_method(:new) do |*args|
+          if self == saved_class
+            value, options, parent = arg_processor.separate_args(self, args)
+            delegate = endian_classes[options[:endian]]
+            return delegate.new(*args) if delegate
+          end
+
+          super(*args)
         end
       end
 
-      def parent_attribute(attr, default = nil)
-        parent = @the_class.superclass.respond_to?(:dsl_parser) ? @the_class.superclass.dsl_parser : nil
-        if parent and parent.respond_to?(attr)
-          parent.send(attr)
+      def subclass_of_big_and_little_endian?
+        parent  = @the_class.superclass
+        pparent = parent.superclass
+
+        obj_attribute(parent, :endian) == :big_and_little and
+        obj_attribute(pparent, :endian) == :big_and_little and
+        [:big, :little].include?(@the_class.endian)
+      end
+
+      def class_with_endian(class_name, endian)
+        RegisteredClasses.lookup(class_name, endian)
+      end
+
+      def obj_attribute(obj, attr, default = nil)
+        parser = obj.respond_to?(:dsl_parser) ? obj.dsl_parser : nil
+        if parser and parser.respond_to?(attr)
+          parser.send(attr)
         else
           default
         end
       end
+    end
+
+    # Extracts the details from a field declaration.
+    class DSLFieldParser
+      def initialize(endian, symbol, *args, &block)
+        @endian = endian
+        @type   = symbol
+        @name   = name_from_field_declaration(args)
+        @params = params_from_field_declaration(args, &block)
+      end
+
+      attr_reader :type, :name, :params
 
       def name_from_field_declaration(args)
         name, params = args
@@ -177,11 +328,11 @@ module BinData
         end
       end
 
-      def params_from_field_declaration(type, args, &block)
+      def params_from_field_declaration(args, &block)
         params = params_from_args(args)
 
         if block_given?
-          params.merge(params_from_block(type, &block))
+          params.merge(params_from_block(&block))
         else
           params
         end
@@ -194,7 +345,7 @@ module BinData
         params || {}
       end
 
-      def params_from_block(type, &block)
+      def params_from_block(&block)
         bindata_classes = {
           :array  => BinData::Array,
           :buffer => BinData::Buffer,
@@ -202,9 +353,9 @@ module BinData
           :struct => BinData::Struct
         }
 
-        if bindata_classes.include?(type)
-          parser = DSLParser.new(bindata_classes[type], type)
-          parser.endian(endian)
+        if bindata_classes.include?(@type)
+          parser = DSLParser.new(bindata_classes[@type], @type)
+          parser.endian(@endian)
           parser.instance_eval(&block)
 
           parser.dsl_params
@@ -212,61 +363,51 @@ module BinData
           {}
         end
       end
+    end
 
-      def append_field(type, name, params)
-        ensure_valid_field(name)
-
-        fields.add_field(type, name, params)
-      rescue ArgumentError => err
-        dsl_raise ArgumentError, err.message
-      rescue UnRegisteredTypeError => err
-        dsl_raise TypeError, "unknown type '#{err.message}'"
+    # Validates a field defined in a DSLMixin.
+    class DSLFieldValidator
+      def initialize(the_class, parser)
+        @the_class = the_class
+        @dsl_parser = parser
       end
 
-      def ensure_valid_field(field_name)
-        if too_many_fields?
-          dsl_raise SyntaxError, "attempting to wrap more than one type"
-        end
-
-        if must_not_have_a_name_failed?(field_name)
-          dsl_raise SyntaxError, "field must not have a name"
+      def validate_field(name)
+        if must_not_have_a_name_failed?(name)
+          raise SyntaxError, "field must not have a name"
         end
 
-        if all_or_none_names_failed?(field_name)
-          dsl_raise SyntaxError, "fields must either all have names, or none must have names"
+        if all_or_none_names_failed?(name)
+          raise SyntaxError, "fields must either all have names, or none must have names"
         end
 
-        if must_have_a_name_failed?(field_name)
-          dsl_raise SyntaxError, "field must have a name"
+        if must_have_a_name_failed?(name)
+          raise SyntaxError, "field must have a name"
         end
 
-        ensure_valid_name(field_name)
+        ensure_valid_name(name)
       end
 
       def ensure_valid_name(name)
         if name and not option?(:fieldnames_are_values)
           if malformed_name?(name)
-            dsl_raise NameError.new("", name), "field '#{name}' is an illegal fieldname"
+            raise NameError.new("", name), "field '#{name}' is an illegal fieldname"
           end
 
           if duplicate_name?(name)
-            dsl_raise SyntaxError, "duplicate field '#{name}'"
+            raise SyntaxError, "duplicate field '#{name}'"
           end
 
           if name_shadows_method?(name)
-            dsl_raise NameError.new("", name), "field '#{name}' shadows an existing method"
+            raise NameError.new("", name), "field '#{name}' shadows an existing method"
           end
 
           if name_is_reserved?(name)
-            dsl_raise NameError.new("", name), "field '#{name}' is a reserved name"
+            raise NameError.new("", name), "field '#{name}' is a reserved name"
           end
         end
       end
 
-      def too_many_fields?
-        option?(:only_one_field) and not fields.empty?
-      end
-
       def must_not_have_a_name_failed?(name)
         option?(:no_fieldnames) and name != nil
       end
@@ -302,46 +443,12 @@ module BinData
         BinData::Struct::RESERVED.include?(name.to_sym)
       end
 
-      def dsl_raise(exception, message)
-        backtrace = caller
-        backtrace.shift while %r{bindata/dsl.rb} =~ backtrace.first
-
-        raise exception, message + " in #{@the_class}", backtrace
-      end
-
-      def to_array_params
-        case fields.length
-        when 0
-          {}
-        when 1
-          {:type => fields[0].prototype}
-        else
-          {:type => [:struct, to_struct_params]}
-        end
-      end
-
-      def to_choice_params
-        if fields.length == 0
-          {}
-        elsif fields.all_field_names_blank?
-          {:choices => fields.collect { |f| f.prototype }}
-        else
-          choices = {}
-          fields.each { |f| choices[f.name] = f.prototype }
-          {:choices => choices}
-        end
+      def fields
+        @dsl_parser.fields
       end
 
-      def to_struct_params
-        result = {:fields => fields}
-        if not endian.nil?
-          result[:endian] = endian
-        end
-        if option?(:hidden_fields) and not hide.empty?
-          result[:hide] = hide
-        end
-
-        result
+      def option?(opt)
+        @dsl_parser.send(:option?, opt)
       end
     end
   end