lib/rack/router/parsing.rb @@ -19,4 +19,9 @@ Some points for discussion: Currently with env['rack_router.route'] * Should I allow an arbitrary hash to be set on the route (so that you can track any information). -* How should multiple request objects be handled in context of mounting. \ No newline at end of file +* How should multiple request objects be handled in context of mounting. + + + + +* Be able to provide route paths using the internal array / string / symbol representation \ No newline at end of file README @@ -28,6 +28,7 @@ module Rack autoload :Route, 'rack/router/route' autoload :Condition, 'rack/router/condition' autoload :PathCondition, 'rack/router/condition' + autoload :Parsing, 'rack/router/parsing' autoload :Builder, 'rack/router/builders' autoload :Utils, 'rack/router/utils' lib/rack/router.rb @@ -19,12 +19,19 @@ class Rack::Router::Builder def map(*args) options = args.last.is_a?(Hash) ? args.pop : {} - + path = args[0] method = args[1] - conditions = options[:conditions] || {} - conditions[:path_info] = path if path + conditions = options[:conditions] || {} + conditions.each { |k,v| conditions[k] = v.to_s unless v.is_a?(Regexp) } + + if path + conditions[:path_info] = Rack::Router::Parsing.parse(path) do |segment_name, delimiter| + conditions[segment_name] = /.+/ if delimiter == '*' + end + end + conditions[:request_method] = upcase_method(method) if method route = Rack::Router::Route.new(options[:to], options[:at], conditions.reject { |k,v| k == :id }, conditions.dup, options[:with] || {}, !options[:anchor]) lib/rack/router/builders/simple.rb @@ -1,8 +1,5 @@ class Rack::Router - SEGMENT_REGEXP = /(?:(:|\*)([a-z](?:_?[a-z0-9])*))/i - OPTIONAL_SEGMENT_REGEXP = /^(?:|.*?[^\\])(?:\\\\)*([\(\)])/ - ESCAPED_REGEXP = /(?:^|[^\\])\\(?:\\\\)*$/ - SEGMENT_CHARACTERS = "[^\/.,;?]".freeze + SEGMENT_CHARACTERS = "[^\/.,;?]".freeze class Condition def self.register(type) @@ -17,21 +14,22 @@ class Rack::Router attr_reader :segments, :captures def initialize(method_name, pattern, conditions, anchored) - @method_name = method_name - @segments = {} - @captures = {} - @conditions = conditions.dup - @anchored = anchored + @method_name = method_name + @segments = {} + @captures = {} + @conditions = conditions.dup + @anchored = anchored @conditions.default = /#{SEGMENT_CHARACTERS}+/ - - case pattern - when String - @segments = parse_segments_with_optionals(pattern.dup) + + if pattern.is_a?(Array) || pattern.is_a?(String) + @segments = pattern.is_a?(Array) ? pattern : [pattern] @pattern = Regexp.new(anchor(compile(@segments))) @captures = captures_for(@segments) + elsif pattern.is_a?(Regexp) + @pattern = pattern else - @pattern = convert_to_regexp(pattern) + raise ArgumentError, "the condition pattern must be an Array (tokens), String, or Regexp" end end @@ -40,6 +38,10 @@ class Rack::Router return data[0], extract_captures(data) end end + + def generatable? + !@segments.nil? + end def generate(params, defaults = {}) raise "Condition cannot be generated" unless @segments @@ -52,58 +54,6 @@ class Rack::Router private - # TODO: Handle escaped characters (parenthesis, colon, etc..) - def parse_segments_with_optionals(pattern, nest_level = 0) - segments = [] - - # Extract all the segments at this parenthesis level - while segment = pattern.slice!(OPTIONAL_SEGMENT_REGEXP) - # Append the segments that we came across so far - # at this level - segments.concat parse_segments(segment[0..-2]) if segment.length > 1 - # If the parenthesis that we came across is an opening - # then we need to jump to the higher level - if segment[-1, 1] == '(' - segments << parse_segments_with_optionals(pattern, nest_level + 1) - else - # Throw an error if we can't actually go back down (aka syntax error) - raise ArgumentError, "There are too many closing parentheses" if nest_level == 0 - return segments - end - end - - # Save any last bit of the string that didn't match the original regex - segments.concat parse_segments(pattern) unless pattern.empty? - - # Throw an error if the string should not actually be done (aka syntax error) - raise ArgumentError, "You have too many opening parentheses" unless nest_level == 0 - - segments - end - - def parse_segments(path) - segments = [] - - while match = (path.match(SEGMENT_REGEXP)) - segment_name = match[2].to_sym - - # Handle false-positives due to escaped special characters - if match.pre_match =~ ESCAPED_REGEXP - segments << "#{match.pre_match[0..-2]}#{match[0]}" - else - segments << match.pre_match unless match.pre_match.empty? - segments << segment_name - - @conditions[segment_name] = /.+/ if match[1] == '*' - end - - path = match.post_match - end - - segments << path unless path.empty? - segments - end - def compile(segments) compiled = segments.map do |segment| case segment lib/rack/router/condition.rb @@ -53,7 +53,7 @@ describe "When generating URLs" do describe "a router with an informal protocol" do before(:each) do - pending + pending "I'm not sure that this is thought out as well as it could be" end it "just works" do spec/generation/dependencies_spec.rb @@ -63,9 +63,9 @@ describe "When recognizing requests" do route_for("", :method => "get").should be_missing end - it "combines Array elements using OR" do + it "can use a regular expression to specify OR" do prepare do |r| - r.map nil, [:get, :post], :to => HelloApp, :with => { :action => "index" } + r.map nil, /get|post/i, :to => HelloApp, :with => { :action => "index" } end route_for('/anything', :method => "get").should have_route(HelloApp, :action => "index") @@ -74,18 +74,6 @@ describe "When recognizing requests" do route_for('/anything', :method => "delete").should be_missing end - it "handles Regexps inside of condition arrays" do - prepare do |r| - r.map nil, [/^g[aeiou]?t$/i, :post], :to => HelloApp - end - - route_for('/anything', :method => "get").should have_route(HelloApp) - route_for('/anything', :method => "got").should have_route(HelloApp) - route_for('/anything', :method => "post").should have_route(HelloApp) - route_for('/anything', :method => "put").should be_missing - route_for('/anything', :method => "delete").should be_missing - end - it "ignores nil values" do prepare do |r| r.map "/hello", :method => nil, :to => HelloApp @@ -116,9 +104,9 @@ describe "When recognizing requests" do route_for("/foo", :scheme => "https").should be_missing end - it "combines Array elements using OR" do + it "can use regular expressions" do prepare do |r| - r.map "/hello", [:get, :post], :to => HelloApp + r.map "/hello", /get|post/i, :to => HelloApp end route_for("/hello", :method => "get").should have_route(HelloApp) spec/recognition/conditions_spec.rb 8bafbe4b772678214f7f818897d76f31a81580dd Carl Lerche carllerche@mac.com http://github.com/carllerche/rack-router/commit/459f83d5d6829e8ac4808ef831602c54db10346c 459f83d5d6829e8ac4808ef831602c54db10346c 2009-04-13T20:22:54-07:00 2009-04-13T20:22:54-07:00 Refactored the plugin API to accept a simple token representation of a condition that allows generation 554455c1023c9ec0091b47e2b892fbbe266de844 Carl Lerche carllerche@mac.com