lutaml-lml 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d249342f8fa771fc6acc926a4a4fa75eb2f2532ccd4461ea0452c7930d6a0372
-  data.tar.gz: 7a852a63a20c02124a7c34c66501f749801711968239ef8e7fd7d92df4b96abb
+  metadata.gz: 8bdefb219dd99a2335669d57b9e7a79a21d822485ebc1a3748d915dee88d2901
+  data.tar.gz: a63770177d2c8ff0b85e0d30caa6c9033529c75eee9738fbe59b25dc7c1d30eb
 SHA512:
-  metadata.gz: 2acbed3dc1c0da892d6344ec7ff87147d13d24de03b44ae8c8ff3ba136a3941a20ac6b95e4d1e4445c52b91ca0997e1d7c9a7425fd92713b954874ce2dd0abf3
-  data.tar.gz: a9f5844e875eba16ef0f3bdcb2f10ff62fe377935cce06f35c7e92571a8e7cfa9a43782919b2661f161cb4be6fffe73b67fc10bbcb9c56a73ab7ec36b2daec48
+  metadata.gz: 3e12f920e7b614aa4902cd953e311fdde4dae2cd93a15bd9c5fe10b1c0ca234412a8228ca6cf2f0d22956ddb67cfd681127dedac417d43cd9b0c5b962e3e777a
+  data.tar.gz: c7a727c6d617731e160d1ad6bebbba053cd6216a10c93c2d177f391881f0405f0304b3bd7a28230c18cd85cddb3383ff7639a348b36489f142d1e6c6e052ec76

data/lib/lutaml/lml/cli.rb

@@ -186,13 +186,22 @@ module Lutaml
           input_path = Pathname.new(path_string)
           return report_file_error(input_path, 'File does not exist') unless input_path.exist?
 
-          parse_document(input_path)
-          say "✓ #{input_path}", :green
-          nil
+          document = parse_document(input_path)
+          violations = Lutaml::Lml::Validator.violations(document)
+          if violations.any?
+            report_file_error(input_path, violations_message(violations))
+          else
+            say "✓ #{input_path}", :green
+            nil
+          end
         rescue StandardError => e
           report_file_error(input_path, e.message)
         end
 
+        def violations_message(violations)
+          violations.map { |v| "[#{v.rule}] #{v.message}" }.join('; ')
+        end
+
         def report_file_error(input_path, message)
           say "✗ #{input_path}: #{message}", :red
           "#{input_path}: #{message}"

data/lib/lutaml/lml/data_processor/attribute_processing.rb

@@ -15,18 +15,52 @@ module Lutaml
 
         def process_attributes_array(obj)
           return [] if obj.empty?
-          return obj.map { |item| process_attributes(item) } unless single_key_hashes?(obj)
+          return obj.map { |item| process_attributes(item) } unless named_attribute_entries?(obj)
+          return merge_named_entries(obj) unless single_key_hashes?(obj)
 
+          obj.each_with_object({}) { |item, hash| append_uniform_entry(hash, item) }
+        end
+
+        def append_uniform_entry(hash, item)
+          hash[:properties] ||= []
+          if item.key?(:properties)
+            hash[:properties] << process_attributes(item[:properties])
+          else
+            hash.merge!(process_attributes(item))
+          end
+        end
+
+        # Attribute-definition groups split across capture depths (e.g. the
+        # comma form: {name, type} beside a nested {value_set}) combine into
+        # one attribute entry. Key/value pair lists (import/export maps)
+        # carry :key and are never merged.
+        def named_attribute_entries?(obj)
+          obj.any? { |e| e.is_a?(Hash) && e.key?(:name) } &&
+            obj.all? { |e| e.is_a?(Hash) && !e.key?(:key) }
+        end
+
+        COLLECTION_KEYS = %i[properties attributes instances].freeze
+
+        def merge_named_entries(obj)
           obj.each_with_object({}) do |item, hash|
-            hash[:properties] ||= []
-            if item.key?(:properties)
-              hash[:properties] << process_attributes(item[:properties])
-            else
-              hash.merge!(process_attributes(item))
+            process_attributes(item).each do |key, value|
+              hash[key] = merge_attribute_value(hash[key], key, value)
             end
           end
         end
 
+        def merge_attribute_value(existing, key, value)
+          return merge_collection_value(existing, value) if COLLECTION_KEYS.include?(key)
+          return existing + value if existing.is_a?(Array) && value.is_a?(Array)
+
+          value
+        end
+
+        def merge_collection_value(existing, value)
+          current = existing.is_a?(Array) ? existing : (existing ? [existing] : [])
+          current + (value.is_a?(Array) ? value : [value])
+        end
+
         def process_attributes_hash(obj)
           result = extract_name_and_value(obj)
           convert_instance_type(result)
@@ -34,18 +68,17 @@ module Lutaml
           result[:literal] = true if obj.key?(:type_literal)
           apply_nested_attributes(result, obj)
           apply_remaining_keys(result, obj)
+          translate_values_argument(result)
           result
         end
 
-        private
-
         def single_key_hashes?(arr)
           arr.all? { |e| e.is_a?(Hash) && e.keys.size == 1 }
         end
 
         def extract_name_and_value(obj)
           result = {}
-          result[:name] = obj[:key] if obj.key?(:key)
+          result[:name] = strip_argument_colon(obj[:key]) if obj.key?(:key)
 
           if obj.key?(:comments)
             result[:name] = 'Comment'
@@ -74,9 +107,16 @@ module Lutaml
           obj.each do |key, value|
             next if EXCLUDED_PASS_THROUGH_KEYS.include?(key)
 
+            value = strip_argument_colon(value) if key == :name
             result[key] = value unless result.key?(key)
           end
         end
+
+        # `default: "Clear"` uses the colon separator (RS 3001 §Attribute);
+        # the colon lands in the captured name and must not.
+        def strip_argument_colon(name)
+          name.to_s.sub(/:\z/, "")
+        end
       end
     end
   end

data/lib/lutaml/lml/data_processor/value_declaration_processing.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      # RS 3001 §Value/§Attribute argument normalization: the canonical
+      # `value` construct and the attribute `values` argument.
+      module ValueDeclarationProcessing
+        # `value <name> { block }` is the canonical enum member; the bare
+        # identifier member is its documented shortcut. Normalize into the
+        # member shape the shortcut produces: the value block's `definition`
+        # lines become the member description and its attribute pairs become
+        # member payload properties.
+        def process_value_declaration(decl)
+          inner = { name: unwrap_string(decl[:value_name]) }
+          Array(decl[:members]).each do |member|
+            normalize_value_member(inner, member)
+          end
+          { attributes: inner }
+        end
+
+        # `values <enum>` types the attribute with the named enum;
+        # `values { v1, v2 }` carries an inline value set that the compiler
+        # expands into an anonymous enum.
+        def translate_values_argument(result)
+          if result.key?(:value_set_ref)
+            ref = unwrap_string(result.delete(:value_set_ref))
+            result[:type] = ref unless result[:type]
+          end
+          return unless result.key?(:value_set)
+
+          result[:value_set] = Array(result[:value_set][:items]).map { |item| unwrap_data_value(item[:item]) }
+        end
+
+        private
+
+        def normalize_value_member(inner, member)
+          if member.key?(:definition)
+            (inner[:attributes] ||= []) << { name: 'description', type: unwrap_string(member[:definition]) }
+          elsif member.key?(:instance)
+            (inner[:instances] ||= []).concat(Array(member[:instance]))
+          elsif member.key?(:attributes)
+            (inner[:properties] ||= []) << member[:attributes]
+          elsif member.key?(:key)
+            (inner[:properties] ||= []) << extract_name_and_value(member)
+          end
+        end
+
+        def unwrap_data_value(item)
+          return item unless item.is_a?(Hash)
+
+          item[:string] || item[:number] || item[:float] ||
+            item[:boolean] || item[:name] || item
+        end
+
+        def unwrap_string(value)
+          value.is_a?(Hash) && value.key?(:string) ? value[:string] : value
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor.rb

@@ -5,12 +5,14 @@ module Lutaml
     class DataProcessor
       autoload :ValueProcessing, "lutaml/lml/data_processor/value_processing"
       autoload :AttributeProcessing, "lutaml/lml/data_processor/attribute_processing"
+      autoload :ValueDeclarationProcessing, "lutaml/lml/data_processor/value_declaration_processing"
       autoload :InstanceProcessing, "lutaml/lml/data_processor/instance_processing"
       autoload :CollectionProcessing, "lutaml/lml/data_processor/collection_processing"
       autoload :ViewProcessing, "lutaml/lml/data_processor/view_processing"
 
       include ValueProcessing
       include AttributeProcessing
+      include ValueDeclarationProcessing
       include InstanceProcessing
       include CollectionProcessing
       include ViewProcessing
@@ -20,6 +22,7 @@ module Lutaml
         instances: :process_instances,
         instance: :process_instance,
         attributes: :process_attributes,
+        value_decl: :process_value_declaration,
         show_list: :process_show_list,
         hide_list: :process_hide_list
       }.freeze

data/lib/lutaml/lml/document_builder.rb

@@ -24,7 +24,9 @@ module Lutaml
         mapping: ::Lutaml::Lml::Mapping,
         string_format: ::Lutaml::Lml::StringFormat,
         derived_field: ::Lutaml::Lml::DerivedField,
-        member_field: ::Lutaml::Lml::MemberField
+        member_field: ::Lutaml::Lml::MemberField,
+        namespace: ::Lutaml::Lml::Namespace,
+        serialization_mapping: ::Lutaml::Lml::SerializationMapping
       }.freeze
 
       attr_reader :registry
@@ -36,7 +38,7 @@ module Lutaml
       FACTORY_KEYS = %i[
         document package class enum data_type diagram view_import view_filter
         attribute association operation constraint value cardinality mapping
-        string_format derived_field
+        string_format derived_field namespace serialization_mapping
       ].freeze
 
       MEMBER_KEY_MAP = {
@@ -52,7 +54,9 @@ module Lutaml
         constraints: :constraint,
         values: :value,
         mappings: :mapping,
-        member_fields: :member_field
+        member_fields: :member_field,
+        namespaces: :namespace,
+        serialization_mappings: :serialization_mapping
       }.freeze
 
       FACTORY_KEYS.each do |key|
@@ -102,9 +106,11 @@ module Lutaml
       end
 
       def add_members(model, hash)
-        expand_mapping_section(model, hash)
-        expand_class_declarations(model, hash)
-        expand_enum_member_fields(model, hash)
+        expand_declared_members(model, hash)
+        normalize_namespace_declaration(hash)
+        normalize_serialization_mapping(hash)
+        expand_instances_collection_name(hash)
+        expand_nested_members(model, hash)
         MEMBER_KEY_MAP.each do |plural_key, singular_key|
           data = hash.delete(plural_key)
           next if data.nil?
@@ -116,6 +122,138 @@ module Lutaml
         remap_filter_keys(hash, model)
       end
 
+      # RS 3001 §Enums: an enum-level `values { v1, v2 }` shorthand
+      # expands into plain members.
+      def expand_value_set_declaration(model, hash)
+        decl = hash.delete(:value_set_decl) or return
+        Array(decl[:items]).each do |item|
+          name = unquote(item[:item])
+          model.attributes << TopElementAttribute.new(name: name)
+        end
+      end
+
+      # RS 3001 §Value: the canonical `value` construct normalizes into
+      # the same member shape the bare-identifier shortcut produces.
+      def expand_value_declaration(model, hash)
+        decl = hash.delete(:value_decl) or return
+        apply_attribute(model, :attributes, decl.fetch(:attributes))
+      end
+
+      # Namespace declaration bodies arrive as keyword-line members
+      # ({uri: …}, {prefix: …}); flatten them onto the namespace hash.
+      def normalize_namespace_declaration(hash)
+        ns = hash[:namespaces] or return
+        Array(ns.delete(:members)).each do |pair|
+          pair.each { |key, value| ns[key] = unquote(value) }
+        end
+      end
+
+      # Serialization mapping rules arrive keyed by their line construct
+      # ({map_element: {wire:, field:}}); normalize into plain MappingRule
+      # hashes so the model cast lands typed rules.
+      def normalize_serialization_mapping(hash)
+        mapping = hash[:serialization_mappings] or return
+        rules = Array(mapping[:rules])
+        return if rules.any? && rules.all? { |e| e.is_a?(Hash) && e.key?(:kind) }
+
+        rules = rules.filter_map do |entry|
+          next nil unless entry.is_a?(Hash)
+
+          if entry[:wire] && entry[:to]
+            next { kind: 'map', wire: unquote(entry[:wire]), field: unquote(entry[:to]) }
+          end
+
+          first_key = entry.keys.first
+          kind = first_key.to_s
+          body = entry[first_key] || {}
+          unless body.is_a?(Hash)
+            kind_n = normalize_mapping_kind(kind)
+            next nil if body.to_s.empty?
+
+            term = unquote(body)
+            next { kind: kind_n, wire: term, field: term } if %w[element attribute map].include?(kind_n)
+            if kind_n == 'namespace'
+              mapping[:namespace_ref] = term
+              next nil
+            end
+
+            next { kind: kind_n, field: term }
+          end
+          if kind == 'element_name'
+            mapping[:element_name] = unquote(body[:element_name])
+            next nil
+          end
+          if kind == 'map_namespace'
+            mapping[:namespace_ref] = unquote(body[:namespace_ref])
+            next nil
+          end
+          normalized = { kind: normalize_mapping_kind(kind) }
+          wire = body[:wire] || body[:element_wire]
+          normalized[:wire] = unquote(wire) if wire
+          field = body[:field] || body[:to_field] || body[:element_field] ||
+                  body[:attribute_field] || body[:to]
+          normalized[:field] = unquote(field) if field
+          normalized[:mode] = body[:mode] if body[:mode]
+          normalized[:namespace_ref] = unquote(body[:namespace_ref]) if body[:namespace_ref]
+          normalized
+        end
+        mapping[:rules] = rules
+      end
+
+      def normalize_mapping_kind(kind)
+        {
+          'map_element' => 'element', 'map_attribute' => 'attribute',
+          'map_content' => 'content', 'map_namespace' => 'namespace',
+          'map_key' => 'key', 'map_value' => 'value', 'map' => 'map',
+          'legacy_map' => 'map'
+        }.fetch(kind, kind)
+      end
+
+      # A named instances collection (`instances "Glazes" { ... }`) arrives
+      # with its name as a sibling of the collection body; move it inside
+      # so the InstanceCollection carries it.
+      def expand_instances_collection_name(hash)
+        return unless hash.key?(:instances) && hash.key?(:name)
+
+        name = unquote(hash.delete(:name))
+        body = hash[:instances].is_a?(Hash) ? hash[:instances] : {}
+        body[:name] = name unless body.key?(:name)
+      end
+
+      # The document root is a repetition of top-level constructs (RS 3001:
+      # documents interleave declarations), so models/packages blocks nest
+      # their members one level down; recurse into them.
+      def expand_nested_members(model, hash)
+        return unless hash.key?(:members)
+
+        members = hash.delete(:members)
+        members.to_a.each do |nested|
+          add_members(model, nested)
+          set_model_attributes(model, nested)
+        end
+      end
+
+      # Declaration-level member hooks: single-line definitions, canonical
+      # `value` members, mapping sections, class declarations, enum
+      # member_fields and from_table all arrive as bare member hashes.
+      def expand_declared_members(model, hash)
+        expand_definition_text(model, hash)
+        expand_value_declaration(model, hash)
+        expand_value_set_declaration(model, hash)
+        expand_mapping_section(model, hash)
+        expand_class_declarations(model, hash)
+        expand_enum_member_fields(model, hash)
+        expand_from_table(model, hash)
+      end
+
+      # RS 3001 §Definition single-line form (`definition "text"`) arrives
+      # as a quoted-string capture; unwrap it for the entity's definition.
+      def expand_definition_text(model, hash)
+        return unless hash.key?(:definition) && model.class.attributes.key?(:definition)
+
+        model.definition = unquote(hash.delete(:definition))
+      end
+
       # A mapping section arrives as a bare member hash
       # { format:, maps: [{ wire:, to: }] }; expand to one Mapping entry
       # per map line, each carrying the format, and strip the section keys
@@ -158,6 +296,23 @@ module Lutaml
                                       type: unquote(derived[:type]))
       end
 
+      # L7a: from_table declares the enum's members as an artifact table
+      # { from_table_name:, from_table_artifact? } — expansion happens at
+      # compile time (deterministic materialization, no runtime data dep)
+      def expand_from_table(model, hash)
+        decl = hash.delete(:from_table_decl)
+        return unless decl && model.is_a?(Enum)
+
+        # the members repetition splits the declaration across iteration
+        # hashes (name part, artifact part) — merge the parts
+        parts = decl.is_a?(Array) ? decl : [decl]
+        decl = parts.each_with_object({}) do |part, acc|
+          acc.merge!(part) { |_key, _old, new_val| new_val }
+        end
+        model.from_table_name = unquote(decl[:from_table_name])
+        model.from_table_artifact = unquote(decl[:artifact_table]) if decl[:artifact_table]
+      end
+
       def expand_enum_member_fields(model, hash)
         decl = hash.delete(:member_fields_decl)
         return unless decl && model.is_a?(Enum)