kleene 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7df94943f1746064025af64823d93819d96d04d5f6526789451dcdac643f54df
-  data.tar.gz: 6590239e59b38ed2155f4329070ee763904dabc7535205bc5f1e23b780be48a0
+  metadata.gz: 674bbda22ddfbc6c4ec1624de621b96c24576cbe8aa656d228697e1d98549cdb
+  data.tar.gz: ddca6b95201b21359dd23c5d6b4d9591561e9045764ce90b470b6add1c4518b8
 SHA512:
-  metadata.gz: 276cec78e2550ff2d7b95f96d3e98c55b6a43ace55d14300ae1406cd292dd5b709eb4074f1c2cac4ac806125a8296172aaa57ee37cece7a4445cb0069629c5ea
-  data.tar.gz: 961ac38a53dbbf716d4cc34c07f26eb3cd36bb9dd0bcd65485f3c2d9cc0b667eb3d297a8d91e19507e6b7ec59180c92fca4574c10df57a4588e337f9012f8e19
+  metadata.gz: 9392d0b56aa48b8cef4f0337be625d6160d49c3fb0214b034f379a505ee3a142347e8bb5e62a82ad0cb982bb3ca00ad6f9b12f951e00cf48b0447a1b6fb78320
+  data.tar.gz: 1521365696f470bc249dac8aa77038bc9121ff60499dc9368aaf86224e64af14a06e092aef191bc9571d62d2dd63567a7051f4b07490e4f377eac8d24de83025

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    kleene (0.1.0)
+    kleene (0.6.0)
       activesupport (~> 7.1)
+      regexp_parser (~> 2.8)
 
 GEM
   remote: https://rubygems.org/
@@ -45,7 +46,7 @@ GEM
     parser (3.2.2.4)
       ast (~> 2.4.1)
       racc
-    racc (1.7.2)
+    racc (1.7.3)
     rainbow (3.1.1)
     rake (13.1.0)
     rbs (2.8.4)

data/build.ops

@@ -7,17 +7,25 @@ imports:
 ...
 
 # when you run this script, it should do something like:
-# ~/sync/projects/kleene-rb
-# ❯ ops run build.ops version:1.0.0
-# Write version.rb for version 1.0.0
-# [localhost] Build gem: gem build opswalrus.gemspec
-# [localhost] Check whether Bitwarden is locked or not: bw status
-# [localhost] Get Rubygems OTP: bw get totp Rubygems
-# [localhost] Push gem: gem push opswalrus-1.0.0.gem
-# [localhost] Build docker image: docker build -t opswalrus/ops:1.0.0 .
-
-# ~/sync/projects/ops/opswalrus on  main via 💎 v3.2.2 took 44s
-
+# ~/sync/projects/kleene-rb on  master via 💎 v3.2.2
+# ❯ ops run build.ops version:0.5.0
+# Write version.rb for version 0.5.0
+# Writing template literal to ./lib/kleene/version.rb
+# localhost | Build gem
+# Finished in 0.181094124 seconds with exit status 0 (success)
+# ********************************************************************************
+# localhost | Commit Gemfile.lock and version.rb and git push changes
+# Finished in 0.798496926 seconds with exit status 0 (success)
+# ********************************************************************************
+# localhost | Check whether Bitwarden is locked or not
+# Finished in 0.008580059 seconds with exit status 0 (success)
+# ********************************************************************************
+# localhost | Get Rubygems OTP
+# Finished in 0.378203313 seconds with exit status 0 (success)
+# ********************************************************************************
+# localhost | Push gem
+# Finished in 4.095049625 seconds with exit status 0 (success)
+# ********************************************************************************
 
 version = params.version
 

data/kleene.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
 
   # Uncomment to register a new dependency of your gem
   spec.add_dependency "activesupport", "~> 7.1"
+  spec.add_dependency "regexp_parser", "~> 2.8"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/kleene/multi_match_dfa.rb

@@ -77,18 +77,10 @@ module Kleene
 
       nfa
     end
+  end
 
-    def match_tracker(input) # : MatchTracker
-      dfa = @composite_dfa.deep_clone
-      match_tracker = setup_callbacks(dfa)
-
-      input.each_char.with_index do |char, index|
-        dfa.handle_token!(char, index)
-      end
-
-      match_tracker
-    end
-
+  class BatchMultiMatchDFA < MultiMatchDFA
+    # #matches(input) is the batch-style matching interface
     def matches(input) # : Hash(NFA, Array(MatchRef))
       mt = match_tracker(input)
 
@@ -131,8 +123,19 @@ module Kleene
       mt.matches
     end
 
+    def match_tracker(input) # : BatchMatchTracker
+      dfa = @composite_dfa.deep_clone
+      match_tracker = setup_callbacks(dfa)
+
+      input.each_char.with_index do |char, index|
+        dfa.handle_token!(char, index)
+      end
+
+      match_tracker
+    end
+
     def setup_callbacks(dfa)
-      match_tracker = MatchTracker.new
+      match_tracker = BatchMatchTracker.new
 
       # 1. identify DFA states that correspond to successful match of first character of the NFAs
       epsilon_closure_of_nfa_start_state = composite_nfa.epsilon_closure(composite_nfa.start_state)
@@ -222,10 +225,9 @@ module Kleene
 
       match_tracker
     end
-
   end
 
-  class MatchTracker
+  class BatchMatchTracker
     # The NFA keys in the following two structures are not the original NFAs supplied to the MultiMatchDFA.
     # They are the original NFAs that have been augmented with a dead end error state, so the keys are objects that
     # are the internal state of a MultiMatchDFA
@@ -249,6 +251,10 @@ module Kleene
     attr_accessor :matches # : Hash(NFA, Array(MatchRef))  # NFA -> Array(MatchRef)
 
     def initialize
+      reset
+    end
+
+    def reset
       @candidate_match_start_positions = Hash.new
       @match_end_positions = Hash.new
       @empty_matches = Hash.new

data/lib/kleene/naive_online_regex.rb

@@ -0,0 +1,63 @@
+require "set"
+require "stringio"
+require_relative "./kleene"
+
+module Kleene
+  class NaiveOnlineRegex
+    def initialize(regexen, window_size = 100)
+      @regexen = regexen
+      @window_size = window_size
+
+      reset
+    end
+
+    def reset
+      @buffer = ""
+      @matches_per_regex = Hash.new   # Hash(Regexp, Set(MatchData))
+    end
+
+    # #ingest(input) is the online-style matching interface
+    def ingest(input, debug = false) # : Set(OnlineMatch)
+      @buffer << input
+      new_online_matches = Set.new
+      @regexen.each do |regex|
+        existing_matches_for_regex = (@matches_per_regex[regex] ||= Set.new)
+        scan_matches = @buffer.scan_matches(regex).to_set
+        new_matches = scan_matches - existing_matches_for_regex   # new_matches : Set(MatchData)
+        existing_matches_for_regex.merge(new_matches)
+        new_online_matches.merge(new_matches.map {|match_data| OnlineMatch.new(regex, match_data) })
+      end
+      resize_buffer!
+      new_online_matches
+    end
+
+    def matches # Hash(Regexp, Set(MatchData))
+      @matches_per_regex
+    end
+
+    def matches_for(regex) # Set(MatchData) | Nil
+      @matches_per_regex[regex]
+    end
+
+    def resize_buffer!
+      if @buffer.size > @window_size
+        @buffer = @buffer[-@window_size..-1]
+      end
+    end
+  end
+
+  # A {Regexp, MatchData} pair
+  class OnlineMatch
+    attr_reader :regex  # Regexp
+    attr_reader :match  # MatchData
+    def initialize(regex, match)
+      @regex, @match = regex, match
+    end
+    def to_a
+      @match.to_a
+    end
+    def to_h
+      {@regex => to_a}
+    end
+  end
+end

data/lib/kleene/online_dfa.rb

@@ -0,0 +1,323 @@
+require "stringio"
+require_relative "./kleene"
+
+module Kleene
+  class MachineTuple
+    attr_accessor :nfa # : NFA
+    attr_accessor :nfa_with_dead_err # : NFA
+    attr_accessor :dfa # : DFA
+
+    def initialize(nfa, nfa_with_dead_err, dfa)
+      @nfa, @nfa_with_dead_err, @dfa = nfa, nfa_with_dead_err, dfa
+    end
+  end
+
+  class OnlineDFA
+    include DSL
+
+    # @original_nfas : Array(NFA)
+    attr_reader :nfas_with_err_state # : Array(NFA)
+    attr_accessor :dead_end_nfa_state_to_dead_end_nfa # : Hash(State, NFA)
+    attr_accessor :composite_nfa # : NFA
+    attr_accessor :composite_dfa # : DFA
+
+    attr_accessor :machines_by_index # : Hash(Int32, MachineTuple)
+    attr_accessor :nfa_to_index # : Hash(NFA, Int32)
+    attr_accessor :nfa_with_dead_err_to_index # : Hash(NFA, Int32)
+    attr_accessor :dfa_to_index # : Hash(DFA, Int32)
+
+    def initialize(nfas)
+      composite_alphabet = nfas.reduce(Set.new) {|memo, nfa| memo | nfa.alphabet }
+
+      @original_nfas = nfas
+      @nfas_with_err_state = nfas.map {|nfa| with_err_dead_end(nfa, composite_alphabet) }     # copy NFAs and add dead-end error states to each of them
+      dfas = @original_nfas.map(&:to_dfa)
+
+      @nfa_to_index = @original_nfas.map.with_index {|nfa, index| [nfa, index] }.to_h
+      @nfa_with_dead_err_to_index = @nfas_with_err_state.map.with_index {|nfa, index| [nfa, index] }.to_h
+      @dfa_to_index = dfas.map.with_index {|dfa, index| [dfa, index] }.to_h
+      @machines_by_index = @original_nfas.zip(nfas_with_err_state, dfas).map.with_index {|tuple, index| nfa, nfa_with_dead_err, dfa = tuple; [index, MachineTuple.new(nfa, nfa_with_dead_err, dfa)] }.to_h
+
+      # build a mapping of (state -> nfa) pairs that capture which nfa owns each state
+      @dead_end_nfa_state_to_dead_end_nfa = Hash.new
+      @nfas_with_err_state.each do |nfa_with_dead_err|
+        nfa_with_dead_err.states.each do |state|
+          @dead_end_nfa_state_to_dead_end_nfa[state] = nfa_with_dead_err
+        end
+      end
+
+      # create a composite NFA as the union of all the NFAs with epsilon transitions from every NFA state back to the union NFA's start state
+      @composite_nfa = create_composite_nfa(@nfas_with_err_state)
+      @composite_dfa = @composite_nfa.to_dfa
+
+      reset
+    end
+
+    def machines_from_nfa(nfa) # : MachineTuple
+      machines_by_index[nfa_to_index[nfa]]
+    end
+
+    def machines_from_nfa_with_dead_err(nfa_with_dead_err) # : MachineTuple
+      machines_by_index[nfa_with_dead_err_to_index[nfa_with_dead_err]]
+    end
+
+    def machines_from_dfa(dfa) # : MachineTuple
+      machines_by_index[dfa_to_index[dfa]]
+    end
+
+    # create a composite NFA as the union of all the NFAs with epsilon transitions from every NFA state back to the union NFA's start state
+    def create_composite_nfa(nfas)
+      nfa = union!(nfas)
+
+      # add epsilon transitions from all the states except the start state back to the start state
+      nfa.states.each do |state|
+        if state != nfa.start_state
+          nfa.add_transition(NFATransition::Epsilon, state, nfa.start_state)
+        end
+      end
+
+      nfa.update_final_states
+
+      nfa
+    end
+
+    def reset # : OnlineMatchTracker
+      @active_composite_dfa = @composite_dfa.deep_clone
+      @active_candidate_dfas = []
+      @match_tracker = setup_callbacks(@active_composite_dfa)
+      @buffer = ""
+    end
+
+    # #ingest(input) is the online-style matching interface
+    def ingest(input, debug = false) # : Hash(NFA, Array(MatchRef))
+      mt = @match_tracker
+
+      start_index_of_input_fragment_in_buffer = @buffer.length
+
+      input.each_char.with_index do |char, index|
+        @active_composite_dfa.handle_token!(char, start_index_of_input_fragment_in_buffer + index)
+      end
+
+      @buffer << input
+
+      start_index_to_nfas_that_may_match = mt.invert_candidate_match_start_positions
+
+      mt.empty_matches.each do |nfa_with_dead_err, indices|
+        original_nfa = machines_from_nfa_with_dead_err(nfa_with_dead_err).nfa
+        indices.select {|index| index >= start_index_of_input_fragment_in_buffer }.each do |index|
+          mt.add_match(original_nfa, MatchRef.new(@buffer, index...index))
+        end
+      end
+
+      input.each_char.with_index do |char, index|
+        index_in_buffer = start_index_of_input_fragment_in_buffer + index
+
+        @active_candidate_dfas.reject! do |active_dfa_tuple|
+          dfa_clone, original_nfa, start_of_match_index = active_dfa_tuple
+
+          dfa_clone.handle_token!(char, index_in_buffer)
+          mt.add_match(original_nfa, MatchRef.new(@buffer, start_of_match_index..index_in_buffer)) if dfa_clone.accept?
+
+          dfa_clone.error?
+        end
+
+        if nfas_with_dead_err = start_index_to_nfas_that_may_match[index_in_buffer]
+          nfas_with_dead_err.each do |nfa_with_dead_err|
+            machines = machines_from_nfa_with_dead_err(nfa_with_dead_err)
+            original_nfa = machines.nfa
+            dfa = machines.dfa
+            dfa_clone = dfa.shallow_clone
+
+            dfa_clone.handle_token!(char, index_in_buffer)
+            mt.add_match(original_nfa, MatchRef.new(@buffer, index_in_buffer..index_in_buffer)) if dfa_clone.accept?
+
+            @active_candidate_dfas << [dfa_clone, original_nfa, index_in_buffer] unless dfa_clone.error?
+          end
+        end
+      end
+
+      matches
+    end
+
+    def matches
+      @match_tracker.matches
+    end
+
+    def setup_callbacks(dfa)
+      match_tracker = OnlineMatchTracker.new
+
+      # 1. identify DFA states that correspond to successful match of first character of the NFAs
+      epsilon_closure_of_nfa_start_state = composite_nfa.epsilon_closure(composite_nfa.start_state)
+      nfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa = composite_nfa.transitions_from(epsilon_closure_of_nfa_start_state).
+                                                                                                         reject {|transition| transition.epsilon? || transition.to.error? }.
+                                                                                                         map(&:to).to_set
+      dfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa = nfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa.
+                                                                                              compact_map {|nfa_state| dfa.nfa_state_to_dfa_state_sets[nfa_state] }.
+                                                                                              reduce(Set.new) {|memo, state_set| memo | state_set }
+      dfa_state_to_dead_end_nfas_that_have_matched_their_first_character = Hash.new
+      dfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa.each do |dfa_state|
+        dfa_state_to_dead_end_nfas_that_have_matched_their_first_character[dfa_state] = dfa.dfa_state_to_nfa_state_sets[dfa_state].
+                                                                                            select {|nfa_state| nfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa.includes?(nfa_state) }.
+                                                                                            compact_map do |nfa_state|
+          dead_end_nfa_state_to_dead_end_nfa[nfa_state] unless nfa_state == composite_nfa.start_state    # composite_nfa.start_state is not referenced in the dead_end_nfa_state_to_dead_end_nfa map
+        end.to_set
+      end
+
+      # 2. identify DFA states that correspond to final states in the NFAs
+      nfa_final_states = @nfas_with_err_state.map(&:final_states).reduce(Set.new) {|memo, state_set| memo | state_set }
+      dfa_states_that_correspond_to_nfa_final_states = nfa_final_states.compact_map {|nfa_state| dfa.nfa_state_to_dfa_state_sets[nfa_state] }.
+                                                                        reduce(Set.new) {|memo, state_set| memo | state_set }
+      dead_end_nfas_that_have_transitioned_to_final_state = Hash.new
+      dfa_states_that_correspond_to_nfa_final_states.each do |dfa_state|
+        dead_end_nfas_that_have_transitioned_to_final_state[dfa_state] = dfa.dfa_state_to_nfa_state_sets[dfa_state].
+                                                                             select {|nfa_state| nfa_final_states.includes?(nfa_state) }.
+                                                                             compact_map do |nfa_state|
+          dead_end_nfa_state_to_dead_end_nfa[nfa_state] unless nfa_state == composite_nfa.start_state    # composite_nfa.start_state is not referenced in the dead_end_nfa_state_to_dead_end_nfa map
+        end.to_set
+      end
+
+      # 3. Identify DFA states that correspond to successful match without even having seen any characters.
+      #    These are cases where the NFA's start state is a final state or can reach a final state by following only epsilon transitions.
+      nfa_final_states_that_are_epsilon_reachable_from_nfa_start_state = epsilon_closure_of_nfa_start_state.select(&:final?).to_set
+      dfa_states_that_represent_both_start_states_and_final_states = nfa_final_states_that_are_epsilon_reachable_from_nfa_start_state.
+                                                                        compact_map {|nfa_state| dfa.nfa_state_to_dfa_state_sets[nfa_state] }.
+                                                                        reduce(Set.new) {|memo, state_set| memo | state_set }
+      dfa_state_to_dead_end_nfas_that_have_matched_before_handling_any_characters = Hash.new
+      dfa_states_that_represent_both_start_states_and_final_states.each do |dfa_state|
+        dfa_state_to_dead_end_nfas_that_have_matched_before_handling_any_characters[dfa_state] = dfa.dfa_state_to_nfa_state_sets[dfa_state].
+                                                                                                     select {|nfa_state| nfa_final_states_that_are_epsilon_reachable_from_nfa_start_state.includes?(nfa_state) }.
+                                                                                                     compact_map do |nfa_state|
+          dead_end_nfa_state_to_dead_end_nfa[nfa_state] unless nfa_state == composite_nfa.start_state    # composite_nfa.start_state is not referenced in the dead_end_nfa_state_to_dead_end_nfa map
+        end.to_set
+      end
+
+      # set up call transition call backs, since the callbacks may only be defined once per state and transition
+      # For (1):
+      #    Set up transition callbacks to push the index position of the start of a match of each NFA that has begun
+      #    to be matched on the transition to one of the states in (1)
+      # For (2):
+      #    set up transition callbacks to push the index position of the end of a successful match onto the list
+      #    of successful matches for the NFA that matched
+      # For (3):
+      #    set up transision callbacks to capture successful empty matches
+      destination_dfa_states_for_callbacks = dfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa | dfa_states_that_correspond_to_nfa_final_states
+      destination_dfa_states_for_callbacks.each do |dfa_state|
+        dfa.on_transition_to(dfa_state) do |transition, token, token_index|
+          destination_dfa_state = transition.to
+
+          should_track_empty_match = dfa_states_that_represent_both_start_states_and_final_states.includes?(destination_dfa_state)
+          should_track_start_of_candidate_match = should_track_empty_match || dfa_states_that_correspond_to_successful_match_of_first_character_of_component_nfa.includes?(destination_dfa_state)
+          should_track_end_of_match = dfa_states_that_correspond_to_nfa_final_states.includes?(destination_dfa_state)
+
+          if should_track_empty_match
+            dfa_state_to_dead_end_nfas_that_have_matched_before_handling_any_characters[destination_dfa_state].each do |nfa_with_dead_end|
+              match_tracker.add_empty_match(nfa_with_dead_end, token_index)
+            end
+          end
+
+          if should_track_start_of_candidate_match
+            nfas_that_matched_first_character = dfa_state_to_dead_end_nfas_that_have_matched_their_first_character[destination_dfa_state] || Set.new
+            nfas_that_matched_empty_match = dfa_state_to_dead_end_nfas_that_have_matched_before_handling_any_characters[destination_dfa_state] || Set.new
+            dead_end_nfas_that_are_starting_to_match = nfas_that_matched_first_character | nfas_that_matched_empty_match
+            dead_end_nfas_that_are_starting_to_match.each do |nfa_with_dead_end|
+              match_tracker.add_start_of_candidate_match(nfa_with_dead_end, token_index)
+            end
+          end
+
+          if should_track_end_of_match
+            dead_end_nfas_that_have_transitioned_to_final_state[destination_dfa_state].each do |nfa_with_dead_end|
+              match_tracker.add_end_of_match(nfa_with_dead_end, token_index)
+            end
+          end
+        end
+      end
+
+      match_tracker
+    end
+  end
+
+  class OnlineMatchTracker
+    # The NFA keys in the following two structures are not the original NFAs supplied to the MultiMatchDFA.
+    # They are the original NFAs that have been augmented with a dead end error state, so the keys are objects that
+    # are the internal state of a MultiMatchDFA
+    attr_accessor :candidate_match_start_positions # : Hash(NFA, Array(Int32))     # NFA -> Array(IndexPositionOfStartOfMatch)
+    #  The end positions are indices at which, after handling the character, the DFA was observed to be in a match/accept state;
+    #  however, the interpretation is ambiguous, because the accepting state may be as a result of (1) transitioning to an error state that is also marked final/accepting,
+    #  OR it may be as a result of transitioning to (2) a non-error final state.
+    #  In the case of (1), the match may be an empty match, where after transitioning to an error state, the DFA is in a state that
+    #  is equivalent to the error state and start state and final state (e.g. as in an optional or kleene star DFA),
+    #  while in the case of (2), the match may be a "normal" match.
+    #  The ambiguity is problematic because it isn't clear whether the index position of the match is end inclusive end of a match
+    #  or the beginning of an empty match.
+    #  This ambiguity is all due to the construction of the composite DFA in the MultiMatchDFA - the dead end error states are epsilon-transitioned
+    #  to the composite DFA's start state.
+    attr_accessor :match_end_positions # : Hash(NFA, Array(Int32))                 # NFA -> Array(IndexPositionOfEndOfMatch)
+    attr_accessor :empty_matches # : Hash(NFA, Array(Int32))                       # NFA -> Array(IndexPositionOfEmptyMatch)
+
+    # The NFA keys in the following structure are the original NFAs supplied to the MultiMatchDFA.
+    # This is in contrast to the augmented NFAs that are used as keys in the candidate_match_start_positions and
+    # match_end_positions structures, documented above ^^^.
+    attr_accessor :matches # : Hash(NFA, Array(MatchRef))  # NFA -> Array(MatchRef)
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @candidate_match_start_positions = Hash.new
+      @match_end_positions = Hash.new
+      @empty_matches = Hash.new
+      @matches = Hash.new
+    end
+
+    def start_positions(nfa)
+      candidate_match_start_positions[nfa] ||= Array.new
+    end
+
+    def end_positions(nfa)
+      match_end_positions[nfa] ||= Array.new
+    end
+
+    def empty_match_positions(nfa)
+      empty_matches[nfa] ||= Array.new
+    end
+
+    def matches_for(nfa)
+      matches[nfa] ||= Array.new
+    end
+
+    def add_start_of_candidate_match(nfa_with_dead_end, token_index)
+      # puts "add_start_of_candidate_match(#{nfa.object_id}, #{token_index})"
+      positions = start_positions(nfa_with_dead_end)
+      positions << token_index
+    end
+
+    #  the end positions are inclusive of the index of the last character matched, so empty matches are not accounted for in the match_end_positions array
+    def add_end_of_match(nfa_with_dead_end, token_index)
+      # puts "add_end_of_match(#{nfa.object_id}, #{token_index})"
+      positions = end_positions(nfa_with_dead_end)
+      positions << token_index
+    end
+
+    def add_empty_match(nfa_with_dead_end, token_index)
+      positions = empty_match_positions(nfa_with_dead_end)
+      positions << token_index
+    end
+
+    def invert_candidate_match_start_positions # : Hash(Int32, Array(NFA))
+      index_to_nfas = Hash.new
+      candidate_match_start_positions.each do |nfa_with_dead_end, indices|
+        indices.each do |index|
+          nfas = index_to_nfas[index] ||= Array.new
+          nfas << nfa_with_dead_end
+        end
+      end
+      index_to_nfas
+    end
+
+    def add_match(nfa, match)
+      matches = matches_for(nfa)
+      matches << match
+    end
+  end
+end

data/lib/kleene/parser.rb

@@ -0,0 +1,9 @@
+
+module Kleene
+  class Parser
+    def parse(pattern)
+      ast = Regexp::Parser.parse(pattern)
+      ast
+    end
+  end
+end

data/lib/kleene/patches.rb

@@ -21,3 +21,9 @@ module Enumerable
 
   alias_method :includes?, :include?
 end
+
+class String
+  def scan_matches(pattern) # : Array(MatchData)
+    to_enum(:scan, pattern).map { Regexp.last_match }
+  end
+end

data/lib/kleene/version.rb

@@ -1,3 +1,3 @@
 module Kleene
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/kleene.rb

@@ -2,6 +2,7 @@
 
 require "active_support"
 require "active_support/core_ext"
+require "regexp_parser"
 require_relative "kleene/version"
 require_relative "kleene/patches"
 require_relative "kleene/kleene"
@@ -9,7 +10,9 @@ require_relative "kleene/dsl"
 require_relative "kleene/nfa"
 require_relative "kleene/dfa"
 require_relative "kleene/multi_match_dfa"
-
+require_relative "kleene/online_dfa"
+require_relative "kleene/naive_online_regex"
+require_relative "kleene/parser"
 
 module Kleene
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kleene
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - David Ellis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-04 00:00:00.000000000 Z
+date: 2023-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: regexp_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 description: kleene is a library for building regular expression recognition automata
   - nfas, dfas, and some specialty structures.
 email:
@@ -45,7 +59,10 @@ files:
 - lib/kleene/dsl.rb
 - lib/kleene/kleene.rb
 - lib/kleene/multi_match_dfa.rb
+- lib/kleene/naive_online_regex.rb
 - lib/kleene/nfa.rb
+- lib/kleene/online_dfa.rb
+- lib/kleene/parser.rb
 - lib/kleene/patches.rb
 - lib/kleene/version.rb
 homepage: https://github.com/davidkellis/kleene-rb