actionpack 5.2.3

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "action_dispatch/journey/gtg/transition_table"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class Builder # :nodoc:
+        DUMMY = Nodes::Dummy.new
+
+        attr_reader :root, :ast, :endpoints
+
+        def initialize(root)
+          @root      = root
+          @ast       = Nodes::Cat.new root, DUMMY
+          @followpos = nil
+        end
+
+        def transition_table
+          dtrans   = TransitionTable.new
+          marked   = {}
+          state_id = Hash.new { |h, k| h[k] = h.length }
+
+          start   = firstpos(root)
+          dstates = [start]
+          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) }
+              next if u.empty?
+
+              if u.uniq == [DUMMY]
+                from = state_id[s]
+                to   = state_id[Object.new]
+                dtrans[from, to] = sym
+
+                dtrans.add_accepting(to)
+                ps.each { |state| dtrans.add_memo(to, state.memo) }
+              else
+                dtrans[state_id[s], state_id[u]] = sym
+
+                if u.include?(DUMMY)
+                  to = state_id[u]
+
+                  accepting = ps.find_all { |l| followpos(l).include?(DUMMY) }
+
+                  accepting.each { |accepting_state|
+                    dtrans.add_memo(to, accepting_state.memo)
+                  }
+
+                  dtrans.add_accepting(state_id[u])
+                end
+              end
+
+              dstates << u
+            end
+          end
+
+          dtrans
+        end
+
+        def nullable?(node)
+          case node
+          when Nodes::Group
+            true
+          when Nodes::Star
+            true
+          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) }.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
+            firstpos(node.left)
+          when Nodes::Or
+            node.children.flat_map { |c| lastpos(c) }.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
+
+        def followpos(node)
+          followpos_table[node]
+        end
+
+        private
+
+          def followpos_table
+            @followpos ||= build_followpos
+          end
+
+          def build_followpos
+            table = Hash.new { |h, k| h[k] = [] }
+            @ast.each do |n|
+              case n
+              when Nodes::Cat
+                lastpos(n.left).each do |i|
+                  table[i] += firstpos(n.right)
+                end
+              when Nodes::Star
+                lastpos(n).each do |i|
+                  table[i] += firstpos(n)
+                end
+              end
+            end
+            table
+          end
+
+          def symbol(edge)
+            case edge
+            when Journey::Nodes::Symbol
+              edge.regexp
+            else
+              edge.left
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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:
+        attr_reader :tt
+
+        def initialize(transition_table)
+          @tt = transition_table
+        end
+
+        def memos(string)
+          input = StringScanner.new(string)
+          state = [0]
+          while sym = input.scan(%r([/.?]|[^/.?]+))
+            state = tt.move(state, sym)
+          end
+
+          acceptance_states = state.find_all { |s|
+            tt.accepting? s
+          }
+
+          return yield if acceptance_states.empty?
+
+          acceptance_states.flat_map { |x| tt.memo(x) }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "action_dispatch/journey/nfa/dot"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class TransitionTable # :nodoc:
+        include Journey::NFA::Dot
+
+        attr_reader :memos
+
+        def initialize
+          @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, a)
+          return [] if t.empty?
+
+          regexps = []
+
+          t.map { |s|
+            if states = @regexp_states[s]
+              regexps.concat states.map { |re, v| re === a ? v : nil }
+            end
+
+            if states = @string_states[s]
+              states[a]
+            end
+          }.compact.concat regexps
+        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,
+            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.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
+            }.compact.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] ||= {}
+          to_mappings[sym] = to
+        end
+
+        def states
+          ss = @string_states.keys + @string_states.values.flat_map(&:values)
+          rs = @regexp_states.keys + @regexp_states.values.flat_map(&:values)
+          (ss + rs).uniq
+        end
+
+        def transitions
+          @string_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
+              @string_states
+            when Regexp
+              @regexp_states
+            else
+              raise ArgumentError, "unknown symbol: %s" % sym.class
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "action_dispatch/journey/nfa/transition_table"
+require "action_dispatch/journey/gtg/transition_table"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module NFA # :nodoc:
+      class Visitor < Visitors::Visitor # :nodoc:
+        def initialize(tt)
+          @tt = tt
+          @i  = -1
+        end
+
+        def visit_CAT(node)
+          left  = visit(node.left)
+          right = visit(node.right)
+
+          @tt.merge(left.last, right.first)
+
+          [left.first, right.last]
+        end
+
+        def visit_GROUP(node)
+          from  = @i += 1
+          left  = visit(node.left)
+          to    = @i += 1
+
+          @tt.accepting = to
+
+          @tt[from, left.first] = nil
+          @tt[left.last, to] = nil
+          @tt[from, to] = nil
+
+          [from, to]
+        end
+
+        def visit_OR(node)
+          from = @i += 1
+          children = node.children.map { |c| visit(c) }
+          to = @i += 1
+
+          children.each do |child|
+            @tt[from, child.first] = nil
+            @tt[child.last, to]    = nil
+          end
+
+          @tt.accepting = to
+
+          [from, to]
+        end
+
+        def terminal(node)
+          from_i = @i += 1 # new state
+          to_i   = @i += 1 # new state
+
+          @tt[from_i, to_i] = node
+          @tt.accepting = to_i
+          @tt.add_memo(to_i, node.memo)
+
+          [from_i, to_i]
+        end
+      end
+
+      class Builder # :nodoc:
+        def initialize(ast)
+          @ast = ast
+        end
+
+        def transition_table
+          tt = TransitionTable.new
+          Visitor.new(tt).accept(@ast)
+          tt
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module NFA # :nodoc:
+      module Dot # :nodoc:
+        def to_dot
+          edges = transitions.map { |from, sym, to|
+            "  #{from} -> #{to} [label=\"#{sym || 'ε'}\"];"
+          }
+
+          # memo_nodes = memos.values.flatten.map { |n|
+          #   label = n
+          #   if Journey::Route === n
+          #     label = "#{n.verb.source} #{n.path.spec}"
+          #   end
+          #   "  #{n.object_id} [label=\"#{label}\", shape=box];"
+          # }
+          # memo_edges = memos.flat_map { |k, memos|
+          #   (memos || []).map { |v| "  #{k} -> #{v.object_id};" }
+          # }.uniq
+
+          <<-eodot
+digraph nfa {
+  rankdir=LR;
+  node [shape = doublecircle];
+  #{accepting_states.join ' '};
+  node [shape = circle];
+#{edges.join "\n"}
+}
+          eodot
+        end
+      end
+    end
+  end
+end