expressir 2.1.17 → 2.1.19

data/lib/expressir/coverage.rb

@@ -0,0 +1,249 @@
+require "pathname"
+
+module Expressir
+  # Coverage module for calculating documentation coverage of EXPRESS entities
+  module Coverage
+    # Mapping of EXPRESS entity type names to their corresponding class names
+    ENTITY_TYPE_MAP = {
+      "TYPE" => "Expressir::Model::Declarations::Type",
+      "ENTITY" => "Expressir::Model::Declarations::Entity",
+      "CONSTANT" => "Expressir::Model::Declarations::Constant",
+      "FUNCTION" => "Expressir::Model::Declarations::Function",
+      "RULE" => "Expressir::Model::Declarations::Rule",
+      "PROCEDURE" => "Expressir::Model::Declarations::Procedure",
+      "SUBTYPE_CONSTRAINT" => "Expressir::Model::Declarations::SubtypeConstraint",
+    }.freeze
+    # Represents a documentation coverage report for EXPRESS schemas
+    class Report
+      attr_reader :repository, :schema_reports, :total_entities, :documented_entities,
+                  :undocumented_entities
+
+      # Initialize a coverage report
+      # @param repository [Expressir::Model::Repository] The repository to analyze
+      # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+      def initialize(repository, skip_types = [])
+        @repository = repository
+        @skip_types = skip_types
+        @schema_reports = []
+        @total_entities = []
+        @documented_entities = []
+        @undocumented_entities = []
+
+        process_repository
+      end
+
+      # Create a report from a repository
+      # @param repository [Expressir::Model::Repository] The repository to analyze
+      # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+      # @return [Report] The coverage report
+      def self.from_repository(repository, skip_types = [])
+        new(repository, skip_types)
+      end
+
+      # Create a report from a schema file
+      # @param path [String] Path to the schema file
+      # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+      # @return [Report] The coverage report
+      def self.from_file(path, skip_types = [])
+        repository = Expressir::Express::Parser.from_file(path)
+        new(repository, skip_types)
+      end
+
+      # Calculate the overall coverage percentage
+      # @return [Float] The coverage percentage
+      def coverage_percentage
+        return 100.0 if @total_entities.empty?
+
+        (@documented_entities.size.to_f / @total_entities.size) * 100
+      end
+
+      # Get file-level reports
+      # @return [Array<Hash>] Array of file report hashes
+      def file_reports
+        @schema_reports.map do |report|
+          absolute_path = report[:schema].file
+          relative_path = begin
+            Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
+          rescue ArgumentError
+            # If paths are on different drives or otherwise incompatible,
+            # fall back to the absolute path
+            absolute_path
+          end
+
+          {
+            "file" => relative_path,
+            "file_basename" => File.basename(absolute_path),
+            "directory" => File.dirname(absolute_path),
+            "total" => report[:total].size,
+            "documented" => report[:documented].size,
+            "undocumented" => report[:undocumented],
+            "coverage" => report[:coverage],
+          }
+        end
+      end
+
+      # Get directory-level reports
+      # @return [Array<Hash>] Array of directory report hashes
+      def directory_reports
+        # Group by directory (absolute path)
+        by_directory = file_reports.group_by { |r| r["directory"] }
+
+        # Aggregate stats for each directory
+        by_directory.map do |directory, reports|
+          # Convert directory to relative path
+          relative_directory = begin
+            Pathname.new(directory).relative_path_from(Pathname.pwd).to_s
+          rescue ArgumentError
+            # If paths are on different drives or otherwise incompatible,
+            # fall back to the absolute path
+            directory
+          end
+
+          total = reports.sum { |r| r["total"] }
+          documented = reports.sum { |r| r["documented"] }
+          coverage = total.positive? ? (documented.to_f / total) * 100 : 100.0
+
+          {
+            "directory" => relative_directory,
+            "total" => total,
+            "documented" => documented,
+            "undocumented" => total - documented,
+            "coverage" => coverage,
+            "files" => reports.size,
+          }
+        end
+      end
+
+      # Convert report to a hash representation
+      # @return [Hash] The report as a hash
+      def to_h
+        {
+          "overall" => {
+            "total" => @total_entities.size,
+            "documented" => @documented_entities.size,
+            "undocumented" => @undocumented_entities.size,
+            "coverage" => coverage_percentage,
+          },
+          "directories" => directory_reports,
+          "files" => file_reports,
+        }
+      end
+
+      private
+
+      # Process the repository and collect coverage information
+      def process_repository
+        return unless @repository
+
+        @repository.schemas.each do |schema|
+          schema_report = process_schema(schema)
+          @schema_reports << schema_report
+
+          @total_entities.concat(schema_report[:total])
+          @documented_entities.concat(schema_report[:documented])
+          @undocumented_entities.concat(schema_report[:undocumented].map do |entity|
+            { schema: schema.id, entity: entity }
+          end)
+        end
+      end
+
+      # Process a schema and collect coverage information
+      # @param schema [Expressir::Model::Declarations::Schema] The schema to analyze
+      # @return [Hash] A hash with coverage information
+      def process_schema(schema)
+        entities = Expressir::Coverage.find_entities(schema, @skip_types)
+        documented = entities.select { |e| Expressir::Coverage.entity_documented?(e) }
+        undocumented = entities - documented
+
+        coverage = entities.empty? ? 100.0 : (documented.size.to_f / entities.size) * 100
+
+        {
+          schema: schema,
+          total: entities,
+          documented: documented,
+          undocumented: undocumented.map { |e| format_entity(e) },
+          coverage: coverage,
+        }
+      end
+
+      # Format an entity for display
+      # @param entity [Expressir::Model::ModelElement] The entity to format
+      # @return [Hash] A hash with type and name of the entity
+      def format_entity(entity)
+        # Get class name (e.g., "Type" from "Expressir::Model::Declarations::Type")
+        type_name = entity.class.name.split("::").last
+
+        # Convert to EXPRESS convention (e.g., "TYPE")
+        express_type = type_name.upcase
+
+        # Return structured format
+        {
+          "type" => express_type,
+          "name" => entity.id.to_s,
+        }
+      end
+    end
+
+    # Check if an entity has documentation (remarks)
+    # @param entity [Expressir::Model::ModelElement] The entity to check
+    # @return [Boolean] True if the entity has documentation
+    def self.entity_documented?(entity)
+      # Check for direct remarks
+      if entity.respond_to?(:remarks) && entity.remarks && !entity.remarks.empty?
+        return true
+      end
+
+      # Check for remark_items
+      if entity.respond_to?(:remark_items) && entity.remark_items && !entity.remark_items.empty?
+        return true
+      end
+
+      # For schema entities, check if there's a remark_item with their ID
+      if entity.parent.respond_to?(:remark_items) && entity.parent.remark_items
+        entity_id = entity.id.to_s.downcase
+        entity.parent.remark_items.any? do |item|
+          item.id.to_s.downcase == entity_id || item.id.to_s.downcase.include?("#{entity_id}.")
+        end
+      else
+        false
+      end
+    end
+
+    # Find all entities in a schema
+    # @param schema [Expressir::Model::Declarations::Schema] The schema to analyze
+    # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+    # @return [Array<Expressir::Model::ModelElement>] Array of entities
+    def self.find_entities(schema, skip_types = [])
+      entities = []
+
+      # Add all schema-level entities
+      entities.concat(schema.constants) if schema.constants
+      entities.concat(schema.types) if schema.types
+      entities.concat(schema.entities) if schema.entities
+      entities.concat(schema.functions) if schema.functions
+      entities.concat(schema.rules) if schema.rules
+      entities.concat(schema.procedures) if schema.procedures
+      entities.concat(schema.subtype_constraints) if schema.subtype_constraints
+
+      # Add enumeration items from types (only if TYPE is not being skipped)
+      unless skip_types.include?("TYPE")
+        schema.types&.each do |type|
+          if type.respond_to?(:enumeration_items) && type.enumeration_items
+            entities.concat(type.enumeration_items)
+          end
+        end
+      end
+
+      # Filter out any nil elements and ensure all have IDs
+      entities = entities.compact.select { |e| e.respond_to?(:id) && e.id }
+
+      # Filter out skipped entity types
+      if skip_types.any?
+        skip_classes = skip_types.map { |type| ENTITY_TYPE_MAP[type] }.compact
+        entities = entities.reject { |entity| skip_classes.include?(entity.class.name) }
+      end
+
+      entities
+    end
+  end
+end

data/lib/expressir/express/formatter.rb

@@ -219,13 +219,15 @@ module Expressir
                " ",
              ].join
            end,
-          *if node.supertype_attribute && node.id
+          *if node.supertype_attribute && node.id != node.supertype_attribute.attribute.id
              [
                "RENAMED",
                " ",
+               node.id,
+               " ",
              ].join
            end,
-          *if node.id
+          *if node.id && !node.supertype_attribute
              [
                node.id,
                " ",

data/lib/expressir/express/parser.rb

@@ -67,7 +67,7 @@ module Expressir
         end
         rule(:aliasStmt) do
           (tALIAS >> variableId >> tFOR >> generalRef >> qualifier.repeat.as(:qualifier) >>
-           op_delim >> stmt.repeat(1).as(:stmt) >> tEND_ALIAS >> (op_delim.as(:op_delim2))).as(:aliasStmt)
+           op_delim >> stmt.repeat(1).as(:stmt) >> tEND_ALIAS >> op_delim.as(:op_delim2)).as(:aliasStmt)
         end
         rule(:anyKeyword) { KEYWORDS.map { |kw| send("t#{kw}") }.inject(:|) }
         rule(:arrayType) do
@@ -116,7 +116,7 @@ module Expressir
         rule(:element) { (expression >> (op_colon >> repetition).maybe).as(:element) }
         rule(:embeddedRemark) { (str("(*") >> (str("*)").absent? >> (embeddedRemark | any)).repeat >> str("*)")).as(:embeddedRemark) }
         rule(:encodedCharacter) { (octet >> octet >> octet >> octet) }
-        rule(:encodedStringLiteral) { cts((str('"') >> (encodedCharacter.repeat(1)) >> str('"')).as(:str)).as(:encodedStringLiteral) }
+        rule(:encodedStringLiteral) { cts((str('"') >> encodedCharacter.repeat(1) >> str('"')).as(:str)).as(:encodedStringLiteral) }
         rule(:entityBody) do
           (explicitAttr.repeat.as(:explicitAttr) >> deriveClause.maybe >> inverseClause.maybe >> uniqueClause.maybe >> whereClause.maybe).as(:entityBody)
         end
@@ -149,7 +149,7 @@ module Expressir
         rule(:functionHead) do
           (tFUNCTION >> functionId >>
            (op_leftparen >> (formalParameter >> (op_delim >> formalParameter).repeat).as(:listOf_formalParameter) >> op_rightparen).maybe >>
-           op_colon >> parameterType >> (op_delim.as(:op_delim2))).as(:functionHead)
+           op_colon >> parameterType >> op_delim.as(:op_delim2)).as(:functionHead)
         end
         rule(:functionId) { simpleId.as(:functionId) }
         rule(:functionRef) { functionId.as(:functionRef) }
@@ -181,7 +181,7 @@ module Expressir
         rule(:intervalItem) { simpleExpression.as(:intervalItem) }
         rule(:intervalLow) { simpleExpression.as(:intervalLow) }
         rule(:interval) do
-          (op_left_curly_brace >> intervalLow >> intervalOp >> intervalItem >> (intervalOp.as(:intervalOp2)) >>
+          (op_left_curly_brace >> intervalLow >> intervalOp >> intervalItem >> intervalOp.as(:intervalOp2) >>
            intervalHigh >> op_right_curly_brace).as(:interval)
         end
         rule(:intervalOp) { (op_less_equal | op_less_than).as(:intervalOp) }
@@ -256,7 +256,7 @@ module Expressir
         rule(:procedureHead) do
           (tPROCEDURE >> procedureId >>
            (op_leftparen >> (procedureHeadParameter >>
-                             (op_delim >> procedureHeadParameter).repeat).as(:listOf_procedureHeadParameter) >> op_rightparen).maybe >> (op_delim.as(:op_delim2))).as(:procedureHead)
+                             (op_delim >> procedureHeadParameter).repeat).as(:listOf_procedureHeadParameter) >> op_rightparen).maybe >> op_delim.as(:op_delim2)).as(:procedureHead)
         end
         rule(:procedureId) { simpleId.as(:procedureId) }
         rule(:procedureRef) { procedureId.as(:procedureRef) }
@@ -281,7 +281,7 @@ module Expressir
         end
         rule(:renameId) { (constantId | entityId | functionId | procedureId | typeId).as(:renameId) }
         rule(:repeatControl) { (incrementControl.maybe >> whileControl.maybe >> untilControl.maybe).as(:repeatControl) }
-        rule(:repeatStmt) { (tREPEAT >> repeatControl >> op_delim >> stmt.repeat(1).as(:stmt) >> tEND_REPEAT >> (op_delim.as(:op_delim2))).as(:repeatStmt) }
+        rule(:repeatStmt) { (tREPEAT >> repeatControl >> op_delim >> stmt.repeat(1).as(:stmt) >> tEND_REPEAT >> op_delim.as(:op_delim2)).as(:repeatStmt) }
         rule(:repetition) { numericExpression.as(:repetition) }
         rule(:resourceOrRename) { (resourceRef >> (tAS >> renameId).maybe).as(:resourceOrRename) }
         rule(:resourceRef) { (constantRef | entityRef | functionRef | procedureRef | typeRef).as(:resourceRef) }
@@ -301,7 +301,7 @@ module Expressir
            schemaBodyDeclaration.repeat.as(:schemaBodyDeclaration)).as(:schemaBody)
         end
         rule(:schemaDecl) do
-          (tSCHEMA >> schemaId >> schemaVersionId.maybe >> op_delim >> schemaBody >> tEND_SCHEMA >> (op_delim.as(:op_delim2))).as(:schemaDecl)
+          (tSCHEMA >> schemaId >> schemaVersionId.maybe >> op_delim >> schemaBody >> tEND_SCHEMA >> op_delim.as(:op_delim2)).as(:schemaDecl)
         end
         rule(:schemaId) { simpleId.as(:schemaId) }
         rule(:schemaRef) { schemaId.as(:schemaRef) }
@@ -353,7 +353,7 @@ module Expressir
           (tTOTAL_OVER >> op_leftparen >> (entityRef >> (op_comma >> entityRef).repeat).as(:listOf_entityRef) >> op_rightparen >> op_delim).as(:totalOver)
         end
         rule(:typeDecl) do
-          (tTYPE >> typeId >> op_equals >> underlyingType >> op_delim >> whereClause.maybe >> tEND_TYPE >> (op_delim.as(:op_delim2))).as(:typeDecl)
+          (tTYPE >> typeId >> op_equals >> underlyingType >> op_delim >> whereClause.maybe >> tEND_TYPE >> op_delim.as(:op_delim2)).as(:typeDecl)
         end
         rule(:typeId) { simpleId.as(:typeId) }
         rule(:typeLabelId) { simpleId.as(:typeLabelId) }
@@ -363,7 +363,7 @@ module Expressir
         rule(:unaryOp) { (op_plus | op_minus | tNOT).as(:unaryOp) }
         rule(:underlyingType) { (concreteTypes | constructedTypes).as(:underlyingType) }
         rule(:uniqueClause) do
-          (tUNIQUE >> (uniqueRule >> op_delim >> (uniqueRule >> (op_delim.as(:op_delim2))).repeat).as(:listOf_uniqueRule)).as(:uniqueClause)
+          (tUNIQUE >> (uniqueRule >> op_delim >> (uniqueRule >> op_delim.as(:op_delim2)).repeat).as(:listOf_uniqueRule)).as(:uniqueClause)
         end
         rule(:uniqueRule) do
           ((ruleLabelId >> op_colon).maybe >> (referencedAttribute >> (op_comma >> referencedAttribute).repeat).as(:listOf_referencedAttribute)).as(:uniqueRule)

data/lib/expressir/express/visitor.rb

@@ -88,7 +88,7 @@ module Expressir
           private_methods.grep(/^visit_/).map do |name|
             rulename = name.to_s.sub(/^visit_/, "").gsub(/_([a-z])/) { $1.upcase }
             [rulename.to_sym, name.to_sym]
-          end
+          end,
         ]
       end
 
@@ -104,7 +104,7 @@ module Expressir
               else
                 [k, to_ctx(v, k)]
               end
-            end
+            end,
           ]
           Ctx.new nodes, name
         when Array
@@ -581,7 +581,13 @@ module Expressir
         ctx__redeclared_attribute__qualified_attribute = ctx__redeclared_attribute&.qualified_attribute
         ctx__redeclared_attribute__attribute_id = ctx__redeclared_attribute&.attribute_id
 
-        id = visit_if(ctx__attribute_id || ctx__redeclared_attribute__attribute_id)
+        attribute_qualifier = ctx__redeclared_attribute__qualified_attribute&.attribute_qualifier
+        attribute_id = attribute_qualifier&.attribute_ref&.attribute_id
+        ctx__redeclared_attribute__qualified_attribute__attribute_qualifier_attribute_id = attribute_id
+
+        id = visit_if(ctx__attribute_id ||
+          ctx__redeclared_attribute__attribute_id ||
+            ctx__redeclared_attribute__qualified_attribute__attribute_qualifier_attribute_id)
         supertype_attribute = visit_if(ctx__redeclared_attribute__qualified_attribute)
 
         Model::Declarations::Attribute.new(
@@ -806,9 +812,8 @@ module Expressir
         type = visit_if(ctx__parameter_type)
         expression = visit_if(ctx__expression)
 
-        Model::Declarations::Attribute.new(
-          id: attribute.id, # reuse
-          kind: Model::Declarations::Attribute::DERIVED,
+        Model::Declarations::DerivedAttribute.new(
+          id: attribute.id,
           supertype_attribute: attribute.supertype_attribute, # reuse
           type: type,
           expression: expression,
@@ -1428,9 +1433,8 @@ module Expressir
                        visit(ctx__attribute_ref)
                      end
 
-        Model::Declarations::Attribute.new(
+        Model::Declarations::InverseAttribute.new(
           id: attribute.id, # reuse
-          kind: Model::Declarations::Attribute::INVERSE,
           supertype_attribute: attribute.supertype_attribute, # reuse
           type: type,
           expression: expression,

data/lib/expressir/model/declarations/derived_attribute.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.1 Attributes
+      class DerivedAttribute < Attribute
+        include Identifier
+
+        DERIVED = "DERIVED".freeze
+
+        attribute :kind, :string, default: -> { DERIVED }
+        attribute :_class, :string, default: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "kind", to: :kind, render_default: true
+          map "supertype_attribute", to: :supertype_attribute
+          map "optional", to: :optional
+          map "type", to: :type
+          map "expression", to: :expression
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/inverse_attribute.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.1 Attributes
+      class InverseAttribute < Attribute
+        include Identifier
+
+        INVERSE = "INVERSE".freeze
+
+        attribute :kind, :string, default: -> { INVERSE }
+        attribute :_class, :string, default: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "kind", to: :kind, render_default: true
+          map "supertype_attribute", to: :supertype_attribute
+          map "optional", to: :optional
+          map "type", to: :type
+          map "expression", to: :expression
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/model_element.rb

@@ -56,6 +56,8 @@ module Expressir
             "Expressir::Model::DataTypes::Set",
                         "Expressir::Model::DataTypes::String" =>
             "Expressir::Model::DataTypes::String",
+                        "Expressir::Model::Declarations::DerivedAttribute" =>
+            "Expressir::Model::Declarations::DerivedAttribute",
                         "Expressir::Model::Declarations::Attribute" =>
             "Expressir::Model::Declarations::Attribute",
                         "Expressir::Model::Declarations::Constant" =>

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.1.17".freeze
+  VERSION = "2.1.19".freeze
 end

data/lib/expressir.rb

@@ -3,6 +3,7 @@ require_relative "expressir/version"
 require_relative "expressir/cli"
 require_relative "expressir/config"
 require_relative "expressir/benchmark"
+require_relative "expressir/coverage"
 require "lutaml/model"
 require "liquid" # To enable Lutaml::Model::Liquefiable
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.1.17
+  version: 2.1.19
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-24 00:00:00.000000000 Z
+date: 2025-06-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -142,10 +184,18 @@ files:
 - lib/expressir.rb
 - lib/expressir/benchmark.rb
 - lib/expressir/cli.rb
+- lib/expressir/commands/base.rb
+- lib/expressir/commands/benchmark.rb
+- lib/expressir/commands/benchmark_cache.rb
+- lib/expressir/commands/clean.rb
+- lib/expressir/commands/coverage.rb
+- lib/expressir/commands/format.rb
+- lib/expressir/commands/validate.rb
+- lib/expressir/commands/version.rb
 - lib/expressir/config.rb
+- lib/expressir/coverage.rb
 - lib/expressir/express/cache.rb
 - lib/expressir/express/error.rb
-- lib/expressir/express/express_remarks_decorator.rb
 - lib/expressir/express/formatter.rb
 - lib/expressir/express/hyperlink_formatter.rb
 - lib/expressir/express/model_visitor.rb
@@ -175,11 +225,13 @@ files:
 - lib/expressir/model/data_types/string.rb
 - lib/expressir/model/declarations/attribute.rb
 - lib/expressir/model/declarations/constant.rb
+- lib/expressir/model/declarations/derived_attribute.rb
 - lib/expressir/model/declarations/entity.rb
 - lib/expressir/model/declarations/function.rb
 - lib/expressir/model/declarations/interface.rb
 - lib/expressir/model/declarations/interface_item.rb
 - lib/expressir/model/declarations/interfaced_item.rb
+- lib/expressir/model/declarations/inverse_attribute.rb
 - lib/expressir/model/declarations/parameter.rb
 - lib/expressir/model/declarations/procedure.rb
 - lib/expressir/model/declarations/remark_item.rb

data/lib/expressir/express/express_remarks_decorator.rb

@@ -1,54 +0,0 @@
-module Expressir
-  module Express
-    class ExpressRemarksDecorator
-      RELATIVE_PREFIX_MACRO_REGEXP = /^(link|image|video|audio|include)(:+)?(?![^\/:]+:\/\/|[A-Z]:\/|\/)([^:\[]+)(\[.*\])?$/.freeze
-
-      attr_reader :remark, :options
-
-      def self.call(remark, options)
-        new(remark, options).call
-      end
-
-      def initialize(remark, options)
-        @remark = remark
-        @options = options
-      end
-
-      def call
-        result = remark
-        if options["relative_path_prefix"]
-          result = update_relative_paths(result,
-                                         options["relative_path_prefix"])
-        end
-        result
-      end
-
-      private
-
-      def update_relative_paths(string, path_prefix)
-        string
-          .split("\n")
-          .map do |line|
-            if line.match?(RELATIVE_PREFIX_MACRO_REGEXP)
-              prefix_relative_paths(line, path_prefix)
-            else
-              line
-            end
-          end
-          .join("\n")
-      end
-
-      def prefix_relative_paths(line, path_prefix)
-        line.gsub(RELATIVE_PREFIX_MACRO_REGEXP) do |_match|
-          prefixed_path = File.join(path_prefix, $3.strip)
-          # When we are dealing with a relative path of a template:
-          # ../path/to/file we need to transform it into
-          # the absolute one because `image::` macro wont understand it other way
-          prefixed_path = File.absolute_path(prefixed_path) if prefixed_path.start_with?("../")
-          full_path = File.expand_path(prefixed_path)
-          "#{$1}#{$2}#{full_path}#{$4}"
-        end
-      end
-    end
-  end
-end