suma 0.2.5 → 0.3.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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Suma
+  module SvgQuality
+    # Batch report wrapping multiple SVG quality reports
+    class BatchReport
+      attr_reader :reports
+
+      def initialize(reports)
+        @reports = reports
+      end
+
+      def total_files
+        @reports.size
+      end
+
+      def successful
+        @reports.count(&:valid?)
+      end
+
+      def failed
+        total_files - successful
+      end
+
+      def avg_quality_score
+        return 0 if @reports.empty?
+
+        @reports.sum(&:quality_score).to_f / total_files
+      end
+
+      def total_errors
+        @reports.sum(&:error_count)
+      end
+
+      def avg_error_count
+        return 0 if @reports.empty?
+
+        total_errors.to_f / total_files
+      end
+
+      def quality_distribution
+        dist = Hash.new(0)
+        @reports.each do |r|
+          dist[r.quality_tier[:name].to_s] += 1
+        end
+        dist
+      end
+
+      def sort_by_quality
+        self.class.new(@reports.sort_by(&:quality_score))
+      end
+
+      def sort_by_errors
+        self.class.new(@reports.sort_by { |r| -r.error_count })
+      end
+
+      def limit(count)
+        return self if count.nil?
+
+        self.class.new(@reports.first(count))
+      end
+
+      def filter_by_min_errors(min)
+        return self if min.nil?
+
+        self.class.new(@reports.select { |r| r.error_count >= min })
+      end
+
+      def to_json(*_args)
+        JSON.pretty_generate(@reports.map(&:to_h))
+      end
+
+      def to_yaml
+        YAML.dump(@reports.map(&:to_h))
+      end
+    end
+  end
+end

data/lib/suma/svg_quality/formatters/json_formatter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Suma
+  module SvgQuality
+    module Formatters
+      # JSON output formatter
+      class JsonFormatter
+        def initialize(batch_report, output: nil)
+          @batch_report = batch_report
+          @output = output
+        end
+
+        def format
+          write_output(@batch_report.to_json)
+        end
+
+        private
+
+        def write_output(content)
+          if @output
+            File.write(@output, content)
+            "[suma] Results written to #{@output}"
+          else
+            content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/suma/svg_quality/formatters/terminal_formatter.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Suma
+  module SvgQuality
+    module Formatters
+      # Terminal output formatter with ASCII art and emojis
+      class TerminalFormatter
+        BORDER = "─"
+        BOX_WIDTH = 80
+
+        def initialize(batch_report, output: nil, sort: :quality)
+          @batch_report = batch_report
+          @output = output
+          @sort = sort.to_sym
+        end
+
+        def format
+          output_content = [
+            header,
+            "",
+            summary_section,
+            "",
+            distribution_section,
+            "",
+            files_by_tier_section,
+            "",
+            footer,
+          ].join("\n")
+
+          write_output(output_content)
+        end
+
+        private
+
+        attr_reader :batch_report
+
+        def header
+          sort_label = case @sort
+                       when :errors then "error count (most first)"
+                       else "quality score (lowest first)"
+                       end
+
+          "╔#{'═' * (BOX_WIDTH - 2)}╗\n" \
+            "║  🔍 SVG Quality Report    Sorted by #{sort_label.ljust(33)}║\n" \
+            "╚#{'═' * (BOX_WIDTH - 2)}╝"
+        end
+
+        def summary_section
+          lines = []
+          lines << "  📊 OVERVIEW"
+          lines << ""
+          lines << "    ● Total Files   : #{batch_report.total_files}"
+          lines << "    ● Valid         : #{batch_report.successful} ✅"
+          lines << "    ● Invalid      : #{batch_report.failed} ❌"
+          lines << "    ● Avg Score    : #{batch_report.avg_quality_score.round(1)}/100"
+          lines << "    ● Total Errors : #{batch_report.total_errors}"
+          lines << "    ● Avg Errors   : #{batch_report.avg_error_count.round(1)}/file"
+          lines << ""
+
+          if (worst = batch_report.reports.first)
+            tier = worst.quality_tier
+            lines << "  🚨 WORST OFFENDER"
+            lines << ""
+            lines << "    #{tier[:emoji]} #{shorten_path(worst.file_path)}"
+            lines << "    Score: #{worst.quality_score}/100 | Errors: #{worst.error_count} | #{tier[:name].to_s.upcase}"
+          end
+
+          lines.join("\n")
+        end
+
+        def distribution_section
+          lines = []
+          lines << "  📈 QUALITY DISTRIBUTION"
+          lines << ""
+
+          total = batch_report.total_files
+          dist = batch_report.quality_distribution
+
+          QualityTiers::ALL.each do |tier|
+            count = dist[tier[:name].to_s].to_i
+            pct = total.positive? ? (count.to_f / total * 100) : 0
+            bar_len = (count.to_f / total * 40).round
+            bar = bar_len.positive? ? "█" * bar_len : ""
+            empty = "░" * (40 - bar_len)
+
+            lines << "    #{tier[:emoji]} #{tier[:name].to_s.upcase.ljust(9)} #{bar}#{empty} #{count.to_s.rjust(4)} (#{sprintf(
+              '%.1f', pct
+            )}%)"
+          end
+
+          lines.join("\n")
+        end
+
+        def files_by_tier_section
+          lines = []
+
+          if @sort == :errors
+            # When sorting by errors, show flat list (worst offenders first)
+            lines << ""
+            lines << "  📋 ALL FILES (sorted by error count, worst first)"
+            lines << ""
+
+            batch_report.reports.each do |report|
+              lines << format_file_line(report)
+            end
+          else
+            # When sorting by quality, group by tier - iterate CRITICAL first (worst first)
+            reports_by_tier = batch_report.reports.group_by do |r|
+              r.quality_tier[:name]
+            end
+
+            QualityTiers::ALL.each do |tier|
+              tier_reports = reports_by_tier[tier[:name]]
+              next unless tier_reports&.any?
+
+              lines << ""
+              lines << "  #{tier[:emoji]} #{tier[:name].to_s.upcase} QUALITY (#{tier_reports.size} files)"
+              lines << ""
+
+              tier_reports.each do |report|
+                lines << format_file_line(report)
+              end
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        def format_file_line(report)
+          path = shorten_path(report.file_path)
+          score = report.quality_score.to_i.to_s.rjust(3)
+          errors = report.error_count.to_s.rjust(5)
+          valid_str = report.valid? ? "✓" : "✗"
+
+          "    #{valid_str} #{score}/100  #{errors} errors  #{path}"
+        end
+
+        def shorten_path(path)
+          p = Pathname.new(path)
+          if p.absolute?
+            begin
+              p.relative_path_from(Pathname.pwd)
+            rescue StandardError
+              p
+            end
+          else
+            p
+          end.to_s
+        end
+
+        def footer
+          BORDER * BOX_WIDTH
+        end
+
+        def write_output(content)
+          if @output
+            File.write(@output, content)
+            "[suma] Results written to #{@output}"
+          else
+            content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/suma/svg_quality/formatters/yaml_formatter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Suma
+  module SvgQuality
+    module Formatters
+      # YAML output formatter
+      class YamlFormatter
+        def initialize(batch_report, output: nil)
+          @batch_report = batch_report
+          @output = output
+        end
+
+        def format
+          write_output(@batch_report.to_yaml)
+        end
+
+        private
+
+        def write_output(content)
+          if @output
+            File.write(@output, content)
+            "[suma] Results written to #{@output}"
+          else
+            content
+          end
+        end
+      end
+    end
+  end
+end

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/report.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Suma
+  module SvgQuality
+    # Simple report object wrapping svg_conform ValidationResult
+    class Report
+      attr_reader :file_path, :error_count, :errors
+
+      def initialize(file_path, validation_result)
+        @file_path = file_path
+        @validation_result = validation_result
+        @error_count = validation_result&.error_count || 0
+        @errors = validation_result&.errors || []
+      end
+
+      def valid?
+        @validation_result&.valid? || false
+      end
+
+      def quality_tier
+        QualityTiers.for_error_count(@error_count)
+      end
+
+      def quality_score
+        return 100 if @error_count.zero?
+        return 0 if @error_count >= 200
+
+        [100 - (@error_count * 0.5), 0].max.round
+      end
+
+      def errors_by_severity
+        {
+          critical: @errors.count { |e| e.requirement_id =~ /critical/i },
+          high: @errors.count { |e| e.requirement_id =~ /high/i },
+          medium: @errors.count { |e| e.requirement_id =~ /medium/i },
+          low: @errors.count { |e| e.requirement_id =~ /low/i },
+        }
+      end
+
+      def to_h
+        {
+          file_path: @file_path,
+          valid: valid?,
+          error_count: @error_count,
+          quality_score: quality_score,
+          quality_tier: quality_tier[:name],
+          errors_by_severity: errors_by_severity,
+        }
+      end
+    end
+  end
+end

data/lib/suma/svg_quality.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "svg_conform"
+
+module Suma
+  module SvgQuality
+    autoload :Report,      "suma/svg_quality/report"
+    autoload :BatchReport, "suma/svg_quality/batch_report"
+
+    module QualityTiers
+      CRITICAL = { name: :critical, min_errors: 200, emoji: "💥" }.freeze
+      HIGH = { name: :high, min_errors: 100, emoji: "🔴" }.freeze
+      MEDIUM = { name: :medium, min_errors: 50, emoji: "⚠️" }.freeze
+      LOW = { name: :low, min_errors: 20, emoji: "🔶" }.freeze
+      MINOR = { name: :minor, min_errors: 0, emoji: "✅" }.freeze
+
+      ALL = [CRITICAL, HIGH, MEDIUM, LOW, MINOR].freeze
+
+      def self.for_error_count(count)
+        ALL.find { |tier| count >= tier[:min_errors] } || MINOR
+      end
+    end
+
+    class << self
+      def validator(profile: :svg_1_2_rfc)
+        SvgConform::Validator.new
+      end
+    end
+  end
+end