lutaml-xsd 1.0.9 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2649418d3ea00927ab8b73628856fa55ed114ca61489f6834b6d6daca9d416b
-  data.tar.gz: 16452655b05b900cb227ea65d63b555d593cd8e31ffceeb8af78872e4ff7a94b
+  metadata.gz: 29e9ba5ed3edf116b76cdf22ed853a37399d00ffda6b11f78a0cccdb5502b4e4
+  data.tar.gz: 6213f84485cad0ffed1eef19d60ae29fea7d5e274522ba8dfcc996048694e677
 SHA512:
-  metadata.gz: ae2220574c0cd979eb05eed45efe8770ba855cf641d6b30d68f899f370a831598392e44e7ab81e6a85d3c5e4c975c24057a2c11e783757d4831e23a8aae6435a
-  data.tar.gz: 4773bd5fc5b44b98d4ca7b2cffc60a233abd60c221829c77611d002e03f07c4de9142c1731ffa58827e22cac0f1a606548d109e08a2466073bece6093fe56ce8
+  metadata.gz: 07a2c5d774d76218e043372749950daa031c3b1ff3177a4eb65c5a05de6e6747479bbbd4acd7a5c7a808553bb75e62808d66bb68157324b4341d25045e11aa0b
+  data.tar.gz: cba0111db7b0b7bf12fb9e0c55edbdfcbc4e3f4f11a653957ad663e6d8c067a1980bcbb7a54898f50b6e408869ca56d0179a822a7fcae8ba201111c68fceeb15

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-04-25 09:44:01 UTC using RuboCop version 1.86.1.
+# on 2026-04-27 11:46:52 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,56 +11,21 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'lutaml-xsd.gemspec'
 
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: with_first_element, with_fixed_indentation
-Layout/ArrayAlignment:
-  Exclude:
-    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-    - 'lib/lutaml/xsd/spa/utils/extract_enumeration.rb'
-
-# Offense count: 4
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: IndentationWidth.
-Layout/AssignmentIndentation:
-  Exclude:
-    - 'lib/lutaml/xsd/commands/package_command.rb'
-    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-
-# Offense count: 7
-# This cop supports safe autocorrection (--autocorrect).
-Layout/ClosingParenthesisIndentation:
-  Exclude:
-    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-
 # Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyleAlignWith.
-# SupportedStylesAlignWith: keyword, variable, start_of_line
-Layout/EndAlignment:
+# SupportedStylesAlignWith: either, start_of_block, start_of_line
+Layout/BlockAlignment:
   Exclude:
     - 'lib/lutaml/xsd/spa/schema_serializer.rb'
 
 # Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: consistent, consistent_relative_to_receiver, special_for_inner_method_call, special_for_inner_method_call_in_parentheses
-Layout/FirstArgumentIndentation:
-  Exclude:
-    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowMultipleStyles, EnforcedHashRocketStyle, EnforcedColonStyle, EnforcedLastArgumentHashStyle.
-# SupportedHashRocketStyles: key, separator, table
-# SupportedColonStyles: key, separator, table
-# SupportedLastArgumentHashStyles: always_inspect, always_ignore, ignore_implicit, ignore_explicit
-Layout/HashAlignment:
+Layout/BlockEndNewline:
   Exclude:
     - 'lib/lutaml/xsd/spa/schema_serializer.rb'
 
-# Offense count: 1
+# Offense count: 2
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Width, EnforcedStyleAlignWith, AllowedPatterns.
 # SupportedStylesAlignWith: start_of_line, relative_to_receiver
@@ -68,30 +33,20 @@ Layout/IndentationWidth:
   Exclude:
     - 'lib/lutaml/xsd/spa/schema_serializer.rb'
 
-# Offense count: 730
+# Offense count: 722
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 7
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: symmetrical, new_line, same_line
-Layout/MultilineMethodCallBraceLayout:
-  Exclude:
-    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-
-# Offense count: 11
+# Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowInHeredoc.
-Layout/TrailingWhitespace:
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: aligned, indented
+Layout/MultilineOperationIndentation:
   Exclude:
-    - 'lib/lutaml/xsd/commands/package_command.rb'
     - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-    - 'lib/lutaml/xsd/spa/utils/extract_enumeration.rb'
-    - 'lib/lutaml/xsd/spa/xml_instance_generator.rb'
 
 # Offense count: 11
 # Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
@@ -126,7 +81,7 @@ Lint/UselessRescue:
   Exclude:
     - 'lib/lutaml/xsd/validation/rule_engine.rb'
 
-# Offense count: 267
+# Offense count: 269
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -142,12 +97,12 @@ Metrics/BlockLength:
 Metrics/BlockNesting:
   Max: 5
 
-# Offense count: 199
+# Offense count: 201
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 370
+# Offense count: 373
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 90
@@ -157,12 +112,12 @@ Metrics/MethodLength:
 Metrics/ParameterLists:
   Max: 9
 
-# Offense count: 149
+# Offense count: 151
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
 
-# Offense count: 24
+# Offense count: 25
 # Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
 # AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
 Naming/MethodParameterName:
@@ -222,6 +177,17 @@ Security/MarshalLoad:
   Exclude:
     - 'lib/lutaml/xsd/package_builder.rb'
 
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, AllowedMethods, AllowedPatterns, AllowBracesOnProceduralOneLiners, BracesRequiredMethods.
+# SupportedStyles: line_count_based, semantic, braces_for_chaining, always_braces
+# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
+# FunctionalMethods: let, let!, subject, watch
+# AllowedMethods: lambda, proc, it
+Style/BlockDelimiters:
+  Exclude:
+    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
+
 # Offense count: 6
 Style/DocumentDynamicEvalDefinition:
   Exclude:
@@ -248,14 +214,6 @@ Style/IdenticalConditionalBranches:
   Exclude:
     - 'lib/lutaml/xsd/package_tree_formatter.rb'
 
-# Offense count: 3
-# This cop supports safe autocorrection (--autocorrect).
-Style/MultilineIfModifier:
-  Exclude:
-    - 'lib/lutaml/xsd/commands/package_command.rb'
-    - 'lib/lutaml/xsd/spa/schema_serializer.rb'
-    - 'lib/lutaml/xsd/spa/utils/extract_enumeration.rb'
-
 # Offense count: 1
 Style/OpenStructUse:
   Exclude:

data/lib/lutaml/xsd/spa/schema_serializer.rb

@@ -4,6 +4,9 @@ require "json"
 require "moxml"
 require "tmpdir"
 require "fileutils"
+require "tempfile"
+require "nokogiri"
+require "xsdvi"
 require_relative "xml_instance_generator"
 require_relative "utils/extract_enumeration"
 
@@ -32,6 +35,12 @@ module Lutaml
       class SchemaSerializer
         include ::Lutaml::Xsd::Spa::Utils::ExtractEnumeration
 
+        # Fields to merge when combining schemas with the same targetNamespace
+        MERGEABLE_CONTENT_FIELDS = %i[
+          elements complex_types simple_types
+          attributes groups attribute_groups
+        ].freeze
+
         attr_reader :repository, :config, :package
 
         # Initialize schema serializer
@@ -214,12 +223,104 @@ module Lutaml
             serialize_schema(schema, index, file_path)
           end.compact
 
+          # Merge schemas that share the same target namespace (from <include>)
+          # XSD <include> merges included schemas into the same namespace.
+          # Group by namespace, keep entry point as primary, merge content from others.
+          schemas_data = merge_included_schemas(schemas_data)
+
           # Post-process: add used_by reverse references
           attach_used_by_references(schemas_data)
 
           schemas_data
         end
 
+        # Merge schemas sharing the same targetNamespace (from <include> directives)
+        #
+        # In XSD, <include> means the included schema targets the same namespace.
+        # These should appear as a single merged schema in the SPA, not as
+        # separate empty + populated entries.
+        #
+        # Schemas with nil namespace (chameleon schemas) are NOT merged since
+        # they adopt the namespace of their including schema at parse time.
+        #
+        # @param schemas_data [Array<Hash>] Serialized schema data
+        # @return [Array<Hash>] Merged schema data
+        def merge_included_schemas(schemas_data)
+          return schemas_data if schemas_data.length <= 1
+
+          ns_groups = {}
+          schemas_data.each do |schema|
+            ns = schema[:namespace]
+            # Skip nil-namespace schemas — chameleon schemas should not be merged
+            next unless ns
+
+            ns_groups[ns] ||= []
+            ns_groups[ns] << schema
+          end
+
+          # Collect schemas that were NOT grouped (nil namespace)
+          merged_schemas = schemas_data.reject { |s| s[:namespace] }
+
+          ns_groups.each_value do |group|
+            if group.length == 1
+              merged_schemas << group.first
+              next
+            end
+
+            primary = group.find { |s| s[:is_entrypoint] }
+            primary ||= group.max_by { |s| content_weight(s) }
+            secondaries = group.reject { |s| s[:id] == primary[:id] }
+
+            merge_content_into!(primary, secondaries)
+            merged_schemas << primary
+          end
+
+          merged_schemas
+        end
+
+        # Measure content richness of a serialized schema for primary selection
+        #
+        # @param schema [Hash] Serialized schema data
+        # @return [Integer] Total item count across content fields
+        def content_weight(schema)
+          MERGEABLE_CONTENT_FIELDS.sum { |f| (schema[f] || []).length }
+        end
+
+        # Merge content arrays from secondary schemas into the primary schema
+        #
+        # Uses Set for O(1) deduplication by hash identity.
+        #
+        # @param primary [Hash] Primary schema to merge into (mutated)
+        # @param secondaries [Array<Hash>] Secondary schemas to absorb
+        # @return [void]
+        def merge_content_into!(primary, secondaries)
+          MERGEABLE_CONTENT_FIELDS.each do |field|
+            primary[field] ||= []
+            seen = primary[field].to_set
+            secondaries.each do |sec|
+              (sec[field] || []).each do |item|
+                primary[field] << item unless seen.include?(item)
+              end
+            end
+          end
+
+          # Merge includes and imports (deduplicated by hash equality)
+          %i[includes imports].each do |field|
+            primary[field] ||= []
+            seen = primary[field].to_set
+            secondaries.each do |sec|
+              (sec[field] || []).each do |item|
+                primary[field] << item unless seen.include?(item)
+              end
+            end
+          end
+
+          # Collect all file paths
+          all_paths = [primary[:file_path]]
+          secondaries.each { |s| all_paths << s[:file_path] if s[:file_path] }
+          primary[:file_paths] = all_paths.compact
+        end
+
         # Serialize single schema (template method hook)
         #
         # Subclasses should override to customize schema serialization
@@ -355,23 +456,48 @@ module Lutaml
           element_data
         end
 
-        def gen_element_diagram(name, file_path)
+        def gen_element_diagram(name, file_path, component_type = :element)
           if !file_path || !File.exist?(file_path)
             warn "xsdvi: XSD file '#{file_path}' not found" if config[:verbose]
             return nil
           end
 
-          output_folder = Dir.mktmpdir("xsdvi-")
+          actual_file_path = file_path
+          wrapper_name = name
 
-          # generate diagram using xsdvi command line tool
-          `bundle exec xsdvi generate #{file_path} -r #{name} -o -p #{output_folder}`
+          if component_type == :type
+            # For types, create a temporary XSD with a synthetic wrapper element
+            # so xsdvi can treat the type as a root element
+            actual_file_path = create_type_wrapper_xsd(name, file_path)
+            wrapper_name = "_diagram_root_#{name}"
+          end
 
+          output_folder = Dir.mktmpdir("xsdvi-")
           svg_file = File.join(output_folder, "#{name}.svg")
-          unless File.exist?(svg_file)
+
+          # Use xsdvi Ruby API directly instead of CLI
+          builder = Xsdvi::Tree::Builder.new
+          xsd_handler = Xsdvi::XsdHandler.new(builder)
+          writer_helper = Xsdvi::Utils::Writer.new
+          svg_generator = Xsdvi::SVG::Generator.new(writer_helper)
+
+          svg_generator.hide_menu_buttons = true
+          svg_generator.embody_style = true
+
+          xsd_handler.root_node_name = wrapper_name
+          xsd_handler.one_node_only = true
+          xsd_handler.process_file(actual_file_path)
+
+          unless builder.root
             warn "xsdvi: SVG not generated for '#{name}'" if config[:verbose]
             return nil
           end
 
+          writer_helper.new_writer(svg_file)
+          svg_generator.draw(builder.root)
+
+          return nil unless File.exist?(svg_file)
+
           # read generated SVG content
           svg_content = File.read(svg_file)
 
@@ -384,8 +510,84 @@ module Lutaml
             .gsub(/<a[^>]*>(.*?)<\/a>/im, '\1') # Remove links but keep content
 
           svg_content
+        rescue StandardError => e
+          warn "xsdvi: Failed to generate diagram for '#{name}': #{e.message}" if config[:verbose]
+          nil
         ensure
           FileUtils.rm_rf(output_folder) if output_folder
+          if component_type == :type && actual_file_path && actual_file_path != file_path
+            FileUtils.rm_f(actual_file_path)
+          end
+        end
+
+        # Create a temporary XSD file that wraps a complexType/simpleType
+        # in a synthetic root element, so xsdvi can generate a diagram for it.
+        #
+        # @param type_name [String] The type name
+        # @param original_file_path [String] Path to the original XSD file
+        # @return [String] Path to the temporary XSD file
+        def create_type_wrapper_xsd(type_name, original_file_path)
+          doc = Nokogiri::XML(File.read(original_file_path))
+          ns = { "xs" => "http://www.w3.org/2001/XMLSchema" }
+          schema = doc.at_xpath("//xs:schema", ns)
+
+          unless schema
+            warn "xsdvi: No xs:schema found in '#{original_file_path}'" if config[:verbose]
+            return original_file_path
+          end
+
+          wrapper_name = "_diagram_root_#{type_name}"
+
+          # Check if this type might need a namespace prefix
+          # Look for how the type is referenced in the original schema
+          type_ref = resolve_type_prefix(type_name, doc, ns)
+
+          # Create element with proper XSD namespace from the schema
+          xsd_ns = "http://www.w3.org/2001/XMLSchema"
+          xsd_ns_decl = schema.namespace_definitions.find do |nd|
+            nd.href == xsd_ns
+          end
+
+          element_node = doc.create_element("element")
+          element_node.namespace = xsd_ns_decl
+          element_node["name"] = wrapper_name
+          element_node["type"] = type_ref
+
+          schema.add_child(element_node)
+
+          tmp = Tempfile.new(["xsdvi-wrapper-", ".xsd"])
+          tmp.write(doc.to_xml)
+          tmp.close
+          tmp.path
+        end
+
+        # Determine the correct type reference prefix for a type in the schema.
+        # If the type is defined in the targetNamespace, use the same prefix
+        # that the schema uses internally for its targetNamespace.
+        #
+        # @param type_name [String] The type name
+        # @param doc [Nokogiri::Document] The parsed XSD document
+        # @param ns [Hash] Namespace mapping
+        # @return [String] The type reference string (possibly prefixed)
+        def resolve_type_prefix(type_name, doc, ns)
+          schema = doc.at_xpath("//xs:schema", ns)
+          target_ns = schema["targetNamespace"]
+
+          # Check if the type is defined in this schema's targetNamespace
+          type_in_schema = doc.xpath("//xs:complexType[@name='#{type_name}']",
+                                     ns).any? ||
+            doc.xpath("//xs:simpleType[@name='#{type_name}']",
+                      ns).any?
+
+          return type_name unless type_in_schema && target_ns
+
+          # Find what prefix maps to the targetNamespace
+          ns_decls = schema.namespace_definitions
+          tns_prefix = ns_decls.find do |nd|
+            nd.href == target_ns && nd.prefix
+          end
+
+          tns_prefix ? "#{tns_prefix.prefix}:#{type_name}" : type_name
         end
 
         # Serialize complex types from schema
@@ -642,24 +844,29 @@ schema_source = nil)
           end.sort_by { |ag| ag[:name] || "" }
         end
 
-        # Extract source information for an attribute group
-        # from the schema
+        # Extract source XML for a schema component identified by type, key, value
+        #
+        # @param type [String] XSD element type name (e.g., "attributeGroup")
+        # @param key [String] Attribute name to match on (e.g., "name")
+        # @param value [String] Attribute value to match
+        # @param prefix [String, nil] Optional namespace prefix
+        # @param source [String, nil] Raw XSD source XML
+        # @return [String, nil] Extracted source XML or nil
         def extract_source_by_type_key_value(type, key, value, prefix = nil,
 source = nil)
           return nil unless source && value
 
-          # parse the schema source and find the attribute group by name
           begin
             doc = Moxml::Context.new.parse(source)
+            escaped_value = value.gsub("'", "''")
             xpath = if prefix
-                      "//#{prefix}:#{type}[@#{key}='#{value}']"
+                      "//#{prefix}:#{type}[@#{key}='#{escaped_value}']"
                     else
-                      "//#{type}[@#{key}='#{value}']"
+                      "//#{type}[@#{key}='#{escaped_value}']"
                     end
-            ag_node = doc.at_xpath(xpath)
-            ag_node&.to_xml(indent: 2)
+            node = doc.at_xpath(xpath)
+            node&.to_xml(indent: 2)
           rescue StandardError
-            # If parsing fails, return nil
             nil
           end
         end
@@ -785,45 +992,52 @@ source = nil)
           end
         end
 
+        # Collect attribute group references from a model (handles extension nesting)
+        #
+        # Used for both direct attribute groups and those inside content model extensions.
+        #
+        # @param model [Object] Any object that may have attribute_group or extension
+        # @return [Array<Object>] Collected attribute group reference objects
+        def collect_attribute_group_refs(model)
+          refs = []
+
+          if model.respond_to?(:attribute_group) && model.attribute_group
+            groups = model.attribute_group.is_a?(Array) ? model.attribute_group : [model.attribute_group]
+            refs.concat(groups)
+          end
+
+          if model.respond_to?(:extension) && model.extension
+            refs.concat(collect_attribute_group_refs(model.extension))
+          end
+
+          refs
+        end
+
         # Serialize attribute group references from a complex type
         #
+        # Collects attribute group refs from three possible locations:
+        # 1. Direct attribute groups on the type
+        # 2. Inside simpleContent.extension
+        # 3. Inside complexContent.extension
+        #
         # @param type [ComplexType] Complex type
         # @return [Array<Hash>] Serialized attribute group references with attributes
         def serialize_type_attr_groups(type)
-          # Collect attribute group refs from all three possible locations:
-          # 1. Direct attribute groups on the type
-          # 2. Inside simpleContent.extension
-          # 3. Inside complexContent.extension
+          return [] unless type
+
           all_ag_refs = []
 
-          # 1. Direct attribute groups
           if type.respond_to?(:attribute_group) && type.attribute_group
             direct_groups = type.attribute_group.is_a?(Array) ? type.attribute_group : [type.attribute_group]
             all_ag_refs.concat(direct_groups)
           end
 
-          # 2. Attribute groups inside simpleContent.extension
           if type.respond_to?(:simple_content) && type.simple_content
-            sc = type.simple_content
-            if sc.respond_to?(:extension) && sc.extension
-              extension = sc.extension
-              if extension.respond_to?(:attribute_group) && extension.attribute_group
-                ext_groups = extension.attribute_group.is_a?(Array) ? extension.attribute_group : [extension.attribute_group]
-                all_ag_refs.concat(ext_groups)
-              end
-            end
+            all_ag_refs.concat(collect_attribute_group_refs(type.simple_content))
           end
 
-          # 3. Attribute groups inside complexContent.extension
           if type.respond_to?(:complex_content) && type.complex_content
-            cc = type.complex_content
-            if cc.respond_to?(:extension) && cc.extension
-              extension = cc.extension
-              if extension.respond_to?(:attribute_group) && extension.attribute_group
-                ext_groups = extension.attribute_group.is_a?(Array) ? extension.attribute_group : [extension.attribute_group]
-                all_ag_refs.concat(ext_groups)
-              end
-            end
+            all_ag_refs.concat(collect_attribute_group_refs(type.complex_content))
           end
 
           return [] if all_ag_refs.empty?
@@ -832,12 +1046,8 @@ source = nil)
             ag_name = ag.respond_to?(:ref) ? ag.ref : ag.name
             next unless ag_name
 
-            # Look up the actual attribute group definition to get its attributes
             attrs = lookup_attribute_group_attributes(ag_name)
-            {
-              ref: ag_name,
-              attributes: attrs,
-            }
+            { ref: ag_name, attributes: attrs }
           end
         end
 
@@ -1076,74 +1286,43 @@ source = nil)
           }
         end
 
+        # Facet serializers: maps facet name to how to extract and format it
+        #
+        # Each entry: [method_name, facet_type_label]
+        #   method_name  — what restriction.respond_to?(:method_name) && restriction.method_name to call
+        #   facet_type   — the type string emitted in serialized facet
+        FACET_METHODS = [
+          [:enumerations, "enumeration"],
+          [:pattern, "pattern"],
+          [:min_length, "min_length"],
+          [:max_length, "max_length"],
+          [:length, "length"],
+          [:min_inclusive, "min_inclusive"],
+          [:max_inclusive, "max_inclusive"],
+          [:min_exclusive, "min_exclusive"],
+          [:max_exclusive, "max_exclusive"],
+          [:total_digits, "total_digits"],
+          [:fraction_digits, "fraction_digits"],
+          [:white_space, "white_space"],
+        ].freeze
+
         # Serialize facets
         #
         # @param restriction [Restriction] Restriction object
         # @return [Array<Hash>] Serialized facets
         def serialize_facets(restriction)
-          facets = []
-
-          if restriction.respond_to?(:enumerations) && restriction.enumerations
-            facets << { type: "enumeration",
-                        values: restriction.enumerations }
-          end
-
-          if restriction.respond_to?(:pattern) && restriction.pattern
-            facets << { type: "pattern",
-                        value: restriction.pattern }
-          end
+          return [] unless restriction
 
-          if restriction.respond_to?(:min_length) && restriction.min_length
-            facets << { type: "min_length",
-                        value: restriction.min_length }
-          end
+          FACET_METHODS.filter_map do |method_name, facet_type|
+            value = restriction.respond_to?(method_name) && restriction.send(method_name)
+            next unless value
 
-          if restriction.respond_to?(:max_length) && restriction.max_length
-            facets << { type: "max_length",
-                        value: restriction.max_length }
-          end
-
-          if restriction.respond_to?(:length) && restriction.length
-            facets << { type: "length",
-                        value: restriction.length }
-          end
-
-          if restriction.respond_to?(:min_inclusive) && restriction.min_inclusive
-            facets << { type: "min_inclusive",
-                        value: restriction.min_inclusive }
-          end
-
-          if restriction.respond_to?(:max_inclusive) && restriction.max_inclusive
-            facets << { type: "max_inclusive",
-                        value: restriction.max_inclusive }
-          end
-
-          if restriction.respond_to?(:min_exclusive) && restriction.min_exclusive
-            facets << { type: "min_exclusive",
-                        value: restriction.min_exclusive }
-          end
-
-          if restriction.respond_to?(:max_exclusive) && restriction.max_exclusive
-            facets << { type: "max_exclusive",
-                        value: restriction.max_exclusive }
-          end
-
-          if restriction.respond_to?(:total_digits) && restriction.total_digits
-            facets << { type: "total_digits",
-                        value: restriction.total_digits }
-          end
-
-          if restriction.respond_to?(:fraction_digits) && restriction.fraction_digits
-            facets << { type: "fraction_digits",
-                        value: restriction.fraction_digits }
-          end
-
-          if restriction.respond_to?(:white_space) && restriction.white_space
-            facets << { type: "white_space",
-                        value: restriction.white_space }
+            if method_name == :enumerations
+              { type: facet_type, values: value }
+            else
+              { type: facet_type, value: value }
+            end
           end
-
-          facets
         end
 
         # Extract documentation from object
@@ -1175,29 +1354,34 @@ source = nil)
           "empty"
         end
 
+        # Extract base type from a content model's extension or restriction
+        #
+        # @param content_model [Object] simpleContent or complexContent
+        # @return [String, nil] Base type name
+        def base_from_content_model(content_model)
+          if content_model.respond_to?(:extension) && content_model.extension
+            ext = content_model.extension
+            return ext.base if ext.respond_to?(:base)
+          elsif content_model.respond_to?(:restriction) && content_model.restriction
+            rst = content_model.restriction
+            return rst.base if rst.respond_to?(:base)
+          end
+          nil
+        end
+
         # Extract base type from complex type
         #
         # @param type [ComplexType] Complex type
         # @return [String, nil] Base type name
         def extract_base_type(type)
-          # Check complex_content for extension or restriction
           if type.respond_to?(:complex_content) && type.complex_content
-            cc = type.complex_content
-            if cc.respond_to?(:extension) && cc.extension
-              return cc.extension.base if cc.extension.respond_to?(:base)
-            elsif cc.respond_to?(:restriction) && cc.restriction
-              return cc.restriction.base if cc.restriction.respond_to?(:base)
-            end
+            base = base_from_content_model(type.complex_content)
+            return base if base
           end
 
-          # Check simple_content for extension or restriction
           if type.respond_to?(:simple_content) && type.simple_content
-            sc = type.simple_content
-            if sc.respond_to?(:extension) && sc.extension
-              return sc.extension.base if sc.extension.respond_to?(:base)
-            elsif sc.respond_to?(:restriction) && sc.restriction
-              return sc.restriction.base if sc.restriction.respond_to?(:base)
-            end
+            base = base_from_content_model(type.simple_content)
+            return base if base
           end
 
           nil
@@ -1459,17 +1643,17 @@ source = nil)
           schema
         end
 
-        # Generate SVG diagram for a component using xsdvi CLI
+        # Generate SVG diagram for a component using xsdvi Ruby API
         #
         # @param component_data [Hash] Serialized component data
         # @param component_type [Symbol] Component type (:element or :type)
         # @param file_path [String, nil] XSD file path for xsdvi
         # @return [String, nil] SVG diagram markup
-        def generate_diagram(component_data, _component_type, file_path = nil)
+        def generate_diagram(component_data, component_type, file_path = nil)
           name = component_data[:name] || component_data["name"]
           return nil unless name && file_path
 
-          gen_element_diagram(name, file_path)
+          gen_element_diagram(name, file_path, component_type)
         rescue StandardError => e
           warn "Warning: Failed to generate SVG diagram: #{e.message}" if ENV["DEBUG"]
           nil

data/lib/lutaml/xsd/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Xsd
-    VERSION = "1.0.9"
+    VERSION = "1.1.1"
   end
 end

data/lutaml-xsd.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
     end + Dir.glob("frontend/dist/*")
   end
 
-  spec.add_dependency "liquid", "~> 5.0"
+  spec.add_dependency "liquid", ">= 4.0", "< 6.0"
   spec.add_dependency "lutaml-model", "~> 0.8.0"
   spec.add_dependency "moxml"
   spec.add_dependency "paint", "~> 2.3"

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-xsd
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.1.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-27 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement