iostruct 0.5.0 → 0.7.0

data/lib/iostruct/pack_fmt.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module IOStruct
+  module PackFmt
+    # https://apidock.com/ruby/String/unpack
+    FMTSPEC = {
+      'C' => [1, Integer ], # 8-bit unsigned                 (uint8_t, unsigned char)
+      'S' => [2, Integer ], # 16-bit unsigned, native endian (uint16_t)
+      'I' => [4, Integer ], # 32-bit unsigned, native endian (uint32_t, unsigned int)
+      'L' => [4, Integer ], # 32-bit unsigned, native endian (unsigned long)
+      'Q' => [8, Integer ], # 64-bit unsigned, native endian (uint64_t)
+
+      'c' => [1, Integer ], # 8-bit signed                 (int8_t, signed char)
+      's' => [2, Integer ], # 16-bit signed, native endian (int16_t)
+      'i' => [4, Integer ], # 32-bit signed, native endian (int32_t, int)
+      'l' => [4, Integer ], # 32-bit signed, native endian (long)
+      'q' => [8, Integer ], # 64-bit signed, native endian (int64_t)
+
+      'n' => [2, Integer ], # 16-bit unsigned, network (big-endian) byte order
+      'N' => [4, Integer ], # 32-bit unsigned, network (big-endian) byte order
+      'v' => [2, Integer ], # 16-bit unsigned, VAX (little-endian) byte order
+      'V' => [4, Integer ], # 32-bit unsigned, VAX (little-endian) byte order
+
+      'A' => [1, String  ], # arbitrary binary string (remove trailing nulls and ASCII spaces)
+      'a' => [1, String  ], # arbitrary binary string
+      'Z' => [1, String  ], # arbitrary binary string (remove trailing nulls)
+      'H' => [1, String  ], # hex string (high nibble first)
+      'h' => [1, String  ], # hex string (low nibble first)
+
+      'D' => [8, Float   ], # double-precision, native format
+      'd' => [8, Float   ],
+      'F' => [4, Float   ], # single-precision, native format
+      'f' => [4, Float   ],
+      'E' => [8, Float   ], # double-precision, little-endian byte order
+      'e' => [4, Float   ], # single-precision, little-endian byte order
+      'G' => [8, Float   ], # double-precision, network (big-endian) byte order
+      'g' => [4, Float   ], # single-precision, network (big-endian) byte order
+
+      'x' => [1, nil     ], # skip forward one byte
+    }.freeze
+
+    private
+
+    def parse_pack_format(fmt, _names)
+      offset = 0
+      fields = []
+      fmt.scan(/([a-z])(\d*)/i).map do |type, len|
+        size, klass = FMTSPEC[type] || raise("Unknown field type #{type.inspect}")
+        len = len.empty? ? 1 : len.to_i
+        case type
+        when 'A', 'a', 'x', 'Z'
+          fields << FieldInfo.new(klass, size * len, offset) if klass
+          offset += len
+        when 'H', 'h'
+          # XXX ruby's String#unpack length for hex strings is in characters, not bytes, i.e. "x".unpack("H2") => ["78"]
+          fields << FieldInfo.new(klass, size * len / 2, offset) if klass
+          offset += len / 2
+        else
+          len.times do |_i|
+            fields << FieldInfo.new(klass, size, offset)
+            offset += size
+          end
+        end
+      end
+      [fields, offset]
+    end
+  end
+end

data/lib/iostruct/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IOStruct
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/iostruct.rb

@@ -1,100 +1,70 @@
 # frozen_string_literal: true
 
-module IOStruct
+require_relative 'iostruct/pack_fmt'
+require_relative 'iostruct/hash_fmt'
 
-  # https://apidock.com/ruby/String/unpack
-  FMTSPEC = {
-    'C' => [1, Integer ], # 8-bit unsigned (unsigned char)
-    'S' => [2, Integer ], # 16-bit unsigned, native endian (uint16_t)
-    'I' => [4, Integer ], # 32-bit unsigned, native endian (uint32_t)
-    'L' => [4, Integer ], # 32-bit unsigned, native endian (uint32_t)
-    'Q' => [8, Integer ], # 64-bit unsigned, native endian (uint64_t)
-
-    'c' => [1, Integer ], # 8-bit signed (signed char)
-    's' => [2, Integer ], # 16-bit signed, native endian (int16_t)
-    'i' => [4, Integer ], # 32-bit signed, native endian (int32_t)
-    'l' => [4, Integer ], # 32-bit signed, native endian (int32_t)
-    'q' => [8, Integer ], # 64-bit signed, native endian (int64_t)
-
-    'n' => [2, Integer ], # 16-bit unsigned, network (big-endian) byte order
-    'N' => [4, Integer ], # 32-bit unsigned, network (big-endian) byte order
-    'v' => [2, Integer ], # 16-bit unsigned, VAX (little-endian) byte order
-    'V' => [4, Integer ], # 32-bit unsigned, VAX (little-endian) byte order
-
-    'A' => [1, String  ], # arbitrary binary string (remove trailing nulls and ASCII spaces)
-    'a' => [1, String  ], # arbitrary binary string
-    'Z' => [1, String  ], # arbitrary binary string (remove trailing nulls)
-    'H' => [1, String  ], # hex string (high nibble first)
-    'h' => [1, String  ], # hex string (low nibble first)
-
-    'D' => [8, Float   ], # double-precision, native format
-    'd' => [8, Float   ],
-    'F' => [4, Float   ], # single-precision, native format
-    'f' => [4, Float   ],
-    'E' => [8, Float   ], # double-precision, little-endian byte order
-    'e' => [4, Float   ], # single-precision, little-endian byte order
-    'G' => [8, Float   ], # double-precision, network (big-endian) byte order
-    'g' => [4, Float   ], # single-precision, network (big-endian) byte order
-
-    'x' => [1, nil     ], # skip forward one byte
-  }.freeze
-
-  FieldInfo = Struct.new :type, :size, :offset
-
-  def self.new fmt, *names, inspect: :hex, inspect_name_override: nil, **renames
-    fields, size = parse_format(fmt, names)
-    names = auto_names(fields, size) if names.empty?
-    names.map!{ |n| renames[n] || n } if renames.any?
-
-    Struct.new( *names ).tap do |x|
-      x.const_set 'FIELDS', names.zip(fields).to_h
-      x.const_set 'FORMAT', fmt
-      x.const_set 'SIZE',  size
-      x.extend ClassMethods
-      x.include InstanceMethods
-      x.include HexInspect if inspect == :hex
-      x.define_singleton_method(:name) { inspect_name_override } if inspect_name_override
+module IOStruct
+  extend PackFmt
+  extend HashFmt
+
+  # rubocop:disable Lint/StructNewOverride
+  FieldInfo = Struct.new :type, :size, :offset, :count, :fmt
+  # rubocop:enable Lint/StructNewOverride
+
+  def self.new fmt = nil, *names, inspect: :hex, inspect_name_override: nil, struct_name: nil, **kwargs
+    struct_name ||= inspect_name_override # XXX inspect_name_override is deprecated
+    if fmt
+      renames = kwargs
+      finfos, size = parse_pack_format(fmt, names)
+      names = auto_names(finfos, size) if names.empty?
+      names.map! { |n| renames[n] || n } if renames.any?
+    elsif kwargs[:fields]
+      fmt, names, finfos, size = parse_hash_format(name: struct_name, **kwargs)
+    else
+      raise "IOStruct: no fmt and no :fields specified"
     end
-  end # self.new
 
-  def self.parse_format(fmt, names)
-    offset = 0
-    fields = []
-    fmt.scan(/([a-z])(\d*)/i).map do |type,len|
-      size, klass = FMTSPEC[type] || raise("Unknown field type #{type.inspect}")
-      len = len.empty? ? 1 : len.to_i
-      case type
-      when 'A', 'a', 'x', 'Z'
-        fields << FieldInfo.new(klass, size*len, offset) if klass
-        offset += len
-      when 'H', 'h'
-        # XXX ruby's String#unpack length for hex strings is in characters, not bytes, i.e. "x".unpack("H2") => ["78"]
-        fields << FieldInfo.new(klass, size*len/2, offset) if klass
-        offset += len/2
+    # if first argument to Struct.new() is a string - it creates a named struct in the Struct:: namespace
+    # convert all just for the case
+    names = names.map(&:to_sym)
+
+    Struct.new( *names ) do
+      const_set 'FIELDS', names.zip(finfos).to_h
+      const_set 'FORMAT', fmt
+      const_set 'SIZE', size
+      extend ClassMethods
+      include InstanceMethods
+      include NestedInstanceMethods if finfos.any?(&:fmt)
+      case inspect
+      when :hex
+        include HexInspect
+      when :dec
+        include DecInspect
       else
-        len.times do |i|
-          fields << FieldInfo.new(klass, size, offset)
-          offset += size
-        end
+        # ruby default inspect
       end
+      define_singleton_method(:to_s) { struct_name } if struct_name
+      define_singleton_method(:name) { struct_name } if struct_name
     end
-    [fields, offset]
-  end
+  end # self.new
 
-  def self.auto_names fields, size
+  def self.auto_names(fields, _size)
     names = []
     offset = 0
     fields.each do |f|
       names << sprintf("f%x", offset).to_sym
       offset += f.size
     end
-    #raise "size mismatch: #{size} != #{offset}" if size != offset
     names
   end
 
+  def self.get_name(klass)
+    (klass.respond_to?(:name) && klass.name) || 'struct'
+  end
+
   module ClassMethods
     # src can be IO or String, or anything that responds to :read or :unpack
-    def read src, size = nil
+    def read(src, size = nil)
       pos = nil
       size ||= const_get 'SIZE'
       data =
@@ -106,19 +76,12 @@ module IOStruct
         else
           raise "[?] don't know how to read from #{src.inspect}"
         end
-#      if data.size < size
-#        $stderr.puts "[!] #{self.to_s} want #{size} bytes, got #{data.size}"
-#      end
-      new(*data.unpack(const_get('FORMAT'))).tap{ |x| x.__offset = pos }
+      new(*data.unpack(const_get('FORMAT'))).tap { |x| x.__offset = pos }
     end
 
     def size
       self::SIZE
     end
-
-    def name
-      self.to_s
-    end
   end # ClassMethods
 
   module InstanceMethods
@@ -129,7 +92,7 @@ module IOStruct
     end
 
     def empty?
-      to_a.all?{ |t| t == 0 || t.nil? || t.to_s.tr("\x00","").empty? }
+      to_a.all? { |t| t == 0 || t.nil? || t.to_s.tr("\x00", "").empty? }
     end
 
     # allow initializing individual struct members by name, like:
@@ -140,7 +103,7 @@ module IOStruct
     def initialize *args
       if args.size == 1 && args.first.is_a?(Hash)
         super()
-        args.first.each do |k,v|
+        args.first.each do |k, v|
           send "#{k}=", v
         end
       else
@@ -149,35 +112,128 @@ module IOStruct
     end
   end # InstanceMethods
 
-  module HexInspect
-    def to_s
-      "<#{self.class.name} " + to_h.map do |k, v|
-        if v.is_a?(Integer) && v > 9
-          "#{k}=0x%x" % v
+  # initialize nested structures / arrays
+  module NestedInstanceMethods
+    def initialize *args
+      super
+      self.class::FIELDS.each do |k, v|
+        next unless v.fmt
+        next unless (value = self[k])
+
+        self[k] =
+          if v.fmt.is_a?(String)
+            # Primitive array (e.g., "i3" for 3 ints)
+            value.unpack(v.fmt)
+          elsif v.count && v.count > 1
+            # Nested struct array: split data and read each chunk
+            item_size = v.fmt.size
+            v.count.times.map { |i| v.fmt.read(value[i * item_size, item_size]) }
+          else
+            # Single nested struct
+            v.fmt.read(value)
+          end
+      end
+    end
+
+    def pack
+      values = self.class::FIELDS.map do |k, v|
+        value = self[k]
+        next value unless v&.fmt && value
+
+        # Reverse the unpacking done in initialize
+        if v.fmt.is_a?(String)
+          # Primitive array
+          value.pack(v.fmt)
+        elsif v.count && v.count > 1
+          # Nested struct array: pack each and concatenate
+          value.map(&:pack).join
         else
-          "#{k}=#{v.inspect}"
+          # Single nested struct
+          value.pack
         end
-      end.join(' ') + ">"
+      end
+      values.pack self.class.const_get('FORMAT')
     end
+  end
+
+  module InspectBase
+    INT_MASKS = { 1 => 0xff, 2 => 0xffff, 4 => 0xffffffff, 8 => 0xffffffffffffffff }.freeze
 
+    # rubocop:disable Lint/DuplicateBranch
     def to_table
-      @fmtstr_tbl = "<#{self.class.name} " + self.class.const_get('FIELDS').map do |name, f|
-        fmt =
-          case 
+      values = to_a
+      "<#{IOStruct.get_name(self.class)} " + self.class::FIELDS.map.with_index do |el, idx|
+        v = values[idx]
+        fname, f = el
+
+        "#{fname}=" +
+          case
+          when f.nil? # unknown field type
+            v.inspect
           when f.type == Integer
-            "%#{f.size*2}x"
+            v ||= 0 # avoid "`sprintf': can't convert nil into Integer" error
+            format_int(v, f.size, fname)
           when f.type == Float
-            "%8.3f"
+            v ||= 0 # avoid "`sprintf': can't convert nil into Float" error
+            "%8.3f" % v
           else
-            "%s"
+            v.inspect
           end
-        "#{name}=#{fmt}"
       end.join(' ') + ">"
-      sprintf @fmtstr_tbl, *to_a.map{ |v| v.is_a?(String) ? v.inspect : (v||0) } # "||0" to avoid "`sprintf': can't convert nil into Integer" error
     end
+    # rubocop:enable Lint/DuplicateBranch
 
+    # don't make inspect an alias to to_s or vice versa, because:
+    #  - ruby's default struct inspect() and to_s() returns same result, but they are different methods
+    #  - inspect/to_s may already be used by some code (zsteg), where aliasing would break things
     def inspect
-      to_s
+      _inspect
+    end
+
+    def to_s
+      _inspect
+    end
+  end
+
+  module DecInspect
+    include InspectBase
+
+    DEC_FMTS = { 1 => "%4d", 2 => "%6d", 4 => "%11d", 8 => "%20d" }.freeze
+
+    def format_int(value, size, fname)
+      fmt = DEC_FMTS[size] || raise("Unsupported Integer size #{size} for field #{fname}")
+      fmt % value
+    end
+
+    private
+
+    def _inspect
+      "<#{IOStruct.get_name(self.class)} " + to_h.map { |k, v| "#{k}=#{v.inspect}" }.join(' ') + ">"
+    end
+  end
+
+  module HexInspect
+    include InspectBase
+
+    HEX_FMTS = { 1 => "%2x", 2 => "%4x", 4 => "%8x", 8 => "%16x" }.freeze
+
+    # display as unsigned, because signed %x looks ugly: "..f" for -1
+    def format_int(value, size, fname)
+      fmt  = HEX_FMTS[size]  || raise("Unsupported Integer size #{size} for field #{fname}")
+      mask = INT_MASKS[size] || raise("Unsupported Integer size #{size} for field #{fname}")
+      fmt % (value & mask)
+    end
+
+    private
+
+    def _inspect
+      "<#{IOStruct.get_name(self.class)} " + to_h.map do |k, v|
+        if v.is_a?(Integer) && v > 9
+          "#{k}=0x%x" % v
+        else
+          "#{k}=#{v.inspect}"
+        end
+      end.join(' ') + ">"
     end
   end
 end # IOStruct

data/spec/.rubocop.yml

@@ -0,0 +1,30 @@
+inherit_from: ../.rubocop.yml
+
+
+Layout/SpaceInsideParens:
+  Enabled: false
+
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+RSpec/ContextWording:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/ExampleWording:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Enabled: false
+
+RSpec/SpecFilePathFormat:
+  Enabled: false