actionpack 3.2.19 → 4.0.0

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

@@ -0,0 +1,76 @@
+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 @@
+# encoding: utf-8
+
+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.map { |k, memos|
+          #  (memos || []).map { |v| "  #{k} -> #{v.object_id};" }
+          #}.flatten.uniq
+
+        <<-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/nfa/simulator.rb

@@ -0,0 +1,47 @@
+require 'strscan'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module NFA # :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 simulate(string)
+          input = StringScanner.new(string)
+          state = tt.eclosure(0)
+          until input.eos?
+            sym   = input.scan(%r([/.?]|[^/.?]+))
+
+            # FIXME: tt.eclosure is not needed for the GTG
+            state = tt.eclosure(tt.move(state, sym))
+          end
+
+          acceptance_states = state.find_all { |s|
+            tt.accepting?(tt.eclosure(s).sort.last)
+          }
+
+          return if acceptance_states.empty?
+
+          memos = acceptance_states.map { |x| tt.memo(x) }.flatten.compact
+
+          MatchData.new(memos)
+        end
+
+        alias :=~    :simulate
+        alias :match :simulate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+require 'action_dispatch/journey/nfa/dot'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module NFA # :nodoc:
+      class TransitionTable # :nodoc:
+        include Journey::NFA::Dot
+
+        attr_accessor :accepting
+        attr_reader :memos
+
+        def initialize
+          @table     = Hash.new { |h,f| h[f] = {} }
+          @memos     = {}
+          @accepting = nil
+          @inverted  = nil
+        end
+
+        def accepting?(state)
+          accepting == state
+        end
+
+        def accepting_states
+          [accepting]
+        end
+
+        def add_memo(idx, memo)
+          @memos[idx] = memo
+        end
+
+        def memo(idx)
+          @memos[idx]
+        end
+
+        def []=(i, f, s)
+          @table[f][i] = s
+        end
+
+        def merge(left, right)
+          @memos[right] = @memos.delete(left)
+          @table[right] = @table.delete(left)
+        end
+
+        def states
+          (@table.keys + @table.values.map(&:keys).flatten).uniq
+        end
+
+        # Returns a generalized transition graph with reduced states. The states
+        # are reduced like a DFA, but the table must be simulated like an NFA.
+        #
+        # Edges of the GTG are regular expressions.
+        def generalized_table
+          gt       = GTG::TransitionTable.new
+          marked   = {}
+          state_id = Hash.new { |h,k| h[k] = h.length }
+          alphabet = self.alphabet
+
+          stack = [eclosure(0)]
+
+          until stack.empty?
+            state = stack.pop
+            next if marked[state] || state.empty?
+
+            marked[state] = true
+
+            alphabet.each do |alpha|
+              next_state = eclosure(following_states(state, alpha))
+              next if next_state.empty?
+
+              gt[state_id[state], state_id[next_state]] = alpha
+              stack << next_state
+            end
+          end
+
+          final_groups = state_id.keys.find_all { |s|
+            s.sort.last == accepting
+          }
+
+          final_groups.each do |states|
+            id = state_id[states]
+
+            gt.add_accepting(id)
+            save = states.find { |s|
+              @memos.key?(s) && eclosure(s).sort.last == accepting
+            }
+
+            gt.add_memo(id, memo(save))
+          end
+
+          gt
+        end
+
+        # Returns set of NFA states to which there is a transition on ast symbol
+        # +a+ from some state +s+ in +t+.
+        def following_states(t, a)
+          Array(t).map { |s| inverted[s][a] }.flatten.uniq
+        end
+
+        # Returns set of NFA states to which there is a transition on ast symbol
+        # +a+ from some state +s+ in +t+.
+        def move(t, a)
+          Array(t).map { |s|
+            inverted[s].keys.compact.find_all { |sym|
+              sym === a
+            }.map { |sym| inverted[s][sym] }
+          }.flatten.uniq
+        end
+
+        def alphabet
+          inverted.values.map(&:keys).flatten.compact.uniq.sort_by { |x| x.to_s }
+        end
+
+        # Returns a set of NFA states reachable from some NFA state +s+ in set
+        # +t+ on nil-transitions alone.
+        def eclosure(t)
+          stack = Array(t)
+          seen  = {}
+          children = []
+
+          until stack.empty?
+            s = stack.pop
+            next if seen[s]
+
+            seen[s] = true
+            children << s
+
+            stack.concat(inverted[s][nil])
+          end
+
+          children.uniq
+        end
+
+        def transitions
+          @table.map { |to, hash|
+            hash.map { |from, sym| [from, sym, to] }
+          }.flatten(1)
+        end
+
+        private
+
+          def inverted
+            return @inverted if @inverted
+
+            @inverted = Hash.new { |h, from|
+              h[from] = Hash.new { |j, s| j[s] = [] }
+            }
+
+            @table.each { |to, hash|
+              hash.each { |from, sym|
+                if sym
+                  sym = Nodes::Symbol === sym ? sym.regexp : sym.left
+                end
+
+                @inverted[from][sym] << to
+              }
+            }
+
+            @inverted
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+require 'action_dispatch/journey/visitors'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    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.new(block).accept(self)
+        end
+
+        def to_s
+          Visitors::String.new.accept(self)
+        end
+
+        def to_dot
+          Visitors::Dot.new.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
+      end
+
+      class Terminal < Node # :nodoc:
+        alias :symbol :left
+      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
+
+      %w{ Symbol Slash Dot }.each do |t|
+        class_eval <<-eoruby, __FILE__, __LINE__ + 1
+          class #{t} < Terminal;
+            def type; :#{t.upcase}; end
+          end
+        eoruby
+      end
+
+      class Symbol < Terminal # :nodoc:
+        attr_accessor :regexp
+        alias :symbol :regexp
+
+        DEFAULT_EXP = /[^\.\/\?]+/
+        def initialize(left)
+          super
+          @regexp = DEFAULT_EXP
+        end
+
+        def default_regexp?
+          regexp == DEFAULT_EXP
+        end
+
+        def symbol?; true; end
+      end
+
+      class Unary < Node # :nodoc:
+        def children; [left] end
+      end
+
+      class Group < Unary # :nodoc:
+        def type; :GROUP; end
+      end
+
+      class Star < Unary # :nodoc:
+        def type; :STAR; 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 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

data/lib/action_dispatch/journey/parser.rb

@@ -0,0 +1,206 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.9
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+
+require 'action_dispatch/journey/parser_extras'
+module ActionDispatch
+  module Journey # :nodoc:
+    class Parser < Racc::Parser # :nodoc:
+##### State transition tables begin ###
+
+racc_action_table = [
+    17,    21,    13,    15,    14,     7,   nil,    16,     8,    19,
+    13,    15,    14,     7,    23,    16,     8,    19,    13,    15,
+    14,     7,   nil,    16,     8,    13,    15,    14,     7,   nil,
+    16,     8,    13,    15,    14,     7,   nil,    16,     8 ]
+
+racc_action_check = [
+     1,    17,     1,     1,     1,     1,   nil,     1,     1,     1,
+    20,    20,    20,    20,    20,    20,    20,    20,     7,     7,
+     7,     7,   nil,     7,     7,    19,    19,    19,    19,   nil,
+    19,    19,     0,     0,     0,     0,   nil,     0,     0 ]
+
+racc_action_pointer = [
+    30,     0,   nil,   nil,   nil,   nil,   nil,    16,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,     1,   nil,    23,
+     8,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -18,   -18,    -2,    -3,    -4,    -5,    -6,   -18,    -9,   -10,
+   -11,   -12,   -13,   -14,   -15,   -16,   -17,   -18,    -1,   -18,
+   -18,    24,    -8,    -7 ]
+
+racc_goto_table = [
+    18,     1,   nil,   nil,   nil,   nil,   nil,   nil,    20,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    22,    18 ]
+
+racc_goto_check = [
+     2,     1,   nil,   nil,   nil,   nil,   nil,   nil,     1,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     2,     2 ]
+
+racc_goto_pointer = [
+   nil,     1,    -1,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,     4,     5,     6,     9,    10,    11,
+    12 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  2, 11, :_reduce_1,
+  1, 11, :_reduce_2,
+  1, 11, :_reduce_none,
+  1, 12, :_reduce_none,
+  1, 12, :_reduce_none,
+  1, 12, :_reduce_none,
+  3, 15, :_reduce_7,
+  3, 13, :_reduce_8,
+  1, 16, :_reduce_9,
+  1, 14, :_reduce_none,
+  1, 14, :_reduce_none,
+  1, 14, :_reduce_none,
+  1, 14, :_reduce_none,
+  1, 19, :_reduce_14,
+  1, 17, :_reduce_15,
+  1, 18, :_reduce_16,
+  1, 20, :_reduce_17 ]
+
+racc_reduce_n = 18
+
+racc_shift_n = 24
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :SLASH => 2,
+  :LITERAL => 3,
+  :SYMBOL => 4,
+  :LPAREN => 5,
+  :RPAREN => 6,
+  :DOT => 7,
+  :STAR => 8,
+  :OR => 9 }
+
+racc_nt_base = 10
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "SLASH",
+  "LITERAL",
+  "SYMBOL",
+  "LPAREN",
+  "RPAREN",
+  "DOT",
+  "STAR",
+  "OR",
+  "$start",
+  "expressions",
+  "expression",
+  "or",
+  "terminal",
+  "group",
+  "star",
+  "symbol",
+  "literal",
+  "slash",
+  "dot" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+ result = Cat.new(val.first, val.last)
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = val.first
+    result
+end
+
+# reduce 3 omitted
+
+# reduce 4 omitted
+
+# reduce 5 omitted
+
+# reduce 6 omitted
+
+def _reduce_7(val, _values, result)
+ result = Group.new(val[1])
+    result
+end
+
+def _reduce_8(val, _values, result)
+ result = Or.new([val.first, val.last])
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = Star.new(Symbol.new(val.last))
+    result
+end
+
+# reduce 10 omitted
+
+# reduce 11 omitted
+
+# reduce 12 omitted
+
+# reduce 13 omitted
+
+def _reduce_14(val, _values, result)
+ result = Slash.new('/')
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = Symbol.new(val.first)
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = Literal.new(val.first)
+    result
+end
+
+def _reduce_17(val, _values, result)
+ result = Dot.new(val.first)
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class Parser
+    end   # module Journey
+  end   # module ActionDispatch

data/lib/action_dispatch/journey/parser.y

@@ -0,0 +1,47 @@
+class ActionDispatch::Journey::Parser
+
+token SLASH LITERAL SYMBOL LPAREN RPAREN DOT STAR OR
+
+rule
+  expressions
+    : expressions expression  { result = Cat.new(val.first, val.last) }
+    | expression              { result = val.first }
+    | or
+    ;
+  expression
+    : terminal
+    | group
+    | star
+    ;
+  group
+    : LPAREN expressions RPAREN { result = Group.new(val[1]) }
+    ;
+  or
+    : expressions OR expression { result = Or.new([val.first, val.last]) }
+    ;
+  star
+    : STAR       { result = Star.new(Symbol.new(val.last)) }
+    ;
+  terminal
+    : symbol
+    | literal
+    | slash
+    | dot
+    ;
+  slash
+    : SLASH              { result = Slash.new('/') }
+    ;
+  symbol
+    : SYMBOL             { result = Symbol.new(val.first) }
+    ;
+  literal
+    : LITERAL            { result = Literal.new(val.first) }
+  dot
+    : DOT                { result = Dot.new(val.first) }
+    ;
+
+end
+
+---- header
+
+require 'action_dispatch/journey/parser_extras'

data/lib/action_dispatch/journey/parser_extras.rb

@@ -0,0 +1,23 @@
+require 'action_dispatch/journey/scanner'
+require 'action_dispatch/journey/nodes/node'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    class Parser < Racc::Parser # :nodoc:
+      include Journey::Nodes
+
+      def initialize
+        @scanner = Scanner.new
+      end
+
+      def parse(string)
+        @scanner.scan_setup(string)
+        do_parse
+      end
+
+      def next_token
+        @scanner.next_token
+      end
+    end
+  end
+end