kaitai-struct 0.10 → 0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbdd2b873476556b609d64f78e10c3ef35ea5ede048ac5ee57a03a24f523bfac
-  data.tar.gz: db41f46711b11efcf12a982e282181ae20d25831f408b7a3e7e668791f14701b
+  metadata.gz: dd4bb9d0b8c7befee55e055dd8eb8aba8e13f08074600f3ed2a49e1b32f11ebc
+  data.tar.gz: 24fe1b2e85d6682c71afb4fd80824634b9113453e3fb80736c12c8051c09c5d9
 SHA512:
-  metadata.gz: ea4b2780d4efa7c645175957059073f6506ee5e39d2525b62f7a5de41816d0115dde2980948ab47e8994b1a7fc97cb94e8fab7692882244fc7d9b58b18b3e8b3
-  data.tar.gz: 99cec16629be56c07b1df24f4a091fbffdd6240341dc0130ef6a5d04195a91c37d6238c4991ba3782667514cf25ae7746aa2fdd3aa307c34352c0dd0698ea4c9
+  metadata.gz: 9f88733d357dbe3962c34437bf775cfd0d9a4c3f48dbc9c88be7a08606c9d4ec8a2adfb8e61804b61bb28ff10cb5cd1178f7ef0397edf0d6d2703e1846ce2afe
+  data.tar.gz: 53e735516abfafc05f0218b93cabfeece0978a3d41aec1afb04c21d89dc76085cb83ecfd5b13bc0d41fe2d8dfec67a4c7acb96e283c62e0fa0b27cded490b48b

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2015-2022 Kaitai Project
+Copyright (c) 2015-2025 Kaitai Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -11,8 +11,8 @@ formats, network stream packet formats, etc.
 
 Further reading:
 
-* [About Kaitai Struct](http://kaitai.io/)
-* [About API implemented in this library](http://doc.kaitai.io/stream_api.html)
+* [About Kaitai Struct](https://kaitai.io/)
+* [About API implemented in this library](https://doc.kaitai.io/stream_api.html)
 
 ## Installing
 

data/lib/kaitai/struct/struct.rb

@@ -3,7 +3,7 @@ require 'stringio'
 module Kaitai
 module Struct
 
-VERSION = '0.10'
+VERSION = '0.11'
 
 ##
 # Common base class for all structured generated by Kaitai Struct.
@@ -12,7 +12,7 @@ VERSION = '0.10'
 # structure in {#_root} and provides a few helper methods.
 class Struct
 
-  def initialize(_io, _parent = nil, _root = self)
+  def initialize(_io, _parent = nil, _root = nil)
     @_io = _io
     @_parent = _parent
     @_root = _root
@@ -76,31 +76,38 @@ end
 # and API to do the actual parsing job.
 class Stream
   ##
-  # Unused since Kaitai Struct Compiler v0.9+ - compatibility with
-  # older versions.
+  # @deprecated Unused since Kaitai Struct compiler 0.9. It
+  #   is only available for backward compatibility and will be
+  #   removed in the future. KSC 0.9 and later versions use
+  #   {ValidationNotEqualError} instead.
   #
   # Exception class for an error that occurs when some fixed content
   # was expected to appear, but actual data read was different.
   class UnexpectedDataError < Exception
     def initialize(actual, expected)
-      super("Unexpected fixed contents: got #{Stream.format_hex(actual)}, was waiting for #{Stream.format_hex(expected)}")
+      super("Unexpected fixed contents: got #{Internal.format_hex(actual)}, " \
+            "was waiting for #{Internal.format_hex(expected)}")
       @actual = actual
       @expected = expected
     end
   end
 
+  # Module#deprecate_constant was added in Ruby 2.3, see
+  # https://rubyreferences.github.io/rubychanges/evolution.html#modules-and-classes
+  deprecate_constant :UnexpectedDataError if respond_to?(:deprecate_constant)
 
   ##
   # Constructs new Kaitai Stream object.
-  # @param arg [String, IO] if String, it will be used as byte array to read data from;
-  #   if IO, if will be used literally as source of data
+  # @param arg [String, IO, StringIO, SubIO] if String, it will be used as byte
+  #   array to read data from; if IO (or StringIO, or SubIO), if will be used literally
+  #   as the source of data
   def initialize(arg)
     if arg.is_a?(String)
       @_io = StringIO.new(arg)
-    elsif arg.is_a?(IO)
+    elsif arg.is_a?(IO) or arg.is_a?(StringIO) or arg.is_a?(SubIO)
       @_io = arg
     else
-      raise TypeError.new('can be initialized with IO or String only')
+      raise TypeError.new('can be initialized with IO, StringIO, SubIO or String only')
     end
     align_to_byte
   end
@@ -116,12 +123,13 @@ class Stream
   ##
   # Closes underlying IO object.
   def close
-    @_io.close
+    # NOTE: `unless @_io.closed?` is only needed in Ruby 2.2 and below. Ruby 2.3
+    # and later versions no longer raise `IOError: closed stream` when
+    # `StringIO#close` is called a second time, see
+    # https://github.com/ruby/ruby/commit/2e02f2dfd2dab936e7cd9a68d46bd910c5d184e5
+    @_io.close unless @_io.closed?
   end
 
-  # Test endianness of the platform
-  @@big_endian = [0x0102].pack('s') == [0x0102].pack('n')
-
   # @!group Stream positioning
 
   ##
@@ -161,21 +169,15 @@ class Stream
   # ........................................................................
 
   def read_s2be
-    to_signed(read_u2be, SIGN_MASK_16)
+    read_bytes(2).unpack('s>')[0]
   end
 
   def read_s4be
-    to_signed(read_u4be, SIGN_MASK_32)
+    read_bytes(4).unpack('l>')[0]
   end
 
-  if @@big_endian
-    def read_s8be
-      read_bytes(8).unpack('q')[0]
-    end
-  else
-    def read_s8be
-      to_signed(read_u8be, SIGN_MASK_64)
-    end
+  def read_s8be
+    read_bytes(8).unpack('q>')[0]
   end
 
   # ........................................................................
@@ -183,21 +185,15 @@ class Stream
   # ........................................................................
 
   def read_s2le
-    to_signed(read_u2le, SIGN_MASK_16)
+    read_bytes(2).unpack('s<')[0]
   end
 
   def read_s4le
-    to_signed(read_u4le, SIGN_MASK_32)
+    read_bytes(4).unpack('l<')[0]
   end
 
-  unless @@big_endian
-    def read_s8le
-      read_bytes(8).unpack('q')[0]
-    end
-  else
-    def read_s8le
-      to_signed(read_u8le, SIGN_MASK_64)
-    end
+  def read_s8le
+    read_bytes(8).unpack('q<')[0]
   end
 
   # ------------------------------------------------------------------------
@@ -213,22 +209,15 @@ class Stream
   # ........................................................................
 
   def read_u2be
-    read_bytes(2).unpack('n')[0]
+    read_bytes(2).unpack('S>')[0]
   end
 
   def read_u4be
-    read_bytes(4).unpack('N')[0]
+    read_bytes(4).unpack('L>')[0]
   end
 
-  if @@big_endian
-    def read_u8be
-      read_bytes(8).unpack('Q')[0]
-    end
-  else
-    def read_u8be
-      a, b = read_bytes(8).unpack('NN')
-      (a << 32) + b
-    end
+  def read_u8be
+    read_bytes(8).unpack('Q>')[0]
   end
 
   # ........................................................................
@@ -236,22 +225,15 @@ class Stream
   # ........................................................................
 
   def read_u2le
-    read_bytes(2).unpack('v')[0]
+    read_bytes(2).unpack('S<')[0]
   end
 
   def read_u4le
-    read_bytes(4).unpack('V')[0]
+    read_bytes(4).unpack('L<')[0]
   end
 
-  unless @@big_endian
-    def read_u8le
-      read_bytes(8).unpack('Q')[0]
-    end
-  else
-    def read_u8le
-      a, b = read_bytes(8).unpack('VV')
-      (b << 32) + a
-    end
+  def read_u8le
+    read_bytes(8).unpack('Q<')[0]
   end
 
   # @!endgroup
@@ -320,9 +302,16 @@ class Stream
     res
   end
 
-  # Unused since Kaitai Struct Compiler v0.9+ - compatibility with
-  # older versions.
+  ##
+  # @deprecated Unused since Kaitai Struct compiler 0.9. It
+  #   is only available for backward compatibility and will be
+  #   removed in the future. KSC 0.9 and later versions use
+  #   {#read_bits_int_be} instead.
   def read_bits_int(n)
+    Internal.warn_deprecated(
+      'method Stream#read_bits_int is deprecated since 0.9, ' \
+      'use Stream#read_bits_int_be instead'
+    )
     read_bits_int_be(n)
   end
 
@@ -330,7 +319,7 @@ class Stream
     res = 0
     bits_needed = n - @bits_left
 
-    if bits_needed > 0 then
+    if bits_needed > 0
       # 1 bit  => 1 byte
       # 8 bits => 1 byte
       # 9 bits => 2 bytes
@@ -368,13 +357,26 @@ class Stream
   # @raise [EOFError] if there were less bytes than requested
   #   available in the stream
   def read_bytes(n)
+    if n.nil?
+      # This `read(0)` call is only used to raise `IOError: not opened for reading`
+      # if the stream is closed. This ensures identical behavior to the `substream`
+      # method.
+      @_io.read(0)
+      raise TypeError.new('no implicit conversion from nil to integer')
+    end
+
     r = @_io.read(n)
-    if r
-      rl = r.bytesize
-    else
-      rl = 0
+    rl = r ? r.bytesize : 0
+    n = n.to_int
+    if rl < n
+      begin
+        @_io.seek(@_io.pos - rl)
+      rescue Errno::ESPIPE
+        # We have a non-seekable stream, so we can't go back to the
+        # previous position - that's fine.
+      end
+      raise EOFError.new("attempted to read #{n} bytes, got only #{rl}")
     end
-    raise EOFError.new("attempted to read #{n} bytes, got only #{rl}") if rl < n
     r
   end
 
@@ -386,17 +388,18 @@ class Stream
   end
 
   def read_bytes_term(term, include_term, consume_term, eos_error)
-    r = ''
+    term_byte = term.chr
+    r = String.new
     loop {
-      if @_io.eof?
+      c = @_io.getc
+      if c.nil?
         if eos_error
           raise EOFError.new("end of stream reached, but no terminator #{term} found")
-        else
-          return r
         end
+
+        return r
       end
-      c = @_io.getc
-      if c.ord == term
+      if c == term_byte
         r << c if include_term
         @_io.seek(@_io.pos - 1) unless consume_term
         return r
@@ -405,9 +408,33 @@ class Stream
     }
   end
 
+  def read_bytes_term_multi(term, include_term, consume_term, eos_error)
+    unit_size = term.bytesize
+    r = String.new
+    loop {
+      c = @_io.read(unit_size) || ''
+      if c.bytesize < unit_size
+        if eos_error
+          raise EOFError.new("end of stream reached, but no terminator #{term} found")
+        end
+
+        r << c
+        return r
+      end
+      if c == term
+        r << c if include_term
+        @_io.seek(@_io.pos - unit_size) unless consume_term
+        return r
+      end
+      r << c
+    }
+  end
+
   ##
-  # Unused since Kaitai Struct Compiler v0.9+ - compatibility with
-  # older versions.
+  # @deprecated Unused since Kaitai Struct compiler 0.9. It
+  #   is only available for backward compatibility and will be
+  #   removed in the future. KSC 0.9 and later versions raise
+  #   {ValidationNotEqualError} instead.
   #
   # Reads next len bytes from the stream and ensures that they match
   # expected fixed byte array. If they differ, throws a
@@ -417,6 +444,10 @@ class Stream
   #   equal to expected
   # @raise [UnexpectedDataError]
   def ensure_fixed_contents(expected)
+    Internal.warn_deprecated(
+      'method Stream#ensure_fixed_contents is deprecated since 0.9, ' \
+      'explicitly raise ValidationNotEqualError from an `if` statement instead'
+    )
     len = expected.bytesize
     actual = @_io.read(len)
     raise UnexpectedDataError.new(actual, expected) if actual != expected
@@ -433,13 +464,27 @@ class Stream
   end
 
   def self.bytes_terminate(bytes, term, include_term)
-    new_len = 0
-    max_len = bytes.length
-    while bytes.getbyte(new_len) != term and new_len < max_len
-      new_len += 1
+    term_index = bytes.index(term.chr)
+    if term_index.nil?
+      bytes.dup
+    else
+      bytes[0, term_index + (include_term ? 1 : 0)]
     end
-    new_len += 1 if include_term and new_len < max_len
-    bytes[0, new_len]
+  end
+
+  def self.bytes_terminate_multi(bytes, term, include_term)
+    unit_size = term.bytesize
+    search_index = bytes.index(term)
+    loop {
+      if search_index.nil?
+        return bytes.dup
+      end
+      mod = search_index % unit_size
+      if mod == 0
+        return bytes[0, search_index + (include_term ? unit_size : 0)]
+      end
+      search_index = bytes.index(term, search_index + (unit_size - mod))
+    }
   end
 
   # @!endgroup
@@ -516,52 +561,150 @@ class Stream
 
   # @!endgroup
 
+  ##
+  # Reserves next n bytes from current stream as a
+  # Kaitai::Struct::Stream substream. Substream has its own pointer
+  # and addressing in the range of [0, n) bytes. This stream's pointer
+  # is advanced to the position right after this substream.
+  # @param n [Fixnum] number of bytes to reserve for a substream
+  # @return [Stream] substream covering n bytes from the current
+  #   position
+  def substream(n)
+    raise IOError.new('not opened for reading') if @_io.closed?
+
+    n = Internal.num2long(n)
+    raise ArgumentError.new("negative length #{n} given") if n < 0
+
+    rl = [0, @_io.size - @_io.pos].max
+    raise EOFError.new("attempted to read #{n} bytes, got only #{rl}") if rl < n
+
+    sub = Stream.new(SubIO.new(@_io, @_io.pos, n))
+    @_io.seek(@_io.pos + n)
+    sub
+  end
+
   ##
   # Resolves value using enum: if the value is not found in the map,
   # we'll just use literal value per se.
   def self.resolve_enum(enum_map, value)
     enum_map[value] || value
   end
+end
 
-  # ========================================================================
+##
+# Substream IO implementation: a IO object which wraps existing IO object
+# and provides similar byte/bytes reading functionality, but only for a
+# limited set of bytes starting from specified offset and spanning up to
+# specified length.
+class SubIO
+  ##
+  # Parent IO object that this substream is projecting data from.
+  attr_reader :parent_io
+
+  ##
+  # Offset of start of substream in coordinates of parent stream. In
+  # coordinates of substream itself start will be always 0.
+  attr_reader :parent_start
+
+  ##
+  # Size of substream in bytes.
+  attr_reader :size
 
-  private
-  SIGN_MASK_16 = (1 << (16 - 1))
-  SIGN_MASK_32 = (1 << (32 - 1))
-  SIGN_MASK_64 = (1 << (64 - 1))
+  ##
+  # Current position in a substream. Independent from a position in a
+  # parent IO.
+  attr_reader :pos
 
-  def to_signed(x, mask)
-    (x & ~mask) - (x & mask)
+  def initialize(parent_io, parent_start, size)
+    @parent_io = parent_io
+    @parent_start = parent_start
+    @size = size
+    @pos = 0
+    @closed = false
   end
 
-  def self.format_hex(bytes)
-    bytes.unpack('H*')[0].gsub(/(..)/, '\1 ').chop
+  def eof?
+    raise IOError.new('not opened for reading') if @closed
+
+    @pos >= @size
   end
 
-  ###
-  # Guess if the given args are most likely byte arrays.
-  # <p>
-  # There's no way to know for sure, but {@code Encoding::ASCII_8BIT} is a special encoding that is
-  # usually used for a byte array(/string), not a character string. For those reasons, that encoding
-  # is NOT planned to be allowed for human readable texts by KS in general as well.
-  # </p>
-  # @param args [...] Something to check.
-  # @see <a href="https://ruby-doc.org/core-3.0.0/Encoding.html">Encoding</a>
-  # @see <a href="https://github.com/kaitai-io/kaitai_struct/issues/116">List of supported encodings</a>
-  #
-  def self.is_byte_array?(*args)
-    args.all? { |arg| arg.is_a?(String) and (arg.encoding == Encoding::ASCII_8BIT) }
+  def seek(offset, whence = IO::SEEK_SET)
+    raise ArgumentError.new('only IO::SEEK_SET is supported by SubIO#seek') unless whence == IO::SEEK_SET
+
+    offset = Internal.num2long(offset)
+    raise IOError.new('closed stream') if @closed
+    raise Errno::EINVAL if offset < 0
+    @pos = offset.to_int
+    return 0
   end
 
-  def self.inspect_values(*args)
-    reprs = args.map { |arg|
-      if Stream.is_byte_array?(arg)
-        "[#{Stream.format_hex(arg)}]"
-      else
-        arg.inspect
+  def getc
+    raise IOError.new('not opened for reading') if @closed
+
+    return nil if @pos >= @size
+
+    # remember position in parent IO
+    old_pos = @parent_io.pos
+    @parent_io.seek(@parent_start + @pos)
+    begin
+      res = @parent_io.getc
+      @pos += 1
+    ensure
+      # restore position in parent IO
+      @parent_io.seek(old_pos)
+    end
+
+    res
+  end
+
+  def read(len = nil)
+    raise IOError.new('not opened for reading') if @closed
+
+    # read until the end of substream
+    if len.nil?
+      len = @size - @pos
+      return String.new if len <= 0
+    elsif len.respond_to?(:to_int)
+      len = len.to_int
+      # special case for requesting exactly 0 bytes
+      return String.new if len == 0
+
+      if len > 0
+        # cap intent to read if going beyond substream boundary
+        left = @size - @pos
+
+        # if actually requested reading and we're beyond the boundary, return nil
+        return nil if left <= 0
+
+        # otherwise, still return something, but less than requested
+        len = left if len > left
       end
-    }
-    reprs.length == 1 ? reprs[0] : reprs
+    end
+
+    # remember position in parent IO
+    old_pos = @parent_io.pos
+
+    @parent_io.seek(@parent_start + @pos)
+    begin
+      res = @parent_io.read(len)
+      read_len = res.bytesize
+      @pos += read_len
+    ensure
+      # restore position in parent IO
+      @parent_io.seek(old_pos)
+    end
+
+    res
+  end
+
+  def close
+    @closed = true
+    nil
+  end
+
+  def closed?
+    @closed
   end
 end
 
@@ -569,7 +712,7 @@ end
 # Common ancestor for all error originating from Kaitai Struct usage.
 # Stores KSY source path, pointing to an element supposedly guilty of
 # an error.
-class KaitaiStructError < Exception
+class KaitaiStructError < StandardError
   def initialize(msg, src_path)
     super("#{src_path}: #{msg}")
     @src_path = src_path
@@ -601,7 +744,7 @@ end
 # "expected", but it turned out that it's not.
 class ValidationNotEqualError < ValidationFailedError
   def initialize(expected, actual, io, src_path)
-    expected_repr, actual_repr = Stream.inspect_values(expected, actual)
+    expected_repr, actual_repr = Internal.inspect_values(expected, actual)
     super("not equal, expected #{expected_repr}, but got #{actual_repr}", io, src_path)
 
     @expected = expected
@@ -614,7 +757,7 @@ end
 # than or equal to "min", but it turned out that it's not.
 class ValidationLessThanError < ValidationFailedError
   def initialize(min, actual, io, src_path)
-    min_repr, actual_repr = Stream.inspect_values(min, actual)
+    min_repr, actual_repr = Internal.inspect_values(min, actual)
     super("not in range, min #{min_repr}, but got #{actual_repr}", io, src_path)
     @min = min
     @actual = actual
@@ -626,7 +769,7 @@ end
 # than or equal to "max", but it turned out that it's not.
 class ValidationGreaterThanError < ValidationFailedError
   def initialize(max, actual, io, src_path)
-    max_repr, actual_repr = Stream.inspect_values(max, actual)
+    max_repr, actual_repr = Internal.inspect_values(max, actual)
     super("not in range, max #{max_repr}, but got #{actual_repr}", io, src_path)
     @max = max
     @actual = actual
@@ -638,22 +781,113 @@ end
 # the given list, but it turned out that it's not.
 class ValidationNotAnyOfError < ValidationFailedError
   def initialize(actual, io, src_path)
-    actual_repr = Stream.inspect_values(actual)
+    actual_repr = Internal.inspect_values(actual)
     super("not any of the list, got #{actual_repr}", io, src_path)
     @actual = actual
   end
 end
 
+##
+# Signals validation failure: we required "actual" value to be in
+# the enum, but it turned out that it's not.
+class ValidationNotInEnumError < ValidationFailedError
+  def initialize(actual, io, src_path)
+    actual_repr = Internal.inspect_values(actual)
+    super("not in the enum, got #{actual_repr}", io, src_path)
+    @actual = actual
+  end
+end
+
 ##
 # Signals validation failure: we required "actual" value to match
 # the expression, but it turned out that it doesn't.
 class ValidationExprError < ValidationFailedError
   def initialize(actual, io, src_path)
-    actual_repr = Stream.inspect_values(actual)
+    actual_repr = Internal.inspect_values(actual)
     super("not matching the expression, got #{actual_repr}", io, src_path)
     @actual = actual
   end
 end
 
+##
+# \Internal implementation helpers.
+module Internal
+  ##
+  # This method reproduces the behavior of the +rb_num2long+ function:
+  # https://github.com/ruby/ruby/blob/d2930f8e7a5db8a7337fa43370940381b420cc3e/numeric.c#L3195-L3221
+  def self.num2long(val)
+    val_as_int = val.to_int
+  rescue NoMethodError
+    raise TypeError.new('no implicit conversion from nil to integer') if val.nil?
+
+    val_as_human =
+      case val
+      when true, false
+        val.to_s
+      else
+        val.class
+      end
+    raise TypeError.new("no implicit conversion of #{val_as_human} into Integer")
+  else
+    val_as_int
+  end
+
+  def self.format_hex(bytes)
+    bytes.unpack('H*')[0].gsub(/(..)/, '\1 ').chop
+  end
+
+  ###
+  # Guess if the given args are most likely byte arrays.
+  # <p>
+  # There's no way to know for sure, but {@code Encoding::ASCII_8BIT} is a special encoding that is
+  # usually used for a byte array(/string), not a character string. For those reasons, that encoding
+  # is NOT planned to be allowed for human readable texts by KS in general as well.
+  # </p>
+  # @param args [...] Something to check.
+  # @see <a href="https://ruby-doc.org/core-3.0.0/Encoding.html">Encoding</a>
+  # @see <a href="https://github.com/kaitai-io/kaitai_struct/issues/116">List of supported encodings</a>
+  #
+  def self.is_byte_array?(*args)
+    args.all? { |arg| arg.is_a?(String) and (arg.encoding == Encoding::ASCII_8BIT) }
+  end
+
+  private_class_method :is_byte_array?
+
+  def self.inspect_values(*args)
+    reprs = args.map { |arg|
+      if is_byte_array?(arg)
+        "[#{format_hex(arg)}]"
+      else
+        arg.inspect
+      end
+    }
+    reprs.length == 1 ? reprs[0] : reprs
+  end
+
+  # The `uplevel` keyword argument of Kernel#warn was added in Ruby 2.5,
+  # see https://rubyreferences.github.io/rubychanges/2.5.html#warn-uplevel-keyword-argument
+  #
+  # The `category` keyword argument of Kernel#warn was added in Ruby 3.0,
+  # see https://rubyreferences.github.io/rubychanges/3.0.html#warningwarn-category-keyword-argument
+  #
+  # NOTE: `.dup` is needed in Ruby 1.9, otherwise `RuntimeError: can't modify frozen String` occurs
+  WARN_SUPPORTS_UPLEVEL = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.5.0')
+  WARN_SUPPORTS_CATEGORY = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('3.0.0')
+  private_constant :WARN_SUPPORTS_UPLEVEL
+  private_constant :WARN_SUPPORTS_CATEGORY
+
+  def self.warn_deprecated(msg)
+    if WARN_SUPPORTS_CATEGORY
+      warn(msg, uplevel: 2, category: :deprecated)
+    elsif WARN_SUPPORTS_UPLEVEL
+      warn(msg, uplevel: 2)
+    else
+      warn(msg)
+    end
+  end
+end
+
+private_constant :Internal
+
 end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: kaitai-struct
 version: !ruby/object:Gem::Version
-  version: '0.10'
+  version: '0.11'
 platform: ruby
 authors:
 - Mikhail Yakshin
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-09 00:00:00.000000000 Z
+date: 2025-09-10 00:00:00.000000000 Z
 dependencies: []
 description: |
   Kaitai Struct is a declarative language used for describe various binary data structures, laid out in files or in memory: i.e. binary file formats, network stream packet formats, etc.
@@ -24,14 +23,15 @@ files:
 - LICENSE
 - README.md
 - lib/kaitai/struct/struct.rb
-homepage: http://kaitai.io
+homepage: https://kaitai.io/
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kaitai-io/kaitai_struct_ruby_runtime/issues
-  homepage_uri: http://kaitai.io
+  documentation_uri: https://www.rubydoc.info/gems/kaitai-struct
+  homepage_uri: https://kaitai.io/
   source_code_uri: https://github.com/kaitai-io/kaitai_struct_ruby_runtime
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -39,15 +39,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.17
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: 'Kaitai Struct: runtime library for Ruby'
 test_files: []