expressir 2.4.29-arm-linux-musl

data/lib/expressir/express/grammar.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # EXPRESS grammar namespace. Houses the Parsanol grammar definition
+    # separate from the I/O orchestration on the outer Parser facade.
+    module Grammar
+      autoload :Parser, "#{__dir__}/grammar/parser"
+    end
+  end
+end

data/lib/expressir/express/hyperlink_formatter.rb

@@ -0,0 +1,35 @@
+module Expressir
+  module Express
+    # Formatter module - format references as hyperlinks
+    # @example Include into Formatter subclass
+    #   formatter = Class.new(Expressir::Express::Formatter) do
+    #     include Expressir::Express::HyperlinkFormatter
+    #   end
+    module HyperlinkFormatter
+      # @!visibility private
+      def self.included(mod)
+        unless mod.superclass <= Expressir::Express::Formatter
+          raise Error::FormatterMethodMissingError.new("HyperlinkFormatter",
+                                                       "format_references_simple_reference")
+        end
+      end
+
+      def format_references_simple_reference(node)
+        return node.id unless node.base_path
+
+        # find closest node with path
+        current_node = node
+        while !current_node.path
+          current_node = current_node.parent
+        end
+
+        # skip if this reference and target node are in the same node with path
+        node_base_path_parts = node.base_path.split(".")
+        current_node_path_parts = current_node.path.split(".")
+        return node.id if node_base_path_parts[0..1] == current_node_path_parts[0..1]
+
+        "{{{<<express:#{node.base_path},#{node.id}>>}}}"
+      end
+    end
+  end
+end

data/lib/expressir/express/interface_dot.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Interface dependency GraphViz emitter — port of eeng
+    # kernel/dot-graph.lisp `:interface` graph (parity-ee stage 10).
+    #
+    # Nodes are schema names (lowercase); edges are USE FROM (default
+    # blue) and REFERENCE FROM (default green). An edge with an item
+    # list uses arrowhead=curve; a bare interface uses arrowhead=normal.
+    class InterfaceDot
+      def initialize(root_schema, repository,
+                     iface: :both, uf_color: :blue, rf_color: :green,
+                     depth: nil, prune: [])
+        @root = root_schema
+        @repository = repository
+        @iface = iface
+        @uf_color = uf_color
+        @rf_color = rf_color
+        @depth = depth
+        @prune = Array(prune).map { |n| n.to_s.downcase }
+        @by_name = repository.schemas.compact.to_h { |s| [s.id.safe_downcase, s] }
+      end
+
+      def write(io = nil)
+        owned = io.nil?
+        io ||= +""
+        schemas, edges = collect
+        io << "// -*- Mode: Dot -*-\n\n"
+        io << "// Dot File Written by Expressir\n"
+        io << "//    #{Expressir::VERSION}\n"
+        io << "\ndigraph interfaces {\n"
+        io << "  node [shape=none];\n"
+        if %i[both use].include?(@iface)
+          io << "  edge [color=#{@uf_color}];\n"
+          edges.select { |e| e[:kind] == :use }.each do |e|
+            head = e[:items] ? "curve" : "normal"
+            io << "  #{e[:from]} -> #{e[:to]} [arrowhead=#{head}];\n"
+          end
+        end
+        if %i[both ref].include?(@iface)
+          io << "  edge [color=#{@rf_color}];\n"
+          edges.select { |e| e[:kind] == :ref }.each do |e|
+            head = e[:items] ? "curve" : "normal"
+            io << "  #{e[:from]} -> #{e[:to]} [arrowhead=#{head}];\n"
+          end
+        end
+        # Ensure isolated schemas still appear as nodes.
+        named = edges.flat_map { |e| [e[:from], e[:to]] }.uniq
+        (schemas.map { |s| s.id.downcase } - named).each do |n|
+          io << "  #{n};\n"
+        end
+        io << "}\n"
+        owned ? io : nil
+      end
+
+      private
+
+      def collect
+        visited = {}
+        edges = []
+        queue = [[@root, 0]]
+        until queue.empty?
+          schema, level = queue.shift
+          key = schema.id.safe_downcase
+          next if visited.key?(key)
+          next if @prune.include?(key)
+
+          visited[key] = schema
+
+          Array(schema.interfaces).each do |iface|
+            target_name = iface_schema_name(iface)
+            next unless target_name
+
+            tkey = target_name.safe_downcase
+            next if @prune.include?(tkey)
+            next if tkey == key
+
+            kind = iface.kind == Model::Declarations::Interface::REFERENCE ? :ref : :use
+            next if @iface == :use && kind != :use
+            next if @iface == :ref && kind != :ref
+
+            edges << {
+              kind: kind,
+              items: Array(iface.items).any?,
+              from: key,
+              to: tkey,
+            }
+
+            target = @by_name[tkey]
+            next unless target
+            next if @depth && level + 1 >= @depth
+
+            queue << [target, level + 1]
+          end
+        end
+        [visited.values, edges.uniq]
+      end
+
+      def iface_schema_name(iface)
+        iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+      end
+    end
+  end
+end

data/lib/expressir/express/lazy_repository.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+module Expressir
+  module Express
+    # Lazy read path over a compiled-set artifact (M2 slice 2,
+    # TODO.parity-ee/19): schemas hydrate individually, on first touch,
+    # instead of the whole repository at once. Metanorma schema-doc
+    # rendering touches one schema per page — the lazy repository makes
+    # that pay: one hydration per page, not one per schema in the set.
+    #
+    # Duck-types the read surface of Model::Repository used by
+    # rendering (schemas, files, each, size, children). Anything beyond
+    # the read surface should wait for eager hydration via
+    # #to_eager (returns a real Model::Repository).
+    class LazyRepository
+      attr_reader :set_path
+
+      # @param set_path [String] compiled-set artifact path
+      # @param read_paths [Hash{String => String}] wire path => source path
+      def initialize(set_path, read_paths = {})
+        @set_path = set_path
+        @set = Core.lazy_set(set_path)
+        @read_paths = read_paths
+        @wire_paths = @set.wire_paths
+        @mutex = Mutex.new
+        @file_cache = {}
+        @hydration_count = 0
+      end
+
+      # Wire paths in artifact order — no hydration.
+      # @return [Array<String>]
+      def wire_paths
+        @wire_paths.dup
+      end
+
+      # Files in artifact order, each wrapped so it hydrates on first
+      # use. The file is the hydration grain: an artifact stores wire
+      # JSON per source file.
+      # @return [Array<LazyFile>]
+      def files
+        @wire_paths.map { |wire_path| file_by_wire_path(wire_path) }
+      end
+
+      # Hydrated (or hydrating) file for one wire path.
+      def file_by_wire_path(wire_path)
+        @mutex.synchronize do
+          @file_cache[wire_path] ||= LazyFile.new(wire_path) do
+            hydrate(wire_path)
+          end
+        end
+      end
+
+      # Schemas across all files. EAGER by definition: it hydrates
+      # every file. Lazy callers iterate #files, or render through
+      # #to_liquid, which keeps per-file hydration lazy.
+      # @return [Array<Declarations::Schema>]
+      def schemas
+        files.map(&:__target__).flat_map(&:schemas).compact
+      end
+
+      # Liquid binding for metanorma (M2): returns a Drop whose
+      # `schemas` is a lazy per-file list — each entry hydrates only
+      # its own file when the template touches it. Schema count per
+      # file is unknown until hydration, so the Drop presents one
+      # entry per FILE; single-schema files (the corpus norm) render
+      # identically to the eager path.
+      def to_liquid
+        LazyRepositoryDrop.new(self)
+      end
+
+      # How many files have actually been hydrated (observability for
+      # the laziness contract).
+      def hydration_count
+        @hydration_count
+      end
+
+      # Hydrate everything and return a real Model::Repository — the
+      # escape hatch for callers needing the full read surface.
+      def to_eager
+        repo = Model::Repository.new
+        repo.files = files.map(&:__target__)
+        repo
+      end
+
+      def each(&)
+        files.each(&)
+      end
+
+      def size
+        @wire_paths.size
+      end
+
+      def children
+        schemas
+      end
+
+      # The read path on disk for a wire path (may be nil when the
+      # caller did not supply source paths).
+      def read_path_for(wire_path)
+        @read_paths[wire_path]
+      end
+
+      def matches_sources?
+        @set.matches_sources(@read_paths.dup) == true
+      end
+
+      private
+
+      def hydrate(wire_path)
+        @mutex.synchronize do
+          _wire, model = @set.hydrate_one(wire_path)
+          @hydration_count += 1
+          model
+        end
+      end
+    end
+
+    # Liquid::Drop over a LazyRepository: `schemas` enumerates lazy
+    # per-file entries; touching an entry hydrates that file and
+    # presents its schemas (single-schema files present the schema
+    # itself, matching the eager Drop's element contract).
+    class LazyRepositoryDrop < ::Liquid::Drop
+      def initialize(repo)
+        @repo = repo
+        super()
+      end
+
+      def schemas
+        @repo.files.map do |file|
+          LazyFileDrop.new(file)
+        end
+      end
+
+      def size
+        @repo.size
+      end
+    end
+
+    # Per-file lazy drop: hydrates on first access, then presents the
+    # file's single schema directly (or the schema list for
+    # multi-schema files).
+    class LazyFileDrop < ::Liquid::Drop
+      def initialize(file)
+        @file = file
+        super()
+      end
+
+      def __file__
+        @file.__target__
+      end
+
+      def method_missing(name, *, &)
+        schemas = __file__.schemas
+        if schemas.size == 1
+          schemas.first.public_send(name, *, &)
+        else
+          __file__.public_send(name, *, &)
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        __file__.respond_to?(name, include_private) ||
+          __file__.schemas.first.respond_to?(name, include_private)
+      end
+    end
+
+    # Stands in for a Model::ExpFile until first method access, then
+    # hydrates through the block and forwards everything.
+    class LazyFile
+      def initialize(wire_path, &hydrator)
+        @wire_path = wire_path
+        @hydrator = hydrator
+        @mutex = Mutex.new
+        @target = nil
+      end
+
+      attr_reader :wire_path
+
+      # The real Schema, hydrating on first call.
+      def __target__
+        @mutex.synchronize do
+          @__target__ ||= @hydrator.call
+        end
+      end
+
+      def method_missing(name, *, &)
+        __target__.public_send(name, *, &)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        __target__.respond_to?(name, include_private)
+      end
+
+      # Identity through the wrapper: rendering compares and groups by
+      # class/is_a?, which the real file answers.
+      def is_a?(klass)
+        super || __target__.is_a?(klass)
+      end
+
+      def instance_of?(klass)
+        __target__.instance_of?(klass)
+      end
+
+      def class
+        __target__.class
+      end
+    end
+  end
+end

data/lib/expressir/express/line_map.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Maps byte positions in a source string to 1-based line numbers.
+    #
+    # Single source of truth for byte→line lookup across the remark pipeline
+    # (RemarkScanner and RemarkAttacher both rely on it). Builds an offset
+    # table once and answers queries in O(log n) via binary search.
+    class LineMap
+      # Newline byte (ASCII 0x0A).
+      NEWLINE = "\n"
+
+      # @param source_bytes [String] BINARY / ASCII-8BIT encoded source.
+      def initialize(source_bytes)
+        @offsets = build_offsets(source_bytes)
+      end
+
+      # Returns the 1-based line number that contains the given byte position.
+      # Returns 1 for position 0 (or any position before the first newline).
+      # Returns the last line number for positions past the final newline.
+      #
+      # @param byte_pos [Integer, nil]
+      # @return [Integer] 1-based line number; nil input yields 1.
+      def line_number(byte_pos)
+        return 1 if byte_pos.nil? || byte_pos <= 0
+
+        idx = @offsets.bsearch_index { |offset| offset > byte_pos }
+        idx || @offsets.size
+      end
+
+      private
+
+      # Builds the sorted array of byte positions where each line begins.
+      # offsets[0] = 0 (line 1 begins at byte 0).
+      # offsets[i] = (byte position of the i-th newline) + 1 (line i+1 begins).
+      def build_offsets(source_bytes)
+        offsets = [0]
+        i = 0
+        while (i = source_bytes.index(NEWLINE, i))
+          offsets << (i + 1)
+          i += 1
+        end
+        offsets
+      end
+    end
+  end
+end

data/lib/expressir/express/listing.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Expressir
+  module Express
+    # Declaration listing and SMRL index writers — ports of eeng
+    # plugins/p11/wo-list.lisp and wo-smrl-xml.lisp (parity-ee stage 09).
+    #
+    # Two encodings share the same schema walk and declaration ordering
+    # (TYPE, ENTITY, SUBTYPE_CONSTRAINT, FUNCTION, RULE, PROCEDURE —
+    # each sorted by name):
+    #   :list     — human-readable SCHEMA.name; inventory
+    #   :smrl_xml — <concatenated_express_file_content_list> index
+    class Listing
+      DECL_ORDER = %i[types entities subtype_constraints functions rules procedures].freeze
+      DECL_LABEL = {
+        types: "TYPE",
+        entities: "ENTITY",
+        subtype_constraints: "SUBTYPE_CONSTRAINT",
+        functions: "FUNCTION",
+        rules: "RULE",
+        procedures: "PROCEDURE",
+      }.freeze
+      XML_TAG = {
+        types: "type",
+        entities: "entity",
+        subtype_constraints: "subtype_constraint",
+        functions: "function",
+        rules: "rule",
+        procedures: "procedure",
+      }.freeze
+
+      def self.list(schemas, io = nil)
+        new(Array(schemas)).write(:list, io)
+      end
+
+      def self.smrl_xml(schemas, io = nil, source: nil)
+        new(Array(schemas)).write(:smrl_xml, io, source: source)
+      end
+
+      def initialize(schemas)
+        @schemas = schemas.compact.sort_by { |s| s.id.to_s.downcase }
+      end
+
+      def write(encoding, io = nil, source: nil)
+        owned = io.nil?
+        io ||= +""
+        case encoding
+        when :list then write_list(io)
+        when :smrl_xml then write_smrl_xml(io, source: source)
+        else
+          raise ArgumentError, "unknown listing encoding #{encoding.inspect}"
+        end
+        owned ? io : nil
+      end
+
+      private
+
+      def write_list(io)
+        @schemas.each_with_index do |schema, i|
+          io << "\n" if i.positive?
+          write_schema_list(schema, io)
+        end
+      end
+
+      def write_schema_list(schema, io)
+        version = schema.version ? " #{schema.version}" : ""
+        io << "SCHEMA #{schema.id.downcase}#{version};\n\n"
+        counts = decl_counts(schema)
+        DECL_ORDER.each do |key|
+          io << format("(* %-20s %4d *)\n", DECL_LABEL[key], counts[key])
+        end
+        ifaces = Array(schema.interfaces)
+        if ifaces.any?
+          io << "\n"
+          ifaces.each do |iface|
+            kind = iface.kind == Model::Declarations::Interface::REFERENCE ? "REFERENCE FROM" : "USE FROM"
+            target = iface_name(iface)
+            suffix = Array(iface.items).any? ? "(...)" : ""
+            io << "    #{kind} #{target}#{suffix};\n"
+          end
+        end
+        constants = Array(schema.constants).sort_by { |c| c.id.to_s.downcase }
+        if constants.any?
+          io << "\n"
+          constants.each { |c| io << "  CONSTANT #{c.id.downcase};\n" }
+        end
+        decls = ordered_decls(schema)
+        if decls.any?
+          io << "\n"
+          decls.each do |key, name|
+            io << "  #{DECL_LABEL[key]} #{schema.id}.#{name.downcase};\n"
+          end
+        end
+      end
+
+      def write_smrl_xml(io, source: nil)
+        io << "<!-- Written by Expressir -->\n"
+        io << "<!--    #{Expressir::VERSION} -->\n"
+        io << "<!-- File: #{source} -->\n" if source
+        io << "<concatenated_express_file_content_list>\n\n"
+        names = @schemas.map { |s| schema_name_string(s.id) }
+        io << "<!-- #{@schemas.size} Schema#{'ta' unless @schemas.size == 1}:\n"
+        io << "   #{names.join(', ')}\n"
+        io << "-->\n"
+        @schemas.each do |schema|
+          io << "\n\n"
+          write_schema_xml(schema, io)
+        end
+        io << "\n</concatenated_express_file_content_list>\n"
+      end
+
+      def write_schema_xml(schema, io)
+        io << "<schema>#{schema_name_string(schema.id)}</schema>\n"
+        if schema.version
+          io << "   <schema_version>#{schema.version}</schema_version>\n"
+        end
+        counts = decl_counts(schema)
+        DECL_ORDER.each do |key|
+          io << format("  <!-- %-20s %4d -->\n", DECL_LABEL[key], counts[key])
+        end
+        Array(schema.interfaces).each do |iface|
+          tag = iface.kind == Model::Declarations::Interface::REFERENCE ? "reference-from" : "use-from"
+          target = iface_name(iface)
+          suffix = Array(iface.items).any? ? "(...)" : ""
+          io << "    <#{tag}>#{target}#{suffix}</#{tag}>\n"
+        end
+        Array(schema.constants).sort_by { |c| c.id.to_s.downcase }.each do |c|
+          io << "  <constant>#{c.id.downcase}</constant>\n"
+        end
+        ordered_decls(schema).each do |key, name|
+          tag = XML_TAG[key] || key.to_s
+          cased = if key == :entities && arm_mode?(schema)
+                    name.split("_").map(&:capitalize).join("_")
+                  else
+                    name.downcase
+                  end
+          io << "  <#{tag}>#{schema.id}.#{cased}</#{tag}>\n"
+        end
+      end
+
+      def decl_counts(schema)
+        DECL_ORDER.to_h { |k| [k, Array(schema.public_send(k)).size] }
+      end
+
+      def ordered_decls(schema)
+        DECL_ORDER.flat_map do |key|
+          Array(schema.public_send(key))
+            .sort_by { |d| d.id.to_s.downcase }
+            .map { |d| [key, d.id] }
+        end
+      end
+
+      def iface_name(iface)
+        name = iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+        schema_name_string(name)
+      end
+
+      # eeng schema-name-string: arm/mim/arm_lf/mim_lf tails stay lowercase;
+      # everything else downcased.
+      def schema_name_string(name)
+        return "" unless name
+
+        name.to_s.downcase
+      end
+
+      def arm_mode?(schema)
+        id = schema.id.to_s.downcase
+        id.end_with?("arm", "arm_lf")
+      end
+    end
+  end
+end

data/lib/expressir/express/model_traversal.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Structural traversal over model trees, mirroring {ModelVisitor}:
+    # every typed attribute, statements included. Nodes are keyed by
+    # attribute path plus array index — stable across a compiled-set
+    # round trip because the wire is byte-identical — which is what the
+    # remark and reference overlays key on ({Model::ModelElement#path}
+    # is empty for id-less nodes).
+    module ModelTraversal
+      module_function
+
+      def each_node(node, key, &block)
+        yield node, key
+        return unless node.is_a?(Model::ModelElement)
+
+        node.class.attributes.each_key do |attr|
+          next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr) || attr == :parent
+
+          value = node.public_send(attr)
+          case value
+          when Array
+            value.each_with_index do |item, index|
+              next unless item.is_a?(Model::ModelElement)
+
+              each_node(item, "#{key}/#{attr}[#{index}]", &block)
+            end
+          when Model::ModelElement
+            each_node(value, "#{key}/#{attr}", &block)
+          end
+        end
+      end
+
+      def each_model(models, &block)
+        models.each_with_index do |model, index|
+          each_node(model, "model[#{index}]", &block)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/model_visitor.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Express
+    # @abstract
+    class ModelVisitor
+      def visit(node)
+        node.class.attributes.each_key do |symbol|
+          next if ::Expressir::Model::ModelElement::SKIP_ATTRIBUTES.include?(symbol)
+
+          value = node.public_send(symbol)
+
+          case value
+          when Array
+            value.each do |val|
+              if val.is_a? Model::ModelElement
+                visit(val)
+              end
+            end
+          when Model::ModelElement
+            visit(value)
+          end
+        end
+      end
+    end
+  end
+end