expressir 2.4.1 → 2.4.3

data/lib/expressir/express/parallel_files.rb

@@ -0,0 +1,229 @@
+require "etc"
+
+module Expressir
+  module Express
+    # Fork-based worker pool for parsing many EXPRESS files in parallel.
+    # The native parser holds the GVL for the whole parse, so process-level
+    # parallelism is the only way to use multiple cores. Files are
+    # independent until reference resolution, which stays in the parent.
+    #
+    # Unlike sequential parsing, the progress block fires in file order
+    # only after all files have been parsed.
+    class ParallelFiles
+      DEFAULT_MAX_PROCESSES = 4
+      FRAME_HEADER_BYTES = 4
+
+      FORK_SUPPORTED = Process.respond_to?(:fork).freeze
+
+      # Forking is never the default: a library must not spawn processes on
+      # behalf of its host (forked children inherit broken thread and lock
+      # state, and fork does not exist on all Rubies). Parallelism requires
+      # an explicit max_processes > 1 from the caller and a platform that
+      # supports fork (e.g. not Windows); otherwise the request degrades
+      # to sequential parsing.
+      def self.sequential?(files, max_processes)
+        !FORK_SUPPORTED || max_processes.nil? || max_processes <= 1 ||
+          files.size < 3
+      end
+
+      # @param files [Array<String>] EXPRESS file paths
+      # @param max_processes [Integer, nil] worker cap; nil auto-selects
+      # @param parse [Proc] callback taking a file path, returning an ExpFile
+      # @param strict [Boolean] re-raise every error, including
+      #   Error::SchemaParseFailure, instead of skipping the file
+      # @yield [file, exp_file, error] called in original file order
+      # @return [Array<Expressir::Model::ExpFile, nil>] parsed files in order;
+      #   nil marks a file that failed with Error::SchemaParseFailure
+      def self.run(files, parse:, max_processes: nil, strict: false, &block)
+        new(files, max_processes, parse, block, strict).run
+      end
+
+      def initialize(files, max_processes, parse, block, strict)
+        @files = files
+        @parse = parse
+        @block = block
+        @strict = strict
+        @worker_count = [
+          files.size - 1,
+          max_processes || [Etc.nprocessors, DEFAULT_MAX_PROCESSES].min,
+        ].min
+      end
+
+      def run
+        job_pipes = Array.new(@worker_count) { IO.pipe }
+        result_pipes = Array.new(@worker_count) { IO.pipe }
+        pids = spawn_workers(job_pipes, result_pipes)
+
+        files_results = schedule_jobs(job_pipes, result_pipes)
+
+        ordered_pass(files_results)
+      ensure
+        cleanup(job_pipes, result_pipes, pids)
+      end
+
+      private
+
+      def spawn_workers(job_pipes, result_pipes)
+        job_pipes.each_index.map do |i|
+          job_r, job_w = job_pipes[i]
+          result_r, result_w = result_pipes[i]
+          fork do
+            job_w.close
+            result_r.close
+            other_pipes = (job_pipes + result_pipes).flatten -
+              [job_r, result_w]
+            other_pipes.each { |io| io.close unless io.closed? }
+            worker_loop(job_r, result_w)
+          end
+        end
+      end
+
+      # Assigns one job at a time to whichever worker reports a result, so
+      # each file is parsed exactly once and each worker holds at most one
+      # in-flight job (keeping result pipes free of interleaved frames).
+      def schedule_jobs(job_pipes, result_pipes)
+        writers = job_pipes.map(&:last)
+        readers = result_pipes.map(&:first)
+        files_results = Array.new(@files.size)
+        next_job = 0
+        busy = {}
+
+        writers.each_index do |wi|
+          break if next_job == @files.size
+
+          dispatch(writers[wi], next_job)
+          busy[wi] = true
+          next_job += 1
+        end
+
+        until busy.empty?
+          ready, = IO.select(readers.values_at(*busy.keys))
+          ready.each do |io|
+            wi = readers.index(io)
+            payload = Marshal.load(read_frame(io)) # rubocop:disable Security/MarshalLoad
+            files_results[payload[:index]] = payload
+
+            if next_job < @files.size
+              dispatch(writers[wi], next_job)
+              next_job += 1
+            else
+              writers[wi].close unless writers[wi].closed?
+              busy.delete(wi)
+            end
+          end
+        end
+
+        files_results
+      end
+
+      def dispatch(writer, job_index)
+        write_frame(writer, pack_frame(Marshal.dump([job_index, @files[job_index]])))
+      end
+
+      def worker_loop(job_r, result_w)
+        until job_r.eof?
+          data = read_frame(job_r)
+          index, file = Marshal.load(data) # rubocop:disable Security/MarshalLoad
+          begin
+            payload = { index: index, exp_file: @parse.call(file) }
+          rescue StandardError => e
+            payload = { index: index, error: transferable_error(e) }
+          end
+          write_frame(result_w, pack_frame(Marshal.dump(payload)))
+        end
+      rescue Errno::EPIPE
+        # parent went away; nothing to report to
+        exit!(0)
+      end
+
+      # SIGTERM cannot interrupt a worker blocked in the native parser (the
+      # GVL is held), so escalate to SIGKILL after a grace period instead of
+      # blocking in waitpid forever.
+      def cleanup(job_pipes, result_pipes, pids)
+        (job_pipes.to_a + result_pipes.to_a).each do |r, w|
+          r.close unless r.closed?
+          w.close unless w.closed?
+        end
+        pids.to_a.each { |pid| Process.kill("TERM", pid) if alive?(pid) }
+
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 2
+        pids.to_a.each do |pid|
+          while alive?(pid) && Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+            Process.waitpid(pid, Process::WNOHANG)
+            sleep 0.05
+          end
+          Process.kill("KILL", pid) if alive?(pid)
+          reap(pid)
+        end
+      end
+
+      def ordered_pass(files_results)
+        files_results.each_with_index do |payload, index|
+          error = payload[:error]
+          @block&.call(@files[index], payload[:exp_file], error)
+          raise error if error && (@strict ||
+                                  !error.is_a?(Error::SchemaParseFailure))
+        end
+
+        files_results.map do |payload|
+          payload[:error] ? nil : payload[:exp_file]
+        end
+      end
+
+      # Errors carrying native-parser state (e.g. Parsanol::ParseFailed with
+      # its cause tree) cannot cross a fork boundary; rebuild them without
+      # the untransferable internals, preserving class and message.
+      def transferable_error(error)
+        Marshal.dump(error)
+        error
+      rescue StandardError
+        if error.is_a?(Error::SchemaParseFailure)
+          Error::SchemaParseFailure.new(error.filename,
+                                        StandardError.new(error.message))
+        else
+          StandardError.new(error.message)
+        end
+      end
+
+      def pack_frame(data)
+        [data.bytesize].pack("N") + data
+      end
+
+      def write_frame(io, frame)
+        io.write(frame)
+      end
+
+      def read_frame(io)
+        header = read_exactly(io, FRAME_HEADER_BYTES)
+        read_exactly(io, header.unpack1("N"))
+      end
+
+      def read_exactly(io, count)
+        data = +""
+        while data.bytesize < count
+          chunk = io.read(count - data.bytesize)
+          unless chunk
+            raise Error::ParallelParseError,
+                  "worker exited before sending its result"
+          end
+
+          data << chunk
+        end
+        data
+      end
+
+      def alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+
+      def reap(pid)
+        Process.waitpid(pid)
+      rescue Errno::ECHILD, Errno::EINVAL
+        nil
+      end
+    end
+  end
+end

data/lib/expressir/express/parser.rb

@@ -100,7 +100,32 @@ module Expressir
       # @yield [filename, schemas, error] Optional block called for each file
       # @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)
+root_path: nil, use_native: nil, max_processes: nil, &progress)
+        all_exp_files = if ParallelFiles.sequential?(files, max_processes)
+                          parse_files_sequentially(
+                            files, skip_references: skip_references, include_source: include_source,
+                                   root_path: root_path, use_native: use_native
+                          ) do |file, exp_file, error|
+                            progress&.call(file, exp_file&.schemas, error)
+                          end
+                        else
+                          ParallelFiles.run(
+                            files,
+                            max_processes: max_processes,
+                            parse: lambda do |file|
+                              from_file(file, skip_references: true, root_path: root_path,
+                                              use_native: use_native)
+                            end,
+                          ) do |file, exp_file, error|
+                            progress&.call(file, exp_file&.schemas, error)
+                          end
+                        end
+
+        build_repository(all_exp_files, skip_references: skip_references)
+      end
+
+      def self.parse_files_sequentially(files, skip_references: nil,
+include_source: nil, root_path: nil, use_native: nil, &block)
         all_exp_files = []
 
         files.each do |file|
@@ -108,12 +133,19 @@ root_path: nil, use_native: nil)
                                      root_path: root_path, use_native: use_native)
           all_exp_files << exp_file
 
-          yield(file, exp_file&.schemas, nil) if block_given?
+          yield(file, exp_file, nil) if block
         rescue StandardError => e
-          yield(file, nil, e) if block_given?
+          # Nil-pad so results align with files by index, exactly like the
+          # parallel path does.
+          all_exp_files << nil if e.is_a?(Error::SchemaParseFailure)
+          yield(file, nil, e) if block
           raise unless e.is_a?(Error::SchemaParseFailure)
         end
 
+        all_exp_files
+      end
+
+      def self.build_repository(all_exp_files, skip_references: nil)
         repository = Model::Repository.new(files: all_exp_files)
 
         unless skip_references
@@ -130,15 +162,18 @@ root_path: nil, use_native: nil)
       # @param skip_references [Boolean] skip resolving references
       # @param include_source [Boolean] attach original source code to model elements
       # @param use_native [Boolean] use native parser (default: true when available)
-      # @param use_streaming [Boolean] use streaming builder for maximum performance
+      # @param use_streaming [Boolean] unsupported on current parsanol;
+      #   passing true raises {Error::StreamingUnsupportedError}. The
+      #   streaming paths return when parsanol exposes a stable
+      #   parse_with_builder (see parsanol-ruby#52 and the TODO.max-perf/02
+      #   notes).
       # @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)
         content = strip_bom(content)
-        if use_streaming && Grammar::Parser.native_available? && defined?(Parsanol::Native.parse_with_builder)
-          return from_exp_streaming(content, skip_references: skip_references,
-                                             include_source: include_source)
+        if use_streaming
+          raise Error::StreamingUnsupportedError
         end
 
         use_native = Grammar::Parser.native_available? if use_native.nil?
@@ -173,83 +208,6 @@ root_path: nil, use_native: nil)
         exp_file
       end
 
-      # Parse using streaming builder (construct-by-construct).
-      # @param content [String] EXPRESS source code
-      # @param skip_references [Boolean] skip resolving references
-      # @param include_source [Boolean] attach original source code to model elements
-      # @return [Model::ExpFile] Parsed ExpFile
-      # @raise [Error::SchemaParseFailure] if the content fails to parse
-      def self.from_exp_streaming_builder(content, skip_references: nil,
-include_source: nil)
-        grammar_json = Grammar::Parser.cached_grammar_json
-        builder = ::Expressir::Express::StreamingBuilder.new(source: content,
-                                                             include_source: include_source)
-
-        begin
-          exp_file = Parsanol::Native.parse_with_builder(grammar_json,
-                                                         content, builder)
-        rescue StandardError => e
-          raise Error::SchemaParseFailure.new("(streaming)", e)
-        end
-
-        exp_file.schemas.each do |schema|
-          schema.file = nil
-          schema.file_basename = nil
-        end
-
-        unless skip_references
-          Expressir::Benchmark.measure_references do
-            ResolveReferencesModelVisitor.new.visit(exp_file)
-          end
-        end
-
-        exp_file
-      end
-
-      # Parse each schema separately with fresh arena (memory-bounded).
-      #
-      # Splits source into schema blocks via {SchemaBlockScanner} and parses
-      # each independently. Memory is bounded by the largest schema, not the
-      # entire file.
-      #
-      # @param content [String] EXPRESS source code
-      # @param skip_references [Boolean] skip resolving references
-      # @param include_source [Boolean] attach original source code to model elements
-      # @return [Model::ExpFile] Parsed ExpFile
-      def self.from_exp_streaming(content, skip_references: nil,
-include_source: nil)
-        grammar_json = Grammar::Parser.cached_schema_grammar_json
-
-        schema_blocks = SchemaBlockScanner.extract_schema_blocks(content)
-
-        schemas = schema_blocks.map do |block|
-          ast = Parsanol::Native.parse_fresh(grammar_json, block[:source])
-          schema_model = Builder.build(ast)
-          schema_model.source = block[:source]
-          schema_model
-        rescue StandardError => e
-          raise Error::SchemaParseFailure.new(
-            "(schema #{block[:name] || 'unknown'})", e
-          )
-        end
-
-        exp_file = Expressir::Model::ExpFile.new
-        exp_file.schemas = schemas
-
-        exp_file.schemas.each do |schema|
-          schema.file = nil
-          schema.file_basename = nil
-        end
-
-        unless skip_references
-          Expressir::Benchmark.measure_references do
-            ResolveReferencesModelVisitor.new.visit(exp_file)
-          end
-        end
-
-        exp_file
-      end
-
       # Transfer file-level untagged remarks that appear before the first
       # SCHEMA keyword to the first schema's +header+ attribute so they are
       # accessible via +schema.header+ and through Liquid drops.
@@ -271,8 +229,8 @@ include_source: nil)
         exp_file.untagged_remarks -= header_remarks
       end
       private_class_method :transfer_header_to_schema
-
-      private_class_method :from_exp_streaming
+      private_class_method :parse_files_sequentially
+      private_class_method :build_repository
     end
   end
 end

data/lib/expressir/express/remark_attacher.rb

@@ -35,6 +35,10 @@ module Expressir
       # via `child_attributes :foo, :bar, ...`. See TODO.bugs/15.
       EXPRESSION_CHILDREN = Model::ModelElement.child_attributes_registry
 
+      # `WHERE <label> :` clause headers; the captured label maps to the
+      # 1-based line number(s) it appears on.
+      WHERE_CLAUSE_PATTERN = /\A\s*WHERE\s+(\w+)\s*:/i
+
       def initialize(source)
         @source = source
         @attached_spans = Set.new
@@ -71,6 +75,8 @@ module Expressir
         @line_map = nil
         @owner_map = nil
         @active_scope_map = nil
+        @source_lines_for_where_clause = nil
+        @where_clause_line_index = nil
       end
 
       private
@@ -239,21 +245,20 @@ module Expressir
       # shares a line with a node or sits outside any statement-bearing node.
       def find_body_comment_target(remark)
         line = remark.line
-        nodes = @node_index.nodes
         # An own-line comment shares its line with no node. A node STARTING
         # here means the remark is an inline tail (code; -- note). The
         # end-line check is restricted to statements: container end_lines are
         # child-derived approximations that can collide with comment lines.
-        return inline_target(remark, nodes) if inline_remark?(remark)
+        return inline_target(remark, @node_index.starting_at(line)) if inline_remark?(remark)
 
         # A closing keyword on the next code line is decisive: the comment
         # closes that body. Without this check the comment would instead be
         # read as leading the next statement of an OUTER region, which is
         # where it would wrongly render.
-        closing = closing_region_target(line, nodes)
+        closing = closing_region_target(line)
         return closing if closing.first
 
-        enclosing, region, = statement_region_for(line, nodes)
+        enclosing, region, = statement_region_for(line)
         return [nil, nil, nil] unless region
 
         following = region
@@ -333,7 +338,7 @@ module Expressir
       # every span and never reaches statement_region_for. Resolve it from
       # the keyword that follows: it names both the owner type and the body
       # being closed.
-      def closing_region_target(line, nodes)
+      def closing_region_target(line)
         keyword_owner, region, keyword_line = closing_keyword_after(line)
         return [nil, nil, nil] unless keyword_owner
 
@@ -345,8 +350,8 @@ module Expressir
         opener_line = active_opener_line(keyword_line, keyword_owner)
         return [nil, nil, nil] unless opener_line
 
-        owner = nodes.find do |n|
-          n[:node].is_a?(keyword_owner) && n[:line] == opener_line
+        owner = @node_index.starting_at(opener_line).find do |n|
+          n[:node].is_a?(keyword_owner)
         end
         return [nil, nil, nil] unless owner
 
@@ -452,18 +457,15 @@ module Expressir
         [nil, nil, nil]
       end
 
-      def statement_region_for(line, nodes)
-        candidates = nodes.select do |n|
+      def statement_region_for(line, nodes = nil)
+        candidates = (nodes || @node_index.spanning(line)).select do |n|
           n[:line] && n[:end_line] && n[:line] <= line && n[:end_line] >= line &&
             (n[:node].is_a?(Model::Statement) || function_rule_procedure?(n[:node]))
         end
         enclosing = innermost_candidate(candidates)
         return [nil, nil, nil] unless enclosing
 
-        children = nodes.select do |n|
-          n[:owner].equal?(enclosing[:node]) &&
-            STATEMENT_REGIONS.include?(n[:collection]) && n[:line]
-        end
+        children = @node_index.children_in(enclosing[:node], STATEMENT_REGIONS)
         return [enclosing, nil, nil] if children.empty?
 
         preceding = children.select { |n| n[:line] < line }.max_by { |n| n[:position] }
@@ -658,27 +660,39 @@ module Expressir
         where_rules = get_collection(scope, :where_rules)
         return nil unless where_rules&.any?
 
-        lines = source_lines_for_where_clause
+        where_clause_lines = where_clause_line_index
 
         where_rules.each do |wr|
           next unless wr.id
 
-          lines.each_with_index do |line, idx|
-            line_num = idx + 1
+          where_clause_lines.fetch(wr.id, []).each do |line_num|
             next unless line_num < remark_line
 
-            if (line =~ /^\s*WHERE\s+#{Regexp.escape(wr.id)}\s*:/i) && remark_line.between?(line_num, line_num + 5)
-              return create_remark_item(wr, tag)
-            end
+            return create_remark_item(wr, tag) if remark_line.between?(line_num, line_num + 5)
           end
         end
 
         nil
       end
 
+      # Single scan over the source lines mapping each `WHERE <id>:` label to
+      # its 1-based line number, so per-remark lookups stop re-testing every
+      # line against every WHERE rule's regex.
+      def where_clause_line_index
+        @where_clause_line_index ||= begin
+          index = Hash.new { |h, k| h[k] = [] }
+          source_lines_for_where_clause.each_with_index do |line, idx|
+            if (match = line.match(WHERE_CLAUSE_PATTERN))
+              index[match[1]] << (idx + 1)
+            end
+          end
+          index
+        end
+      end
+
       def source_lines_for_where_clause
         # @source is set for the duration of `attach`; freed at the end.
-        @source.lines
+        @source_lines_for_where_clause ||= @source.lines
       end
 
       def find_node_in_statement(stmt, tag)

data/lib/expressir/express/schema_block_scanner.rb

@@ -6,8 +6,9 @@ module Expressir
     #
     # A hand-rolled state machine that skips comments (`(* ... *)`) and
     # string literals, tracks SCHEMA/END_SCHEMA depth, and returns one
-    # block per schema declaration. Used by `Parser.from_exp_streaming`
-    # to parse each schema independently with a fresh memory arena.
+    # block per schema declaration. Retained for the future streaming
+    # parse path (see TODO.max-perf/02) that parses each schema
+    # independently with a fresh memory arena.
     #
     # Extracted from the outer Parser class (TODO.bugs/09) so block-
     # scanning logic lives in one focused module behind one interface.

data/lib/expressir/express/scope_resolver.rb

@@ -50,8 +50,13 @@ module Expressir
         @model = model
         @nodes_with_positions = nodes_with_positions
         @scope_map = nil
+        @source_lines = nil
+        @position_buckets = nil
       end
 
+      # Line-band width for the position fallback index.
+      BUCKET_LINES = 1024
+
       # Returns the innermost Model::ScopeContainer whose source span contains
       # the given 1-based remark line, or nil if none is found.
       def containing_scope_for(remark_line)
@@ -69,7 +74,7 @@ module Expressir
         type_state = { line: nil, name: nil }
         rule_state = { line: nil, name: nil }
 
-        @source.lines.each_with_index do |line, idx|
+        source_lines.each_with_index do |line, idx|
           line_num = idx + 1
 
           case line
@@ -131,8 +136,15 @@ module Expressir
         @scope_map ||= build_scope_map
       end
 
+      # Source split into lines, computed once per resolver: both the
+      # scope-map build and find_by_source_text need it, and re-splitting the
+      # whole source per lookup dominates remark attachment on large files.
+      def source_lines
+        @source_lines ||= @source.lines
+      end
+
       def build_scope_map
-        lines = @source.lines
+        lines = source_lines
         map = {}
         return map if lines.empty?
 
@@ -160,10 +172,27 @@ module Expressir
 
       # --- Strategy 2: position-based fallback against the node index ---
 
+      # Nodes bucketed by 1024-line bands: a node spanning [line, end_line]
+      # is registered in every band it overlaps, so a remark-line lookup only
+      # scans nodes that can possibly contain it. Bucket order preserves the
+      # original index order, so select+reverse_each semantics are unchanged.
+      def position_buckets
+        @position_buckets ||= begin
+          buckets = Hash.new { |h, k| h[k] = [] }
+          @nodes_with_positions.each do |n|
+            next unless n[:line] && n[:end_line]
+
+            ((n[:line] / BUCKET_LINES)..(n[:end_line] / BUCKET_LINES)).each do |b|
+              buckets[b] << n
+            end
+          end
+          buckets
+        end
+      end
+
       def find_by_position(remark_line)
-        containing = @nodes_with_positions.select do |n|
-          n[:line] && n[:end_line] &&
-            remark_line >= n[:line] && remark_line <= n[:end_line] &&
+        containing = position_buckets[remark_line / BUCKET_LINES].select do |n|
+          remark_line.between?(n[:line], n[:end_line]) &&
             !n[:node].is_a?(Model::Repository) && !n[:node].is_a?(Model::Cache)
         end
 

data/lib/expressir/express.rb

@@ -2,6 +2,7 @@
 
 module Expressir
   module Express
+    autoload :AstKeyConverter, "#{__dir__}/express/ast_key_converter"
     autoload :Builder, "#{__dir__}/express/builder"
     autoload :BuilderContext, "#{__dir__}/express/builder_context"
     autoload :BuilderRegistry, "#{__dir__}/express/builder_registry"
@@ -17,6 +18,7 @@ module Expressir
     autoload :LineMap, "#{__dir__}/express/line_map"
     autoload :ModelVisitor, "#{__dir__}/express/model_visitor"
     autoload :NodePositionIndex, "#{__dir__}/express/node_position_index"
+    autoload :ParallelFiles, "#{__dir__}/express/parallel_files"
     autoload :Parser, "#{__dir__}/express/parser"
     autoload :PrettyFormatter, "#{__dir__}/express/pretty_formatter"
     autoload :RemarkAttacher, "#{__dir__}/express/remark_attacher"

data/lib/expressir/model/model_element.rb

@@ -155,7 +155,12 @@ module Expressir
       end
 
       def source
-        Expressir::Express::SourceFormatter.format(self)
+        # Formatting is not free and callers probe `source` repeatedly while
+        # walking the tree (position index, remark attachment), so the text is
+        # computed once per node. Deliberately NOT @source: that ivar holds
+        # the raw source span lutaml-model's `source=` stores when
+        # include_source is on, and readers must keep seeing formatted text.
+        @formatted_source ||= Expressir::Express::SourceFormatter.format(self) # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       # @param [Hash] options

data/lib/expressir/model/repository.rb

@@ -291,14 +291,27 @@ reference_index: nil)
       # Build repository from list of schema files
       # @param file_paths [Array<String>] Schema file paths
       # @param base_dir [String, nil] Base directory for path resolution
+      # @param max_processes [Integer, nil] parse in a fork worker pool when
+      #   set above 1 on a fork-capable platform (advisory; degrades to
+      #   sequential otherwise). Unlike Express::Parser.from_files, a file
+      #   that fails to parse always raises.
       # @return [Repository] Built repository with all schemas
-      def self.from_files(file_paths, base_dir: nil)
+      def self.from_files(file_paths, base_dir: nil, max_processes: nil)
         repo = new(base_dir: base_dir)
 
-        file_paths.each do |path|
-          parsed = Expressir::Express::Parser.from_file(path)
-          next unless parsed
-
+        pool = Expressir::Express::ParallelFiles
+        parsed_files = if pool.sequential?(file_paths, max_processes)
+                         file_paths.map do |path|
+                           Expressir::Express::Parser.from_file(path)
+                         end
+                       else
+                         pool.run(file_paths,
+                                  parse: ->(path) { Expressir::Express::Parser.from_file(path) },
+                                  max_processes: max_processes,
+                                  strict: true)
+                       end
+
+        parsed_files.each do |parsed|
           repo.files << parsed if parsed.is_a?(ExpFile)
         end