expressir 2.1.30 → 2.2.0

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

@@ -0,0 +1,224 @@
+module Expressir
+  module Express
+    module StatementsFormatter
+      private
+
+      def format_statements_alias(node)
+        [
+          [
+            "ALIAS",
+            " ",
+            node.id,
+            " ",
+            "FOR",
+            " ",
+            format(node.expression),
+            ";",
+          ].join,
+          *if node.statements&.length&.positive?
+             indent(node.statements.map { |x| format(x) }.join("\n"))
+           end,
+          *format_remarks(node),
+          [
+            "END_ALIAS",
+            ";",
+          ].join,
+        ].join("\n")
+      end
+
+      def format_statements_assignment(node)
+        [
+          format(node.ref),
+          " ",
+          ":=",
+          " ",
+          format(node.expression),
+          ";",
+        ].join
+      end
+
+      def format_statements_procedure_call(node)
+        [
+          format(node.procedure),
+          *if node.parameters&.length&.positive?
+             [
+               "(",
+               node.parameters.map { |x| format(x) }.join(", "),
+               ")",
+             ].join
+           end,
+          ";",
+        ].join
+      end
+
+      def format_statements_case(node)
+        [
+          [
+            "CASE",
+            " ",
+            format(node.expression),
+            " ",
+            "OF",
+          ].join,
+          *if node.actions&.length&.positive?
+             node.actions.map { |x| format(x) }
+           end,
+          *if node.otherwise_statement
+             [
+               [
+                 "OTHERWISE",
+                 " ",
+                 ":",
+               ].join,
+               indent(format(node.otherwise_statement)),
+             ]
+           end,
+          [
+            "END_CASE",
+            ";",
+          ].join,
+        ].join("\n")
+      end
+
+      def format_statements_case_action(node)
+        node.labels ||= []
+        [
+          [
+            node.labels.map { |x| format(x) }.join(", "),
+            " ",
+            ":",
+          ].join,
+          indent(format(node.statement)),
+        ].join("\n")
+      end
+
+      def format_statements_compound(node)
+        node.statements ||= []
+        [
+          "BEGIN",
+          *if node.statements&.length&.positive?
+             indent(node.statements.map { |x| format(x) }.join("\n"))
+           end,
+          [
+            "END",
+            ";",
+          ].join,
+        ].join("\n")
+      end
+
+      def format_statements_escape(_node)
+        [
+          "ESCAPE",
+          ";",
+        ].join
+      end
+
+      def format_statements_if(node)
+        [
+          [
+            "IF",
+            " ",
+            format(node.expression),
+            " ",
+            "THEN",
+          ].join,
+          *if node.statements&.length&.positive?
+             indent(node.statements.map { |x| format(x) }.join("\n"))
+           end,
+          *if node.else_statements&.length&.positive?
+             [
+               "ELSE",
+               indent(node.else_statements.map { |x| format(x) }.join("\n")),
+             ].join("\n")
+           end,
+          [
+            "END_IF",
+            ";",
+          ].join,
+        ].join("\n")
+      end
+
+      def format_statements_null(_node)
+        ";"
+      end
+
+      def format_statements_repeat(node)
+        node.statements ||= []
+        [
+          [
+            "REPEAT",
+            *if node.id
+               [
+                 " ",
+                 node.id,
+                 " ",
+                 ":=",
+                 " ",
+                 format(node.bound1),
+                 " ",
+                 "TO",
+                 " ",
+                 format(node.bound2),
+                 *if node.increment
+                    [
+                      " ",
+                      "BY",
+                      " ",
+                      format(node.increment),
+                    ].join
+                  end,
+               ].join
+             end,
+            *if node.while_expression
+               [
+                 " ",
+                 "WHILE",
+                 " ",
+                 format(node.while_expression),
+               ].join
+             end,
+            *if node.until_expression
+               [
+                 " ",
+                 "UNTIL",
+                 " ",
+                 format(node.until_expression),
+               ].join
+             end,
+            ";",
+          ].join,
+          *if node.statements&.length&.positive?
+             indent(node.statements.map { |x| format(x) }.join("\n"))
+           end,
+          *format_remarks(node),
+          [
+            "END_REPEAT",
+            ";",
+          ].join,
+        ].join("\n")
+      end
+
+      def format_statements_return(node)
+        [
+          "RETURN",
+          *if node.expression
+             [
+               " ",
+               "(",
+               format(node.expression),
+               ")",
+             ].join
+           end,
+          ";",
+        ].join
+      end
+
+      def format_statements_skip(_node)
+        [
+          "SKIP",
+          ";",
+        ].join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Expressir
+  module Express
+    module SupertypeExpressionsFormatter
+      private
+
+      def format_supertype_expressions_binary_supertype_expression(node)
+        supertype_precedence = self.class.const_get(:SUPERTYPE_OPERATOR_PRECEDENCE)
+        op1_higher_precedence = node.operand1.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
+          (supertype_precedence[node.operand1.operator] > supertype_precedence[node.operator])
+        op2_higher_precedence = node.operand2.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression) &&
+          (supertype_precedence[node.operand2.operator] > supertype_precedence[node.operator])
+
+        [
+          *if op1_higher_precedence
+             "("
+           end,
+          format(node.operand1),
+          *if op1_higher_precedence
+             ")"
+           end,
+          " ",
+          case node.operator
+          when Model::SupertypeExpressions::BinarySupertypeExpression::AND then "AND"
+          when Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR then "ANDOR"
+          end,
+          " ",
+          *if op2_higher_precedence
+             "("
+           end,
+          format(node.operand2),
+          *if op2_higher_precedence
+             ")"
+           end,
+        ].join
+      end
+
+      def format_supertype_expressions_oneof_supertype_expression(node)
+        node.operands ||= []
+        [
+          "ONEOF",
+          "(",
+          node.operands.map { |x| format(x) }.join(", "),
+          ")",
+        ].join
+      end
+    end
+  end
+end

data/lib/expressir/express/parser.rb

@@ -1,12 +1,79 @@
-require "parslet"
+require "parsanol"
 require_relative "error"
+require_relative "builder"
+require_relative "builders"
+require_relative "remark_attacher"
+require_relative "streaming_builder"
 
 module Expressir
   module Express
     class Parser
-      class Parser < Parslet::Parser
+      class Parser < Parsanol::Parser
         root(:syntax)
 
+        # Cache for native parser grammar (class-level)
+        @@cached_grammar_json = nil
+        @@cached_grammar_atom_id = nil
+
+        # Cache for parser instance (avoids ~7ms overhead of Parser.new)
+        @@cached_parser = nil
+        @@parser_mutex = Mutex.new
+
+        # Get cached parser instance (thread-safe)
+        # Reusing the parser avoids the overhead of reinitializing all rule definitions
+        def self.cached_parser
+          return @@cached_parser if @@cached_parser
+
+          @@parser_mutex.synchronize do
+            @@cached_parser ||= new
+          end
+        end
+
+        # Clear the cached parser (useful for testing or after grammar changes)
+        def self.clear_parser_cache
+          @@parser_mutex.synchronize do
+            @@cached_parser = nil
+          end
+        end
+
+        # Check if native parsing is available
+        def self.native_available?
+          return @native_available unless @native_available.nil?
+
+          @native_available = begin
+            require "parsanol/native"
+            Parsanol::Native.available?
+          rescue LoadError
+            false
+          end
+        end
+
+        # Get cached grammar JSON for native parsing
+        def self.cached_grammar_json
+          return @@cached_grammar_json if @@cached_grammar_json
+
+          parser = new
+          atom = parser.syntax
+
+          # Cache by atom object_id
+          if atom.object_id != @@cached_grammar_atom_id
+            @@cached_grammar_atom_id = atom.object_id
+            @@cached_grammar_json = Parsanol::Native.serialize_grammar(atom)
+          end
+
+          @@cached_grammar_json
+        end
+
+        # Parse using native engine (with caching)
+        def self.parse_native(source)
+          unless native_available?
+            raise LoadError, "Native parser not available"
+          end
+
+          # Use Parsanol 2.0 API - parse returns Slice objects with position info
+          new.parse(source, mode: :native)
+        end
+
         def cts(atom)
           spaces >> atom
         end
@@ -610,15 +677,14 @@ module Expressir
           schema_file = root_path ? Pathname.new(file.to_s).relative_path_from(root_path).to_s : file.to_s
 
           begin
-            ast = Parser.new.parse source
-          rescue Parslet::ParseFailed => e
+            ast = Parser.cached_parser.parse source
+          rescue Parsanol::ParseFailed => e
             # Instead of just printing, raise a proper error with file context
             raise Error::SchemaParseFailure.new(schema_file, e)
           end
 
-          visitor = Expressir::Express::Visitor.new(source,
-                                                    include_source: include_source)
-          @repository = visitor.visit_ast ast, :top
+          @repository = Builder.build_with_remarks(ast, source: source,
+                                                        include_source: include_source)
 
           @repository.schemas.each do |schema|
             schema.file = schema_file
@@ -680,6 +746,88 @@ root_path: nil)
 
         @repository
       end
+
+      # Parses Express content string into an Express model
+      # @param [String] content Express content as string
+      # @param [Boolean] skip_references skip resolving references
+      # @param [Boolean] include_source attach original source code to model elements
+      # @param [Boolean] use_native use native parser if available (default: false - AST format differs slightly)
+      # @param [Boolean] use_streaming use streaming builder for maximum performance (default: false)
+      # @return [Model::Repository] Parsed repository
+      # @raise [SchemaParseFailure] if the content fails to parse
+      def self.from_exp(content, skip_references: nil, include_source: nil,
+                         use_native: false, use_streaming: false)
+        # Streaming builder mode - uses Parsanol streaming callbacks
+        if use_streaming && Parser.native_available? && defined?(Parsanol::Native.parse_with_builder)
+          return from_exp_streaming(content, skip_references: skip_references,
+                                             include_source: include_source)
+        end
+
+        begin
+          # Use cached parser instance for performance (avoids ~7ms Parser.new overhead)
+          ast = if use_native && Parser.native_available?
+                  Parser.parse_native(content)
+                else
+                  Parser.cached_parser.parse(content)
+                end
+        rescue Parsanol::ParseFailed, StandardError => e
+          raise Error::SchemaParseFailure.new("(from string)", e)
+        end
+
+        repository = Builder.build_with_remarks(ast, source: content,
+                                                     include_source: include_source)
+
+        repository.schemas.each do |schema|
+          schema.file = nil
+          schema.file_basename = nil
+          schema.formatted = schema.to_s(no_remarks: true)
+        end
+
+        unless skip_references
+          Expressir::Benchmark.measure_references do
+            resolve_references_model_visitor = ResolveReferencesModelVisitor.new
+            resolve_references_model_visitor.visit(repository)
+          end
+        end
+
+        repository
+      end
+
+      # Parse using streaming builder (maximum performance)
+      # @param [String] content Express content as string
+      # @param [Boolean] skip_references skip resolving references
+      # @param [Boolean] include_source attach original source code to model elements
+      # @return [Model::Repository] Parsed repository
+      # @raise [SchemaParseFailure] if the content fails to parse
+      def self.from_exp_streaming(content, skip_references: nil,
+include_source: nil)
+        grammar_json = Parser.cached_grammar_json
+        builder = StreamingBuilder.new(source: content,
+                                       include_source: include_source)
+
+        begin
+          repository = Parsanol::Native.parse_with_builder(grammar_json,
+                                                           content, builder)
+        rescue StandardError => e
+          raise Error::SchemaParseFailure.new("(streaming)", e)
+        end
+
+        repository.schemas.each do |schema|
+          schema.file = nil
+          schema.file_basename = nil
+          schema.formatted = schema.to_s(no_remarks: true)
+        end
+
+        unless skip_references
+          Expressir::Benchmark.measure_references do
+            resolve_references_model_visitor = ResolveReferencesModelVisitor.new
+            resolve_references_model_visitor.visit(repository)
+          end
+        end
+
+        repository
+      end
+      private_class_method :from_exp_streaming
     end
   end
 end