expressir 2.4.3 → 2.4.4

data/lib/expressir/express/formatters/remark_formatter.rb

@@ -125,7 +125,7 @@ module Expressir
 
           # For scope containers: exclude last remark ONLY if it's a tail remark (END_* remark)
           # Keep all embedded remarks
-          if is_scope_container && preamble_remarks.length > 1
+          if is_scope_container && preamble_remarks.length >= 1
             last_remark = preamble_remarks.last
             # Only exclude if it's a tail remark
             preamble_remarks = preamble_remarks[0..-2] if last_remark.tail?
@@ -154,15 +154,39 @@ module Expressir
           end
         end
 
-        # Remarks written after their statement on the same line. Attachment
-        # only assigns these to single-line statements, so appending keeps
-        # them on that statement's line.
+        # Remarks written after their statement on the same line, which for a
+        # single-line statement is where appending puts them back. Opener
+        # remarks are excluded: those belong on the first line rather than
+        # after the closing keyword, and {#format_opener_remarks} emits them.
+        # Mid-keyword remarks (ELSE / OTHERWISE regions) are excluded too:
+        # {#format_mid_keyword_remarks} emits them after their keyword.
         def format_inline_statement_remarks(node)
+          formatted_inline_remarks(node) { |remark| remark.region.nil? }
+        end
+
+        # Remarks that trailed the opening line of a statement spanning
+        # several lines, as in `IF x THEN -- why`. Where they are written back
+        # is Formatter#format's business, not this method's.
+        def format_opener_remarks(node)
+          formatted_inline_remarks(node, &:opener?)
+        end
+
+        # Remarks that trailed a mid-construct keyword of `node` — the ELSE
+        # line of an IF, the OTHERWISE line of a CASE — emitted after that
+        # keyword, where they were written.
+        def format_mid_keyword_remarks(node, region)
+          formatted_inline_remarks(node) { |remark| remark.inline_region?(region) }
+        end
+
+        # The inline remarks of a node that the given block accepts, formatted
+        # and joined. The callers partition the same collection, so every
+        # inline remark is emitted by exactly one of them.
+        def formatted_inline_remarks(node, &)
           return "" if @no_remarks
-          return "" unless node.is_a?(Model::Statement)
+          return "" unless node.is_a?(Model::TakesInlineRemark)
 
           Array(node.untagged_remarks).filter_map do |remark|
-            next unless remark.inline?
+            next unless remark.inline? && yield(remark)
 
             formatted = format_untagged_remark(remark)
             formatted unless formatted.empty?

data/lib/expressir/express/formatters/statements_formatter.rb

@@ -98,6 +98,8 @@ module Expressir
                    "OTHERWISE",
                    " ",
                    ":",
+                   format_mid_keyword_remarks(node,
+                                              Model::RemarkPlacement::OTHERWISE_REGION),
                  ].join,
                  indent(format(node.otherwise_statement)),
                ]
@@ -167,7 +169,11 @@ module Expressir
             *(then_trailing if has_else),
             *if has_else
                [
-                 "ELSE",
+                 [
+                   "ELSE",
+                   format_mid_keyword_remarks(node,
+                                              Model::RemarkPlacement::ELSE_REGION),
+                 ].join,
                  indent(node.else_statements.map { |x| format(x) }.join("\n")),
                ].join("\n")
              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/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/node_position_index.rb

@@ -142,15 +142,15 @@ module Expressir
 
       # Returns the most-specific node whose span contains `remark_line`,
       # preferring same-line starts/ends, then smallest containing span.
-      # Excludes Repository and Cache (not semantic scopes for remarks).
+      # Skips nodes that cannot own such a remark; see {#remark_scope?}.
       def nearest_node_to(remark_line)
-        same_start = starting_at(remark_line)
+        same_start = starting_at(remark_line).select { |n| remark_scope?(n[:node]) }
         return same_start.last[:node] if same_start.any?
 
-        same_end = ending_at(remark_line)
+        same_end = ending_at(remark_line).select { |n| remark_scope?(n[:node]) }
         return same_end.last[:node] if same_end.any?
 
-        containing = spanning(remark_line)
+        containing = spanning(remark_line).select { |n| remark_scope?(n[:node]) }
 
         if containing.any?
           exp_file_node = containing.find { |n| n[:node].is_a?(Model::ExpFile) }
@@ -218,6 +218,20 @@ module Expressir
         !node.is_a?(Model::Repository) && !node.is_a?(Model::Cache)
       end
 
+      # Whether a node can own a remark sitting on a line of its own.
+      # Distinct from Model::TakesInlineRemark, which asks whether a node can
+      # own a remark written AFTER it on the same line: a statement answers
+      # yes to both; an interface clause only to that one.
+      #
+      # An interface clause is indexed (so a remark trailing it can find it
+      # via the same-line lookup), but it encloses nothing: an own-line
+      # remark below `REFERENCE FROM x;` introduces whatever comes next, and
+      # giving it to the clause would both misplace it and lose it, since
+      # nothing renders remarks there.
+      def remark_scope?(node)
+        semantic?(node) && !node.is_a?(Model::Declarations::Interface)
+      end
+
       def build_sorted_nodes
         result = []
         collect_nodes(@model, result, Set.new)