omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/journey/gtg/builder.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/journey/gtg/transition_table"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class Builder # :nodoc:
+        DUMMY_END_NODE = Nodes::Dummy.new
+
+        attr_reader :root, :ast, :endpoints
+
+        def initialize(root)
+          @root      = root
+          @ast       = Nodes::Cat.new root, DUMMY_END_NODE
+          @followpos = build_followpos
+        end
+
+        def transition_table
+          dtrans   = TransitionTable.new
+          marked   = {}.compare_by_identity
+          state_id = Hash.new { |h, k| h[k] = h.length }.compare_by_identity
+          dstates  = [firstpos(root)]
+
+          until dstates.empty?
+            s = dstates.shift
+            next if marked[s]
+            marked[s] = true # mark s
+
+            s.group_by { |state| symbol(state) }.each do |sym, ps|
+              u = ps.flat_map { |l| @followpos[l] }.uniq
+              next if u.empty?
+
+              from = state_id[s]
+
+              if u.all? { |pos| pos == DUMMY_END_NODE }
+                to = state_id[Object.new]
+                dtrans[from, to] = sym
+                dtrans.add_accepting(to)
+
+                ps.each { |state| dtrans.add_memo(to, state.memo) }
+              else
+                to = state_id[u]
+                dtrans[from, to] = sym
+
+                if u.include?(DUMMY_END_NODE)
+                  ps.each do |state|
+                    if @followpos[state].include?(DUMMY_END_NODE)
+                      dtrans.add_memo(to, state.memo)
+                    end
+                  end
+
+                  dtrans.add_accepting(to)
+                end
+              end
+
+              dstates << u
+            end
+          end
+
+          dtrans
+        end
+
+        def nullable?(node)
+          case node
+          when Nodes::Group
+            true
+          when Nodes::Star
+            # the default star regex is /(.+)/ which is NOT nullable but since different
+            # constraints can be provided we must actually check if this is the case or not.
+            node.regexp.match?("")
+          when Nodes::Or
+            node.children.any? { |c| nullable?(c) }
+          when Nodes::Cat
+            nullable?(node.left) && nullable?(node.right)
+          when Nodes::Terminal
+            !node.left
+          when Nodes::Unary
+            nullable?(node.left)
+          else
+            raise ArgumentError, "unknown nullable: %s" % node.class.name
+          end
+        end
+
+        def firstpos(node)
+          case node
+          when Nodes::Star
+            firstpos(node.left)
+          when Nodes::Cat
+            if nullable?(node.left)
+              firstpos(node.left) | firstpos(node.right)
+            else
+              firstpos(node.left)
+            end
+          when Nodes::Or
+            node.children.flat_map { |c| firstpos(c) }.tap(&:uniq!)
+          when Nodes::Unary
+            firstpos(node.left)
+          when Nodes::Terminal
+            nullable?(node) ? [] : [node]
+          else
+            raise ArgumentError, "unknown firstpos: %s" % node.class.name
+          end
+        end
+
+        def lastpos(node)
+          case node
+          when Nodes::Star
+            lastpos(node.left)
+          when Nodes::Or
+            node.children.flat_map { |c| lastpos(c) }.tap(&:uniq!)
+          when Nodes::Cat
+            if nullable?(node.right)
+              lastpos(node.left) | lastpos(node.right)
+            else
+              lastpos(node.right)
+            end
+          when Nodes::Terminal
+            nullable?(node) ? [] : [node]
+          when Nodes::Unary
+            lastpos(node.left)
+          else
+            raise ArgumentError, "unknown lastpos: %s" % node.class.name
+          end
+        end
+
+        private
+          def build_followpos
+            table = Hash.new { |h, k| h[k] = [] }.compare_by_identity
+            @ast.each do |n|
+              case n
+              when Nodes::Cat
+                lastpos(n.left).each do |i|
+                  table[i] += firstpos(n.right)
+                end
+              end
+            end
+            table
+          end
+
+          def symbol(edge)
+            edge.symbol? ? edge.regexp : edge.left
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "strscan"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class MatchData # :nodoc:
+        attr_reader :memos
+
+        def initialize(memos)
+          @memos = memos
+        end
+      end
+
+      class Simulator # :nodoc:
+        INITIAL_STATE = [ [0, nil] ].freeze
+
+        attr_reader :tt
+
+        def initialize(transition_table)
+          @tt = transition_table
+        end
+
+        def memos(string)
+          input = StringScanner.new(string)
+          state = INITIAL_STATE
+          start_index = 0
+
+          while sym = input.scan(%r([/.?]|[^/.?]+))
+            end_index = start_index + sym.length
+
+            state = tt.move(state, string, start_index, end_index)
+
+            start_index = end_index
+          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)
+          end
+
+          acceptance_states.empty? ? yield : acceptance_states
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/journey/nfa/dot"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class TransitionTable # :nodoc:
+        include Journey::NFA::Dot
+
+        attr_reader :memos
+
+        DEFAULT_EXP = /[^.\/?]+/
+        DEFAULT_EXP_ANCHORED = /\A#{DEFAULT_EXP}\Z/
+
+        def initialize
+          @stdparam_states = {}
+          @regexp_states   = {}
+          @string_states   = {}
+          @accepting       = {}
+          @memos           = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def add_accepting(state)
+          @accepting[state] = true
+        end
+
+        def accepting_states
+          @accepting.keys
+        end
+
+        def accepting?(state)
+          @accepting[state]
+        end
+
+        def add_memo(idx, memo)
+          @memos[idx] << memo
+        end
+
+        def memo(idx)
+          @memos[idx]
+        end
+
+        def eclosure(t)
+          Array(t)
+        end
+
+        def move(t, full_string, start_index, end_index)
+          return [] if t.empty?
+
+          next_states = []
+
+          tok = full_string.slice(start_index, end_index - start_index)
+          token_matches_default_component = DEFAULT_EXP_ANCHORED.match?(tok)
+
+          t.each { |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_component && states = @stdparam_states[s]
+                states.each { |re, v| next_states << [v, nil].freeze if !v.nil? }
+              end
+
+              # When we have a literal string, we can just pull the next state
+              if states = @string_states[s]
+                next_states << [states[tok], nil].freeze unless states[tok].nil?
+              end
+            end
+
+            # For regexes that aren't the "default" style, they may potentially not be
+            # terminated by the first "token" [./?], so we need to continue to attempt to
+            # match this regexp as well as any successful paths that continue out of it.
+            # both paths could be valid.
+            if states = @regexp_states[s]
+              slice_start = if previous_start.nil?
+                start_index
+              else
+                previous_start
+              end
+
+              slice_length = end_index - slice_start
+              curr_slice = full_string.slice(slice_start, slice_length)
+
+              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)
+              }
+
+              # 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
+            end
+          }
+
+          next_states
+        end
+
+        def as_json(options = nil)
+          simple_regexp = Hash.new { |h, k| h[k] = {} }
+
+          @regexp_states.each do |from, hash|
+            hash.each do |re, to|
+              simple_regexp[from][re.source] = to
+            end
+          end
+
+          {
+            regexp_states:   simple_regexp,
+            string_states:   @string_states,
+            stdparam_states: @stdparam_states,
+            accepting:       @accepting
+          }
+        end
+
+        def to_svg
+          svg = IO.popen("dot -Tsvg", "w+") { |f|
+            f.write(to_dot)
+            f.close_write
+            f.readlines
+          }
+          3.times { svg.shift }
+          svg.join.sub(/width="[^"]*"/, "").sub(/height="[^"]*"/, "")
+        end
+
+        def visualizer(paths, title = "FSM")
+          viz_dir   = File.join __dir__, "..", "visualizer"
+          fsm_js    = File.read File.join(viz_dir, "fsm.js")
+          fsm_css   = File.read File.join(viz_dir, "fsm.css")
+          erb       = File.read File.join(viz_dir, "index.html.erb")
+          states    = "function tt() { return #{to_json}; }"
+
+          fun_routes = paths.sample(3).map do |ast|
+            ast.filter_map { |n|
+              case n
+              when Nodes::Symbol
+                case n.left
+                when ":id" then rand(100).to_s
+                when ":format" then %w{ xml json }.sample
+                else
+                  "omg"
+                end
+              when Nodes::Terminal then n.symbol
+              else
+                nil
+              end
+            }.join
+          end
+
+          stylesheets = [fsm_css]
+          svg         = to_svg
+          javascripts = [states, fsm_js]
+
+          fun_routes  = fun_routes
+          stylesheets = stylesheets
+          svg         = svg
+          javascripts = javascripts
+
+          require "erb"
+          template = ERB.new erb
+          template.result(binding)
+        end
+
+        def []=(from, to, sym)
+          to_mappings = states_hash_for(sym)[from] ||= {}
+          case sym
+          when Regexp
+            # we must match the whole string to a token boundary
+            if sym == DEFAULT_EXP
+              sym = DEFAULT_EXP_ANCHORED
+            else
+              sym = /\A#{sym}\Z/
+            end
+          when Symbol
+            # account for symbols in the constraints the same as strings
+            sym = sym.to_s
+          end
+          to_mappings[sym] = to
+        end
+
+        def states
+          ss = @string_states.keys + @string_states.values.flat_map(&:values)
+          ps = @stdparam_states.keys + @stdparam_states.values.flat_map(&:values)
+          rs = @regexp_states.keys + @regexp_states.values.flat_map(&:values)
+          (ss + ps + rs).uniq
+        end
+
+        def transitions
+          @string_states.flat_map { |from, hash|
+            hash.map { |s, to| [from, s, to] }
+          } + @stdparam_states.flat_map { |from, hash|
+            hash.map { |s, to| [from, s, to] }
+          } + @regexp_states.flat_map { |from, hash|
+            hash.map { |s, to| [from, s, to] }
+          }
+        end
+
+        private
+          def states_hash_for(sym)
+            case sym
+            when String, Symbol
+              @string_states
+            when Regexp
+              if sym == DEFAULT_EXP
+                @stdparam_states
+              else
+                @regexp_states
+              end
+            else
+              raise ArgumentError, "unknown symbol: %s" % sym.class
+            end
+          end
+      end
+    end
+  end
+end

data/lib/action_dispatch/journey/nfa/dot.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module NFA # :nodoc:
+      module Dot # :nodoc:
+        def to_dot
+          edges = transitions.map { |from, sym, to|
+            "  #{from} -> #{to} [label=\"#{sym || 'ε'}\"];"
+          }
+
+          <<-eodot
+digraph nfa {
+  rankdir=LR;
+  node [shape = doublecircle];
+  #{accepting_states.join ' '};
+  node [shape = circle];
+#{edges.join "\n"}
+}
+          eodot
+        end
+      end
+    end
+  end
+end

data/lib/action_dispatch/journey/nodes/node.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/journey/visitors"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Ast # :nodoc:
+      attr_reader :names, :path_params, :tree, :wildcard_options, :terminals
+      alias :root :tree
+
+      def initialize(tree, formatted)
+        @tree = tree
+        @path_params = []
+        @names = []
+        @symbols = []
+        @stars = []
+        @terminals = []
+        @wildcard_options = {}
+
+        visit_tree(formatted)
+      end
+
+      def requirements=(requirements)
+        # inject any regexp requirements for `star` nodes so they can be determined
+        # nullable, which requires knowing if the regex accepts an empty string.
+        (symbols + stars).each do |node|
+          re = requirements[node.to_sym]
+          node.regexp = re if re
+        end
+      end
+
+      def route=(route)
+        terminals.each { |n| n.memo = route }
+      end
+
+      def glob?
+        stars.any?
+      end
+
+      private
+        attr_reader :symbols, :stars
+
+        def visit_tree(formatted)
+          tree.each do |node|
+            if node.symbol?
+              path_params << node.to_sym
+              names << node.name
+              symbols << node
+            elsif node.star?
+              stars << node
+
+              if formatted != false
+                # Add a constraint for wildcard route to make it non-greedy and match the
+                # optional format part of the route by default.
+                wildcard_options[node.name.to_sym] ||= /.+?/m
+              end
+            end
+
+            if node.terminal?
+              terminals << node
+            end
+          end
+        end
+    end
+
+    module Nodes # :nodoc:
+      class Node # :nodoc:
+        include Enumerable
+
+        attr_accessor :left, :memo
+
+        def initialize(left)
+          @left = left
+          @memo = nil
+        end
+
+        def each(&block)
+          Visitors::Each::INSTANCE.accept(self, block)
+        end
+
+        def to_s
+          Visitors::String::INSTANCE.accept(self, "")
+        end
+
+        def to_dot
+          Visitors::Dot::INSTANCE.accept(self)
+        end
+
+        def to_sym
+          name.to_sym
+        end
+
+        def name
+          -left.tr("*:", "")
+        end
+
+        def type
+          raise NotImplementedError
+        end
+
+        def symbol?; false; end
+        def literal?; false; end
+        def terminal?; false; end
+        def star?; false; end
+        def cat?; false; end
+        def group?; false; end
+      end
+
+      class Terminal < Node # :nodoc:
+        alias :symbol :left
+        def terminal?; true; end
+      end
+
+      class Literal < Terminal # :nodoc:
+        def literal?; true; end
+        def type; :LITERAL; end
+      end
+
+      class Dummy < Literal # :nodoc:
+        def initialize(x = Object.new)
+          super
+        end
+
+        def literal?; false; end
+      end
+
+      class Slash < Terminal # :nodoc:
+        def type; :SLASH; end
+      end
+
+      class Dot < Terminal # :nodoc:
+        def type; :DOT; end
+      end
+
+      class Symbol < Terminal # :nodoc:
+        attr_accessor :regexp
+        alias :symbol :regexp
+        attr_reader :name
+
+        DEFAULT_EXP = /[^.\/?]+/
+        GREEDY_EXP = /(.+)/
+        def initialize(left, regexp = DEFAULT_EXP)
+          super(left)
+          @regexp = regexp
+          @name = -left.tr("*:", "")
+        end
+
+        def type; :SYMBOL; end
+        def symbol?; true; end
+      end
+
+      class Unary < Node # :nodoc:
+        def children; [left] end
+      end
+
+      class Group < Unary # :nodoc:
+        def type; :GROUP; end
+        def group?; true; end
+      end
+
+      class Star < Unary # :nodoc:
+        attr_accessor :regexp
+
+        def initialize(left)
+          super(left)
+
+          # By default wildcard routes are non-greedy and must match something.
+          @regexp = /.+?/m
+        end
+
+        def star?; true; end
+        def type; :STAR; end
+
+        def name
+          left.name.tr "*:", ""
+        end
+      end
+
+      class Binary < Node # :nodoc:
+        attr_accessor :right
+
+        def initialize(left, right)
+          super(left)
+          @right = right
+        end
+
+        def children; [left, right] end
+      end
+
+      class Cat < Binary # :nodoc:
+        def cat?; true; end
+        def type; :CAT; end
+      end
+
+      class Or < Node # :nodoc:
+        attr_reader :children
+
+        def initialize(children)
+          @children = children
+        end
+
+        def type; :OR; end
+      end
+    end
+  end
+end