expressir 1.3.3-x86_64-linux-musl

data/lib/expressir/model/statement.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Model
+    # Specified in ISO 10303-11:2004
+    # - section 13 Executable statements
+    # @abstract
+    class Statement < ModelElement
+    end
+  end
+end

data/lib/expressir/model/statements/alias.rb

@@ -0,0 +1,35 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.2 Alias statement
+      class Alias < Statement
+        include Identifier
+
+        model_attr_accessor :expression, 'Expression'
+        model_attr_accessor :statements, 'Array<Statement>'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Expression] :expression
+        # @option options [Array<Statement>] :statements
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @expression = options[:expression]
+          @statements = options[:statements] || []
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            self,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/assignment.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.3 Assignment
+      class Assignment < Statement
+        model_attr_accessor :ref, 'Reference'
+        model_attr_accessor :expression, 'Expression'
+
+        # @param [Hash] options
+        # @option options [Reference] :ref
+        # @option options [Expression] :expression
+        def initialize(options = {})
+          @ref = options[:ref]
+          @expression = options[:expression]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/case.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.4 Case statement
+      class Case < Statement
+        model_attr_accessor :expression, 'Expression'
+        model_attr_accessor :actions, 'Array<CaseAction>'
+        model_attr_accessor :otherwise_statement, 'Statement'
+
+        # @param [Hash] options
+        # @option options [Expression] :expression
+        # @option options [Array<CaseAction>] :statements
+        # @option options [Statement] :otherwise_statement
+        def initialize(options = {})
+          @expression = options[:expression]
+          @actions = options[:actions] || []
+          @otherwise_statement = options[:otherwise_statement]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/case_action.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.4 Case statement
+      class CaseAction < ModelElement
+        model_attr_accessor :labels, 'Array<Expression>'
+        model_attr_accessor :statement, 'Statement'
+
+        # @param [Hash] options
+        # @option options [Array<Expression>] :labels
+        # @option options [Statement] :statement
+        def initialize(options = {})
+          @labels = options[:labels] || []
+          @statement = options[:statement]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/compound.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.5 Compound statement
+      class Compound < Statement
+        model_attr_accessor :statements, 'Array<Statement>'
+
+        # @param [Hash] options
+        # @option options [Array<Statement>] :statements
+        def initialize(options = {})
+          @statements = options[:statements] || []
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/escape.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.6 Escape statement
+      class Escape < Statement
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/if.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.7 If ... Then ... Else statement
+      class If < Statement
+        model_attr_accessor :expression, 'Expression'
+        model_attr_accessor :statements, 'Array<Statement>'
+        model_attr_accessor :else_statements, 'Array<Statement>'
+
+        # @param [Hash] options
+        # @option options [Expression] :expression
+        # @option options [Array<Statement>] :statements
+        # @option options [Array<Statement>] :else_statements
+        def initialize(options = {})
+          @expression = options[:expression]
+          @statements = options[:statements] || []
+          @else_statements = options[:else_statements] || []
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/null.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.1 Null (statement)
+      class Null < Statement
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/procedure_call.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.8 Procedure call statement
+      class ProcedureCall < Statement
+        model_attr_accessor :procedure, 'Reference'
+        model_attr_accessor :parameters, 'Array<Expression>'
+
+        # @param [Hash] options
+        # @option options [Reference] :procedure
+        # @option options [Array<Expression>] :parameters
+        def initialize(options = {})
+          @procedure = options[:procedure]
+          @parameters = options[:parameters] || []
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/repeat.rb

@@ -0,0 +1,47 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.9 Repeat statement
+      class Repeat < Statement
+        include Identifier
+
+        model_attr_accessor :bound1, 'Expression'
+        model_attr_accessor :bound2, 'Expression'
+        model_attr_accessor :increment, 'Expression'
+        model_attr_accessor :while_expression, 'Expression'
+        model_attr_accessor :until_expression, 'Expression'
+        model_attr_accessor :statements, 'Array<Statement>'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Expression] :bound1
+        # @option options [Expression] :bound2
+        # @option options [Expression] :increment
+        # @option options [Expression] :while_expression
+        # @option options [Expression] :until_expression
+        # @option options [Array<Statement>] :statements
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @bound1 = options[:bound1]
+          @bound2 = options[:bound2]
+          @increment = options[:increment]
+          @while_expression = options[:while_expression]
+          @until_expression = options[:until_expression]
+          @statements = options[:statements] || []
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            self,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/return.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.10 Return statement
+      class Return < Statement
+        model_attr_accessor :expression, 'Expression'
+
+        # @param [Hash] options
+        # @option options [Expression] :expression
+        def initialize(options = {})
+          @expression = options[:expression]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/statements/skip.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.11 Skip statement
+      class Skip < Statement
+      end
+    end
+  end
+end

data/lib/expressir/model/supertype_expression.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Model
+    # Specified in ISO 10303-11:2004
+    # - section 9.2.5 Subtype/supertype constraints
+    # @abstract
+    class SupertypeExpression < ModelElement
+    end
+  end
+end

data/lib/expressir/model/supertype_expressions/binary_supertype_expression.rb

@@ -0,0 +1,29 @@
+module Expressir
+  module Model
+    module SupertypeExpressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.5.3 ANDOR
+      # - section 9.2.5.4 AND
+      class BinarySupertypeExpression < SupertypeExpression
+        AND = :AND
+        ANDOR = :ANDOR
+
+        model_attr_accessor :operator, ':AND, :ANDOR'
+        model_attr_accessor :operand1, 'SupertypeExpression'
+        model_attr_accessor :operand2, 'SupertypeExpression'
+
+        # @param [Hash] options
+        # @option options [:AND, :ANDOR] :operator
+        # @option options [SupertypeExpression] :operand1
+        # @option options [SupertypeExpression] :operand2
+        def initialize(options = {})
+          @operator = options[:operator]
+          @operand1 = options[:operand1]
+          @operand2 = options[:operand2]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/supertype_expressions/oneof_supertype_expression.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module SupertypeExpressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.5.2 ONEOF
+      class OneofSupertypeExpression < SupertypeExpression
+        model_attr_accessor :operands, 'Array<SupertypeExpression>'
+
+        # @param [Hash] options
+        # @option options [Array<SupertypeExpression>] :operands
+        def initialize(options = {})
+          @operands = options[:operands]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model.rb

@@ -0,0 +1,79 @@
+require "expressir/model/model_element"
+
+require "expressir/model/cache"
+require "expressir/model/data_type"
+require "expressir/model/declaration"
+require "expressir/model/expression"
+require "expressir/model/identifier"
+require "expressir/model/literal"
+require "expressir/model/reference"
+require "expressir/model/repository"
+require "expressir/model/statement"
+require "expressir/model/supertype_expression"
+require "expressir/model/data_types/aggregate"
+require "expressir/model/data_types/array"
+require "expressir/model/data_types/bag"
+require "expressir/model/data_types/binary"
+require "expressir/model/data_types/boolean"
+require "expressir/model/data_types/enumeration"
+require "expressir/model/data_types/enumeration_item"
+require "expressir/model/data_types/generic_entity"
+require "expressir/model/data_types/generic"
+require "expressir/model/data_types/integer"
+require "expressir/model/data_types/list"
+require "expressir/model/data_types/logical"
+require "expressir/model/data_types/number"
+require "expressir/model/data_types/real"
+require "expressir/model/data_types/set"
+require "expressir/model/data_types/select"
+require "expressir/model/data_types/string"
+require "expressir/model/declarations/attribute"
+require "expressir/model/declarations/constant"
+require "expressir/model/declarations/entity"
+require "expressir/model/declarations/function"
+require "expressir/model/declarations/interface"
+require "expressir/model/declarations/interface_item"
+require "expressir/model/declarations/interfaced_item"
+require "expressir/model/declarations/parameter"
+require "expressir/model/declarations/procedure"
+require "expressir/model/declarations/remark_item"
+require "expressir/model/declarations/rule"
+require "expressir/model/declarations/schema"
+require "expressir/model/declarations/schema_version"
+require "expressir/model/declarations/schema_version_item"
+require "expressir/model/declarations/subtype_constraint"
+require "expressir/model/declarations/type"
+require "expressir/model/declarations/unique_rule"
+require "expressir/model/declarations/variable"
+require "expressir/model/declarations/where_rule"
+require "expressir/model/expressions/aggregate_initializer"
+require "expressir/model/expressions/aggregate_initializer_item"
+require "expressir/model/expressions/binary_expression"
+require "expressir/model/expressions/entity_constructor"
+require "expressir/model/expressions/function_call"
+require "expressir/model/expressions/interval"
+require "expressir/model/expressions/query_expression"
+require "expressir/model/expressions/unary_expression"
+require "expressir/model/literals/binary"
+require "expressir/model/literals/integer"
+require "expressir/model/literals/logical"
+require "expressir/model/literals/real"
+require "expressir/model/literals/string"
+require "expressir/model/references/attribute_reference"
+require "expressir/model/references/group_reference"
+require "expressir/model/references/index_reference"
+require "expressir/model/references/simple_reference"
+require "expressir/model/statements/alias"
+require "expressir/model/statements/assignment"
+require "expressir/model/statements/case"
+require "expressir/model/statements/case_action"
+require "expressir/model/statements/compound"
+require "expressir/model/statements/escape"
+require "expressir/model/statements/if"
+require "expressir/model/statements/null"
+require "expressir/model/statements/procedure_call"
+require "expressir/model/statements/repeat"
+require "expressir/model/statements/return"
+require "expressir/model/statements/skip"
+require "expressir/model/supertype_expressions/binary_supertype_expression"
+require "expressir/model/supertype_expressions/oneof_supertype_expression"

data/lib/expressir/version.rb

@@ -0,0 +1,3 @@
+module Expressir
+  VERSION = "1.3.3".freeze
+end

data/lib/expressir.rb

@@ -0,0 +1,44 @@
+require "expressir/version"
+
+require "expressir/cli"
+require "expressir/config"
+
+Dir[File.join(__dir__, "expressir", "express", "*.rb")].sort.each do |fea|
+  require fea
+end
+
+# ..........................................................
+# https://bugs.ruby-lang.org/issues/19319
+# The issue is that this bug is fixed for 3.1 and above,
+# but not for 3.0 or 2.7, so we need a "safe" function
+# ..........................................................
+
+if RUBY_VERSION < "3.1"
+  class String
+    def safe_downcase
+      each_char.map(&:downcase).join
+    end
+  end
+else
+  class String
+    def safe_downcase
+      downcase
+    end
+  end
+end
+
+module Expressir
+  class Error < StandardError; end
+
+  def self.ui
+    Expressir::Cli::UI
+  end
+
+  def self.root
+    File.dirname(__dir__)
+  end
+
+  def self.root_path
+    @root_path ||= Pathname.new(Expressir.root)
+  end
+end

data/rakelib/antlr4-native.rake

@@ -0,0 +1,173 @@
+require "fileutils"
+require "antlr4-native"
+require "rake"
+
+def create_class_declarations(parser_source_lines)
+  i = parser_source_lines.index { |x| x == "Class rb_cContextProxy;" }
+  parser_source_lines[i] += <<~CPP.split("\n").map { |x| x == "" ? x : x.to_s }.join("\n")
+
+    Class rb_cParserExt;
+    Class rb_cTokenExt;
+
+  CPP
+end
+
+def create_tp_class_definition(parser_source_lines)
+  i = parser_source_lines.index { |x| x == "class ContextProxy {" }
+  parser_source_lines[i - 2] += <<~CPP.split("\n").map { |x| x == "" ? x : x.to_s }.join("\n")
+
+
+    class TokenProxy : public Object {
+      public:
+        TokenProxy(Token* orig) {
+          this -> orig = orig;
+        }
+
+        std::string getText() {
+          return orig->getText();
+        }
+
+        size_t getChannel() {
+          return orig->getChannel();
+        }
+
+        size_t getTokenIndex() {
+          return orig->getTokenIndex();
+        }
+
+      private:
+        Token * orig = nullptr;
+    };
+
+  CPP
+end
+
+def create_pp_class_definition(parser_source_lines)
+  i = parser_source_lines.index { |x| x == "extern \"C\"" }
+  parser_source_lines[i - 2] += <<~CPP.split("\n").map { |x| x == "" ? x : x.to_s }.join("\n")
+
+    class ParserProxyExt : public Object {
+      public:
+        ParserProxyExt(string file) {
+          ifstream stream;
+          stream.open(file);
+          input = new ANTLRInputStream(stream);
+          lexer = new ExpressLexer(input);
+          tokens = new CommonTokenStream(lexer);
+          parser = new ExpressParser(tokens);
+          stream.close();
+        };
+
+        ~ParserProxyExt() {
+          delete parser;
+          delete tokens;
+          delete lexer;
+          delete input;
+        }
+
+        Object syntax() {
+          auto ctx = parser -> syntax();
+
+          SyntaxContextProxy proxy((ExpressParser::SyntaxContext*) ctx);
+          return detail::To_Ruby<SyntaxContextProxy>().convert(proxy);
+        }
+
+        Object getTokens() {
+          std::vector<TokenProxy> tk;
+          for (auto token : tokens -> getTokens()) {
+            tk.push_back(TokenProxy(token));
+          }
+          return detail::To_Ruby<std::vector<TokenProxy>>().convert(tk);
+        }
+
+        Object visit(VisitorProxy* visitor) {
+          auto result = visitor -> visit(parser -> syntax());
+
+          lexer -> reset();
+          parser -> reset();
+
+          try {
+            return std::any_cast<Object>(result);
+          } catch(std::bad_any_cast) {
+            return Qnil;
+          }
+        }
+
+      private:
+        ANTLRInputStream* input;
+        ExpressLexer* lexer;
+        CommonTokenStream* tokens;
+        ExpressParser* parser;
+    };
+
+
+  CPP
+end
+
+def create_class_api(parser_source_lines)
+  i = parser_source_lines.index { |x| x == "    .define_method(\"visit\", &ParserProxy::visit);" }
+  parser_source_lines[i] += <<~CPP.split("\n").map { |x| x == "" ? x : "  #{x}" }.join("\n")
+
+
+    rb_cTokenExt = define_class_under<TokenProxy>(rb_mExpressParser, "TokenExt")
+      .define_method("text", &TokenProxy::getText)
+      .define_method("channel", &TokenProxy::getChannel)
+      .define_method("token_index", &TokenProxy::getTokenIndex);
+
+    rb_cParserExt = define_class_under<ParserProxyExt>(rb_mExpressParser, "ParserExt")
+      .define_constructor(Constructor<ParserProxyExt, string>())
+      .define_method("syntax", &ParserProxyExt::syntax)
+      .define_method("tokens", &ParserProxyExt::getTokens, Return().keepAlive())
+      .define_method("visit", &ParserProxyExt::visit);
+
+    define_vector<std::vector<TokenProxy>>("TokenVector");
+
+  CPP
+end
+
+def create_vector_definition(parser_source_lines)
+  i = parser_source_lines.index { |x| x == "    .define_method(\"visit\", &ParserProxy::visit);" }
+  parser_source_lines[i] += <<~CPP.split("\n").map { |x| x == "" ? x : "  #{x}" }.join("\n")
+
+  CPP
+end
+
+def generate_extended_parser
+  # Generate extended parser that provide Ruby access to token stream
+  parser_source_file = File.join("ext", "express_parser", "express_parser.cpp")
+  parser_source_lines = File.read(parser_source_file)
+    .gsub!("bad_cast", "bad_any_cast")
+    .gsub!("return detail::To_Ruby<Token*>().convert(token)", "return detail::To_Ruby<TokenProxy>().convert(TokenProxy(token))")
+    .split("\n")
+  create_class_declarations(parser_source_lines)
+  create_tp_class_definition(parser_source_lines)
+  create_pp_class_definition(parser_source_lines)
+  create_class_api(parser_source_lines)
+  File.write(parser_source_file, "#{parser_source_lines.join("\n")}\n")
+end
+
+desc "Generate parser  (Usage: 'rake generate <grammar_file>')"
+task "generate" do
+  grammar_file = ARGV[1]
+  if grammar_file.nil?
+    grammar_file = File.expand_path(File.join("..", "ext", "express-grammar", "Express.g4"), __dir__)
+  end
+
+  puts "Generating parser from '#{grammar_file}'"
+  # ANTLR does weird things if the grammar file isn't in the current working directory
+  temp_grammar_file = File.join(FileUtils.pwd, File.basename(grammar_file))
+  FileUtils.cp(grammar_file, temp_grammar_file)
+
+  # generate parser
+  generator = Antlr4Native::Generator.new(
+    grammar_files: [File.basename(temp_grammar_file)],
+    output_dir: "ext",
+    parser_root_method: "syntax",
+  )
+  generator.generate
+
+  puts "Generating extended parser"
+  generate_extended_parser
+  # cleanup
+  FileUtils.rm(temp_grammar_file)
+end