joshbuddy-usher 0.4.1 → 0.4.2

data/README.rdoc

@@ -43,9 +43,25 @@ However, <tt>/path/test/one_more/path</tt> would not be matched.
 
 In the above examples, ['one', 'two', 'three'] and ['four', 'five'] respectively would be bound to the key :variable.
 
+As well, variables can have a regex matcher.
+
+<b>Example:</b>
+<tt>/product/{:id,\d+}</tt> would match
+
+* <tt>/product/123</tt>
+* <tt>/product/4521</tt>
+
+But not
+* <tt>/product/AE-35</tt>
+
+As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
+actually be bound to the variable
+
 ==== Static
 
 Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
+As well, static parts can have a regex pattern in them as well, such as <tt>/path/something.{html|xml}</tt> which would match only
+<tt>/path/something.html</tt> and <tt>/path/something.xml</tt>
 
 ==== Optional sections
 
@@ -53,12 +69,14 @@ Sections of a route can be marked as optional by surrounding it with brackets. F
 
 ==== One and only one sections
 
-Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes. For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and <tt>/path/something.html</tt>.
+Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes.
+For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and
+<tt>/path/something.html</tt>. Generally its more efficent to use one and only sections over using regex.
 
 === +options+
 * +transformers+ - Transforms a variable before it gets to the requirements. Takes either a +proc+ or a +symbol+. If its a +symbol+, calls the method on the incoming parameter. If its a +proc+, its called with the variable.
 * +requirements+ - After transformation, tests the condition using ===. If it returns false, it raises an <tt>Usher::ValidationException</tt>
-* +conditions+ - Accepts any of the following <tt>:protocol</tt>, <tt>:domain</tt>, <tt>:port</tt>, <tt>:query_string</tt>, <tt>:remote_ip</tt>, <tt>:user_agent</tt>, <tt>:referer</tt> and <tt>:method</tt>. This can be either a <tt>string</tt> or a regular expression.
+* +conditions+ - Accepts any of the +request_methods+ specificied in the construction of Usher. This can be either a <tt>string</tt> or a regular expression.
 * Any other key is interpreted as a requirement for the variable of its name.
 
 == Rails

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 4
-:patch: 1
+:patch: 2

data/lib/usher/interface/email_interface.rb

@@ -0,0 +1,31 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rack_interface/route'
+
+class Usher
+  module Interface
+    class EmailInterface
+      
+      def initialize(&blk)
+        @routes = Usher.new(:delimiters => ['@', '-', '.'], :valid_regex => '[\+a-zA-Z0-9]+', :globs_capture_separators => true)
+        instance_eval(&blk) if blk
+      end
+      
+      def for(path, &block)
+        @routes.add_route(path).to(block)
+      end
+
+      def reset!
+        @routes.reset!
+      end
+
+      def act(email)
+        response = @routes.recognize(email, email)
+        if response.path
+          response.path.route.params.first.call(response.params.inject({}){|h,(k,v)| h[k]=v.to_s; h })
+        end
+      end
+
+    end
+  end
+end

data/lib/usher/interface.rb

@@ -5,6 +5,7 @@ class Usher
     autoload :Rails2Interface, 'interface/rails2_interface'
     autoload :MerbInterface, 'interface/merb_interface'
     autoload :RackInterface, 'interface/rack_interface'
+    autoload :EmailInterface, 'interface/email_interface'
     
     def self.for(type, &blk)
       case type
@@ -14,7 +15,10 @@ class Usher
         MerbInterface.new(&blk)
       when :rack
         RackInterface.new(&blk)
+      when :email
+        EmailInterface.new(&blk)
       end
+      
     end
     
     

data/lib/usher/node.rb

@@ -9,7 +9,7 @@ class Usher
     Response = Struct.new(:path, :params)
     
     attr_reader :lookup
-    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods
+    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods, :globs_capture_separators
 
     def initialize(parent, value)
       @parent = parent
@@ -26,9 +26,10 @@ class Usher
       @depth ||= @parent && @parent.is_a?(Node) ? @parent.depth + 1 : 0
     end
     
-    def self.root(route_set, request_methods)
+    def self.root(route_set, request_methods, globs_capture_separators)
       root = self.new(route_set, nil)
       root.request_methods = request_methods
+      root.globs_capture_separators = globs_capture_separators
       root
     end
 
@@ -69,6 +70,8 @@ class Usher
               current_node.lookup[nil] ||= Node.new(current_node, Route::RequestMethod.new(current_node.exclusive_type, nil))
             end
           else
+            key.globs_capture_separators = globs_capture_separators if key.is_a?(Route::Variable)
+            
             if !key.is_a?(Route::Variable)
               current_node.upgrade_lookup if key.is_a?(Regexp)
               current_node.lookup[key] ||= Node.new(current_node, key)
@@ -116,7 +119,7 @@ class Usher
                 path.unshift(next_part.parent.value) if next_part.parent.value.is_a?(Symbol)
                 break
               else
-                unless part.is_a?(Symbol)
+                unless part.is_a?(Symbol) && !next_part.value.globs_capture_separators
                   part = next_part.value.transform!(part)
                   next_part.value.valid!(part)
                   params.last.last << part
@@ -152,7 +155,7 @@ class Usher
               path.unshift(next_part.parent.value) if next_part.parent.value.is_a?(Symbol)
               next_part.find(request, path, params)
             else
-              unless part.is_a?(Symbol)
+              unless part.is_a?(Symbol) && !next_part.value.globs_capture_separators
                 part = next_part.value.transform!(part)
                 next_part.value.valid!(part)
                 params.last.last << part

data/lib/usher/route/variable.rb

@@ -2,14 +2,15 @@ class Usher
   class Route
     class Variable
       attr_reader :type, :name, :validator, :transformer, :regex_matcher
-      attr_accessor :look_ahead
+      attr_accessor :look_ahead, :globs_capture_separators
       
-      def initialize(type, name, validator = nil, transformer = nil, regex_matcher = nil)
+      def initialize(type, name, validator = nil, transformer = nil, regex_matcher = nil, globs_capture_separators = false)
         @type = type
         @name = :"#{name}"
         @validator = validator
         @transformer = transformer
         @regex_matcher = regex_matcher
+        @globs_capture_separators = globs_capture_separators
       end
 
       def to_s

data/lib/usher/splitter.rb

@@ -3,13 +3,12 @@ require 'strscan'
 class Usher
   class Splitter
     
-    def self.for_delimiters(delimiters)
+    def self.for_delimiters(delimiters, valid_regex)
       delimiters_regex = delimiters.collect{|d| Regexp.quote(d)} * '|'
-      
       SplitterInstance.new(
         delimiters,
-        Regexp.new('((:|\*)?[0-9A-Za-z\$\-_\+!\*\',]+|' + delimiters_regex + '|\(|\)|\||\{)'),
-        Regexp.new(delimiters_regex + '|[0-9A-Za-z\$\-_\+!\*\',]+')
+        Regexp.new('((:|\*)?' + valid_regex + '|' + delimiters_regex + '|\(|\)|\||\{)'),
+        Regexp.new(delimiters_regex + '|' + valid_regex)
       )
     end
     
@@ -51,7 +50,7 @@ class Usher
             type = part.slice!(0).chr.to_sym
             current_group << Usher::Route::Variable.new(type, part, requirements && requirements[part.to_sym], transformers && transformers[part.to_sym])
           when ?{
-            pattern = ''
+            pattern = '^'
             count = 1
             variable = ss.scan(/[:\*]([^,]+),/)
             until count.zero?
@@ -64,7 +63,7 @@ class Usher
               end
               pattern << regex_part
             end
-            pattern.slice!(pattern.size - 1)
+            pattern[pattern.size - 1] = ?$
             regex = Regexp.new(pattern)
             if variable
               variable_type = variable.slice!(0).chr.to_sym

data/lib/usher.rb

@@ -31,7 +31,7 @@ class Usher
   #   set.reset!
   #   set.empty? => true
   def reset!
-    @tree = Node.root(self, @request_methods)
+    @tree = Node.root(self, @request_methods, @globs_capture_separators)
     @named_routes = {}
     @routes = []
     @route_count = 0
@@ -39,16 +39,24 @@ class Usher
   end
   alias clear! reset!
   
-  # Creates a route set, with optional Array of +delimiters+ and +request_methods+
+  # Creates a route set, with options
   # 
-  # The +delimiters+ must be one character. By default <tt>['/', '.']</tt> are used.
-  # The +request_methods+ are methods that are called against the request object in order to
-  # enforce the +conditions+ segment of the routes. For HTTP routes (and in fact the default), those 
-  # methods are <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method]</tt>.
+  # <tt>:globs_capture_separators</tt>: +true+ or +false+. (default +false+) Specifies whether glob matching will also include separators
+  # that are matched.
+  # 
+  # <tt>:delimiters</tt>: Array of Strings. (default <tt>['/', '.']</tt>). Delimiters used in path separation. Array must be single character strings.
+  # 
+  # <tt>:valid_regex</tt>: String. (default <tt>'[0-9A-Za-z\$\-_\+!\*\',]+'</tt>). String that can be interpolated into regex to match
+  # valid character sequences within path.
+  # 
+  # <tt>:request_methods</tt>: Array of Symbols. (default <tt>[:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]</tt>)
+  # Array of methods called against the request object for the purposes of matching route requirements.
   def initialize(options = nil)
-    @delimiters = options && options.delete(:options) || ['/', '.']
+    @globs_capture_separators = options && options.key?(:globs_capture_separators) ? options.delete(:globs_capture_separators) : false
+    @delimiters = options && options.delete(:delimiters) || ['/', '.']
+    @valid_regex = options && options.delete(:valid_regex) || '[0-9A-Za-z\$\-_\+!\*\',]+'
     @request_methods = options && options.delete(:request_methods) || [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method, :subdomains]
-    @splitter = Splitter.for_delimiters(@delimiters)
+    @splitter = Splitter.for_delimiters(@delimiters, @valid_regex)
     reset!
   end
 
@@ -96,9 +104,25 @@ class Usher
   #
   # In the above examples, ['one', 'two', 'three'] and ['four', 'five'] respectively would be bound to the key :variable.
   #
+  # As well, variables can have a regex matcher.
+  #
+  # <b>Example:</b>
+  # <tt>/product/{:id,\d+}</tt> would match
+  # 
+  # * <tt>/product/123</tt>
+  # * <tt>/product/4521</tt>
+  # 
+  # But not
+  # * <tt>/product/AE-35</tt>
+  # 
+  # As well, the same logic applies for * variables as well, where only parts matchable by the supplied regex will
+  # actually be bound to the variable
+  #
   # ==== Static
   #
   # Static parts of literal character sequences. For instance, <tt>/path/something.html</tt> would match only the same path.
+  # As well, static parts can have a regex pattern in them as well, such as <tt>/path/something.{html|xml}</tt> which would match only
+  # <tt>/path/something.html</tt> and <tt>/path/something.xml</tt>
   #
   # ==== Optional sections
   #
@@ -106,7 +130,9 @@ class Usher
   #
   # ==== One and only one sections
   #
-  # Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes. For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and <tt>/path/something.html</tt>.
+  # Sections of a route can be marked as "one and only one" by surrounding it with brackets and separating parts of the route with pipes.
+  # For instance, the path, <tt>/path/something(.xml|.html)</tt> would only match <tt>/path/something.xml</tt> and
+  # <tt>/path/something.html</tt>. Generally its more efficent to use one and only sections over using regex.
   #
   # === +options+
   # * +transformers+ - Transforms a variable before it gets to the requirements. Takes either a +proc+ or a +symbol+. If its a +symbol+, calls the method on the incoming parameter. If its a +proc+, its called with the variable.

data/spec/private/email/recognize_spec.rb

@@ -0,0 +1,40 @@
+require 'lib/usher'
+
+
+
+def build_email_mock(email)
+  request = mock "Request"
+  request.should_receive(:email).any_number_of_times.and_return(email)
+  request
+end
+
+SampleController = Object.new
+
+describe "Usher (for email) route recognition" do
+
+  before(:each) do
+    @route_set = Usher::Interface.for(:email)
+  end
+
+  it "should recognize a simple request" do
+    receiver = mock('receiver')
+    receiver.should_receive(:action).with({}).exactly(1)
+    @route_set.for('joshbuddy@gmail.com') { |params| receiver.action(params) }
+    @route_set.act('joshbuddy@gmail.com')
+  end
+
+  it "should recognize a wildcard domain" do
+    receiver = mock('receiver')
+    receiver.should_receive(:action).with({:domain => 'gmail.com'}).exactly(1)
+    @route_set.for('joshbuddy@*domain') { |params| receiver.action(params) }
+    @route_set.act('joshbuddy@gmail.com')
+  end
+
+  it "should recognize a complex email" do
+    receiver = mock('receiver')
+    receiver.should_receive(:action).with({:subject => 'sub+ect', :id => '123', :sid => '456', :tok => 'sdqwe123ae', :domain => 'mydomain.org'}).exactly(1)
+    @route_set.for(':subject.{:id,^\d+$}-{:sid,^\d+$}-{:tok,^\w+$}@*domain') { |params| receiver.action(params) }
+    @route_set.act('sub+ect.123-456-sdqwe123ae@mydomain.org')
+  end
+
+end

data/spec/private/split_spec.rb

@@ -4,38 +4,42 @@ describe "Usher route tokenizing" do
   
   
   it "should split / delimited routes" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this/split').should == [[:/, 'test', :/,'this', :/, 'split']]
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this/split').should == [[:/, 'test', :/,'this', :/, 'split']]
   end
 
   it "should split / delimited routes with a regex in it" do
-    Usher::Splitter.for_delimiters(['/', '.']).
-      split('/test/{this}/split').should == [[:/, 'test', :/, /this/, :/, 'split']]
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').
+      split('/test/{this}/split').should == [[:/, 'test', :/, /^this$/, :/, 'split']]
   end
   
   it "should split on ' ' delimited routes as well" do
-    Usher::Splitter.for_delimiters([' ']).split('test this split').should == [['test', :' ', 'this', :' ', 'split']]
+    Usher::Splitter.for_delimiters([' '], '[0-9A-Za-z\$\-_\+!\*\',]+').split('test this split').should == [['test', :' ', 'this', :' ', 'split']]
+  end
+  
+  it "should split on email delimiters as well" do
+    Usher::Splitter.for_delimiters(['@', '+', '-', '.'], '[a-zA-Z0-9]+').split('one+more.12345-09876-alphanum3ric5@domain.com').should == [["one", :+, "more", :".", "12345", :-, "09876", :-, "alphanum3ric5", :"@", "domain", :".", "com"]]
   end
   
   it "should split on ' ' delimited routes for more complex routes as well" do
-    Usher::Splitter.for_delimiters([' ']).split('(test|this) split').should == [['test', :' ', 'split'], ['this', :' ', 'split']]
+    Usher::Splitter.for_delimiters([' '], '[0-9A-Za-z\$\-_\+!\*\',]+').split('(test|this) split').should == [['test', :' ', 'split'], ['this', :' ', 'split']]
   end
   
   it "should group optional parts with brackets" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split)').should == [
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split)').should == [
       [:/, 'test', :/, 'this'],
       [:/, 'test', :/, 'this', :/, 'split']
     ]
   end
 
   it "should group exclusive optional parts with brackets and pipes" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split|/split2)').should == [
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split|/split2)').should == [
       [:/, 'test', :/, 'this',:/, 'split'],
       [:/, 'test', :/, 'this',:/, 'split2']
     ]
   end
 
   it "should group exclusive optional-optional parts with brackets and pipes" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this((/split|/split2))').should == [
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this((/split|/split2))').should == [
       [:/, 'test',:/, 'this'],
       [:/, 'test',:/, 'this', :/, 'split'],
       [:/, 'test',:/, 'this', :/, 'split2']
@@ -43,7 +47,7 @@ describe "Usher route tokenizing" do
   end
 
   it "should group optional parts with brackets (for non overlapping groups)" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split)(/split2)') == [
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split)(/split2)') == [
       [:/, "test", :/, "this"],
       [:/, "test", :/, "this", :/, "split"],
       [:/, "test", :/, "this", :/, "split2"],
@@ -52,7 +56,7 @@ describe "Usher route tokenizing" do
   end
 
   it "should group nested-optional parts with brackets" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/test/this(/split(.:format))') == [
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/test/this(/split(.:format))') == [
       [:/, "test", :/, "this"],
       [:/, "test", :/, "this", :/, "split"],
       [:/, "test", :/, "this", :/, "split", :'.', Usher::Route::Variable.new(:':', :format)]
@@ -60,12 +64,12 @@ describe "Usher route tokenizing" do
   end
 
   it "should to_s all different variable types" do
-    Usher::Splitter.for_delimiters(['/', '.']).split('/:split/*splitter').first.collect{|v| v.to_s} == 
+    Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/:split/*splitter').first.collect{|v| v.to_s} == 
       [ ':split', '*splitter' ]
   end
   
   it "should == variable types" do
-    parts = Usher::Splitter.for_delimiters(['/', '.']).split('/:split/:split').first
+    parts = Usher::Splitter.for_delimiters(['/', '.'], '[0-9A-Za-z\$\-_\+!\*\',]+').split('/:split/:split').first
     parts[1].should == parts[3]
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: joshbuddy-usher
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors: 
 - Joshua Hull
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-09 00:00:00 -07:00
+date: 2009-05-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,6 +40,7 @@ files:
 - lib/usher/exceptions.rb
 - lib/usher/grapher.rb
 - lib/usher/interface
+- lib/usher/interface/email_interface.rb
 - lib/usher/interface/merb_interface.rb
 - lib/usher/interface/rack_interface
 - lib/usher/interface/rack_interface/mapper.rb
@@ -58,6 +59,8 @@ files:
 - lib/usher/splitter.rb
 - lib/usher.rb
 - spec/private
+- spec/private/email
+- spec/private/email/recognize_spec.rb
 - spec/private/generate_spec.rb
 - spec/private/grapher_spec.rb
 - spec/private/path_spec.rb