packetgen 3.1.4 → 3.2.0

data/lib/packetgen/types/enum.rb

@@ -71,6 +71,10 @@ module PacketGen
       def to_human
         @enum.key(to_i) || "<unknown:#{@value}>"
       end
+
+      def format_inspect
+        format_str % [to_human, to_i]
+      end
     end
 
     # Enumeration on one byte. See {Enum}.

data/lib/packetgen/types/fieldable.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Types
+    # Mixin to define minimal API for a class to be embbeded as a field in
+    # {Fields} type.
+    #
+    # == Optional methods
+    # These methods may, optionally, be defined by fieldable types:
+    # * +from_human+ to load data from a human-readable string.
+    # @author Sylvain Daubert
+    # @since 3.1.6
+    module Fieldable
+      # Get type name
+      # @return [String]
+      def type_name
+        self.class.to_s.split('::').last
+      end
+
+      # rubocop:disable Lint/UselessMethodDefinition
+      # These methods are defined for documentation.
+
+      # Populate object from a binary string
+      # @param [String] str
+      # @return [Fields] self
+      # @abstract subclass should overload it.
+      def read(str)
+        super
+      end
+
+      # Return object as a binary string
+      # @return [String]
+      # @abstract subclass should overload it.
+      def to_s
+        super
+      end
+
+      # Size of object as binary string
+      # @return [Integer]
+      def sz
+        to_s.size
+      end
+
+      # Return a human-readbale string
+      # @return [String]
+      # @abstract subclass should overload it.
+      def to_human
+        super
+      end
+
+      # rubocop:enable Lint/UselessMethodDefinition
+
+      # Format object when inspecting a {Field} object
+      # @return [String]
+      def format_inspect
+        to_human
+      end
+    end
+  end
+end

data/lib/packetgen/types/fields.rb

@@ -5,6 +5,8 @@
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
+# rubocop:disable Metrics/ClassLength
+
 module PacketGen
   module Types
     # @abstract Set of fields
@@ -13,8 +15,7 @@ module PacketGen
     #
     # == Basics
     # A {Fields} subclass is generaly composed of multiple binary fields. These fields
-    # have each a given type. All types from {Types} module are supported, and all
-    # {Fields} subclasses may also be used as field type.
+    # have each a given type. All {Fieldable} types are supported.
     #
     # To define a new subclass, it has to inherit from {Fields}. And some class
     # methods have to be used to declare attributes/fields:
@@ -119,17 +120,23 @@ module PacketGen
         # @return [Hash]
         # @since 3.1.0
         attr_reader :field_defs
+        # Get bit fields defintions for this class
+        # @return [Hash]
+        # @since 3.1.5
+        attr_reader :bit_fields
 
         # On inheritage, create +@field_defs+ class variable
         # @param [Class] klass
         # @return [void]
         def inherited(klass)
+          super
+
           field_defs = {}
           @field_defs.each do |k, v|
             field_defs[k] = v.clone
           end
           ordered = @ordered_fields.clone
-          bf = @bit_fields.clone
+          bf = bit_fields.clone
 
           klass.class_eval do
             @ordered_fields = ordered
@@ -158,7 +165,7 @@ module PacketGen
         #   bs[value1]   # => Types::Int8
         #   bs.value1    # => Integer
         # @param [Symbol] name field name
-        # @param [Object] type class or instance
+        # @param [Fieldable] type class or instance
         # @param [Hash] options Unrecognized options are passed to object builder if
         #   +:builder+ option is not set.
         # @option options [Object] :default default value. May be a proc. This lambda
@@ -172,44 +179,22 @@ module PacketGen
         #   Define enumeration: hash's keys are +String+, and values are +Integer+.
         # @return [void]
         def define_field(name, type, options={})
-          define = []
-          if type < Types::Enum
-            define << "def #{name}; self[:#{name}].to_i; end"
-            define << "def #{name}=(val) self[:#{name}].value = val; end"
-          else
-            define << "def #{name}\n" \
-                      "  if self[:#{name}].respond_to?(:to_human) && self[:#{name}].respond_to?(:from_human)\n" \
-                      "    self[:#{name}].to_human\n" \
-                      "  else\n" \
-                      "    self[:#{name}]\n" \
-                      "  end\n" \
-                      'end'
-            define << "def #{name}=(val)\n" \
-                      "  if self[:#{name}].respond_to?(:to_human) && self[:#{name}].respond_to?(:from_human)\n" \
-                      "    self[:#{name}].from_human val\n" \
-                      "  else\n" \
-                      "    self[:#{name}].read val\n" \
-                      "  end\n" \
-                      'end'
-          end
-
-          define.delete_at(1) if instance_methods.include? "#{name}=".to_sym
-          define.delete_at(0) if instance_methods.include? name
-          class_eval define.join("\n")
+          fields << name
           field_defs[name] = FieldDef.new(type,
                                           options.delete(:default),
                                           options.delete(:builder),
                                           options.delete(:optional),
                                           options.delete(:enum),
                                           options)
-          fields << name
+
+          add_methods(name, type)
         end
 
         # Define a field, before another one
         # @param [Symbol,nil] other field name to create a new one before. If +nil+,
         #    new field is appended.
         # @param [Symbol] name field name to create
-        # @param [Object] type class or instance
+        # @param [Fieldable] type class or instance
         # @param [Hash] options See {.define_field}.
         # @return [void]
         # @see .define_field
@@ -228,7 +213,7 @@ module PacketGen
         # @param [Symbol,nil] other field name to create a new one after. If +nil+,
         #    new field is appended.
         # @param [Symbol] name field name to create
-        # @param [Object] type class or instance
+        # @param [Fieldable] type class or instance
         # @param [Hash] options See {.define_field}.
         # @return [void]
         # @see .define_field
@@ -262,12 +247,12 @@ module PacketGen
         # @raise [ArgumentError] unknown +field+
         # @since 2.8.4
         def update_field(field, options)
-          raise ArgumentError, "unkown #{field} field for #{self}" unless field_defs.key?(field)
+          check_existence_of field
+
+          %i[default builder optional enum].each do |property|
+            field_defs_property_from(field, property, options)
+          end
 
-          field_defs[field].default = options.delete(:default) if options.key?(:default)
-          field_defs[field].builder = options.delete(:builder) if options.key?(:builder)
-          field_defs[field].optional = options.delete(:optional) if options.key?(:optional)
-          field_defs[field].enum = options.delete(:enum) if options.key?(:enum)
           field_defs[field].options.merge!(options)
         end
 
@@ -289,61 +274,29 @@ module PacketGen
         #   subclass)
         # @param [Array] args list of bitfield names. Name may be followed
         #   by bitfield size. If no size is given, 1 bit is assumed.
+        # @raise [ArgumentError] unknown +attr+
         # @return [void]
         def define_bit_fields_on(attr, *args)
-          attr_def = field_defs[attr]
-          raise ArgumentError, "unknown #{attr} field" if attr_def.nil?
+          check_existence_of attr
 
-          type = attr_def.type
+          type = field_defs[attr].type
           raise TypeError, "#{attr} is not a PacketGen::Types::Int" unless type < Types::Int
 
           total_size = type.new.width * 8
           idx = total_size - 1
 
-          field = args.shift
-          while field
+          until args.empty?
+            field = args.shift
             next unless field.is_a? Symbol
 
-            size = if args.first.is_a? Integer
-                     args.shift
-                   else
-                     1
-                   end
+            size = size_from(args)
+
             unless field == :_
-              shift = idx - (size - 1)
-              field_mask = (2**size - 1) << shift
-              clear_mask = (2**total_size - 1) & (~field_mask & (2**total_size - 1))
-
-              if size == 1
-                class_eval <<-METHODS
-                def #{field}?
-                  val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-                  val != 0
-                end
-                def #{field}=(v)
-                  val = v ? 1 : 0
-                  self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-                  self[:#{attr}].value |= val << #{shift}
-                end
-                METHODS
-              else
-                class_eval <<-METHODS
-                def #{field}
-                  (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-                end
-                def #{field}=(v)
-                  self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-                  self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
-                end
-                METHODS
-              end
-
-              @bit_fields[attr] = {} if @bit_fields[attr].nil?
-              @bit_fields[attr][field] = size
+              add_bit_methods(attr, field, size, total_size, idx)
+              register_bit_field_size(attr, field, size)
             end
 
             idx -= size
-            field = args.shift
           end
         end
 
@@ -352,7 +305,7 @@ module PacketGen
         # @return [void]
         # @since 2.8.4
         def remove_bit_fields_on(attr)
-          fields = @bit_fields.delete(attr)
+          fields = bit_fields.delete(attr)
           return if fields.nil?
 
           fields.each do |field, size|
@@ -360,6 +313,98 @@ module PacketGen
             undef_method(size == 1 ? "#{field}?" : field)
           end
         end
+
+        private
+
+        def add_methods(name, type)
+          define = []
+          if type < Types::Enum
+            define << "def #{name}; self[:#{name}].to_i; end"
+            define << "def #{name}=(val) self[:#{name}].value = val; end"
+          else
+            define << "def #{name}\n" \
+                      "  to_and_from_human?(:#{name}) ? self[:#{name}].to_human : self[:#{name}]\n" \
+                      'end'
+            define << "def #{name}=(val)\n" \
+                      "  to_and_from_human?(:#{name}) ? self[:#{name}].from_human(val) : self[:#{name}].read(val)\n" \
+                      'end'
+          end
+
+          define.delete_at(1) if instance_methods.include? "#{name}=".to_sym
+          define.delete_at(0) if instance_methods.include? name
+          class_eval define.join("\n")
+        end
+
+        def add_bit_methods(attr, name, size, total_size, idx)
+          shift = idx - (size - 1)
+
+          if size == 1
+            add_single_bit_methods(attr, name, size, total_size, shift)
+          else
+            add_multibit_methods(attr, name, size, total_size, shift)
+          end
+        end
+
+        def compute_field_mask(size, shift)
+          (2**size - 1) << shift
+        end
+
+        def compute_clear_mask(total_size, field_mask)
+          (2**total_size - 1) & (~field_mask & (2**total_size - 1))
+        end
+
+        def add_single_bit_methods(attr, name, size, total_size, shift)
+          field_mask = compute_field_mask(size, shift)
+          clear_mask = compute_clear_mask(total_size, field_mask)
+
+          class_eval <<-METHODS
+          def #{name}?
+            val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
+            val != 0
+          end
+          def #{name}=(v)
+            val = v ? 1 : 0
+            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
+            self[:#{attr}].value |= val << #{shift}
+          end
+          METHODS
+        end
+
+        def add_multibit_methods(attr, name, size, total_size, shift)
+          field_mask = compute_field_mask(size, shift)
+          clear_mask = compute_clear_mask(total_size, field_mask)
+
+          class_eval <<-METHODS
+          def #{name}
+            (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
+          end
+          def #{name}=(v)
+            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
+            self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
+          end
+          METHODS
+        end
+
+        def register_bit_field_size(attr, field, size)
+          bit_fields[attr] = {} if bit_fields[attr].nil?
+          bit_fields[attr][field] = size
+        end
+
+        def field_defs_property_from(field, property, options)
+          field_defs[field].send("#{property}=", options.delete(property)) if options.key?(property)
+        end
+
+        def size_from(args)
+          if args.first.is_a? Integer
+            args.shift
+          else
+            1
+          end
+        end
+
+        def check_existence_of(field)
+          raise ArgumentError, "unknown #{field} field for #{self}" unless field_defs.key?(field)
+        end
       end
 
       # Create a new fields object
@@ -369,36 +414,13 @@ module PacketGen
         @fields = {}
         @optional_fields = {}
 
-        field_defs = self.class.field_defs
         self.class.fields.each do |field|
-          type = field_defs[field].type
-          default = field_defs[field].default
-          default = default.to_proc.call(self) if default.is_a?(Proc)
-          builder = field_defs[field].builder
-          optional = field_defs[field].optional
-          enum = field_defs[field].enum
-          field_options = field_defs[field].options
-
-          @fields[field] = if builder
-                             builder.call(self, type)
-                           elsif enum
-                             type.new(enum)
-                           elsif !field_options.empty?
-                             type.new(field_options)
-                           else
-                             type.new
-                           end
-
-          value = options[field] || default
-          if value.class <= type
-            @fields[field] = value
-          elsif @fields[field].respond_to? :from_human
-            @fields[field].from_human(value)
-          end
-
-          @optional_fields[field] = optional if optional
+          build_field field
+          initialize_value field, options[field]
+          initialize_optional field
         end
-        self.class.class_eval { @bit_fields }.each do |_, hsh|
+
+        self.class.bit_fields.each do |_, hsh|
           hsh.each_key do |bit_field|
             self.send "#{bit_field}=", options[bit_field] if options[bit_field]
           end
@@ -407,7 +429,7 @@ module PacketGen
 
       # Get field object
       # @param [Symbol] field
-      # @return [Object]
+      # @return [Fieldable]
       def [](field)
         @fields[field]
       end
@@ -427,6 +449,7 @@ module PacketGen
       end
 
       # Get all optional field name
+      # @return[Array<Symbol>,nil]
       def optional_fields
         @optional_fields.keys
       end
@@ -457,11 +480,7 @@ module PacketGen
           next unless present?(field)
 
           obj = self[field].read str[start..-1]
-          if self[field].respond_to? :sz
-            start += self[field].sz
-          else
-            start = str.size
-          end
+          start += self[field].sz
           self[field] = obj unless obj == self[field]
         end
 
@@ -528,7 +547,7 @@ module PacketGen
       # @return [Hash,nil] keys: bit fields, values: their size in bits
       # @since 2.8.3
       def bits_on(field)
-        self.class.class_eval { @bit_fields }[field]
+        self.class.bit_fields[field]
       end
 
       private
@@ -547,6 +566,54 @@ module PacketGen
       def force_binary(str)
         PacketGen.force_binary(str)
       end
+
+      # @param [Symbol] attr attribute
+      # @return [Boolean] +tru+e if #from_human and #to_human are both defined for given attribute
+      def to_and_from_human?(attr)
+        self[attr].respond_to?(:to_human) && self[attr].respond_to?(:from_human)
+      end
+
+      def field_defs
+        self.class.field_defs
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def build_field(field)
+        type = field_defs[field].type
+
+        @fields[field] = if field_defs[field].builder
+                           field_defs[field].builder.call(self, type)
+                         elsif field_defs[field].enum
+                           type.new(field_defs[field].enum)
+                         elsif !field_defs[field].options.empty?
+                           type.new(field_defs[field].options)
+                         else
+                           type.new
+                         end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def initialize_value(field, val)
+        type = field_defs[field].type
+        default = field_defs[field].default
+        default = default.to_proc.call(self) if default.is_a?(Proc)
+
+        value = val || default
+        if value.class <= type
+          @fields[field] = value
+        elsif @fields[field].respond_to? :from_human
+          @fields[field].from_human(value)
+        else
+          @fields[field].read(value)
+        end
+      end
+
+      def initialize_optional(field)
+        optional = field_defs[field].optional
+        @optional_fields[field] = optional if optional
+      end
     end
   end
 end
+
+# rubocop:enable Metrics/ClassLength