expressir 2.4.3 → 2.4.4

data/lib/expressir/commands/parity_inputs.rb

@@ -0,0 +1,85 @@
+require "find"
+
+module Expressir
+  module Commands
+    # Common parser/discovery helpers shared by parity CLI commands
+    # (expand, flatten, check) — they all need: list of files in the
+    # interface closure of a root file, and the root schema parsed.
+    module ParityInputs
+      module_function
+
+      # Resolve the transitive interface closure of +root_path+. Deps are
+      # looked up by schema name: first in the file's own directory, then
+      # across the enclosing STEPmod checkout (the nearest ancestor holding
+      # a `schemas/` directory, e.g. resources/ and modules/ trees).
+      def closure_paths(root_path, manifest: nil, stepmod: nil)
+        index = schema_index(root_path)
+        seen = { File.basename(root_path, ".exp").downcase => root_path }
+        queue = [File.basename(root_path, ".exp").downcase]
+        until queue.empty?
+          name = queue.shift
+          path = seen[name] || index[name]
+          next unless path
+          next if seen.key?(name) && seen[name] != root_path
+
+          seen[name] = path
+          closure_names(File.read(path)).each { |d| queue << d.downcase }
+        end
+        seen.values.uniq
+      end
+
+      # Schema-name → path map for the STEPmod checkout around +root_path+,
+      # built once per invocation. The index root is the nearest ancestor
+      # directory NAMED `schemas` (wg12-step layout:
+      # `schemas/modules/<module>/mim.exp`), and entries key on the schema
+      # name declared inside each file — module files are `arm.exp` /
+      # `mim.exp`, so basenames cannot be the key. Falls back to the file's
+      # own directory when there is no schemas/ ancestor.
+      def schema_index(root_path)
+        dir = File.dirname(File.expand_path(root_path))
+        until dir == "/" || File.basename(dir) == "schemas"
+          parent = File.dirname(dir)
+          break if parent == dir
+
+          dir = parent
+        end
+        return same_dir_index(root_path) unless File.basename(dir) == "schemas"
+
+        @@indexes ||= {}
+        @@indexes[dir] ||= begin
+          h = {}
+          Find.find(dir) do |path|
+            next unless path.end_with?(".exp")
+
+            declared = File.read(path)[/\bSCHEMA\s+(\w+)/i, 1]
+            h[declared.downcase] = path if declared
+            h[File.basename(path, ".exp").downcase] ||= path
+          end
+          h
+        end
+      end
+
+      def same_dir_index(root_path)
+        dir = File.dirname(File.expand_path(root_path))
+        Dir.glob(File.join(dir, "*.exp")).to_h do |p|
+          [File.basename(p, ".exp").downcase, p]
+        end
+      end
+
+      def closure_names(source)
+        source.scan(/\bUSE\s+FROM\s+(\w+)/i).flatten.uniq +
+          source.scan(/\bREFERENCE\s+FROM\s+(\w+)/i).flatten.uniq
+      end
+
+      # manifest:/stepmod: are accepted for the ELF-manifest resolver
+      # contract; the directory-index fallback ignores them until that
+      # resolver lands.
+      def root_schema(root_path, manifest: nil, stepmod: nil)
+        name = File.read(root_path)[/\bSCHEMA\s+(\w+)/, 1]
+        cp = closure_paths(root_path)
+        repo = Expressir::Express::Parser.from_files(cp, max_processes: 1)
+        [repo.schemas.find { |s| s.id == name }, repo]
+      end
+    end
+  end
+end

data/lib/expressir/commands/validate.rb

@@ -79,6 +79,28 @@ module Expressir
       def ascii(path)
         ValidateAscii.new(options).run(path)
       end
+
+      desc "check *PATHS", "Run eeng check-p11 semantic checks"
+      long_desc <<~DESC
+        Walks one or more EXPRESS files (or directories of .exp) and
+        reports the eeng check-p11 note subset covered by Checker:
+        redundant interfaces, duplicate resources, unresolved interface
+        schema/ref, SUBTYPE OF targets, SELECT/ENUM BASED_ON, and
+        WHERE/UNIQUE label patterns.
+
+        Exits 1 when any error-severity note fires.
+      DESC
+      method_option :json, type: :boolean, default: false,
+                           desc: "Emit the report as JSON (errors + warnings)"
+      method_option :manifest, type: :string,
+                               desc: "ELF schema manifest YAML defining where schemas live " \
+                                     "(primary resolution mode)"
+      method_option :stepmod, type: :string,
+                              desc: "STEPmod checkout root — explicit opt-in to directory-" \
+                                    "convention resolution as the fallback"
+      def check(*paths)
+        Check.new(options).run(*paths)
+      end
     end
   end
 end

data/lib/expressir/commands.rb

@@ -4,9 +4,14 @@ module Expressir
     autoload :Base, "#{__dir__}/commands/base"
     autoload :Benchmark, "#{__dir__}/commands/benchmark"
     autoload :BenchmarkCache, "#{__dir__}/commands/benchmark_cache"
+    autoload :Check, "#{__dir__}/commands/check"
     autoload :Clean, "#{__dir__}/commands/clean"
     autoload :Coverage, "#{__dir__}/commands/coverage"
+    autoload :Expand, "#{__dir__}/commands/expand"
+    autoload :Fix, "#{__dir__}/commands/fix"
+    autoload :Flatten, "#{__dir__}/commands/flatten"
     autoload :Format, "#{__dir__}/commands/format"
+    autoload :ParityInputs, "#{__dir__}/commands/parity_inputs"
     autoload :Validate, "#{__dir__}/commands/validate"
     autoload :ValidateLoad, "#{__dir__}/commands/validate_load"
     autoload :ValidateAscii, "#{__dir__}/commands/validate_ascii"

data/lib/expressir/express/builder_registry.rb

@@ -325,13 +325,22 @@ module Expressir
 
       # Simple types
       Builder.register(:boolean_type) { |d| type_builder.build_boolean_type(d) }
+      # GENERIC[: label] / GENERIC_ENTITY[: label] — ISO 10303-11
+      # 9.5.3.2 type label (GH-339).
+      def self.type_label_id(ast_data)
+        label = ast_data.is_a?(Hash) ? ast_data[:type_label] : nil
+        return nil unless label.is_a?(Hash)
+
+        Builder.build_optional({ simple_id: label[:type_label_id][:simple_id] })
+      end
+
       Builder.register(:integer_type) { |d| type_builder.build_integer_type(d) }
       Builder.register(:logical_type) { |d| type_builder.build_logical_type(d) }
       Builder.register(:number_type) { |d| type_builder.build_number_type(d) }
 
       # Type constructors
-      Builder.register(:generic_type) { |_d| Expressir::Model::DataTypes::Generic.new }
-      Builder.register(:generic_entity_type) { |_d| Expressir::Model::DataTypes::GenericEntity.new }
+      Builder.register(:generic_type) { |d| Expressir::Model::DataTypes::Generic.new(id: BuilderRegistry.type_label_id(d)) }
+      Builder.register(:generic_entity_type) { |d| Expressir::Model::DataTypes::GenericEntity.new(id: BuilderRegistry.type_label_id(d)) }
       Builder.register(:aggregate_type) do |d|
         type_builder.build_aggregate_type(d)
       end

data/lib/expressir/express/builders/entity_decl_builder.rb

@@ -46,13 +46,22 @@ module Expressir
 
             if subtype_declaration.is_a?(Hash)
               list_ref = subtype_declaration[:list_of_entity_ref]
-              if list_ref.is_a?(Hash)
-                entity_ref_data = list_ref[:entity_ref]
-                if entity_ref_data
-                  subtype_of = Builder.build_children(Builder.ensure_array(entity_ref_data).map do |d|
-                    { entity_ref: d }
-                  end)
+              # SUBTYPE OF (a) flattens to a Hash; SUBTYPE OF (a, b) to an
+              # Array of single-key fragments (entity_ref possibly merged
+              # with its op_comma). Collect entity_ref from either shape
+              # (lutaml/expressir#341).
+              raw_entity_refs =
+                if list_ref.is_a?(Hash)
+                  ref = list_ref[:entity_ref]
+                  ref.is_a?(Array) ? ref : [ref]
+                elsif list_ref.is_a?(Array)
+                  list_ref.filter_map { |el| el[:entity_ref] if el.is_a?(Hash) }
+                    .flat_map { |d| d.is_a?(Array) ? d : [d] }
                 end
+              if raw_entity_refs && !raw_entity_refs.empty?
+                subtype_of = Builder.build_children(raw_entity_refs.map do |d|
+                  { entity_ref: d }
+                end)
               end
             end
           end
@@ -78,7 +87,8 @@ module Expressir
             end
 
             if entity_body[:unique_clause]
-              unique_rules = Builder.build({ unique_clause: entity_body[:unique_clause] })
+              built = Builder.build({ unique_clause: entity_body[:unique_clause] })
+              unique_rules = Array(built).compact
             end
             unique_rules ||= []
 

data/lib/expressir/express/builders/subtype_constraint_builder.rb

@@ -21,7 +21,9 @@ module Expressir
           if body.is_a?(Hash)
             abstract = !body[:abstract_supertype].nil?
             if body[:total_over].is_a?(Hash)
-              total_over = Builder.build_children(Builder.ensure_array(body[:total_over][:entity_ref]))
+              refs = body[:total_over][:list_of_entity_ref] ||
+                body[:total_over][:entity_ref]
+              total_over = Builder.build_children(Builder.ensure_array(refs))
             end
             # Wrap supertype_expression in its node type so Builder.build dispatches correctly
             supertype_expression = if body[:supertype_expression]

data/lib/expressir/express/builders/type_builder.rb

@@ -114,10 +114,18 @@ module Expressir
           bound1 = Builder.build_optional(bound_spec[:bound1])
           bound2 = Builder.build_optional(bound_spec[:bound2])
           base_type = Builder.build_optional(ast_data[:parameter_type])
+          # Element modifiers are legal on general aggregations too
+          # (attributes and parameters); dropping them silently changed
+          # element constraints (GH-338). ARRAY carries both flags,
+          # LIST only UNIQUE, per the model.
+          optional = !ast_data[:t_optional].nil? if type_class.method_defined?(:optional)
+          unique = !ast_data[:t_unique].nil? if type_class.method_defined?(:unique)
 
           type_class.new(
             bound1: bound1,
             bound2: bound2,
+            optional: optional,
+            unique: unique,
             base_type: base_type,
           )
         end

data/lib/expressir/express/builders/unique_rule_builder.rb

@@ -25,8 +25,15 @@ module Expressir
             attributes = Builder.build_children(inner_data[:referenced_attribute])
           end
 
+          attributes = attributes.compact
+
+          # The grammar's separator repetition can yield a phantom rule
+          # fragment (no label, no referenced attributes) between real
+          # rules; drop it so clean never emits a bare ";" (GH-340).
+          return nil if id.nil? && attributes.empty?
+
           Expressir::Model::Declarations::UniqueRule.new(id: id,
-                                                         attributes: attributes.compact)
+                                                         attributes: attributes)
         end
       end
     end