andyjeffries-journey 1.0.0

data/lib/journey/parser.rb

@@ -0,0 +1,204 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+
+require 'journey/parser_extras'
+module Journey
+  class Parser < Racc::Parser
+##### State transition tables begin ###
+
+racc_action_table = [
+    17,    22,    13,    15,    14,     7,    15,    16,     8,    19,
+    13,    15,    14,     7,    24,    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,     8,     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,     3,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,     1,   nil,    23,
+     8,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -18,   -18,    -2,    -3,    -4,    -5,    -6,   -18,   -18,   -10,
+   -11,   -12,   -13,   -14,   -15,   -16,   -17,   -18,    -1,   -18,
+   -18,    -9,    25,    -8,    -7 ]
+
+racc_goto_table = [
+    18,     1,    21,   nil,   nil,   nil,   nil,   nil,    20,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    23,    18 ]
+
+racc_goto_check = [
+     2,     1,     7,   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,    -6,   nil,   nil,
+   nil ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,     4,     5,     6,    10,     9,    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,
+  2, 16, :_reduce_9,
+  1, 14, :_reduce_none,
+  1, 14, :_reduce_none,
+  1, 14, :_reduce_none,
+  1, 14, :_reduce_none,
+  1, 19, :_reduce_14,
+  1, 18, :_reduce_15,
+  1, 17, :_reduce_16,
+  1, 20, :_reduce_17 ]
+
+racc_reduce_n = 18
+
+racc_shift_n = 25
+
+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",
+  "literal",
+  "symbol",
+  "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.left)) 
+    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

data/lib/journey/parser.y

@@ -0,0 +1,47 @@
+class 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 literal       { result = Star.new(Symbol.new(val.last.left)) }
+    ;
+  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 'journey/parser_extras'

data/lib/journey/parser_extras.rb

@@ -0,0 +1,21 @@
+require 'journey/scanner'
+require 'journey/nodes/node'
+
+module Journey
+  class Parser < Racc::Parser
+    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

data/lib/journey/path/pattern.rb

@@ -0,0 +1,190 @@
+module Journey
+  module Path
+    class Pattern
+      attr_reader :spec, :requirements, :anchored
+
+      def initialize strexp
+        parser = Journey::Parser.new
+
+        @anchored = true
+
+        case strexp
+        when String
+          @spec         = parser.parse strexp
+          @requirements = {}
+          @separators   = "/.?"
+        when Router::Strexp
+          @spec         = parser.parse strexp.path
+          @requirements = strexp.requirements
+          @separators   = strexp.separators.join
+          @anchored     = strexp.anchor
+        else
+          raise "wtf bro: #{strexp}"
+        end
+
+        @names          = nil
+        @optional_names = nil
+        @required_names = nil
+        @re = nil
+      end
+
+      def ast
+        @spec.grep(Nodes::Symbol).each do |node|
+          re = @requirements[node.to_sym]
+          node.regexp = re if re
+        end
+
+        @spec.grep(Nodes::Star).each do |node|
+          node = node.left
+          node.regexp = @requirements[node.to_sym] || /(.+)/
+        end
+
+        @spec
+      end
+
+      def names
+        @names ||= spec.grep(Nodes::Symbol).map { |n| n.name }
+      end
+
+      def required_names
+        @required_names ||= names - optional_names
+      end
+
+      def optional_names
+        @optional_names ||= spec.grep(Nodes::Group).map { |group|
+          group.grep(Nodes::Symbol)
+        }.flatten.map { |n| n.name }.uniq
+      end
+
+      class RegexpOffsets < Journey::Visitors::Visitor # :nodoc:
+        attr_reader :offsets
+
+        def initialize matchers
+          @matchers      = matchers
+          @capture_count = [0]
+        end
+
+        def visit node
+          super
+          @capture_count
+        end
+
+        def visit_SYMBOL node
+          node = node.to_sym
+
+          if @matchers.key? node
+            re = /#{@matchers[node]}|/
+            @capture_count.push((re.match('').length - 1) + (@capture_count.last || 0))
+          else
+            @capture_count << (@capture_count.last || 0)
+          end
+        end
+      end
+
+      class AnchoredRegexp < Journey::Visitors::Visitor # :nodoc:
+        def initialize separator, matchers
+          @separator = separator
+          @matchers  = matchers
+          @separator_re = "([^#{separator}]+)"
+          super()
+        end
+
+        def accept node
+          %r{\A#{visit node}\Z}
+        end
+
+        def visit_CAT node
+          [visit(node.left), visit(node.right)].join
+        end
+
+        def visit_SYMBOL node
+          node = node.to_sym
+
+          return @separator_re unless @matchers.key? node
+
+          re = @matchers[node]
+          # FIXME: is the question mark needed?
+          "(#{re}?)"
+        end
+
+        def visit_GROUP node
+          "(?:#{visit node.left})?"
+        end
+
+        def visit_LITERAL node
+          Regexp.escape node.left
+        end
+        alias :visit_DOT :visit_LITERAL
+
+        def visit_SLASH node
+          node.left
+        end
+
+        def visit_STAR node
+          "(.+)"
+        end
+      end
+
+      class UnanchoredRegexp < AnchoredRegexp # :nodoc:
+        def accept node
+          %r{\A#{visit node}}
+        end
+      end
+
+      class MatchData
+        attr_reader :names
+
+        def initialize names, offsets, match
+          @names   = names
+          @offsets = offsets
+          @match   = match
+        end
+
+        def captures
+          (length - 1).times.map { |i| self[i + 1] }
+        end
+
+        def [] x
+          idx = @offsets[x - 1] + x
+          @match[idx]
+        end
+
+        def length
+          @offsets.length
+        end
+
+        def post_match
+          @match.post_match
+        end
+
+        def to_s
+          @match.to_s
+        end
+      end
+
+      def match other
+        return unless match = to_regexp.match(other)
+        MatchData.new names, offsets, match
+      end
+      alias :=~ :match
+
+      def source
+        to_regexp.source
+      end
+
+      private
+      def to_regexp
+        @re ||= regexp_visitor.new(@separators, @requirements).accept spec
+      end
+
+      def regexp_visitor
+        @anchored ? AnchoredRegexp : UnanchoredRegexp
+      end
+
+      def offsets
+        viz = RegexpOffsets.new @requirements
+        viz.accept spec
+      end
+    end
+  end
+end

data/lib/journey/route.rb

@@ -0,0 +1,92 @@
+module Journey
+  class Route
+    attr_reader :app, :path, :verb, :defaults, :ip, :name
+
+    attr_reader :constraints
+    alias :conditions :constraints
+
+    ##
+    # +path+ is a path constraint.
+    # +constraints+ is a hash of constraints to be applied to this route.
+    def initialize name, app, path, constraints, defaults = {}
+      constraints  = constraints.dup
+      @name        = name
+      @app         = app
+      @path        = path
+      @verb        = constraints[:request_method] || //
+      @ip          = constraints.delete(:ip) || //
+
+      @constraints = constraints
+      @constraints.keep_if { |_,v| Regexp === v || String === v }
+      @defaults    = defaults
+      @required_defaults = nil
+      @required_parts    = nil
+      @parts             = nil
+      @decorated_ast     = nil
+    end
+
+    def ast
+      return @decorated_ast if @decorated_ast
+
+      @decorated_ast = path.ast
+      @decorated_ast.grep(Nodes::Terminal).each { |n| n.memo = self }
+      @decorated_ast
+    end
+
+    def requirements # :nodoc:
+      # needed for rails `rake routes`
+      path.requirements.merge(@defaults).delete_if { |_,v|
+        /.+?/ == v
+      }
+    end
+
+    def segments
+      @path.names
+    end
+
+    def required_keys
+      path.required_names.map { |x| x.to_sym } + required_defaults.keys
+    end
+
+    def score constraints
+      required_keys = path.required_names
+      supplied_keys = constraints.map { |k,v| v && k.to_s }.compact
+
+      return -1 unless (required_keys - supplied_keys).empty?
+
+      score = (supplied_keys & path.names).length
+      score + (required_defaults.length * 2)
+    end
+
+    def parts
+      @parts ||= segments.map { |n| n.to_sym }
+    end
+    alias :segment_keys :parts
+
+    def format path_options
+      (defaults.keys - required_parts).each do |key|
+        path_options.delete key if defaults[key].to_s == path_options[key].to_s
+      end
+
+      formatter      = Visitors::Formatter.new(path_options)
+
+      formatted_path = formatter.accept(path.spec)
+      formatted_path.gsub(/\/\x00/, '')
+    end
+
+    def optional_parts
+      path.optional_names.map { |n| n.to_sym }
+    end
+
+    def required_parts
+      @required_parts ||= path.required_names.map { |n| n.to_sym }
+    end
+
+    def required_defaults
+      @required_defaults ||= begin
+        matches = parts
+        @defaults.dup.delete_if { |k,_| matches.include? k }
+      end
+    end
+  end
+end

data/lib/journey/router/strexp.rb

@@ -0,0 +1,22 @@
+module Journey
+  class Router
+    class Strexp
+      class << self
+        alias :compile :new
+      end
+
+      attr_reader :path, :requirements, :separators, :anchor
+
+      def initialize path, requirements, separators, anchor = true
+        @path         = path
+        @requirements = requirements
+        @separators   = separators
+        @anchor       = anchor
+      end
+
+      def names
+        @path.scan(/:\w+/).map { |s| s.tr(':', '') }
+      end
+    end
+  end
+end

data/lib/journey/router/utils.rb

@@ -0,0 +1,57 @@
+require 'uri'
+
+module Journey
+  class Router
+    class Utils
+      # Normalizes URI path.
+      #
+      # Strips off trailing slash and ensures there is a leading slash.
+      #
+      #   normalize_path("/foo")  # => "/foo"
+      #   normalize_path("/foo/") # => "/foo"
+      #   normalize_path("foo")   # => "/foo"
+      #   normalize_path("")      # => "/"
+      def self.normalize_path(path)
+        path = "/#{path}"
+        path.squeeze!('/')
+        path.sub!(%r{/+\Z}, '')
+        path = '/' if path == ''
+        path
+      end
+
+      # URI path and fragment escaping
+      # http://tools.ietf.org/html/rfc3986
+      module UriEscape
+        # Symbol captures can generate multiple path segments, so include /.
+        reserved_segment  = '/'
+        reserved_fragment = '/?'
+        reserved_pchar    = ':@&=+$,;%'
+
+        safe_pchar    = "#{URI::REGEXP::PATTERN::UNRESERVED}#{reserved_pchar}"
+        safe_segment  = "#{safe_pchar}#{reserved_segment}"
+        safe_fragment = "#{safe_pchar}#{reserved_fragment}"
+        if RUBY_VERSION >= '1.9'
+          UNSAFE_SEGMENT  = Regexp.new("[^#{safe_segment}]", false).freeze
+          UNSAFE_FRAGMENT = Regexp.new("[^#{safe_fragment}]", false).freeze
+        else
+          UNSAFE_SEGMENT = Regexp.new("[^#{safe_segment}]", false, 'N').freeze
+          UNSAFE_FRAGMENT = Regexp.new("[^#{safe_fragment}]", false, 'N').freeze
+        end
+      end
+
+      Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
+      def self.escape_path(path)
+        Parser.escape(path.to_s, UriEscape::UNSAFE_SEGMENT)
+      end
+
+      def self.escape_fragment(fragment)
+        Parser.escape(fragment.to_s, UriEscape::UNSAFE_FRAGMENT)
+      end
+
+      def self.unescape_uri(uri)
+        Parser.unescape(uri)
+      end
+    end
+  end
+end