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
|
module ActionDispatch
module Journey # :nodoc:
class Route # :nodoc:
attr_reader :app, :path, :defaults, :name
attr_reader :constraints
alias :conditions :constraints
attr_accessor :precedence
ANY = //
def self.build(name, app, path, constraints, required_defaults, defaults)
request_method_match = constraints.delete(:request_method) || ANY
new name, app, path, constraints, required_defaults, defaults, request_method_match
end
##
# +path+ is a path constraint.
# +constraints+ is a hash of constraints to be applied to this route.
def initialize(name, app, path, constraints, required_defaults, defaults, request_method_match)
@name = name
@app = app
@path = path
@request_method_match = request_method_match
@constraints = constraints
@defaults = defaults
@required_defaults = nil
@_required_defaults = required_defaults
@required_parts = nil
@parts = nil
@decorated_ast = nil
@precedence = 0
@path_formatter = @path.build_formatter
end
def ast
@decorated_ast ||= begin
decorated_ast = path.ast
decorated_ast.find_all(&:terminal?).each { |n| n.memo = self }
decorated_ast
end
end
def requirements # :nodoc:
# needed for rails `rake routes`
@defaults.merge(path.requirements).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(&:to_sym)
end
alias :segment_keys :parts
def format(path_options)
@path_formatter.evaluate path_options
end
def required_parts
@required_parts ||= path.required_names.map(&:to_sym)
end
def required_default?(key)
@_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?
@app.dispatcher?
end
def matches?(request)
match_verb(request) &&
constraints.all? { |method, value|
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
def ip
constraints[:ip] || //
end
def requires_matching_verb?
@request_method_match != ANY
end
def verb
@request_method_match
end
private
def match_verb(request)
return true unless requires_matching_verb?
verb === request.request_method
end
end
end
end
|
