suma 0.2.6 → 0.4.0

data/lib/suma/schema_template/document.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Suma
+  module SchemaTemplate
+    # Emits an AsciiDoc body with cross-reference anchors for every
+    # schema element so other documents can deep-link into the compiled
+    # HTML. Only XML is produced — the anchors only resolve against the
+    # XML output, not the HTML rendering.
+    class Document
+      EXTENSIONS = "xml"
+
+      attr_reader :schema_id
+
+      def initialize(schema_id)
+        @schema_id = schema_id
+      end
+
+      def extensions
+        EXTENSIONS
+      end
+
+      def render(path_to_schema_yaml)
+        <<~ADOC
+          = #{schema_id}
+          :lutaml-express-index: schemas; #{path_to_schema_yaml};
+          :bare: true
+          :mn-document-class: iso
+          :mn-output-extensions: #{extensions}
+
+          [lutaml_express_liquid,schemas,context]
+          ----
+          {% for schema in context.schemas %}
+
+          [[#{schema_id}]]
+          [%unnumbered,type=express]
+          == #{schema_id} #{rendered_anchors}
+
+          [source%unnumbered]
+          --
+          {{ schema.formatted }}
+          --
+          {% endfor %}
+          ----
+
+        ADOC
+      end
+
+      private
+
+      # The raw anchor block contains Liquid comments and newlines that
+      # are illegal on the section header line; strip them before
+      # interpolating.
+      def rendered_anchors
+        schema_anchors.gsub(%r{//[^\r\n]+}, "").gsub(/[\n\r]+/, "").gsub(
+          /^[\n\r]/, ""
+        )
+      end
+
+      def schema_anchors
+        <<~HEREDOC
+          // _fund_cons.liquid
+          [[#{schema_id}_funds]]
+
+          // _constants.liquid
+          {% if schema.constants.size > 0 %}
+          #{bookmark('constants')}
+          {% for thing in schema.constants %}
+          #{bookmark('{{thing.id}}')}
+          {% endfor %}
+          {% endif %}
+
+          // _types.liquid
+          {% if schema.types.size > 0 %}
+          #{bookmark('types')}
+          // _type.liquid
+          {% for thing in schema.types %}
+          #{bookmark('{{thing.id}}')}
+          {% if thing.items.size > 0 %}
+          // _type_items.liquid
+          #{bookmark('{{thing.id}}.items')}
+          {% for item in thing.items %}
+          #{bookmark('{{thing.id}}.items.{{item.id}}')}
+          {% endfor %}
+          {% endif %}
+          {% endfor %}
+          {% endif %}
+
+          // _entities.liquid
+          {% if schema.entities.size > 0 %}
+          #{bookmark('entities')}
+          {% for thing in schema.entities %}
+          // _entity.liquid
+          #{bookmark('{{thing.id}}')}
+          {% endfor %}
+          {% endif %}
+
+          // _subtype_constraints.liquid
+          {% if schema.subtype_constraints.size > 0 %}
+          #{bookmark('subtype_constraints')}
+          // _subtype_constraint.liquid
+          {% for thing in schema.subtype_constraints %}
+          #{bookmark('{{thing.id}}')}
+          {% endfor %}
+          {% endif %}
+
+          // _functions.liquid
+          {% if schema.functions.size > 0 %}
+          #{bookmark('functions')}
+          // _function.liquid
+          {% for thing in schema.functions %}
+          #{bookmark('{{thing.id}}')}
+          {% endfor %}
+          {% endif %}
+
+          // _procedures.liquid
+          {% if schema.procedures.size > 0 %}
+          #{bookmark('procedures')}
+          // _procedure.liquid
+          {% for thing in schema.procedures %}
+          #{bookmark('{{thing.id}}')}
+          {% endfor %}
+          {% endif %}
+
+          // _rules.liquid
+          {% if schema.rules.size > 0 %}
+          #{bookmark('rules')}
+          // _rule.liquid
+          {% for thing in schema.rules %}
+          #{bookmark('{{thing.id}}')}
+          {% endfor %}
+          {% endif %}
+        HEREDOC
+      end
+
+      def bookmark(anchor)
+        mangled = anchor.gsub("}}", ' | replace: "\", "-", "-}}')
+        "[[#{schema_id}.#{mangled}]]"
+      end
+    end
+  end
+end

data/lib/suma/schema_template/plain.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Suma
+  module SchemaTemplate
+    # Emits a plain AsciiDoc body for a single EXPRESS schema, producing
+    # both HTML and XML outputs via Metanorma.
+    class Plain
+      EXTENSIONS = "xml,html"
+
+      attr_reader :schema_id
+
+      def initialize(schema_id)
+        @schema_id = schema_id
+      end
+
+      def extensions
+        EXTENSIONS
+      end
+
+      def render(path_to_schema_yaml)
+        <<~ADOC
+          = #{schema_id}
+          :lutaml-express-index: schemas; #{path_to_schema_yaml};
+          :bare: true
+          :mn-document-class: iso
+          :mn-output-extensions: #{extensions}
+
+          [lutaml_express_liquid,schemas,context]
+          ----
+          {% for schema in context.schemas %}
+
+          [%unnumbered]
+          == #{schema_id}
+
+          [source%unnumbered]
+          --
+          {{ schema.formatted }}
+          --
+          {% endfor %}
+          ----
+
+        ADOC
+      end
+    end
+  end
+end

data/lib/suma/schema_template.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Suma
+  # Pure renderers for the AsciiDoc source fed to Metanorma when compiling
+  # an EXPRESS schema to HTML/XML.
+  #
+  # Each template knows how to produce the adoc body for one compilation
+  # flavour (plain HTML, or HTML with cross-reference anchors). Templates
+  # have no I/O and no knowledge of the underlying ExpressSchema — they
+  # only need the schema id, because the rendered adoc is consumed by
+  # Liquid inside Metanorma, which fetches the schema by id from the
+  # surrounding lutaml-express-index.
+  #
+  # Composition with the compiler lives in SchemaCompiler.
+  module SchemaTemplate
+    autoload :Plain, "suma/schema_template/plain"
+    autoload :Document, "suma/schema_template/document"
+  end
+end

data/lib/suma/svg_quality/batch_report.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "report"
-
 module Suma
   module SvgQuality
     # Batch report wrapping multiple SVG quality reports

data/lib/suma/svg_quality/formatters.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Suma
+  module SvgQuality
+    module Formatters
+      autoload :TerminalFormatter,
+               "suma/svg_quality/formatters/terminal_formatter"
+      autoload :JsonFormatter,     "suma/svg_quality/formatters/json_formatter"
+      autoload :YamlFormatter,     "suma/svg_quality/formatters/yaml_formatter"
+    end
+  end
+end

data/lib/suma/svg_quality/scanner.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "svg_conform"
+
+module Suma
+  module SvgQuality
+    # Deep module behind the SVG-quality seam: takes paths in, returns
+    # +Report+ / +BatchReport+ out. Owns validator construction and
+    # per-file result capture. Does not own file discovery, sorting,
+    # filtering, or presentation — those stay in the CLI adapter.
+    #
+    # The progress adapter is injected: pass any object responding to
+    # +#call(index, total, report)+. +NullProgress+ is the default
+    # no-op; the CLI passes a lambda that writes to +$stderr+.
+    class Scanner
+      DEFAULT_PROFILE = :metanorma
+
+      attr_reader :profile, :progress
+
+      def initialize(profile: DEFAULT_PROFILE,
+                     progress: NullProgress.new)
+        @profile = profile
+        @progress = progress
+      end
+
+      def scan(paths)
+        validator = build_validator
+        reports = paths.each_with_index.map do |path, index|
+          scan_one(validator, path, index, paths.size)
+        end
+        BatchReport.new(reports)
+      end
+
+      def scan_file(path)
+        Report.new(path.to_s, build_validator.validate_file(path.to_s,
+                                                            profile: profile))
+      end
+
+      # Default no-op progress adapter. Real progress reporters are
+      # passed by the caller; this satisfies the same interface so the
+      # scanner can be invoked from specs without forcing the
+      # dependency.
+      class NullProgress
+        def call(_index, _total, _report); end
+      end
+
+      private
+
+      def build_validator
+        SvgConform::Validator.new
+      end
+
+      def scan_one(validator, path, index, total)
+        result = validator.validate_file(path.to_s, profile: profile)
+        report = Report.new(path.to_s, result)
+        progress.call(index, total, report)
+        report
+      end
+    end
+  end
+end

data/lib/suma/svg_quality.rb

@@ -4,7 +4,10 @@ require "svg_conform"
 
 module Suma
   module SvgQuality
-    # Quality levels computed from error count
+    autoload :Report,      "suma/svg_quality/report"
+    autoload :BatchReport, "suma/svg_quality/batch_report"
+    autoload :Scanner,     "suma/svg_quality/scanner"
+
     module QualityTiers
       CRITICAL = { name: :critical, min_errors: 200, emoji: "💥" }.freeze
       HIGH = { name: :high, min_errors: 100, emoji: "🔴" }.freeze

data/lib/suma/term_classification.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Suma
+  # Term-extractor-specific classification of an EXPRESS schema.
+  #
+  # Bridges ExpressSchema::Type (the canonical classification shared
+  # across the codebase) and the Glossarist-specific labels
+  # TermExtractor emits: the domain string ("application module" /
+  # "resource") that goes into a concept's +domain+ field, and the
+  # entity-type URN term used in generated concept definitions.
+  #
+  # The mapping is data — a frozen Hash keyed by ExpressSchema::Type
+  # symbol — so adding a new schema type is a one-line addition to
+  # BY_TYPE (open/closed principle). The previous implementation
+  # switched on string keys in three separate places; this consolidates
+  # them into one source of truth.
+  class TermClassification
+    attr_reader :type, :domain_label, :entity_term, :entity_display
+
+    def initialize(type:, domain_label:, entity_term:, entity_display:)
+      @type = type
+      @domain_label = domain_label
+      @entity_term = entity_term
+      @entity_display = entity_display
+      freeze
+    end
+
+    def domain_for(schema_id)
+      "#{domain_label}: #{schema_id}"
+    end
+
+    BY_TYPE = {
+      ExpressSchema::Type::RESOURCE => new(
+        type: ExpressSchema::Type::RESOURCE,
+        domain_label: "resource",
+        entity_term: "express-language.entity_data_type",
+        entity_display: "entity data type",
+      ),
+      ExpressSchema::Type::MODULE_ARM => new(
+        type: ExpressSchema::Type::MODULE_ARM,
+        domain_label: "application module",
+        entity_term: "general.application_object",
+        entity_display: "application object",
+      ),
+      ExpressSchema::Type::MODULE_MIM => new(
+        type: ExpressSchema::Type::MODULE_MIM,
+        domain_label: "application module",
+        entity_term: "express-language.entity_data_type",
+        entity_display: "entity data type",
+      ),
+      ExpressSchema::Type::BUSINESS_OBJECT_MODEL => new(
+        type: ExpressSchema::Type::BUSINESS_OBJECT_MODEL,
+        domain_label: "resource",
+        entity_term: "express-language.entity_data_type",
+        entity_display: "entity data type",
+      ),
+      ExpressSchema::Type::CORE_MODEL => new(
+        type: ExpressSchema::Type::CORE_MODEL,
+        domain_label: "resource",
+        entity_term: "express-language.entity_data_type",
+        entity_display: "entity data type",
+      ),
+      ExpressSchema::Type::STANDALONE => new(
+        type: ExpressSchema::Type::STANDALONE,
+        domain_label: "resource",
+        entity_term: "express-language.entity_data_type",
+        entity_display: "entity data type",
+      ),
+    }.freeze
+
+    def self.for_schema(id:, path:)
+      type = ExpressSchema::Type.classify(id: id, path: path)
+      BY_TYPE.fetch(type) do |t|
+        raise Error, "[suma] no term classification for type #{t.inspect}"
+      end
+    end
+  end
+end