expressir 2.4.35-arm-linux → 2.4.37-arm-linux

data/lib/expressir/express/dialect.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Edition awareness for ISO 10303-11. The grammar accepts the union
+    # of both editions' text syntax; edition gating is reported by the
+    # Checker so a 1994 consumer sees exactly which declarations use
+    # 2004-only constructs, and a 2004 consumer sees the edition-1
+    # syntax the 2004 edition deprecates (Annex K).
+    module Dialect
+      EDITION_1994 = :"10303-11:1994"
+      EDITION_2004 = :"10303-11:2004"
+      DIALECTS = [EDITION_1994, EDITION_2004].freeze
+      DEFAULT = EDITION_2004
+
+      # The audited change list lives in
+      # spec/fixtures/dialects/iso-10303-11-2004-changes.yaml; every
+      # construct there maps to a note id below.
+      NOTE_IDS = %i[
+        check_dialect_2004_only
+        check_dialect_deprecated
+        check_dialect_mixed
+      ].freeze
+
+      module_function
+
+      def normalize(value)
+        return DEFAULT if value.nil?
+
+        candidate = value.to_s
+        dialect = DIALECTS.find do |entry|
+          entry.to_s == candidate || entry.to_s.end_with?(":#{candidate}")
+        end
+        return dialect if dialect
+
+        raise Expressir::InvalidOptionError.new(
+          "dialect",
+          value,
+          valid_options: DIALECTS.map(&:to_s),
+        )
+      end
+    end
+  end
+end

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

@@ -154,7 +154,10 @@ module Expressir
 
         def format_expressions_unary_expression(node)
           needs_parens = node.operand.is_a?(Model::Expressions::BinaryExpression) ||
-            node.operand.is_a?(Model::Expressions::Interval)
+            node.operand.is_a?(Model::Expressions::Interval) ||
+            # Nested unary must stay parenthesized: "- -x" is not a
+            # simple factor, and "--x" opens a comment.
+            node.operand.is_a?(Model::Expressions::UnaryExpression)
 
           [
             case node.operator

data/lib/expressir/express/parser.rb

@@ -56,8 +56,11 @@ module Expressir
       # @raise [Error::SchemaParseFailure] if the schema file fails to parse
       def self.from_file(file, skip_references: nil, include_source: nil,
                          root_path: nil, use_native: nil,
-                         use_core: nil) # rubocop:disable Metrics/AbcSize
-        use_core = Core::NATIVE_AVAILABLE if use_core.nil?
+                         use_core: nil, dialect: nil) # rubocop:disable Metrics/AbcSize
+        Dialect.normalize(dialect)
+        # use_native: false pins the Ruby grammar path; the core path
+        # must not silently take over that request.
+        use_core = Core::NATIVE_AVAILABLE if use_core.nil? && use_native != false
         if use_core && Core::NATIVE_AVAILABLE
           return from_file_core(file, skip_references: skip_references,
                                       include_source: include_source,
@@ -115,7 +118,8 @@ module Expressir
       # @return [Model::Repository] Repository containing all parsed ExpFiles
       def self.from_files(files, skip_references: nil, include_source: nil,
                           root_path: nil, use_native: nil, max_processes: nil,
-                          compiled_set: nil, &progress)
+                          compiled_set: nil, dialect: nil, &progress)
+        Dialect.normalize(dialect)
         set_path = compiled_set || ENV.fetch("EXPRESSIR_COMPILED_SET", nil)
         if set_path && core_set_available?
           repo = from_compiled_set(set_path, files,
@@ -457,7 +461,8 @@ include_source: nil, root_path: nil, use_native: nil, &block)
       # @return [Model::ExpFile] Parsed ExpFile
       # @raise [Error::SchemaParseFailure] if the content fails to parse
       def self.from_exp(content, skip_references: nil, include_source: nil,
-                         use_native: nil, use_streaming: false)
+                         use_native: nil, use_streaming: false, dialect: nil)
+        Dialect.normalize(dialect)
         content = strip_bom(content)
         if use_streaming
           raise Error::StreamingUnsupportedError

data/lib/expressir/express.rb

@@ -15,6 +15,7 @@ module Expressir
     autoload :Checker, "#{__dir__}/express/checker"
     autoload :Concatenator, "#{__dir__}/express/concatenator"
     autoload :Core, "#{__dir__}/express/core"
+    autoload :Dialect, "#{__dir__}/express/dialect"
     autoload :RemarkOverlay, "#{__dir__}/express/remark_overlay"
     autoload :ModelTraversal, "#{__dir__}/express/model_traversal"
     autoload :RefsOverlay, "#{__dir__}/express/refs_overlay"

data/lib/expressir/interop/json_schema.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Interop
+    # JSON Schema 2020-12 rendering of an EXPRESS schema. Decisions
+    # (docs/interop/json-schema.md): entities become object definitions
+    # composed by allOf over their subtype_of supertypes; explicit
+    # attributes are properties in declaration order; OPTIONAL
+    # attributes leave `required` and admit null; aggregates become
+    # arrays with bounds; SELECT becomes anyOf; ENUMERATION becomes a
+    # string enum; derived and inverse attributes are not exported
+    # (they are not part of the Part 21 exchange structure).
+    class JsonSchema
+      DRAFT = "https://json-schema.org/draft/2020-12/schema"
+      BASE_IRI = "https://expressir.org/json-schema"
+
+      def self.export(schema)
+        new(schema).export
+      end
+
+      attr_reader :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def export
+        result = {
+          "$schema" => DRAFT,
+          "$id" => "#{BASE_IRI}/#{schema.id}",
+          "title" => schema.id.to_s,
+          "$defs" => definitions,
+        }
+        entities = Array(schema.entities)
+        result["anyOf"] = entities.map { |entity| reference(entity.id) } unless entities.empty?
+        result
+      end
+
+      def to_json(pretty: true)
+        pretty ? JSON.pretty_generate(export) : JSON.generate(export)
+      end
+
+      private
+
+      def definitions
+        result = {}
+        Array(schema.types).each do |type|
+          result[type.id] = defined_type_schema(type)
+        end
+        Array(schema.entities).each do |entity|
+          result[entity.id] = entity_schema(entity)
+        end
+        result
+      end
+
+      def defined_type_schema(type)
+        case type.underlying_type
+        when Model::DataTypes::Enumeration
+          enumeration_schema(type.underlying_type)
+        when Model::DataTypes::Select
+          select_schema(type.underlying_type)
+        else
+          type_schema(type.underlying_type)
+        end
+      end
+
+      def entity_schema(entity)
+        own = {
+          "type" => "object",
+          "properties" => explicit_attributes(entity).to_h do |attribute|
+            [attribute.id, attribute_schema(attribute)]
+          end,
+        }
+        required = explicit_attributes(entity).reject(&:optional)
+          .map(&:id)
+        own["required"] = required unless required.empty?
+
+        supertypes = Array(entity.subtype_of).map do |supertype|
+          reference(supertype.id)
+        end
+        return own.merge("title" => entity.id) if supertypes.empty?
+
+        { "title" => entity.id, "allOf" => [*supertypes, own] }
+      end
+
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |attribute| attribute.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def attribute_schema(attribute)
+        base = type_schema(attribute.type)
+        return base unless attribute.optional
+
+        { "anyOf" => [base, { "type" => "null" }] }
+      end
+
+      def type_schema(type)
+        case type
+        when Model::DataTypes::Integer then { "type" => "integer" }
+        when Model::DataTypes::Real, Model::DataTypes::Number
+          { "type" => "number" }
+        when Model::DataTypes::String then { "type" => "string" }
+        when Model::DataTypes::Boolean then { "type" => "boolean" }
+        when Model::DataTypes::Logical
+          { "enum" => [true, false, nil] }
+        when Model::DataTypes::Binary
+          { "type" => "string", "pattern" => "\\A[01]*\\z" }
+        when Model::DataTypes::Enumeration
+          enumeration_schema(type)
+        when Model::DataTypes::Select
+          select_schema(type)
+        when Model::DataTypes::List, Model::DataTypes::Array,
+             Model::DataTypes::Set, Model::DataTypes::Bag
+          aggregate_schema(type)
+        when Model::References::SimpleReference then reference(type.id)
+        when nil then {}
+        else { "type" => "object" }
+        end
+      end
+
+      def enumeration_schema(enumeration)
+        { "type" => "string",
+          "enum" => enumeration_values(enumeration).map(&:to_s) }
+      end
+
+      def enumeration_values(enumeration, seen = [])
+        return [] if enumeration.nil? || seen.include?(enumeration.object_id)
+
+        seen += [enumeration.object_id]
+        values = []
+        base_type = resolve_reference(enumeration.based_on)
+        if base_type&.underlying_type.is_a?(Model::DataTypes::Enumeration)
+          values.concat(enumeration_values(base_type.underlying_type, seen))
+        end
+        values.concat(Array(enumeration.items).filter_map(&:id))
+        values.uniq
+      end
+
+      def select_schema(select)
+        { "anyOf" => select_schemas(select) }
+      end
+
+      def select_schemas(select, seen = [])
+        return [] if select.nil? || seen.include?(select.object_id)
+
+        seen += [select.object_id]
+        refs = []
+        base_type = resolve_reference(select.based_on)
+        if base_type&.underlying_type.is_a?(Model::DataTypes::Select)
+          refs.concat(select_schemas(base_type.underlying_type, seen))
+        end
+        refs.concat(Array(select.items).map { |item| type_schema(item) })
+        refs.uniq
+      end
+
+      def aggregate_schema(type)
+        result = { "type" => "array",
+                   "items" => type_schema(type.base_type) }
+        lower, upper = aggregate_bounds(type)
+        result["minItems"] = lower if lower
+        result["maxItems"] = upper if upper
+        result["uniqueItems"] = true if unique?(type)
+        result
+      end
+
+      def aggregate_bounds(type)
+        [bound_value(type.bound1), bound_value(type.bound2)]
+      end
+
+      def bound_value(bound)
+        return nil unless bound.is_a?(Model::Literals::Integer)
+
+        bound.value.to_i
+      end
+
+      def unique?(type)
+        type.is_a?(Model::DataTypes::Set) ||
+          (type.is_a?(Model::DataTypes::List) && type.unique)
+      end
+
+      def resolve_reference(reference)
+        return nil unless reference.respond_to?(:id) && reference.id
+
+        schema.find(reference.id)
+      rescue StandardError
+        nil
+      end
+
+      def reference(id)
+        { "$ref" => "#/$defs/#{id}" }
+      end
+    end
+  end
+end

data/lib/expressir/interop/owl.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Interop
+    # OWL 2 / RDF Turtle rendering of an EXPRESS schema, in the ifcOWL
+    # lineage generalized to arbitrary EXPRESS (docs/interop/owl-rdf.md).
+    # Entities become owl:Class with rdfs:subClassOf per supertype;
+    # explicit attributes become properties with rdfs:domain/rdfs:range;
+    # SELECT becomes an owl:unionOf equivalent class; ENUMERATION items
+    # become individuals of the enumeration class. WHERE rules are not
+    # exported (documented scope limit).
+    class Owl
+      PREFIXES = {
+        "owl" => "http://www.w3.org/2002/07/owl#",
+        "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+        "rdfs" => "http://www.w3.org/2000/01/rdf-schema#",
+        "xsd" => "http://www.w3.org/2001/XMLSchema#",
+      }.freeze
+
+      PRIMITIVE_RANGES = {
+        Model::DataTypes::Integer => "xsd:integer",
+        Model::DataTypes::Real => "xsd:double",
+        Model::DataTypes::Number => "xsd:double",
+        Model::DataTypes::String => "xsd:string",
+        Model::DataTypes::Boolean => "xsd:boolean",
+        Model::DataTypes::Logical => "xsd:boolean",
+        Model::DataTypes::Binary => "xsd:hexBinary",
+      }.freeze
+
+      def self.export(schema, base_iri: nil)
+        new(schema, base_iri: base_iri).export
+      end
+
+      attr_reader :schema, :base_iri
+
+      def initialize(schema, base_iri: nil)
+        @schema = schema
+        @base_iri = base_iri || "https://expressir.org/owl/#{schema.id}#"
+      end
+
+      def export
+        blocks = [ontology_block]
+        Array(schema.types).each { |type| blocks.concat(type_blocks(type)) }
+        Array(schema.entities).each { |entity| blocks.concat(entity_blocks(entity)) }
+        ([prefix_block, ""] + blocks).join("\n")
+      end
+
+      private
+
+      def prefix_block
+        prefixes = { "ex" => base_iri }.merge(PREFIXES)
+        prefixes.map { |name, iri| "@prefix #{name}: <#{iri}> ." }.join("\n")
+      end
+
+      def ontology_block
+        block(["a owl:Ontology", "rdfs:label #{quote(schema.id.to_s)}"],
+              subject: "<#{base_iri}>")
+      end
+
+      def entity_blocks(entity)
+        lines = ["a owl:Class", "rdfs:label #{quote(entity.id.to_s)}"]
+        supertypes = Array(entity.subtype_of)
+        if supertypes.any?
+          parents = supertypes.map { |parent| "ex:#{parent.id}" }
+          lines << "rdfs:subClassOf #{parents.join(', ')}"
+        end
+        lines << "rdfs:comment #{quote('EXPRESS ABSTRACT SUPERTYPE')}" if entity.abstract
+        [block(lines, subject: "ex:#{entity.id}")] + attribute_blocks(entity)
+      end
+
+      def attribute_blocks(entity)
+        explicit_attributes(entity).map do |attribute|
+          range = range_for(attribute.type)
+          lines = ["a #{property_kind(attribute.type)}",
+                   "rdfs:domain ex:#{entity.id}",
+                   "rdfs:range #{range}"]
+          lines << "rdfs:comment #{quote('OPTIONAL')}" if attribute.optional
+          block(lines, subject: "ex:#{attribute.id}")
+        end
+      end
+
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |attribute| attribute.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def type_blocks(type)
+        underlying = type.underlying_type
+        case underlying
+        when Model::DataTypes::Enumeration
+          enumeration_blocks(type.id, underlying)
+        when Model::DataTypes::Select
+          [select_block(type.id, underlying)]
+        else
+          [defined_type_block(type.id, underlying)]
+        end
+      end
+
+      def enumeration_blocks(name, enumeration)
+        values = enumeration_values(enumeration)
+        blocks = [block(["a owl:Class", "rdfs:label #{quote(name.to_s)}"],
+                        subject: "ex:#{name}")]
+        values.each do |value|
+          blocks << "ex:#{value} a owl:NamedIndividual, ex:#{name} ."
+        end
+        blocks
+      end
+
+      def enumeration_values(enumeration, seen = [])
+        return [] if enumeration.nil? || seen.include?(enumeration.object_id)
+
+        seen += [enumeration.object_id]
+        values = []
+        base_type = resolve_reference(enumeration.based_on)
+        if base_type&.underlying_type.is_a?(Model::DataTypes::Enumeration)
+          values.concat(enumeration_values(base_type.underlying_type, seen))
+        end
+        values.concat(Array(enumeration.items).filter_map(&:id))
+        values.uniq
+      end
+
+      def select_block(name, select)
+        items = select_items(select).map { |item| "ex:#{item}" }
+        block(
+          ["a owl:Class",
+           "rdfs:label #{quote(name.to_s)}",
+           "owl:equivalentClass [ a owl:Class ; owl:unionOf ( #{items.join(' ')} ) ]"],
+          subject: "ex:#{name}",
+        )
+      end
+
+      def select_items(select, seen = [])
+        return [] if select.nil? || seen.include?(select.object_id)
+
+        seen += [select.object_id]
+        names = []
+        base_type = resolve_reference(select.based_on)
+        if base_type&.underlying_type.is_a?(Model::DataTypes::Select)
+          names.concat(select_items(base_type.underlying_type, seen))
+        end
+        names.concat(Array(select.items).filter_map(&:id))
+        names.uniq
+      end
+
+      def defined_type_block(name, underlying)
+        primitive = PRIMITIVE_RANGES[underlying.class]
+        lines = ["a #{primitive ? 'rdfs:Datatype' : 'owl:Class'}",
+                 "rdfs:label #{quote(name.to_s)}"]
+        lines << if primitive
+                   "owl:equivalentClass #{primitive}"
+                 elsif underlying.is_a?(Model::References::SimpleReference)
+                   "rdfs:subClassOf ex:#{underlying.id}"
+                 else
+                   "rdfs:subClassOf rdf:List"
+                 end
+        block(lines, subject: "ex:#{name}")
+      end
+
+      def property_kind(type)
+        object_property?(type) ? "owl:ObjectProperty" : "owl:DatatypeProperty"
+      end
+
+      def object_property?(type, seen = [])
+        case type
+        when Model::DataTypes::List, Model::DataTypes::Array,
+             Model::DataTypes::Set, Model::DataTypes::Bag,
+             Model::DataTypes::Select, Model::DataTypes::Enumeration
+          true
+        when Model::References::SimpleReference
+          return false if seen.include?(type.id)
+
+          target = resolve_reference(type)
+          case target
+          when Model::Declarations::Entity then true
+          when Model::Declarations::Type
+            object_property?(target.underlying_type, seen + [type.id])
+          else false
+          end
+        else false
+        end
+      end
+
+      def range_for(type)
+        case type
+        when Model::DataTypes::List, Model::DataTypes::Array,
+             Model::DataTypes::Set, Model::DataTypes::Bag
+          "rdf:List"
+        when Model::DataTypes::Enumeration, Model::DataTypes::Select
+          "rdfs:Resource"
+        when Model::References::SimpleReference
+          "ex:#{type.id}"
+        else
+          PRIMITIVE_RANGES[type.class] || "rdfs:Resource"
+        end
+      end
+
+      def resolve_reference(reference)
+        return nil unless reference.respond_to?(:id) && reference.id
+
+        schema.find(reference.id)
+      rescue StandardError
+        nil
+      end
+
+      def block(predicates, subject: nil)
+        head = subject ? "#{subject} #{predicates.first}" : predicates.first
+        rest = predicates.drop(1).map { |line| "    #{line}" }
+        "#{([head] + rest).join(" ;\n")} ."
+      end
+
+      def quote(text)
+        JSON.generate(text)
+      end
+    end
+  end
+end

data/lib/expressir/interop.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Expressir
+  # Mappings from EXPRESS to other modeling notations. These are
+  # contributions, not ISO mappings; every decision is documented under
+  # docs/interop/.
+  module Interop
+    autoload :JsonSchema, "#{__dir__}/interop/json_schema"
+    autoload :Owl, "#{__dir__}/interop/owl"
+  end
+end