metaschema 0.2.0 → 0.2.2

data/lib/metaschema/model_generator/field_factory.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Metaschema
+  class ModelGenerator
+    # Creates field classes from Metaschema field definitions.
+    # Each field class inherits from Lutaml::Model::Serializable and
+    # includes XML + JSON mappings for the field's content and flags.
+    class FieldFactory
+      def initialize(field_def, generator)
+        @field_def = field_def
+        @g = generator
+      end
+
+      def create
+        fd = @field_def
+        return unless fd.name
+
+        klass_name = "Field_#{fd.name.gsub('-', '_')}"
+        klass = Class.new(Lutaml::Model::Serializable)
+        @g.classes[klass_name] = klass
+
+        is_markup = TypeMapper.markup?(fd.as_type)
+        is_multiline = TypeMapper.multiline?(fd.as_type)
+        content_type = TypeMapper.map(fd.as_type)
+
+        if is_multiline
+          self.class.apply_markup_multiline_attributes(klass)
+        elsif is_markup
+          self.class.apply_markup_attributes(klass)
+        elsif fd.collapsible == "yes"
+          klass.attribute :content, content_type, collection: true
+        else
+          klass.attribute :content, content_type
+        end
+
+        fd.define_flag&.each { |f| @g.add_inline_flag(klass, f) }
+        fd.flag&.each { |f| @g.add_flag_reference(klass, f) }
+
+        build_field_xml(klass, fd.name, is_markup || is_multiline,
+                        fd, is_multiline)
+        build_field_json(klass, fd)
+
+        has_flags = fd.define_flag&.any? || fd.flag&.any?
+        has_json_vk = fd.json_value_key || fd.json_value_key_flag
+        is_collapsible = fd.collapsible == "yes"
+        value_key = fd.json_value_key || TypeMapper.json_value_key(fd.as_type)
+
+        klass.define_singleton_method(:of_json) do |data|
+          if data.is_a?(String)
+            new(content: data)
+          else
+            super(data)
+          end
+        end
+
+        klass.define_singleton_method(:from_json) do |data|
+          if data.is_a?(String)
+            new(content: data)
+          else
+            super(data)
+          end
+        end
+
+        if has_flags || has_json_vk || is_collapsible
+          flag_attr_names = (fd.define_flag || []).filter_map do |f|
+            Utils.safe_attr(f.name) if f.name
+          end +
+            (fd.flag || []).filter_map do |f|
+              Utils.safe_attr(f.ref) if f.ref
+            end
+
+          orig_as_json = klass.method(:as_json)
+          klass.define_singleton_method(:as_json) do |instance, options = {}|
+            result = orig_as_json.call(instance, options)
+
+            if is_collapsible && result.is_a?(Hash) && result[value_key].is_a?(Array) && result[value_key].length == 1
+              result[value_key] = result[value_key].first
+            end
+
+            if (has_flags || has_json_vk) && result.is_a?(Hash) && result.key?(value_key)
+              flags_present = flag_attr_names.any? do |attr|
+                val = instance.send(attr)
+                val && !(val.respond_to?(:using_default?) && val.using_default?)
+              end
+              unless flags_present
+                return result[value_key]
+              end
+            end
+
+            result
+          end
+        end
+
+        @g.apply_constraint_validation(klass, fd.constraint)
+      end
+
+      class << self
+        # Add inline markup attributes (a, code, em, etc.) for markup-line fields.
+        def apply_markup_attributes(klass)
+          klass.attribute :content, :string, collection: true
+          klass.attribute :a, AnchorType, collection: true
+          klass.attribute :insert, InsertType, collection: true
+          klass.attribute :br, :string, collection: true
+          klass.attribute :code, CodeType, collection: true
+          klass.attribute :em, InlineMarkupType, collection: true
+          klass.attribute :i, InlineMarkupType, collection: true
+          klass.attribute :b, InlineMarkupType, collection: true
+          klass.attribute :strong, InlineMarkupType, collection: true
+          klass.attribute :sub, InlineMarkupType, collection: true
+          klass.attribute :sup, InlineMarkupType, collection: true
+          klass.attribute :q, InlineMarkupType, collection: true
+          klass.attribute :img, ImageType, collection: true
+        end
+
+        # Add block-level markup attributes (p, h1-h6, ul, etc.) for markup-multiline fields.
+        def apply_markup_multiline_attributes(klass)
+          apply_markup_attributes(klass)
+          klass.attribute :p, InlineMarkupType, collection: true
+          klass.attribute :h1, InlineMarkupType, collection: true
+          klass.attribute :h2, InlineMarkupType, collection: true
+          klass.attribute :h3, InlineMarkupType, collection: true
+          klass.attribute :h4, InlineMarkupType, collection: true
+          klass.attribute :h5, InlineMarkupType, collection: true
+          klass.attribute :h6, InlineMarkupType, collection: true
+          klass.attribute :ul, ListType, collection: true
+          klass.attribute :ol, OrderedListType, collection: true
+          klass.attribute :pre, PreformattedType, collection: true
+          klass.attribute :hr, :string, collection: true
+          klass.attribute :blockquote, BlockQuoteType, collection: true
+          klass.attribute :table, TableType, collection: true
+        end
+      end
+
+      private
+
+      def build_field_xml(klass, xml_element, is_markup, field_def,
+is_multiline = false)
+        flag_defs = field_def.define_flag || []
+        flag_refs = field_def.flag || []
+
+        flag_attr_maps = flag_defs.filter_map do |f|
+          [f.name, Utils.safe_attr(f.name)] if f.name
+        end
+        flag_ref_maps = flag_refs.filter_map do |f|
+          [f.ref, Utils.safe_attr(f.ref)] if f.ref
+        end
+
+        klass.class_eval do
+          xml do
+            element xml_element
+            mixed_content if is_markup
+            ordered if is_markup
+
+            map_content to: :content
+
+            if is_markup
+              map_element "a", to: :a
+              map_element "insert", to: :insert
+              map_element "br", to: :br
+              map_element "code", to: :code
+              map_element "em", to: :em
+              map_element "i", to: :i
+              map_element "b", to: :b
+              map_element "strong", to: :strong
+              map_element "sub", to: :sub
+              map_element "sup", to: :sup
+              map_element "q", to: :q
+              map_element "img", to: :img
+            end
+
+            if is_multiline
+              map_element "p", to: :p
+              map_element "h1", to: :h1
+              map_element "h2", to: :h2
+              map_element "h3", to: :h3
+              map_element "h4", to: :h4
+              map_element "h5", to: :h5
+              map_element "h6", to: :h6
+              map_element "ul", to: :ul
+              map_element "ol", to: :ol
+              map_element "pre", to: :pre
+              map_element "hr", to: :hr
+              map_element "blockquote", to: :blockquote
+              map_element "table", to: :table
+            end
+
+            flag_attr_maps.each do |xml_name, attr_name|
+              map_attribute xml_name, to: attr_name
+            end
+
+            flag_ref_maps.each do |xml_name, attr_name|
+              map_attribute xml_name, to: attr_name
+            end
+          end
+        end
+      end
+
+      def build_field_json(klass, field_def)
+        flag_defs = field_def.define_flag || []
+        flag_refs = field_def.flag || []
+        has_flags = flag_defs.any? || flag_refs.any?
+        json_vk = field_def.json_value_key
+        json_vk_flag = field_def.json_value_key_flag&.flag_ref
+
+        if json_vk_flag
+          build_field_json_value_key_flag(klass, field_def, json_vk_flag)
+          return
+        end
+
+        value_key = json_vk || TypeMapper.json_value_key(field_def.as_type)
+
+        flag_attr_maps = flag_defs.filter_map do |f|
+          [f.name, Utils.safe_attr(f.name)] if f.name
+        end
+        flag_ref_maps = flag_refs.filter_map do |f|
+          [f.ref, Utils.safe_attr(f.ref)] if f.ref
+        end
+
+        klass.class_eval do
+          key_value do
+            root field_def.name
+
+            if has_flags || json_vk
+              map value_key, to: :content
+            else
+              map "content", to: :content
+            end
+
+            flag_attr_maps.each do |xml_name, attr_name|
+              map xml_name, to: attr_name
+            end
+
+            flag_ref_maps.each do |xml_name, attr_name|
+              map xml_name, to: attr_name
+            end
+          end
+        end
+      end
+
+      def build_field_json_value_key_flag(klass, field_def, key_flag_ref)
+        key_attr = Utils.safe_attr(key_flag_ref)
+        flag_defs = field_def.define_flag || []
+        flag_refs = field_def.flag || []
+
+        other_flag_maps = flag_defs.reject { |f| f.name == key_flag_ref }
+          .filter_map do |f|
+          if f.name
+            [f.name,
+             Utils.safe_attr(f.name)]
+          end
+        end +
+          flag_refs.reject { |f| f.ref == key_flag_ref }
+            .filter_map do |f|
+            if f.ref
+              [f.ref,
+               Utils.safe_attr(f.ref)]
+            end
+          end
+
+        klass.instance_variable_set(:@json_vk_flag_key_attr, key_attr)
+        klass.instance_variable_set(:@json_vk_flag_other_flag_maps,
+                                    other_flag_maps)
+
+        klass.class_eval do
+          key_value do
+            root field_def.name
+            other_flag_maps.each do |json_name, attr_name|
+              map json_name, to: attr_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metaschema/model_generator/services/collapsibles_collapser.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Metaschema
+  class ModelGenerator
+    module Services
+      # Collapses multiple model instances that share the same flag values
+      # into a single instance with array-valued content. Implements the
+      # Metaschema "collapsible" field semantics.
+      #
+      # The inverse operation (expanding collapsed items) is performed by
+      # FieldDeserializer#separate.
+      class CollapsiblesCollapser
+        attr_reader :collapsibles
+
+        def initialize(model_class, collapsible_attributes, format, models)
+          @model_class = model_class
+          @collapsible_attributes = collapsible_attributes
+          @format = format
+          @uncollapsible_mappings = model_class.mappings[format].mappings
+            .reject { |n| collapsible_attributes.key?(n.to) }
+          @collapsibles = []
+          @groups = {}
+          process(models)
+        end
+
+        def call(value)
+          @groups.map { |_, group| collapse_group(group, value) }
+        end
+
+        private
+
+        def process(models)
+          models.each_with_index do |model, index|
+            collapsible = create_collapsible(model)
+            @collapsibles << collapsible
+            group_id = group_id_for(collapsible)
+            (@groups[group_id] ||= []) << [index, collapsible]
+          end
+        end
+
+        def create_collapsible(model)
+          @model_class.new(attributes_from(model))
+        end
+
+        def attributes_from(model)
+          model.class.attributes.each_with_object({}) do |(name, attr), attrs|
+            value = model.public_send(name)
+            next if value == attr.default && @collapsible_attributes.key?(name)
+
+            attrs[name] = value
+          end
+        end
+
+        def group_id_for(model)
+          @collapsible_attributes.transform_values do |attr|
+            model.public_send(attr.name)
+          end
+        end
+
+        def collapse_group(group, value)
+          indices = group.map { |idx, _| idx }
+          first_collapsed = value[indices.first]
+
+          return first_collapsed if indices.one?
+
+          merge_uncollapsible(first_collapsed, indices, value)
+        end
+
+        def merge_uncollapsible(first, indices, value)
+          return first unless @uncollapsible_mappings.any?
+
+          result = first.dup
+          @uncollapsible_mappings.each do |rule|
+            values = indices.map { |idx| value[idx][rule.name] }
+            result[rule.name] = values
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/metaschema/model_generator/services/field_deserializer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Metaschema
+  class ModelGenerator
+    module Services
+      # Deserializes a field value from the source format into a model instance.
+      # Handles SINGLETON_OR_ARRAY normalization and collapsible field expansion.
+      #
+      # Pipeline: normalize -> separate -> cast -> validate_collection -> transform
+      class FieldDeserializer
+        def initialize(model, attr, format, data, group_as:, collapsible:)
+          @model = model
+          @attribute = model.class.attributes[attr]
+          @format = format
+          @mapping_rule = model.class.mappings[format].mappings
+            .find { |r| r.to == attr }
+          @data = data
+          @group_as = group_as
+          @collapsible = collapsible
+        end
+
+        def self.call(...)
+          new(...).call
+        end
+
+        def call
+          data = normalize(@data)
+          data = separate(data) if @collapsible
+          data = cast(data)
+          validate_collection!(data)
+          data = transform(data)
+          data = unwrap_singleton(data)
+
+          @model.public_send(:"#{@attribute.name}=", data)
+        end
+
+        private
+
+        # Wrap non-array data in an array for SINGLETON_OR_ARRAY fields.
+        def normalize(data)
+          if @group_as == "SINGLETON_OR_ARRAY" && !data.is_a?(Array)
+            [data].compact
+          else
+            data
+          end
+        end
+
+        # Expand collapsed items back into individual instances.
+        # Collapsed data has array-valued non-collapsible attributes;
+        # we expand each array position into a separate instance.
+        def separate(data)
+          data.each_with_object([]) do |item, results|
+            size = item.each_value.find { |v| v.is_a?(Array) }&.size
+
+            if size
+              size.times do |index|
+                results << item.transform_values do |v|
+                  v.is_a?(Array) ? v[index] : v
+                end
+              end
+            else
+              results << item
+            end
+          end
+        end
+
+        def cast(data)
+          opts = { polymorphic: @mapping_rule&.polymorphic }.compact
+          @attribute.cast(data, @format, @model.lutaml_register, opts)
+        end
+
+        def validate_collection!(data)
+          @attribute.valid_collection!(data, @model.class)
+        end
+
+        def transform(data)
+          Lutaml::Model::ImportTransformer.call(data, @mapping_rule, @attribute)
+        end
+
+        # For SINGLETON_OR_ARRAY with non-collection attributes, unwrap
+        # a single-element array back to a scalar value.
+        def unwrap_singleton(data)
+          return data unless data.is_a?(Array)
+          return data unless @group_as == "SINGLETON_OR_ARRAY"
+          return data if @attribute.collection
+
+          data.one? ? data.first : data
+        end
+      end
+    end
+  end
+end

data/lib/metaschema/model_generator/services/field_serializer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "collapsibles_collapser"
+
+module Metaschema
+  class ModelGenerator
+    module Services
+      # Serializes a field value from a model instance to the target format.
+      # Handles SINGLETON_OR_ARRAY normalization and collapsible field merging.
+      #
+      # Pipeline: transform -> make_collapsible -> serialize -> apply_value_map
+      #           -> collapse -> denormalize
+      class FieldSerializer
+        def initialize(model, attr, format, data, group_as:, collapsible:)
+          @model = model
+          @attribute = model.class.attributes[attr]
+          @format = format
+          @mapping_rule = model.class.mappings[format].mappings
+            .find { |r| r.to == attr }
+          @data = data
+          @group_as = group_as
+          @collapsible = collapsible
+        end
+
+        def self.call(...)
+          new(...).call
+        end
+
+        def call
+          value = @model.public_send(@attribute.name)
+          return if value.nil?
+
+          value = transform(value)
+          value = make_collapsible(value) if @collapsible
+          value = serialize(value)
+          return unless @mapping_rule&.render?(value, @model)
+
+          value = apply_value_map(value)
+          value = collapse(value) if @collapsible
+          value = denormalize(value)
+
+          @data[@mapping_rule.name] = value
+        end
+
+        private
+
+        def transform(value)
+          Lutaml::Model::ExportTransformer.call(value, @mapping_rule,
+                                                @attribute)
+        end
+
+        def make_collapsible(value)
+          collapsible_attrs = @attribute.type.attributes
+            .reject { |_, attr| content_attribute?(attr) }
+          @collapser = CollapsiblesCollapser.new(
+            @attribute.type, collapsible_attrs, @format, value
+          )
+          @collapser.collapsibles
+        end
+
+        def content_attribute?(attr)
+          attr.name == :content && attr.type < Lutaml::Model::Type::Value
+        end
+
+        def serialize(value)
+          @attribute.serialize(value, @format, @model.lutaml_register)
+        end
+
+        def apply_value_map(value)
+          if value.nil?
+            value_for_option(value_map[:nil], @attribute)
+          elsif Lutaml::Model::Utils.empty?(value)
+            value_for_option(value_map[:empty], @attribute, value)
+          elsif Lutaml::Model::Utils.uninitialized?(value)
+            value_for_option(value_map[:omitted], @attribute)
+          else
+            value
+          end
+        end
+
+        def value_map
+          @mapping_rule.value_map(:to)
+        end
+
+        def value_for_option(option, attr, empty_value = nil)
+          return nil if option == :nil
+          return empty_value || empty_object(attr) if option == :empty
+
+          Lutaml::Model::UninitializedClass.instance
+        end
+
+        def empty_object(attr)
+          attr.collection? ? [] : ""
+        end
+
+        def collapse(value)
+          @collapser.call(value)
+        end
+
+        def denormalize(value)
+          soa = @group_as == "SINGLETON_OR_ARRAY"
+          if soa && value.is_a?(Array) && value.one?
+            value.first
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metaschema/model_generator/utils.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Metaschema
+  class ModelGenerator
+    # Shared utility methods extracted from ModelGenerator.
+    # Used by FieldFactory, AssemblyFactory, and ModelGenerator itself.
+    module Utils
+      RESERVED_WORDS = %i[class module method hash object_id nil? is_a? kind_of?
+                          instance_of? respond_to? send].freeze
+
+      # Convert a Metaschema name (hyphenated) to a safe Ruby attribute name.
+      def self.safe_attr(name)
+        sym = name.gsub("-", "_").to_sym
+        RESERVED_WORDS.include?(sym) ? :"#{sym}_attr" : sym
+      end
+
+      # Check if a max-occurs value represents an unbounded collection.
+      def self.unbounded?(max_occurs)
+        max_occurs.nil? || max_occurs == "unbounded" ||
+          (max_occurs.respond_to?(:to_i) && max_occurs.to_i > 1)
+      end
+
+      # Generate a scoped name for inline field classes to avoid collisions.
+      def self.scoped_field_name(field_name, parent_name = nil)
+        if parent_name
+          "Field_#{parent_name}_#{field_name.gsub('-', '_')}"
+        else
+          "Field_#{field_name.gsub('-', '_')}"
+        end
+      end
+
+      # Create an anonymous class with a debuggable temporary name.
+      def self.create_model(name, super_class = Lutaml::Model::Serializable)
+        model = Class.new(super_class)
+        set_model_temporary_name(model, name)
+        model
+      end
+
+      # Check if an object is a lutaml-model Serializable subclass.
+      def self.model?(object)
+        object.is_a?(Class) && object.include?(Lutaml::Model::Serialize)
+      end
+
+      # Assign a human-readable name to an anonymous class for debugging.
+      def self.set_model_temporary_name(model, name)
+        display_name = name.gsub(/(?:^|[-._]+)./) do |n|
+          n[-1].upcase
+        end + ":Class"
+
+        if model.respond_to?(:set_temporary_name)
+          model.set_temporary_name(display_name)
+          return
+        end
+
+        model.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def self.to_s
+            name || #{display_name.inspect}
+          end
+          singleton_class.alias_method :inspect, :to_s
+        RUBY
+      end
+    end
+  end
+end