omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/journey/router.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/journey/router/utils"
+require "action_dispatch/journey/routes"
+require "action_dispatch/journey/formatter"
+
+before = $-w
+$-w = false
+require "action_dispatch/journey/parser"
+$-w = before
+
+require "action_dispatch/journey/route"
+require "action_dispatch/journey/path/pattern"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Router # :nodoc:
+      attr_accessor :routes
+
+      def initialize(routes)
+        @routes = routes
+      end
+
+      def eager_load!
+        # Eagerly trigger the simulator's initialization so it doesn't happen during a
+        # request cycle.
+        simulator
+        nil
+      end
+
+      def serve(req)
+        find_routes(req) do |match, parameters, route|
+          set_params  = req.path_parameters
+          path_info   = req.path_info
+          script_name = req.script_name
+
+          unless route.path.anchored
+            req.script_name = (script_name.to_s + match.to_s).chomp("/")
+            req.path_info = match.post_match
+            req.path_info = "/" + req.path_info unless req.path_info.start_with? "/"
+          end
+
+          tmp_params = set_params.merge route.defaults
+          parameters.each_pair { |key, val|
+            tmp_params[key] = val.force_encoding(::Encoding::UTF_8)
+          }
+
+          req.path_parameters = tmp_params
+          req.route_uri_pattern = route.path.spec.to_s
+
+          _, headers, _ = response = route.app.serve(req)
+
+          if "pass" == headers[Constants::X_CASCADE]
+            req.script_name     = script_name
+            req.path_info       = path_info
+            req.path_parameters = set_params
+            next
+          end
+
+          return response
+        end
+
+        [404, { Constants::X_CASCADE => "pass" }, ["Not Found"]]
+      end
+
+      def recognize(rails_req)
+        find_routes(rails_req) do |match, parameters, route|
+          unless route.path.anchored
+            rails_req.script_name = match.to_s
+            rails_req.path_info   = match.post_match
+            rails_req.path_info   = "/" + rails_req.path_info unless rails_req.path_info.start_with? "/"
+          end
+
+          parameters = route.defaults.merge parameters
+          yield(route, parameters)
+        end
+      end
+
+      def visualizer
+        tt     = GTG::Builder.new(ast).transition_table
+        groups = partitioned_routes.first.map(&:ast).group_by(&:to_s)
+        asts   = groups.values.map(&:first)
+        tt.visualizer(asts)
+      end
+
+      private
+        def partitioned_routes
+          routes.partition { |r|
+            r.path.anchored && r.path.requirements_anchored?
+          }
+        end
+
+        def ast
+          routes.ast
+        end
+
+        def simulator
+          routes.simulator
+        end
+
+        def custom_routes
+          routes.custom_routes
+        end
+
+        def filter_routes(path)
+          return [] unless ast
+          simulator.memos(path) { [] }
+        end
+
+        def find_routes(req)
+          path_info = req.path_info
+          routes = filter_routes(path_info).concat custom_routes.find_all { |r|
+            r.path.match?(path_info)
+          }
+
+          if req.head?
+            routes = match_head_routes(routes, req)
+          else
+            routes.select! { |r| r.matches?(req) }
+          end
+
+          routes.sort_by!(&:precedence)
+
+          routes.each { |r|
+            match_data = r.path.match(path_info)
+            path_parameters = {}
+            match_data.names.each_with_index { |name, i|
+              val = match_data[i + 1]
+              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
+            }
+            yield [match_data, path_parameters, r]
+          }
+        end
+
+        def match_head_routes(routes, req)
+          head_routes = routes.select { |r| r.requires_matching_verb? && r.matches?(req) }
+          return head_routes unless head_routes.empty?
+
+          begin
+            req.request_method = "GET"
+            routes.select! { |r| r.matches?(req) }
+            routes
+          ensure
+            req.request_method = "HEAD"
+          end
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/routes.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Journey # :nodoc:
+    # The Routing table. Contains all routes for a system. Routes can be added to
+    # the table by calling Routes#add_route.
+    class Routes # :nodoc:
+      include Enumerable
+
+      attr_reader :routes, :custom_routes, :anchored_routes
+
+      def initialize(routes = [])
+        @routes             = routes
+        @ast                = nil
+        @anchored_routes    = []
+        @custom_routes      = []
+        @simulator          = nil
+      end
+
+      def empty?
+        routes.empty?
+      end
+
+      def length
+        routes.length
+      end
+      alias :size :length
+
+      def last
+        routes.last
+      end
+
+      def each(&block)
+        routes.each(&block)
+      end
+
+      def clear
+        routes.clear
+        anchored_routes.clear
+        custom_routes.clear
+      end
+
+      def partition_route(route)
+        if route.path.anchored && route.path.requirements_anchored?
+          anchored_routes << route
+        else
+          custom_routes << route
+        end
+      end
+
+      def ast
+        @ast ||= begin
+          nodes = anchored_routes.map(&:ast)
+          Nodes::Or.new(nodes)
+        end
+      end
+
+      def simulator
+        @simulator ||= begin
+          gtg = GTG::Builder.new(ast).transition_table
+          GTG::Simulator.new(gtg)
+        end
+      end
+
+      def add_route(name, mapping)
+        route = mapping.make_route name, routes.length
+        routes << route
+        partition_route(route)
+        clear_cache!
+        route
+      end
+
+      private
+        def clear_cache!
+          @ast                = nil
+          @simulator          = nil
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/scanner.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "strscan"
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Scanner # :nodoc:
+      STATIC_TOKENS = Array.new(150)
+      STATIC_TOKENS[".".ord] = :DOT
+      STATIC_TOKENS["/".ord] = :SLASH
+      STATIC_TOKENS["(".ord] = :LPAREN
+      STATIC_TOKENS[")".ord] = :RPAREN
+      STATIC_TOKENS["|".ord] = :OR
+      STATIC_TOKENS[":".ord] = :SYMBOL
+      STATIC_TOKENS["*".ord] = :STAR
+      STATIC_TOKENS.freeze
+
+      class Scanner < StringScanner
+        unless method_defined?(:peek_byte) # https://github.com/ruby/strscan/pull/89
+          def peek_byte
+            string.getbyte(pos)
+          end
+        end
+      end
+
+      def initialize
+        @scanner = nil
+        @length = nil
+      end
+
+      def scan_setup(str)
+        @scanner = Scanner.new(str)
+      end
+
+      def next_token
+        return if @scanner.eos?
+
+        until token = scan || @scanner.eos?; end
+        token
+      end
+
+      def last_string
+        -@scanner.string.byteslice(@scanner.pos - @length, @length)
+      end
+
+      def last_literal
+        last_str = @scanner.string.byteslice(@scanner.pos - @length, @length)
+        last_str.tr! "\\", ""
+        -last_str
+      end
+
+      private
+        def scan
+          next_byte = @scanner.peek_byte
+          case
+          when (token = STATIC_TOKENS[next_byte])
+            @scanner.pos += 1
+            @length = @scanner.skip(/\w+/).to_i + 1 if token == :SYMBOL || token == :STAR
+            token
+          when @length = @scanner.skip(/(?:[\w%\-~!$&'*+,;=@]|\\[:()])+/)
+            :LITERAL
+          when @length = @scanner.skip(/./)
+            :LITERAL
+          end
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/visitors.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # :stopdoc:
+  module Journey
+    class Format
+      ESCAPE_PATH    = ->(value) { Router::Utils.escape_path(value) }
+      ESCAPE_SEGMENT = ->(value) { Router::Utils.escape_segment(value) }
+
+      Parameter = Struct.new(:name, :escaper) do
+        def escape(value); escaper.call value; end
+      end
+
+      def self.required_path(symbol)
+        Parameter.new symbol, ESCAPE_PATH
+      end
+
+      def self.required_segment(symbol)
+        Parameter.new symbol, ESCAPE_SEGMENT
+      end
+
+      def initialize(parts)
+        @parts      = parts
+        @children   = []
+        @parameters = []
+
+        parts.each_with_index do |object, i|
+          case object
+          when Journey::Format
+            @children << i
+          when Parameter
+            @parameters << i
+          end
+        end
+      end
+
+      def evaluate(hash)
+        parts = @parts.dup
+
+        @parameters.each do |index|
+          param = parts[index]
+          value = hash[param.name]
+          return "" if value.nil?
+          parts[index] = param.escape value
+        end
+
+        @children.each { |index| parts[index] = parts[index].evaluate(hash) }
+
+        parts.join
+      end
+    end
+
+    module Visitors # :nodoc:
+      class Visitor # :nodoc:
+        DISPATCH_CACHE = {}
+
+        def accept(node)
+          visit(node)
+        end
+
+        private
+          def visit(node)
+            send(DISPATCH_CACHE[node.type], node)
+          end
+
+          def binary(node)
+            visit(node.left)
+            visit(node.right)
+          end
+          def visit_CAT(n); binary(n); end
+
+          def nary(node)
+            node.children.each { |c| visit(c) }
+          end
+          def visit_OR(n); nary(n); end
+
+          def unary(node)
+            visit(node.left)
+          end
+          def visit_GROUP(n); unary(n); end
+          def visit_STAR(n); unary(n); end
+
+          def terminal(node); end
+          def visit_LITERAL(n); terminal(n); end
+          def visit_SYMBOL(n);  terminal(n); end
+          def visit_SLASH(n);   terminal(n); end
+          def visit_DOT(n);     terminal(n); end
+
+          private_instance_methods(false).each do |pim|
+            next unless pim =~ /^visit_(.*)$/
+            DISPATCH_CACHE[$1.to_sym] = pim
+          end
+      end
+
+      class FunctionalVisitor # :nodoc:
+        DISPATCH_CACHE = {}
+
+        def accept(node, seed)
+          visit(node, seed)
+        end
+
+        def visit(node, seed)
+          send(DISPATCH_CACHE[node.type], node, seed)
+        end
+
+        def binary(node, seed)
+          visit(node.right, visit(node.left, seed))
+        end
+        def visit_CAT(n, seed); binary(n, seed); end
+
+        def nary(node, seed)
+          node.children.inject(seed) { |s, c| visit(c, s) }
+        end
+        def visit_OR(n, seed); nary(n, seed); end
+
+        def unary(node, seed)
+          visit(node.left, seed)
+        end
+        def visit_GROUP(n, seed); unary(n, seed); end
+        def visit_STAR(n, seed); unary(n, seed); end
+
+        def terminal(node, seed);   seed; end
+        def visit_LITERAL(n, seed); terminal(n, seed); end
+        def visit_SYMBOL(n, seed);  terminal(n, seed); end
+        def visit_SLASH(n, seed);   terminal(n, seed); end
+        def visit_DOT(n, seed);     terminal(n, seed); end
+
+        instance_methods(false).each do |pim|
+          next unless pim =~ /^visit_(.*)$/
+          DISPATCH_CACHE[$1.to_sym] = pim
+        end
+      end
+
+      class FormatBuilder < Visitor # :nodoc:
+        def accept(node); Journey::Format.new(super); end
+        def terminal(node); [node.left]; end
+
+        def binary(node)
+          visit(node.left) + visit(node.right)
+        end
+
+        def visit_GROUP(n); [Journey::Format.new(unary(n))]; end
+
+        def visit_STAR(n)
+          [Journey::Format.required_path(n.left.to_sym)]
+        end
+
+        def visit_SYMBOL(n)
+          symbol = n.to_sym
+          if symbol == :controller
+            [Journey::Format.required_path(symbol)]
+          else
+            [Journey::Format.required_segment(symbol)]
+          end
+        end
+      end
+
+      # Loop through the requirements AST.
+      class Each < FunctionalVisitor # :nodoc:
+        def visit(node, block)
+          block.call(node)
+          super
+        end
+
+        INSTANCE = new
+      end
+
+      class String < FunctionalVisitor # :nodoc:
+        private
+          def binary(node, seed)
+            visit(node.right, visit(node.left, seed))
+          end
+
+          def nary(node, seed)
+            last_child = node.children.last
+            node.children.inject(seed) { |s, c|
+              string = visit(c, s)
+              string << "|" unless last_child == c
+              string
+            }
+          end
+
+          def terminal(node, seed)
+            seed + node.left
+          end
+
+          def visit_GROUP(node, seed)
+            visit(node.left, seed.dup << "(") << ")"
+          end
+
+          INSTANCE = new
+      end
+
+      class Dot < FunctionalVisitor # :nodoc:
+        def initialize
+          @nodes = []
+          @edges = []
+        end
+
+        def accept(node, seed = [[], []])
+          super
+          nodes, edges = seed
+          <<-eodot
+  digraph parse_tree {
+    size="8,5"
+    node [shape = none];
+    edge [dir = none];
+    #{nodes.join "\n"}
+    #{edges.join("\n")}
+  }
+          eodot
+        end
+
+        private
+          def binary(node, seed)
+            seed.last.concat node.children.map { |c|
+              "#{node.object_id} -> #{c.object_id};"
+            }
+            super
+          end
+
+          def nary(node, seed)
+            seed.last.concat node.children.map { |c|
+              "#{node.object_id} -> #{c.object_id};"
+            }
+            super
+          end
+
+          def unary(node, seed)
+            seed.last << "#{node.object_id} -> #{node.left.object_id};"
+            super
+          end
+
+          def visit_GROUP(node, seed)
+            seed.first << "#{node.object_id} [label=\"()\"];"
+            super
+          end
+
+          def visit_CAT(node, seed)
+            seed.first << "#{node.object_id} [label=\"○\"];"
+            super
+          end
+
+          def visit_STAR(node, seed)
+            seed.first << "#{node.object_id} [label=\"*\"];"
+            super
+          end
+
+          def visit_OR(node, seed)
+            seed.first << "#{node.object_id} [label=\"|\"];"
+            super
+          end
+
+          def terminal(node, seed)
+            value = node.left
+
+            seed.first << "#{node.object_id} [label=\"#{value}\"];"
+            seed
+          end
+          INSTANCE = new
+      end
+    end
+  end
+  # :startdoc:
+end

data/lib/action_dispatch/journey/visualizer/fsm.css

@@ -0,0 +1,30 @@
+body {
+  font-family: "Helvetica Neue", Helvetica, Arial, Sans-Serif;
+  margin: 0;
+}
+
+h1 {
+  font-size: 2.0em; font-weight: bold; text-align: center;
+  color: white; background-color: black;
+  padding: 5px 0;
+  margin: 0 0 20px;
+}
+
+h2 {
+  text-align: center;
+  display: none;
+  font-size: 0.5em;
+}
+
+.clearfix {display: inline-block; }
+.input { overflow: show;}
+.instruction { color: #666; padding: 0 30px 20px; font-size: 0.9em}
+.instruction p { padding: 0 0 5px; }
+.instruction li { padding: 0 10px 5px; }
+
+.form { background: #EEE; padding: 20px 30px; border-radius: 5px; margin-left: auto; margin-right: auto; width: 500px; margin-bottom: 20px}
+.form p, .form form { text-align: center }
+.form form {padding: 0 10px 5px; }
+.form .fun_routes { font-size: 0.9em;}
+.form .fun_routes a { margin: 0 5px 0 0; }
+