Rack::Mount::GeneratableRegexp::InstanceMethods

    # File lib/rack/mount/generatable_regexp.rb, line 31
31:       def self.extended(obj)
32:         obj.segments
33:       end

    # File lib/rack/mount/generatable_regexp.rb, line 72
72:       def captures
73:         segments.flatten.find_all { |s| s.is_a?(DynamicSegment) }
74:       end

    # File lib/rack/mount/generatable_regexp.rb, line 42
42:       def defaults
43:         @defaults ||= {}
44:       end

    # File lib/rack/mount/generatable_regexp.rb, line 35
35:       def defaults=(defaults)
36:         @required_captures = nil
37:         @required_params = nil
38:         @required_defaults = nil
39:         @defaults = defaults
40:       end

     # File lib/rack/mount/generatable_regexp.rb, line 96
 96:       def freeze
 97:         segments
 98:         captures
 99:         required_captures
100:         required_params
101:         required_defaults
102:         super
103:       end

    # File lib/rack/mount/generatable_regexp.rb, line 46
46:       def generatable?
47:         segments.any?
48:       end

    # File lib/rack/mount/generatable_regexp.rb, line 50
50:       def generate(params = {}, recall = {}, options = {})
51:         return nil unless generatable?
52: 
53:         merged = recall.merge(params)
54:         return nil unless required_params.all? { |p| merged.include?(p) }
55:         return nil unless required_defaults.all? { |k, v| merged[k] == v }
56: 
57:         generate_from_segments(segments, params, merged, options)
58:       end

    # File lib/rack/mount/generatable_regexp.rb, line 76
76:       def required_captures
77:         @required_captures ||= segments.find_all { |s|
78:           s.is_a?(DynamicSegment) && !@defaults.include?(s.name)
79:         }.freeze
80:       end

    # File lib/rack/mount/generatable_regexp.rb, line 86
86:       def required_defaults
87:         @required_defaults ||= begin
88:           required_defaults = @defaults.dup
89:           captures.inject({}) { |h, s| h.merge!(s.to_hash) }.keys.each { |name|
90:             required_defaults.delete(name)
91:           }
92:           required_defaults
93:         end
94:       end

    # File lib/rack/mount/generatable_regexp.rb, line 82
82:       def required_params
83:         @required_params ||= required_captures.map { |s| s.name }.freeze
84:       end

    # File lib/rack/mount/generatable_regexp.rb, line 60
60:       def segments
61:         @segments ||= begin
62:           defaults
63:           segments = []
64:           catch(:halt) do
65:             expression = Utils.parse_regexp(self)
66:             segments = parse_segments(expression)
67:           end
68:           segments
69:         end
70:       end

     # File lib/rack/mount/generatable_regexp.rb, line 138
138:         def generate_from_segments(segments, params, merged, options, optional = false)
139:           if optional
140:             return EMPTY_STRING if segments.all? { |s| s.is_a?(String) }
141:             return EMPTY_STRING unless segments.flatten.any? { |s|
142:               params.has_key?(s.name) if s.is_a?(DynamicSegment)
143:             }
144:             return EMPTY_STRING if segments.any? { |segment|
145:               if segment.is_a?(DynamicSegment)
146:                 value = merged[segment.name] || @defaults[segment.name]
147:                 value = parameterize(segment.name, value, options)
148: 
149:                 merged_value  = parameterize(segment.name, merged[segment.name], options)
150:                 default_value = parameterize(segment.name, @defaults[segment.name], options)
151: 
152:                 if value.nil? || segment !~ value
153:                   true
154:                 elsif merged_value == default_value
155:                   # Nasty control flow
156:                   return :clear_remaining_segments
157:                 else
158:                   false
159:                 end
160:               end
161:             }
162:           end
163: 
164:           generated = segments.map do |segment|
165:             case segment
166:             when String
167:               segment
168:             when DynamicSegment
169:               value = params[segment.name] || merged[segment.name] || @defaults[segment.name]
170:               value = parameterize(segment.name, value, options)
171:               if value && segment =~ value.to_s
172:                 value
173:               else
174:                 return
175:               end
176:             when Array
177:               value = generate_from_segments(segment, params, merged, options, true)
178:               if value == :clear_remaining_segments
179:                 segment.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
180:                 EMPTY_STRING
181:               elsif value.nil?
182:                 EMPTY_STRING
183:               else
184:                 value
185:               end
186:             end
187:           end
188: 
189:           # Delete any used items from the params
190:           segments.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
191: 
192:           generated.join
193:         end

     # File lib/rack/mount/generatable_regexp.rb, line 195
195:         def parameterize(name, value, options)
196:           if block = options[:parameterize]
197:             block.call(name, value)
198:           else
199:             value
200:           end
201:         end

     # File lib/rack/mount/generatable_regexp.rb, line 106
106:         def parse_segments(segments)
107:           s = []
108:           segments.each_with_index do |part, index|
109:             case part
110:             when Regin::Anchor
111:               # ignore
112:             when Regin::Character
113:               throw :halt unless part.literal?
114: 
115:               if s.last.is_a?(String)
116:                 s.last << part.value.dup
117:               else
118:                 s << part.value.dup
119:               end
120:             when Regin::Group
121:               if part.name
122:                 s << DynamicSegment.new(part.name, part.expression.to_regexp(true))
123:               else
124:                 s << parse_segments(part.expression)
125:               end
126:             when Regin::Expression
127:               return parse_segments(part)
128:             else
129:               throw :halt
130:             end
131:           end
132: 
133:           s
134:         end