red-flatbuffers 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f420730ce2d852a96022a53cf2e41d98df56b8048c0c18f9d5759d5ac9b642fe
-  data.tar.gz: cbcce85101110095d3d2dd7ea811427bcba031e49dcdb38728d716ab16a86b40
+  metadata.gz: 39624c3160429b2d1492aa6bcf66b0d4e8028cb11c2e5e8538a40014bbfaea58
+  data.tar.gz: 296cce04665d4cd2095b60e72e052dc650aede2215e9fba0a9dfd0082f64d242
 SHA512:
-  metadata.gz: 20212508d82713f2ce413c4fa77f020556e049192f4aad8c61afc1d89105dc8fdf5e5d808f59f36fe5e848c9beb16639dc00fe579ae1a18b08fe9446fcfb9287
-  data.tar.gz: a8f5f2ef94bb3dda4dd32bb5154e02f0336c47efba31dbaf0b1435c6cc54797d3644ff5c8e1be3faf6dc153b231af063d9fdef7b545efb0ef7376962aa7dd7be
+  metadata.gz: bc547bfdc66275abebf0160367c293ff5a3ab328fe6d191fc1ab00952fa6f578330dbe987cce19fba954d145a0881f757012b0e34d80ffeeb69c43cbfa341df1
+  data.tar.gz: 7436bbce98bb2fc5400a4392eef2cd7d1438c4585e97ec26f193b0aabd7410f0fda7241fd6be84a34712cbe59941e8b65d98de76b5532dedda9b134de551b2a8

data/doc/text/news.md

@@ -1,5 +1,11 @@
 # News
 
+## 0.0.4 - 2026-01-12
+
+### Improvements
+
+  * Added support for serializing.
+
 ## 0.0.3 - 2025-11-28
 
 ### Improvements

data/lib/flatbuffers/alignable.rb

@@ -0,0 +1,42 @@
+# Copyright 2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative "append_as_bytes"
+
+module FlatBuffers
+  using AppendAsBytes if const_defined?(:AppendAsBytes)
+
+  module Alignable
+    LARGEST_ALIGNMENT_SIZE = 8 # IO::Buffer.size_of(:u64)
+    LARGEST_PADDING = "\x00" * 7
+
+    private
+    def compute_padding_size(size, alignment_byte)
+      (alignment_byte - (size & (alignment_byte - 1))) & (alignment_byte - 1)
+    end
+
+    def padding(padding_size)
+      LARGEST_PADDING[0, padding_size]
+    end
+
+    def pad!(data, padding_size)
+      return if padding_size.zero?
+      data.append_as_bytes(padding(padding_size))
+    end
+
+    def align!(data, alignment_byte)
+      pad!(data, compute_padding_size(data.bytesize, alignment_byte))
+    end
+  end
+end

data/lib/flatbuffers/append_as_bytes.rb

@@ -0,0 +1,26 @@
+# Copyright 2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This is for Ruby < 3.4
+unless String.method_defined?(:append_as_bytes)
+  module FlatBuffers
+    module AppendAsBytes
+      refine String do
+        def append_as_bytes(*objects)
+          concat(*objects)
+        end
+      end
+    end
+  end
+end

data/lib/flatbuffers/data_definable.rb

@@ -0,0 +1,35 @@
+# Copyright 2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module FlatBuffers
+  module DataDefinable
+    def define_data_class
+      if self::FIELDS.empty?
+        klass = Class.new
+      else
+        klass = ::Struct.new(*self::FIELDS.keys) do
+          members.each do |member|
+            next unless member.end_with?("?")
+            alias_method :"#{member.to_s.delete_suffix("?")}=", :"#{member}="
+          end
+        end
+      end
+      table_class = self
+      klass.singleton_class.define_method(:table_class) do
+        table_class
+      end
+      klass
+    end
+  end
+end

data/lib/flatbuffers/error.rb

@@ -0,0 +1,21 @@
+# Copyright 2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module FlatBuffers
+  class Error < StandardError
+  end
+
+  class VerificationError < Error
+  end
+end

data/lib/flatbuffers/field.rb

@@ -0,0 +1,57 @@
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative "view"
+
+module FlatBuffers
+  class Field
+    attr_reader :name
+    attr_reader :index
+    attr_reader :offset
+    attr_reader :base_type
+    attr_reader :padding
+    def initialize(name, index, offset, base_type, padding)
+      @name = name
+      @index = index
+      @offset = offset
+      @base_type = base_type
+      @padding = padding
+    end
+
+    def alignment_size
+      case @base_type
+      when :utype
+        4
+      when :bool, :byte, :ubyte
+        1
+      when :short, :ushort
+        2
+      when :int, :uint
+        4
+      when :long, :ulong
+        8
+      when :float
+        4
+      when :double
+        8
+      when :string
+        4
+      when String
+        4
+      when Array
+        4
+      end
+    end
+  end
+end

data/lib/flatbuffers/generator.rb

@@ -1,4 +1,4 @@
-# Copyright 2025 Sutou Kouhei <kou@clear-code.com>
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -338,20 +338,113 @@ module FlatBuffers
       start_modules(writer, namespaces)
 
       if object.struct?
+        is_root_table = false
         parent = "::FlatBuffers::Struct"
       else
-        parent = "::FlatBuffers::Table"
+        is_root_table = (object.name == @schema.root_table&.name)
+        if is_root_table
+          parent = "::FlatBuffers::RootTable"
+        else
+          parent = "::FlatBuffers::Table"
+        end
       end
       generate_documentation(writer, object.documentation)
       writer << "class #{to_class_name(name)} < #{parent}"
       writer.indent
 
-      n_processed_fields = 0
+      if is_root_table
+        writer << "class << self"
+        writer.indent
+
+        writer << "def file_identifier"
+        writer.indent
+        writer << to_ruby_code(@schema.file_ident)
+        writer.end
+        writer << ""
+        writer << "def file_extension"
+        writer.indent
+        writer << to_ruby_code(@schema.file_ext)
+        writer.end
+
+        writer.end
+        writer << ""
+      end
+
+      generate_object_fields(writer, object)
+
+      writer << "Data = define_data_class"
+
+      generate_object_methods(writer, object, namespaces)
+
+      writer.end # class
+
+      end_modules(writer, namespaces)
+    end
+
+    def generate_object_fields(writer, object)
+      writer << "FIELDS = {"
+      writer.indent
+
+      offset_sorted_fields = object.fields&.sort_by(&:offset)
+      offset_sorted_fields&.each_with_index do |field, index|
+        # Skip writing deprecated fields altogether.
+        next if field.deprecated?
+
+        method_name = to_method_name(field.name)
+        type = field.type
+        base_type = type.base_type
+        if base_type == Reflection::BaseType::BOOL
+          method_name = "#{method_name}?".delete_prefix("is_")
+        end
+        ruby_index = to_ruby_code(index)
+        ruby_offset = to_ruby_code(field.offset)
+        case base_type
+        when Reflection::BaseType::OBJ
+          object = @schema.objects[type.index]
+          *object_namespaces, object_name = denamespace(object.name)
+          klass = to_absolute_class_name(@outer_namespaces,
+                                         object_namespaces,
+                                         object_name)
+          ruby_base_type = to_ruby_code(klass)
+        when Reflection::BaseType::UNION
+          union = @schema.enums[type.index]
+          *union_namespaces, union_name = denamespace(union.name)
+          klass = to_absolute_class_name(@outer_namespaces,
+                                         union_namespaces,
+                                         union_name)
+          ruby_base_type = to_ruby_code(klass)
+        when Reflection::BaseType::VECTOR
+          element_base_type = type.element
+          if element_base_type == Reflection::BaseType::OBJ
+            object = @schema.objects[type.index]
+            *object_namespaces, object_name = denamespace(object.name)
+            klass = to_absolute_class_name(@outer_namespaces,
+                                           object_namespaces,
+                                           object_name)
+            ruby_base_type = "[#{to_ruby_code(klass)}]"
+          else
+            ruby_base_type = "[:#{to_lower_snake_case(element_base_type.name)}]"
+          end
+        else
+          ruby_base_type = ":#{to_lower_snake_case(base_type.name)}"
+        end
+        ruby_padding = to_ruby_code(field.padding)
+        writer << ("#{method_name}: ::FlatBuffers::Field.new(" +
+                   ":#{method_name}, #{ruby_index}, " +
+                   "#{ruby_offset}, #{ruby_base_type}, #{ruby_padding}),")
+      end
+
+      writer.unindent
+      writer << "}"
+      writer << ""
+    end
+
+    def generate_object_methods(writer, object, namespaces)
       object.fields&.each do |field|
         # Skip writing deprecated fields altogether.
         next if field.deprecated?
 
-        writer << "" if n_processed_fields > 0
+        writer << ""
 
         method_name = to_method_name(field.name)
         type = field.type
@@ -471,13 +564,7 @@ module FlatBuffers
           writer.end
         end
         writer.end
-
-        n_processed_fields += 1
       end
-
-      writer.end # class
-
-      end_modules(writer, namespaces)
     end
 
     def generate_documentation(writer, documentation)

data/lib/flatbuffers/root_table.rb

@@ -0,0 +1,57 @@
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative "serializer"
+require_relative "table"
+require_relative "view"
+
+module FlatBuffers
+  class RootTable < Table
+    class << self
+      def save(base_name, data)
+        name = "#{base_name}.#{file_extension}"
+        File.open(name, "wb") do |output|
+          output.print(serialize(data))
+        end
+      end
+
+      def serialize(data, table_serializer=nil)
+        if table_serializer
+          # Referenced table
+          super(data, table_serializer)
+        else
+          # Root table
+          serializer = Serializer.new(file_identifier)
+          serializer.start_table do |table_serializer|
+            super(data, table_serializer)
+          end
+        end
+      end
+    end
+
+    def initialize(input)
+      if input.is_a?(View)
+        # Referenced table
+        super
+      else
+        # Root table
+        if input.is_a?(String)
+          input = IO::Buffer.for(input)
+        end
+        offset = input.get_value(:u32, 0)
+        super(View.new(input, offset, have_vtable: true))
+      end
+    end
+  end
+end

data/lib/flatbuffers/serializer.rb

@@ -0,0 +1,348 @@
+# Copyright 2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative "alignable"
+
+module FlatBuffers
+  using AppendAsBytes if const_defined?(:AppendAsBytes)
+
+  class Serializer
+    module Packable
+      private
+      def pack_value(base_type, value)
+        case base_type
+        when :bool
+          [value ? 1 : 0].pack("c")
+        when :utype
+          [value || 0].pack("C")
+        when :byte
+          [value || 0].pack("c")
+        when :ubyte
+          [value || 0].pack("C")
+        when :short
+          [value || 0].pack("s<")
+        when :ushort
+          [value || 0].pack("S<")
+        when :int
+          [value || 0].pack("l<")
+        when :uint
+          [value || 0].pack("L<")
+        when :long
+          [value || 0].pack("q<")
+        when :ulong
+          [value || 0].pack("Q<")
+        when :float
+          [value || 0.0].pack("e")
+        when :double
+          [value || 0.0].pack("E")
+        when :string
+          value ||= ""
+          packed_value = [value.bytesize].pack("L<")
+          packed_value.append_as_bytes(value)
+          packed_value.append_as_bytes("\x00")
+          packed_value
+        when String
+          klass = Object.const_get(base_type)
+          if klass < Struct
+            sub_struct_serializer = StructSerializer.new(+"".b)
+            klass.serialize(value, sub_struct_serializer)
+          end
+        end
+      end
+    end
+
+    class StructSerializer
+      include Alignable
+      include Packable
+
+      def initialize(buffer)
+        @buffer = buffer
+      end
+
+      def start
+        yield
+        finish
+      end
+
+      def add_field(field, value)
+        packed_value = pack_value(field.base_type, value)
+        @buffer.append_as_bytes(packed_value)
+        unless field.padding.zero?
+          pad!(@buffer, field.padding)
+        end
+      end
+
+      def finish
+        @buffer
+      end
+    end
+
+    class TableSerializer
+      include Alignable
+      include Packable
+
+      DUMMY_OFFSET = [0].pack("L<")
+
+      def initialize
+        @field_metadata = {}
+        # vtable_offset. This is replaced later.
+        @table = DUMMY_OFFSET.dup
+        @values = +"".b
+      end
+
+      def start
+        yield
+        finish
+      end
+
+      def add_field(field, value)
+        if value.nil?
+          @field_metadata[field] = {
+            inline: true,
+            offset: nil,
+          }
+        else
+          case field.base_type
+          when String
+            add_field_object(field, value)
+          when Array
+            add_field_array(field, value)
+          when :string
+            align!(@table, View::OFFSET_SIZE)
+            @field_metadata[field] = {
+              inline: false,
+              table_offset: @table.bytesize,
+              value_offset: @values.bytesize,
+            }
+            @values.append_as_bytes(pack_value(field.base_type, value))
+            @table.append_as_bytes(DUMMY_OFFSET) # Replaced later
+          else
+            align!(@table, field.alignment_size)
+            @field_metadata[field] = {
+              inline: true,
+              offset: @table.bytesize,
+            }
+            @table.append_as_bytes(pack_value(field.base_type, value))
+          end
+        end
+      end
+
+      def finish
+        vtable_size = View::VTable.compute_size(@field_metadata.size)
+        align!(@table, LARGEST_ALIGNMENT_SIZE)
+        table_size = @table.bytesize
+
+        field_offsets = []
+        @field_metadata.each do |field, metadata|
+          if metadata[:inline] # Scalar or struct
+            offset = metadata[:offset]
+            if offset.nil?
+              field_offsets[field.index] = 0
+            else
+              field_offsets[field.index] = offset
+            end
+          else # Table, string or vector.
+            # |vtable|@table|@values|
+            #
+            # `vtable:` |vtable_size|table_size|field_offsets|
+            # `field_offsets` uses relative offset from the start of
+            # `vtable`.
+            #
+            # `@table`: |vtable_offset|fields|
+            # `fields` uses relative offset from itself.
+
+            # The offset in `fields`. This is relative from the start
+            # of `@table`.
+            table_offset = metadata[:table_offset]
+            # The offset in `@values`. This is relative from the start
+            # of `@table`.
+            value_offset = metadata[:value_offset]
+            # `@values` is placed just after `@table`.
+            # `offset` is relative from `table_offset`.
+            offset = table_size - table_offset + value_offset
+            @table[table_offset, View::Table::VTABLE_OFFSET_SIZE] =
+              [offset].pack("L<")
+            field_offsets[field.index] = table_offset
+          end
+        end
+        field_offsets.each_with_index do |offset, i|
+          field_offsets[i] = 0 if offset.nil?
+        end
+
+        data = +"".b
+        vtable = View::VTable.serialize(vtable_size,
+                                        table_size,
+                                        field_offsets)
+        data.append_as_bytes(vtable)
+        # We don't need "-" here because vtable_offset is subtracted
+        # (not added).
+        vtable_offset = vtable_size
+        @table[0, View::Table::VTABLE_OFFSET_SIZE] = [vtable_offset].pack("l<")
+        data.append_as_bytes(@table)
+        align!(@values, LARGEST_ALIGNMENT_SIZE)
+        data.append_as_bytes(@values)
+        table_offset = vtable_size
+        [data, table_offset]
+      end
+
+      private
+      # Struct, union or table
+      def add_field_object(field, value)
+        align!(@table, View::OFFSET_SIZE)
+        klass = Object.const_get(field.base_type)
+        if klass < Struct
+          @field_metadata[field] = {
+            inline: true,
+            offset: @table.bytesize,
+          }
+          sub_struct_serializer = StructSerializer.new(@table)
+          klass.serialize(value, sub_struct_serializer)
+        elsif klass < Union
+          align!(@values, LARGEST_ALIGNMENT_SIZE)
+          sub_table_serializer = TableSerializer.new
+          sub_table_data, sub_table_offset =
+          value.class.table_class.serialize(value, sub_table_serializer)
+          @field_metadata[field] = {
+            inline: false,
+            table_offset: @table.bytesize,
+            value_offset: @values.bytesize + sub_table_offset,
+          }
+          @values.append_as_bytes(sub_table_data)
+          @table.append_as_bytes(DUMMY_OFFSET) # Replaced later
+        else
+          align!(@values, LARGEST_ALIGNMENT_SIZE)
+          sub_table_serializer = TableSerializer.new
+          sub_table_data, sub_table_offset =
+          klass.serialize(value, sub_table_serializer)
+          @field_metadata[field] = {
+            inline: false,
+            table_offset: @table.bytesize,
+            value_offset: @values.bytesize + sub_table_offset,
+          }
+          @values.append_as_bytes(sub_table_data)
+          @table.append_as_bytes(DUMMY_OFFSET) # Replaced later
+        end
+      end
+
+      def add_field_array(field, value)
+        align!(@table, View::OFFSET_SIZE)
+        align!(@values, View::OFFSET_SIZE)
+        value_offset = @values.bytesize
+        # The number of elements.
+        @values.append_as_bytes([value.size].pack("L<"))
+        element_base_type = field.base_type[0]
+        case element_base_type
+        when String
+          klass = Object.const_get(element_base_type)
+          if klass < Struct
+            value.each do |v|
+              sub_struct_serializer = StructSerializer.new(@values)
+              klass.serialize(v, sub_struct_serializer)
+            end
+          else
+            offset_base = @values.bytesize
+            # Placeholder for offsets.
+            value.size.times do
+              @values.append_as_bytes(DUMMY_OFFSET) # Replaced later
+            end
+            align!(@values, LARGEST_ALIGNMENT_SIZE)
+            value.each do |v|
+              sub_table_serializer = TableSerializer.new
+              sub_table_data, sub_table_offset =
+              klass.serialize(v, sub_table_serializer)
+
+              element_offset = @values.bytesize + sub_table_offset
+              # Update offset placeholder.
+              relative_element_offset = element_offset - offset_base
+              @values[offset_base, View::OFFSET_SIZE] =
+                [relative_element_offset].pack("L<")
+              offset_base += View::OFFSET_SIZE
+
+              @values.append_as_bytes(sub_table_data)
+            end
+          end
+          @field_metadata[field] = {
+            inline: false,
+            table_offset: @table.bytesize,
+            value_offset: value_offset,
+          }
+        when :string
+          offset_base = @values.bytesize
+          # Placeholder for offsets.
+          value.size.times do
+            @values.append_as_bytes(DUMMY_OFFSET) # Replaced later
+          end
+          value.each do |v|
+            packed_value = pack_value(element_base_type, v)
+
+            element_offset = @values.bytesize
+            # Update offset placeholder.
+            relative_element_offset = element_offset - offset_base
+            @values[offset_base, View::OFFSET_SIZE] =
+              [relative_element_offset].pack("L<")
+            offset_base += View::OFFSET_SIZE
+
+            @values.append_as_bytes(packed_value)
+          end
+          @field_metadata[field] = {
+            inline: false,
+            table_offset: @table.bytesize,
+            value_offset: value_offset,
+          }
+        else
+          value.each do |v|
+            packed_value = pack_value(element_base_type, v)
+            @values.append_as_bytes(packed_value)
+          end
+          @field_metadata[field] = {
+            inline: false,
+            table_offset: @table.bytesize,
+            value_offset: value_offset,
+          }
+        end
+        @table.append_as_bytes(DUMMY_OFFSET) # Replaced later
+      end
+    end
+
+    include Alignable
+
+    def initialize(identifier)
+      identifier = nil if identifier.is_a?(String) and identifier.empty?
+      validate_identifier(identifier)
+      @identifier = identifier
+    end
+
+    def start_table
+      table_serializer = TableSerializer.new
+      table, table_offset = yield(table_serializer)
+      header_size = View::OFFSET_SIZE
+      header_size += View::IDENTIFIER_SIZE if @identifier
+      header_size += compute_padding_size(header_size, LARGEST_ALIGNMENT_SIZE)
+      root_table_offset = header_size + table_offset
+      data = [root_table_offset].pack("L<")
+      data.append_as_bytes(@identifier) if @identifier
+      align!(data, LARGEST_ALIGNMENT_SIZE)
+      data.append_as_bytes(table)
+      data
+    end
+
+    private
+    def validate_identifier(identifier)
+      return if identifier.nil?
+      return if identifier.bytesize == View::IDENTIFIER_SIZE
+      raise ArgumentError,
+            "Identifier must be nil or 4 bytes string: #{identifier.inspect}"
+    end
+  end
+end

data/lib/flatbuffers/struct.rb

@@ -1,4 +1,4 @@
-# Copyright 2025 Sutou Kouhei <kou@clear-code.com>
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,15 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative "data_definable"
 require_relative "inspectable"
-require_relative "view"
 
 module FlatBuffers
   class Struct
+    extend DataDefinable
     include Inspectable
 
+    class << self
+      def serialize(data, struct_serializer)
+        struct_serializer.start do
+          self::FIELDS.each do |name, field|
+            value = data&.public_send(name)
+            struct_serializer.add_field(field, value)
+          end
+        end
+      end
+    end
+
     def initialize(view)
       @view = view
     end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      self.class::FIELDS.keys.all? do |name|
+        public_send(name) == other.public_send(name)
+      end
+    end
   end
 end

data/lib/flatbuffers/table.rb

@@ -1,4 +1,4 @@
-# Copyright 2025 Sutou Kouhei <kou@clear-code.com>
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,22 +12,60 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative "data_definable"
+require_relative "field"
 require_relative "inspectable"
-require_relative "view"
 
 module FlatBuffers
   class Table
     include Inspectable
+    extend DataDefinable
 
-    def initialize(input)
-      if input.is_a?(View)
-        @view = input
-      else
-        if input.is_a?(String)
-          input = IO::Buffer.for(input)
+    class << self
+      def table_class
+        self
+      end
+
+      def serialize(data, table_serializer)
+        table_serializer.start do
+          self::FIELDS.each do |name, field|
+            if field.base_type == :utype
+              union_field_name = :"#{name.to_s.delete_suffix("_type")}"
+              union_field = self::FIELDS[union_field_name]
+              union_value = data.public_send(union_field_name)
+              if union_value.nil?
+                value = nil
+              else
+                union_class = Object.const_get(union_field.base_type)
+                value = union_class.try_convert(union_value.class.table_class)
+              end
+            else
+              value = data.public_send(name)
+            end
+            table_serializer.add_field(field, value)
+          end
         end
-        offset = input.get_value(:u32, 0)
-        @view = View.new(input, offset, have_vtable: true)
+      end
+    end
+
+    def initialize(view)
+      unless view.is_a?(View)
+        # For backward compatibility
+        if view.is_a?(IO::Buffer)
+          buffer = view
+        else
+          buffer = IO::Buffer.for(view)
+        end
+        offset = buffer.get_value(:u32, 0)
+        view = View.new(buffer, offset, have_vtable: true)
+      end
+      @view = view
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      self.class::FIELDS.keys.all? do |name|
+        public_send(name) == other.public_send(name)
       end
     end
   end

data/lib/flatbuffers/union.rb

@@ -1,4 +1,4 @@
-# Copyright 2025 Sutou Kouhei <kou@clear-code.com>
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -24,7 +24,13 @@ module FlatBuffers
         when self
           value
         else
-          nil
+          if value < Table
+            @name_to_union.values.find do |union|
+              union.table_class == value
+            end
+          else
+            nil
+          end
         end
       end
 

data/lib/flatbuffers/verifier.rb

@@ -0,0 +1,54 @@
+# Copyright 2026 Sutou Kouhei <kou@clear-code.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative "append_as_bytes"
+
+module FlatBuffers
+  class Verifier
+    def initialize(target)
+      @target = target
+    end
+
+    def verify
+      view = @target.instance_variable_get(:@view)
+      @target.class::FIELDS.each_value do |field|
+        offset = view.offset + view.unpack_virtual_offset(field.offset)
+        verify_alignment(field, offset)
+        case field.base_type
+        when String
+          sub_target = @target.public_send(field.name)
+          next if sub_target.nil?
+          next if sub_target.is_a?(Struct)
+          Verifier.new(sub_target).verify
+        when Array
+          next unless field.base_type[0].is_a?(String)
+          @target.public_send(field.name)&.each do |value|
+            next if value.is_a?(Struct)
+            Verifier.new(value).verify
+          end
+        end
+      end
+    end
+
+    private
+    def verify_alignment(field, offset)
+      unless (offset % field.alignment_size).zero?
+        message = "#{@target.class.name}'s #{field.name} " +
+                  "(#{field.base_type}) value isn't aligned: #{offset}: " +
+                  "#{field.alignment_size}"
+        raise VerificationError.new(message)
+      end
+    end
+  end
+end

data/lib/flatbuffers/version.rb

@@ -13,5 +13,5 @@
 # limitations under the License.
 
 module FlatBuffers
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/flatbuffers/view.rb

@@ -1,4 +1,4 @@
-# Copyright 2025 Sutou Kouhei <kou@clear-code.com>
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,11 +12,78 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative "alignable"
+
 module FlatBuffers
+  using AppendAsBytes if const_defined?(:AppendAsBytes)
+
   class View
-    OFFSET_BYTE_SIZE = 4
-    VIRTUAL_OFFSET_BYTE_SIZE = 2
+    OFFSET_SIZE = 4 # IO::Buffer.size_of(:u32)
+    VIRTUAL_OFFSET_SIZE = 2 # IO::Buffer.size_of(:u16)
+    IDENTIFIER_SIZE = 4
+
+    module VTable
+      # https://flatbuffers.dev/internals/#tables
+      #
+      # vtable_size: voffset_t (== uint16_t)
+      # table_size: voffset_t (== uint16_t)
+      # field_offsets: [voffset_t (== uint16_t)]
+
+      VTABLE_SIZE_SIZE = VIRTUAL_OFFSET_SIZE
+      TABLE_SIZE_SIZE = VIRTUAL_OFFSET_SIZE
+
+      class << self
+        include Alignable
+
+        def compute_size(n_fields)
+          size = VTABLE_SIZE_SIZE +
+                 TABLE_SIZE_SIZE +
+                 (VIRTUAL_OFFSET_SIZE * n_fields)
+          size += compute_padding_size(size, LARGEST_ALIGNMENT_SIZE)
+          size
+        end
+
+        def compute_field_index(offset)
+          # offset includes vtable_size and table_size.
+          field_offset = (offset - VTABLE_SIZE_SIZE - TABLE_SIZE_SIZE)
+          field_offset / VIRTUAL_OFFSET_SIZE
+        end
+
+        def serialize(vtable_size, table_size, field_offsets)
+          data = [vtable_size, table_size, *field_offsets].pack("S<*")
+          align!(data, LARGEST_ALIGNMENT_SIZE)
+          data
+        end
+      end
+    end
+
+    module Table
+      # https://flatbuffers.dev/internals/#tables
+      #
+      # vtable_offset: soffset_t (== int32_t)
+      # fields: []
+
+      VTABLE_OFFSET_SIZE = OFFSET_SIZE
+
+      class << self
+        include Alignable
 
+        def compute_size(fields_size)
+          size = VTABLE_OFFSET_SIZE + fields_size
+          size += compute_padding_size(size, LARGEST_ALIGNMENT_SIZE)
+          size
+        end
+
+        def serialize(vtable_offset, fields)
+          data = [vtable_offset].pack("l<")
+          data.append_as_bytes(fields)
+          align!(data, LARGEST_ALIGNMENT_SIZE)
+          data
+        end
+      end
+    end
+
+    attr_reader :offset
     def initialize(data, offset, have_vtable: false)
       @data = data
       @offset = offset
@@ -24,15 +91,15 @@ module FlatBuffers
         vtable_offset = unpack_signed_offset(0)
         @vtable_start = @offset - vtable_offset
         # We assume vtable must have length.
-        @vtable_max_offset = VIRTUAL_OFFSET_BYTE_SIZE
-        @vtable_length = unpack_virtual_offset(0)
-        @vtable_max_offset = @vtable_length - VIRTUAL_OFFSET_BYTE_SIZE
-        @table_length = unpack_virtual_offset(VIRTUAL_OFFSET_BYTE_SIZE)
+        @vtable_max_offset = VTable::VTABLE_SIZE_SIZE
+        @vtable_size = unpack_virtual_offset(0)
+        @vtable_max_offset = @vtable_size
+        @table_size = unpack_virtual_offset(VTable::TABLE_SIZE_SIZE)
       end
     end
 
     def unpack_virtual_offset(vtable_offset)
-      return 0 if vtable_offset > @vtable_max_offset
+      return 0 if (vtable_offset + VIRTUAL_OFFSET_SIZE > @vtable_max_offset)
       @data.get_value(:u16, @vtable_start + vtable_offset)
     end
 
@@ -103,7 +170,7 @@ module FlatBuffers
     def unpack_string(offset)
       value_offset = resolve_indirect(offset)
       length = unpack_offset_raw(value_offset)
-      @data.get_string(value_offset + OFFSET_BYTE_SIZE,
+      @data.get_string(value_offset + OFFSET_SIZE,
                        length)
     end
 
@@ -135,42 +202,12 @@ module FlatBuffers
       length = unpack_offset(relative_vector_offset)
       return nil if length.zero?
 
-      relative_vector_body_offset = relative_vector_offset + OFFSET_BYTE_SIZE
+      relative_vector_body_offset = relative_vector_offset + OFFSET_SIZE
       length.times.collect do |i|
         relative_element_offset =
           relative_vector_body_offset + (element_size * i)
         yield(relative_element_offset)
       end
     end
-
-    def unpack_bool_vector(offset, element_size)
-      unpack_vector(offset, element_size) do |relative_element_offset|
-        unpack_bool(relative_element_offset)
-      end
-    end
-
-    def unpack_ubyte_vector(offset, element_size)
-      unpack_vector(offset, element_size) do |relative_element_offset|
-        unpack_ubyte(relative_element_offset)
-      end
-    end
-
-    def unpack_string_vector(offset, element_size)
-      unpack_vector(offset, element_size) do |relative_element_offset|
-        unpack_string(relative_element_offset)
-      end
-    end
-
-    def unpack_table_vector(offset, element_size, klass)
-      unpack_vector(offset, element_size) do |relative_element_offset|
-        unpack_table(klass, relative_element_offset)
-      end
-    end
-
-    def unpack_struct_vector(offset, element_size, klass)
-      unpack_vector(offset, element_size) do |relative_element_offset|
-        unpack_struct(klass, relative_element_offset)
-      end
-    end
   end
 end

data/lib/flatbuffers.rb

@@ -1,4 +1,4 @@
-# Copyright 2025  Sutou Kouhei <kou@clear-code.com>
+# Copyright 2025-2026 Sutou Kouhei <kou@clear-code.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,9 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative "flatbuffers/serializer"
 require_relative "flatbuffers/enum"
+require_relative "flatbuffers/error"
 require_relative "flatbuffers/flags"
 require_relative "flatbuffers/struct"
-require_relative "flatbuffers/table"
+require_relative "flatbuffers/root_table"
 require_relative "flatbuffers/union"
+require_relative "flatbuffers/verifier"
 require_relative "flatbuffers/version"

data/red-flatbuffers.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   description = clean_white_space.call(entries[2])
   spec.summary, spec.description, = description.split(/\n\n+/, 3)
   spec.license = "Apache-2.0"
+  spec.required_ruby_version = ">= 3.1.0"
   spec.files = ["README.md", "#{spec.name}.gemspec"]
   spec.files += Dir.glob("lib/**/*.rb")
   spec.files += Dir.glob("doc/text/*")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-flatbuffers
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Sutou Kouhei
@@ -27,8 +27,13 @@ files:
 - doc/text/apache-2.0.txt
 - doc/text/news.md
 - lib/flatbuffers.rb
+- lib/flatbuffers/alignable.rb
+- lib/flatbuffers/append_as_bytes.rb
 - lib/flatbuffers/command/rbflatc.rb
+- lib/flatbuffers/data_definable.rb
 - lib/flatbuffers/enum.rb
+- lib/flatbuffers/error.rb
+- lib/flatbuffers/field.rb
 - lib/flatbuffers/flags.rb
 - lib/flatbuffers/generator.rb
 - lib/flatbuffers/inspectable.rb
@@ -44,9 +49,12 @@ files:
 - lib/flatbuffers/reflection/schema_file.rb
 - lib/flatbuffers/reflection/service.rb
 - lib/flatbuffers/reflection/type.rb
+- lib/flatbuffers/root_table.rb
+- lib/flatbuffers/serializer.rb
 - lib/flatbuffers/struct.rb
 - lib/flatbuffers/table.rb
 - lib/flatbuffers/union.rb
+- lib/flatbuffers/verifier.rb
 - lib/flatbuffers/version.rb
 - lib/flatbuffers/view.rb
 - red-flatbuffers.gemspec
@@ -55,7 +63,7 @@ licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/red-data-tools/red-flatbuffers/issues
-  changelog_uri: https://github.com/red-data-tools/red-flatbuffers/releases/tag/0.0.3
+  changelog_uri: https://github.com/red-data-tools/red-flatbuffers/releases/tag/0.0.4
   source_code_uri: https://github.com/red-data-tools/red-flatbuffers
 rdoc_options: []
 require_paths:
@@ -64,14 +72,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Red FlatBuffers is a pure Ruby FlatBuffers implementation.
 test_files: []