actionpack 3.2.19 → 4.2.11.3

data/lib/action_dispatch/journey/router.rb

@@ -0,0 +1,144 @@
+require 'action_dispatch/journey/router/utils'
+require 'action_dispatch/journey/router/strexp'
+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:
+      class RoutingError < ::StandardError # :nodoc:
+      end
+
+      # :nodoc:
+      VERSION = '2.0.0'
+
+      attr_accessor :routes
+
+      def initialize(routes)
+        @routes = routes
+      end
+
+      def serve(req)
+        find_routes(req).each 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
+
+          req.path_parameters = set_params.merge parameters
+
+          status, headers, body = route.app.serve(req)
+
+          if 'pass' == headers['X-Cascade']
+            req.script_name     = script_name
+            req.path_info       = path_info
+            req.path_parameters = set_params
+            next
+          end
+
+          return [status, headers, body]
+        end
+
+        return [404, {'X-Cascade' => 'pass'}, ['Not Found']]
+      end
+
+      def recognize(rails_req)
+        find_routes(rails_req).each do |match, parameters, route|
+          unless route.path.anchored
+            rails_req.script_name = match.to_s
+            rails_req.path_info   = match.post_match.sub(/^([^\/])/, '/\1')
+          end
+
+          yield(route, parameters)
+        end
+      end
+
+      def visualizer
+        tt     = GTG::Builder.new(ast).transition_table
+        groups = partitioned_routes.first.map(&:ast).group_by { |a| a.to_s }
+        asts   = groups.values.map { |v| v.first }
+        tt.visualizer(asts)
+      end
+
+      private
+
+        def partitioned_routes
+          routes.partitioned_routes
+        end
+
+        def ast
+          routes.ast
+        end
+
+        def simulator
+          routes.simulator
+        end
+
+        def custom_routes
+          partitioned_routes.last
+        end
+
+        def filter_routes(path)
+          return [] unless ast
+          simulator.memos(path) { [] }
+        end
+
+        def find_routes req
+          routes = filter_routes(req.path_info).concat custom_routes.find_all { |r|
+            r.path.match(req.path_info)
+          }
+
+          routes =
+            if req.request_method == "HEAD"
+              match_head_routes(routes, req)
+            else
+              match_routes(routes, req)
+            end
+
+          routes.sort_by!(&:precedence)
+
+          routes.map! { |r|
+            match_data  = r.path.match(req.path_info)
+            path_parameters = r.defaults.dup
+            match_data.names.zip(match_data.captures) { |name,val|
+              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
+            }
+            [match_data, path_parameters, r]
+          }
+        end
+
+        def match_head_routes(routes, req)
+          verb_specific_routes = routes.reject { |route| route.verb == // }
+          head_routes = match_routes(verb_specific_routes, req)
+
+          if head_routes.empty?
+            begin
+              req.request_method = "GET"
+              match_routes(routes, req)
+            ensure
+              req.request_method = "HEAD"
+            end
+          else
+            head_routes
+          end
+        end
+
+        def match_routes(routes, req)
+          routes.select { |r| r.matches?(req) }
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/routes.rb

@@ -0,0 +1,80 @@
+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, :named_routes
+
+      def initialize
+        @routes             = []
+        @named_routes       = {}
+        @ast                = nil
+        @partitioned_routes = nil
+        @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
+        named_routes.clear
+      end
+
+      def partitioned_routes
+        @partitioned_routes ||= routes.partition do |r|
+          r.path.anchored && r.ast.grep(Nodes::Symbol).all?(&:default_regexp?)
+        end
+      end
+
+      def ast
+        @ast ||= begin
+          asts = partitioned_routes.first.map(&:ast)
+          Nodes::Or.new(asts) unless asts.empty?
+        end
+      end
+
+      def simulator
+        @simulator ||= begin
+          gtg = GTG::Builder.new(ast).transition_table
+          GTG::Simulator.new(gtg)
+        end
+      end
+
+      # Add a route to the routing table.
+      def add_route(app, path, conditions, defaults, name = nil)
+        route = Route.new(name, app, path, conditions, defaults)
+
+        route.precedence = routes.length
+        routes << route
+        named_routes[name] = route if name && !named_routes[name]
+        clear_cache!
+        route
+      end
+
+      private
+
+        def clear_cache!
+          @ast                = nil
+          @partitioned_routes = nil
+          @simulator          = nil
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/scanner.rb

@@ -0,0 +1,61 @@
+require 'strscan'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Scanner # :nodoc:
+      def initialize
+        @ss = nil
+      end
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+      end
+
+      def eos?
+        @ss.eos?
+      end
+
+      def pos
+        @ss.pos
+      end
+
+      def pre_match
+        @ss.pre_match
+      end
+
+      def next_token
+        return if @ss.eos?
+
+        until token = scan || @ss.eos?; end
+        token
+      end
+
+      private
+
+        def scan
+          case
+            # /
+          when text = @ss.scan(/\//)
+            [:SLASH, text]
+          when text = @ss.scan(/\*\w+/)
+            [:STAR, text]
+          when text = @ss.scan(/(?<!\\)\(/)
+            [:LPAREN, text]
+          when text = @ss.scan(/(?<!\\)\)/)
+            [:RPAREN, text]
+          when text = @ss.scan(/\|/)
+            [:OR, text]
+          when text = @ss.scan(/\./)
+            [:DOT, text]
+          when text = @ss.scan(/(?<!\\):\w+/)
+            [:SYMBOL, text]
+          when text = @ss.scan(/(?:[\w%\-~!$&'*+,;=@]|\\:|\\\(|\\\))+/)
+            [:LITERAL, text.tr('\\', '')]
+            # any char
+          when text = @ss.scan(/./)
+            [:LITERAL, text]
+          end
+        end
+    end
+  end
+end

data/lib/action_dispatch/journey/visitors.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Format
+      ESCAPE_PATH    = ->(value) { Router::Utils.escape_path(value) }
+      ESCAPE_SEGMENT = ->(value) { Router::Utils.escape_segment(value) }
+
+      class Parameter < Struct.new(:name, :escaper)
+        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 ''.freeze unless value
+          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 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 < Visitor # :nodoc:
+        attr_reader :block
+
+        def initialize(block)
+          @block = block
+        end
+
+        def visit(node)
+          block.call(node)
+          super
+        end
+      end
+
+      class String < Visitor # :nodoc:
+        private
+
+        def binary(node)
+          [visit(node.left), visit(node.right)].join
+        end
+
+        def nary(node)
+          node.children.map { |c| visit(c) }.join '|'
+        end
+
+        def terminal(node)
+          node.left
+        end
+
+        def visit_GROUP(node)
+          "(#{visit(node.left)})"
+        end
+      end
+
+      class Dot < Visitor # :nodoc:
+        def initialize
+          @nodes = []
+          @edges = []
+        end
+
+        def accept(node)
+          super
+          <<-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)
+            node.children.each do |c|
+              @edges << "#{node.object_id} -> #{c.object_id};"
+            end
+            super
+          end
+
+          def nary(node)
+            node.children.each do |c|
+              @edges << "#{node.object_id} -> #{c.object_id};"
+            end
+            super
+          end
+
+          def unary(node)
+            @edges << "#{node.object_id} -> #{node.left.object_id};"
+            super
+          end
+
+          def visit_GROUP(node)
+            @nodes << "#{node.object_id} [label=\"()\"];"
+            super
+          end
+
+          def visit_CAT(node)
+            @nodes << "#{node.object_id} [label=\"○\"];"
+            super
+          end
+
+          def visit_STAR(node)
+            @nodes << "#{node.object_id} [label=\"*\"];"
+            super
+          end
+
+          def visit_OR(node)
+            @nodes << "#{node.object_id} [label=\"|\"];"
+            super
+          end
+
+          def terminal(node)
+            value = node.left
+
+            @nodes << "#{node.object_id} [label=\"#{value}\"];"
+          end
+      end
+    end
+  end
+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; }
+

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

@@ -0,0 +1,134 @@
+function tokenize(input, callback) {
+  while(input.length > 0) {
+    callback(input.match(/^[\/\.\?]|[^\/\.\?]+/)[0]);
+    input = input.replace(/^[\/\.\?]|[^\/\.\?]+/, '');
+  }
+}
+
+var graph = d3.select("#chart-2 svg");
+var svg_edges = {};
+var svg_nodes = {};
+
+graph.selectAll("g.edge").each(function() {
+  var node  = d3.select(this);
+  var index = node.select("title").text().split("->");
+  var left  = parseInt(index[0]);
+  var right = parseInt(index[1]);
+
+  if(!svg_edges[left]) { svg_edges[left] = {} }
+  svg_edges[left][right] = node;
+});
+
+graph.selectAll("g.node").each(function() {
+  var node  = d3.select(this);
+  var index = parseInt(node.select("title").text());
+  svg_nodes[index] = node;
+});
+
+function reset_graph() {
+  for(var key in svg_edges) {
+    for(var mkey in svg_edges[key]) {
+      var node = svg_edges[key][mkey];
+      var path = node.select("path");
+      var arrow = node.select("polygon");
+      path.style("stroke", "black");
+      arrow.style("stroke", "black").style("fill", "black");
+    }
+  }
+
+  for(var key in svg_nodes) {
+    var node = svg_nodes[key];
+    node.select('ellipse').style("fill", "white");
+    node.select('polygon').style("fill", "white");
+  }
+  return false;
+}
+
+function highlight_edge(from, to) {
+  var node = svg_edges[from][to];
+  var path = node.select("path");
+  var arrow = node.select("polygon");
+
+  path
+    .transition().duration(500)
+    .style("stroke", "green");
+
+  arrow
+    .transition().duration(500)
+    .style("stroke", "green").style("fill", "green");
+}
+
+function highlight_state(index, color) {
+  if(!color) { color = "green"; }
+
+  svg_nodes[index].select('ellipse')
+    .style("fill", "white")
+    .transition().duration(500)
+    .style("fill", color);
+}
+
+function highlight_finish(index) {
+  svg_nodes[index].select('polygon')
+    .style("fill", "while")
+    .transition().duration(500)
+    .style("fill", "blue");
+}
+
+function match(input) {
+  reset_graph();
+  var table         = tt();
+  var states        = [0];
+  var regexp_states = table['regexp_states'];
+  var string_states = table['string_states'];
+  var accepting     = table['accepting'];
+
+  highlight_state(0);
+
+  tokenize(input, function(token) {
+    var new_states = [];
+    for(var key in states) {
+      var state = states[key];
+
+      if(string_states[state] && string_states[state][token]) {
+        var new_state = string_states[state][token];
+        highlight_edge(state, new_state);
+        highlight_state(new_state);
+        new_states.push(new_state);
+      }
+
+      if(regexp_states[state]) {
+        for(var key in regexp_states[state]) {
+          var re = new RegExp("^" + key + "$");
+          if(re.test(token)) {
+            var new_state = regexp_states[state][key];
+            highlight_edge(state, new_state);
+            highlight_state(new_state);
+            new_states.push(new_state);
+          }
+        }
+      }
+    }
+
+    if(new_states.length == 0) {
+      return;
+    }
+    states = new_states;
+  });
+
+  for(var key in states) {
+    var state = states[key];
+    if(accepting[state]) {
+      for(var mkey in svg_edges[state]) {
+        if(!regexp_states[mkey] && !string_states[mkey]) {
+          highlight_edge(state, mkey);
+          highlight_finish(mkey);
+        }
+      }
+    } else {
+      highlight_state(state, "red");
+    }
+  }
+
+  return false;
+}
+