Flatten the transition table state arrays

Using arrays of arrays means lots of extra small allocations
we can instead store it all in a single array.

Author: byroot

actionpack/lib/action_dispatch/journey/gtg/simulator.rb

@@ -20,7 +20,7 @@ class Simulator # :nodoc:
         STATIC_TOKENS["?".ord] = "?"
         STATIC_TOKENS.freeze
 
-        INITIAL_STATE = [ [0, nil] ].freeze
+        INITIAL_STATE = [0, nil].freeze
 
         attr_reader :tt
 
@@ -50,9 +50,9 @@ def memos(string)
             end
           end
 
-          acceptance_states = state.each_with_object([]) do |s_d, memos|
-            s, idx = s_d
-            memos.concat(tt.memo(s)) if idx.nil? && tt.accepting?(s)
+          acceptance_states = []
+          state.each_slice(2) do |s, idx|
+            acceptance_states.concat(tt.memo(s)) if idx.nil? && tt.accepting?(s)
           end
 
           acceptance_states.empty? ? yield : acceptance_states

actionpack/lib/action_dispatch/journey/gtg/transition_table.rb

@@ -52,17 +52,18 @@ def move(t, full_string, token, start_index, token_matches_default)
 
           next_states = []
 
-          t.each { |s, previous_start|
+          t.each_slice(2) { |s, previous_start|
             if previous_start.nil?
               # In the simple case of a "default" param regex do this fast-path and add all
               # next states.
               if token_matches_default && std_state = @stdparam_states[s]
-                next_states << [std_state, nil].freeze
+                next_states << std_state << nil
               end
 
               # When we have a literal string, we can just pull the next state
               if states = @string_states[s]
-                next_states << [states[token], nil].freeze unless states[token].nil?
+                state = states[token]
+                next_states << state << nil unless state.nil?
               end
             end
 
@@ -82,12 +83,12 @@ def move(t, full_string, token, start_index, token_matches_default)
 
               states.each { |re, v|
                 # if we match, we can try moving past this
-                next_states << [v, nil].freeze if !v.nil? && re.match?(curr_slice)
+                next_states << v << nil if !v.nil? && re.match?(curr_slice)
               }
 
               # and regardless, we must continue accepting tokens and retrying this regexp. we
               # need to remember where we started as well so we can take bigger slices.
-              next_states << [s, slice_start].freeze
+              next_states << s << slice_start
             end
           }
 

actionpack/test/journey/gtg/builder_test.rb

@@ -8,13 +8,13 @@ module GTG
       class TestBuilder < ActiveSupport::TestCase
         def test_following_states_multi
           table = tt ["a|a"]
-          assert_equal 1, table.move([[0, nil]], "a", "a", 0, true).length
+          assert_equal 1, table.move([0, nil], "a", "a", 0, true).each_slice(2).count
         end
 
         def test_following_states_multi_regexp
           table = tt [":a|b"]
-          assert_equal 1, table.move([[0, nil]], "fooo", "fooo", 0, true).length
-          assert_equal 2, table.move([[0, nil]], "b", "b", 0, true).length
+          assert_equal 1, table.move([0, nil], "fooo", "fooo", 0, true).each_slice(2).count
+          assert_equal 2, table.move([0, nil], "b", "b", 0, true).each_slice(2).count
         end
 
         def test_multi_path
@@ -25,9 +25,9 @@ def test_multi_path
             [2, "b"],
             [2, "/"],
             [1, "c"],
-          ].inject([[0, nil]]) { |state, (exp, sym)|
+          ].inject([0, nil]) { |state, (exp, sym)|
             new = table.move(state, sym, sym, 0, sym != "/")
-            assert_equal exp, new.length
+            assert_equal exp, new.each_slice(2).count
             new
           }
         end