1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
module ActionDispatch
module Journey # :nodoc:
class Route # :nodoc:
attr_reader :app, :path, :defaults, :name
attr_reader :constraints
alias :conditions :constraints
attr_accessor :precedence
##
# +path+ is a path constraint.
# +constraints+ is a hash of constraints to be applied to this route.
def initialize(name, app, path, constraints, defaults = {})
@name = name
@app = app
@path = path
# Unwrap any constraints so we can see what's inside for route generation.
# This allows the formatter to skip over any mounted applications or redirects
# that shouldn't be matched when using a url_for without a route name.
while app.is_a?(Routing::Mapper::Constraints) do
app = app.app
end
@dispatcher = app.is_a?(Routing::RouteSet::Dispatcher)
@constraints = constraints
@defaults = defaults
@required_defaults = nil
@required_parts = nil
@parts = nil
@decorated_ast = nil
@precedence = 0
end
def ast
@decorated_ast ||= begin
decorated_ast = path.ast
decorated_ast.grep(Nodes::Terminal).each { |n| n.memo = self }
decorated_ast
end
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
required_parts + 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)
path_options.delete_if do |key, value|
value.to_s == defaults[key].to_s && !required_parts.include?(key)
end
Visitors::Formatter.new(path_options).accept(path.spec)
end
def optimized_path
Visitors::OptimizedPath.new.accept(path.spec)
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_default?(key)
(constraints[:required_defaults] || []).include?(key)
end
def required_defaults
@required_defaults ||= @defaults.dup.delete_if do |k,_|
parts.include?(k) || !required_default?(k)
end
end
def glob?
!path.spec.grep(Nodes::Star).empty?
end
def dispatcher?
@dispatcher
end
def matches?(request)
constraints.all? do |method, value|
next true unless request.respond_to?(method)
case value
when Regexp, String
value === request.send(method).to_s
when Array
value.include?(request.send(method))
when TrueClass
request.send(method).present?
when FalseClass
request.send(method).blank?
else
value === request.send(method)
end
end
end
def ip
constraints[:ip] || //
end
def verb
constraints[:request_method] || //
end
end
end
end
|
