packetgen 3.1.1 → 3.1.6

data/lib/packetgen/proto.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
+# 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.
 
-# frozen_string_literal: true
-
 require 'socket'
 
 module PacketGen

data/lib/packetgen/types.rb

@@ -1,3 +1,5 @@
+# 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>
@@ -10,6 +12,7 @@ module PacketGen
 end
 
 require_relative 'types/length_from'
+require_relative 'types/fieldable'
 require_relative 'types/int'
 require_relative 'types/enum'
 require_relative 'types/string'

data/lib/packetgen/types/abstract_tlv.rb

@@ -1,16 +1,16 @@
 # coding: utf-8
+# 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.
 
-# frozen_string_literal: true
-
 module PacketGen
   module Types
     # This class is an abstract class to define type-length-value data.
     #
-    # This class supersede {TLV} class, which is not well defined on some corner
+    # This class supersedes {TLV} class, which is not well defined on some corner
     # cases.
     #
     # ===Usage
@@ -33,7 +33,7 @@ module PacketGen
     #   tlv.value       #=> "abcd"
     #
     # ===Advanced usage
-    # Each field's type may be change at generating TLV class:
+    # Each field's type may be changed at generating TLV class:
     #   MyTLV = PacketGen::Types::AbstractTLV.create(type_class: PacketGen::Types::Int16,
     #                                                length_class: PacketGen::Types::Int16,
     #                                                value_class: PacketGen::Header::IP::Addr)
@@ -58,9 +58,12 @@ module PacketGen
     # @since 3.1.0
     # @since 3.1.1 add +:aliases+ keyword to {#initialize}
     class AbstractTLV < Types::Fields
+      include Fieldable
+
       class <<self
         # @return [Hash]
         attr_accessor :aliases
+        attr_accessor :header_in_length
       end
       self.aliases = {}
 
@@ -68,12 +71,17 @@ module PacketGen
       # @param [Class] type_class Class to use for +type+
       # @param [Class] length_class Class to use for +length+
       # @param [Class] value_class Class to use for +value+
+      # @param [Boolean] header_in_length if +true +, +type+ and +length+ fields are
+      #   included in length
       # @return [Class]
-      def self.create(type_class: Int8Enum, length_class: Int8, value_class: String, aliases: {})
+      # @since 3.1.4 Add +header_in_length+ parameter
+      def self.create(type_class: Int8Enum, length_class: Int8, value_class: String,
+                      aliases: {}, header_in_length: false)
         raise Error, '.create cannot be called on a subclass of PacketGen::Types::AbstractTLV' unless self.equal? AbstractTLV
 
         klass = Class.new(self)
         klass.aliases = aliases
+        klass.header_in_length = header_in_length
 
         if type_class < Enum
           klass.define_field :type, type_class, enum: {}
@@ -117,6 +125,7 @@ module PacketGen
       # @option options [Integer] :length
       # @option options [Object] :value
       def initialize(options={})
+        @header_in_length = self.class.header_in_length
         self.class.aliases.each do |al, orig|
           options[orig] = options[al] if options.key?(al)
         end
@@ -136,7 +145,7 @@ module PacketGen
         idx += self[:type].sz
         self[:length].read str[idx, self[:length].sz]
         idx += self[:length].sz
-        self[:value].read str[idx, self.length]
+        self[:value].read str[idx, real_length]
         self
       end
 
@@ -147,6 +156,7 @@ module PacketGen
       def value=(val)
         self[:value].from_human val
         self.length = self[:value].sz
+        self.length += self[:type].sz + self[:length].sz if @header_in_length
         val
       end
 
@@ -160,8 +170,18 @@ module PacketGen
       # @abstract Should only be called on real TLV class instances.
       # @return [String]
       def to_human
-        my_value = self[:value].is_a?(String) ? value.inspect : value.to_human
-        "type:%s,length:%u,value:#{my_value}" % [human_type, length]
+        my_value = self[:value].is_a?(String) ? self[:value].inspect : self[:value].to_human
+        'type:%s,length:%u,value:%s' % [human_type, length, my_value]
+      end
+
+      private
+
+      def real_length
+        if @header_in_length
+          self.length - self[:type].sz - self[:length].sz
+        else
+          self.length
+        end
       end
     end
   end

data/lib/packetgen/types/array.rb

@@ -1,10 +1,10 @@
+# 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.
 
-# frozen_string_literal: true
-
 require 'forwardable'
 
 module PacketGen
@@ -27,6 +27,9 @@ module PacketGen
     # @author Sylvain Daubert
     class Array
       extend Forwardable
+      include Enumerable
+      include Fieldable
+      include LengthFrom
 
       # @!method [](index)
       #   Return the element at +index+.
@@ -54,9 +57,6 @@ module PacketGen
       def_delegators :@array, :[], :clear, :each, :empty?, :first, :last, :size
       alias length size
 
-      include Enumerable
-      include LengthFrom
-
       # Separator used in {#to_human}.
       # May be ovverriden by subclasses
       HUMAN_SEPARATOR = ','
@@ -106,7 +106,7 @@ module PacketGen
       # @return [void]
       def clear!
         @array.clear
-        @counter.read(0) if @counter
+        @counter&.read(0)
       end
 
       # Delete an object from this array. Update associated counter if any
@@ -150,7 +150,7 @@ module PacketGen
       # @return [Array] self
       def <<(obj)
         push obj
-        @counter.read(@counter.to_i + 1) if @counter
+        @counter&.read(@counter.to_i + 1)
         self
       end
 
@@ -160,14 +160,11 @@ module PacketGen
       def read(str)
         clear
         return self if str.nil?
-        return self if @counter && @counter.to_i.zero?
+        return self if @counter&.to_i&.zero?
 
         str = read_with_length_from(str)
-        klass = self.class.set_of_klass
         until str.empty?
-          obj = klass.new.read(str)
-          real_klass = real_type(obj)
-          obj = real_klass.new.read(str) unless real_klass == klass
+          obj = create_object_from_str(str)
           @array << obj
           str.slice!(0, obj.sz)
           break if @counter && self.size == @counter.to_i
@@ -203,9 +200,7 @@ module PacketGen
 
       def record_from_hash(hsh)
         obj_klass = self.class.set_of_klass
-        unless obj_klass
-          raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of'
-        end
+        raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of' unless obj_klass
 
         obj = obj_klass.new(hsh) if obj_klass
         klass = real_type(obj)
@@ -215,6 +210,18 @@ module PacketGen
       def real_type(obj)
         obj.class
       end
+
+      def create_object_from_str(str)
+        klass = self.class.set_of_klass
+        obj = klass.new.read(str)
+        real_klass = real_type(obj)
+
+        if real_klass == klass
+          obj
+        else
+          real_klass.new.read(str)
+        end
+      end
     end
 
     # Specialized array to handle serie of {Int8}.

data/lib/packetgen/types/cstring.rb

@@ -1,20 +1,34 @@
 # coding: utf-8
+# 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.
 
-# frozen_string_literal: true
+require 'forwardable'
 
 module PacketGen
   module Types
     # This class handles null-terminated strings (aka C strings).
     # @author Sylvain Daubert
-    class CString < ::String
+    # @since 3.1.6 no more a subclass or regular String
+    class CString
+      extend Forwardable
+      include Fieldable
+
+      def_delegators :@string, :[], :length, :size, :inspect, :==, :<<,
+                     :unpack, :force_encoding, :encoding, :index, :empty?
+
+      # @return [::String]
+      attr_reader :string
+      # @return [Integer]
+      attr_reader :static_length
+
       # @param [Hash] options
       # @option options [Integer] :static_length set a static length for this string
       def initialize(options={})
-        super()
+        register_internal_string ''
         @static_length = options[:static_length]
       end
 
@@ -22,38 +36,41 @@ module PacketGen
       # @return [String] self
       def read(str)
         s = str.to_s
-        s = s[0, @static_length] if @static_length.is_a? Integer
+        s = s[0, static_length] if static_length?
         idx = s.index(0.chr)
         s = s[0, idx] unless idx.nil?
-        self.replace s
+        register_internal_string s
         self
       end
 
       # get null-terminated string
       # @return [String]
       def to_s
-        if defined?(@static_length) && @static_length.is_a?(Integer)
-          if self.size >= @static_length
-            s = self[0, @static_length]
-            s[-1] = "\x00".encode(s.encoding)
-            PacketGen.force_binary s
-          else
-            PacketGen.force_binary(self + "\0" * (@static_length - self.length))
-          end
+        if static_length?
+          s = string[0, static_length - 1]
+          s << "\x00" * (static_length - s.length)
         else
-          PacketGen.force_binary(self + +"\x00".encode(self.encoding))
+          s = "#{string}\x00"
         end
+        PacketGen.force_binary(s)
       end
 
       # @return [Integer]
       def sz
-        if @static_length.is_a? Integer
-          @static_length
+        if static_length?
+          static_length
         else
           to_s.size
         end
       end
 
+      # Say if a static length is defined
+      # @return [Boolean]
+      # @since 3.1.6
+      def static_length?
+        !static_length.nil?
+      end
+
       # Populate CString from a human readable string
       # @param [String] str
       # @return [self]
@@ -66,6 +83,13 @@ module PacketGen
         idx = self.index(+"\x00".encode(self.encoding)) || self.sz
         self[0, idx]
       end
+
+      private
+
+      def register_internal_string(str)
+        @string = str
+        PacketGen.force_binary(@string)
+      end
     end
   end
 end

data/lib/packetgen/types/enum.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
+# frozen_string_literal: true
+
 # This file is part of PacketGen
 # See https://github.com/sdaubert/packetgen for more informations
-# Copyright (C) 2032 Sylvain Daubert <sylvain.daubert@laposte.net>
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
-# frozen_string_literal: true
-
 module PacketGen
   module Types
     # @abstract Base enum class to handle binary integers with limited
@@ -55,6 +55,7 @@ module PacketGen
                  nil
                when ::String
                  raise ArgumentError, "#{value.inspect} not in enumeration" unless @enum.key? value
+
                  @enum[value]
                else
                  value.to_i
@@ -70,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

@@ -1,9 +1,11 @@
+# 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.
 
-# frozen_string_literal: true
+# rubocop:disable Metrics/ClassLength
 
 module PacketGen
   module Types
@@ -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,63 +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
-          unless type < Types::Int
-            raise TypeError, "#{attr} is not a PacketGen::Types::Int"
-          end
+          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
 
@@ -354,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|
@@ -362,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
@@ -371,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
@@ -409,7 +429,7 @@ module PacketGen
 
       # Get field object
       # @param [Symbol] field
-      # @return [Object]
+      # @return [Fieldable]
       def [](field)
         @fields[field]
       end
@@ -429,6 +449,7 @@ module PacketGen
       end
 
       # Get all optional field name
+      # @return[Array<Symbol>,nil]
       def optional_fields
         @optional_fields.keys
       end
@@ -459,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
 
@@ -530,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
@@ -549,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