joshbuddy-usher 0.5.4 → 0.5.6

data/lib/usher/interface/text_interface.rb

@@ -0,0 +1,44 @@
+class Usher
+  module Interface
+    class TextInterface
+      
+      def initialize(&blk)
+        @usher = Usher.new(:delimiters => [' '], :generator => Usher::Util::Generators::Generic.new)
+        instance_eval(&blk) if blk
+      end
+      
+      def generate(name, params = nil)
+        @usher.generator.generate(name, params)
+      end
+      
+      def on(text, name = nil, &blk)
+        r = @usher.add_route(text).to(:block => blk, :arg_type => :array)
+        r.name(name) if name
+      end
+      
+      def unrecognized(&blk)
+        @unrecognize_block = blk
+      end
+      
+      def on_with_hash(text, name = nil, &blk)
+        r = @usher.add_route(text).to(:block => blk, :arg_type => :hash)
+        r.name(name) if name
+      end
+      
+      def run(text)
+        response = @usher.recognize_path(text.strip)
+        if response
+          case response.path.route.destination[:arg_type]
+          when :hash
+            response.path.route.destination[:block].call(response.params.inject({}){|h,(k,v)| h[k]=v; h })
+          when :array
+            response.path.route.destination[:block].call(*response.params.collect{|p| p.last})
+          end
+        else
+          @unrecognize_block ? @unrecognize_block.call(text) : nil
+        end
+      end
+
+    end
+  end
+end

data/lib/usher/node.rb

@@ -4,7 +4,11 @@ class Usher
 
   class Node
     
-    Response = Struct.new(:path, :params, :remaining_path, :matched_path)
+    class Response < Struct.new(:path, :params, :remaining_path, :matched_path)
+      def partial_match?
+        !remaining_path.nil?
+      end
+    end
     
     attr_reader :normal, :greedy, :request
     attr_accessor :terminates, :request_method_type, :parent, :value, :request_methods
@@ -108,15 +112,7 @@ class Usher
     end
     
     def find(usher, request_object, original_path, path, params = [], position = 0)
-      if request_method_type
-        if (specific_node = request[request_object.send(request_method_type)]) && (ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
-          ret
-        elsif (general_node = request[nil]) && (ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position))
-          ret
-        else
-          nil
-        end
-      elsif terminates? && (path.empty? || terminates.route.partial_match?)
+      if terminates? && (path.empty? || terminates.route.partial_match?)
         terminates.route.partial_match? ?
           Response.new(terminates, params, original_path[position, original_path.size], original_path[0, position]) :
           Response.new(terminates, params, nil, original_path)
@@ -130,7 +126,7 @@ class Usher
         case next_part.value
         when Route::Variable::Glob
           params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
-          loop do
+          while true
             if (next_part.value.look_ahead === part || (!usher.delimiter_chars.include?(part[0]) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
               path.unshift(part)
               position -= part.size
@@ -153,13 +149,21 @@ class Usher
           var = next_part.value
           var.valid!(part)
           params << [var.name, part]
-          until (var.look_ahead === path.first) || path.empty?
+          until path.empty? || (var.look_ahead === path.first)
             next_path_part = path.shift
             position += next_path_part.size
             params.last.last << next_path_part
-          end
+          end if var.look_ahead && usher.delimiter_chars.size > 1
         end
         next_part.find(usher, request_object, original_path, path, params, position)
+      elsif request_method_type
+        if (specific_node = request[request_object.send(request_method_type)]) && (ret = specific_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          ret
+        elsif (general_node = request[nil]) && (ret = general_node.find(usher, request_object, original_path, path.dup, params.dup, position))
+          ret
+        else
+          nil
+        end
       else
         nil
       end

data/lib/usher/route.rb

@@ -8,16 +8,16 @@ class Usher
     attr_reader   :paths, :requirements, :conditions,
                   :destination, :named, :generate_with,
                   :default_values, :match_partially
-    attr_accessor :parent_route
-    
+    attr_accessor :parent_route, :router
+
     GenerateWith = Struct.new(:scheme, :port, :host)
-    
-    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)            
+
+    def initialize(parsed_paths, router, conditions, requirements, default_values, generate_with, match_partially)
       @paths = parsed_paths.collect {|path| Path.new(self, path)}
       @router, @requirements, @conditions, @default_values, @match_partially = router, requirements, conditions, default_values, match_partially
       @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
     end
-    
+
     def grapher
       unless @grapher
         @grapher = Grapher.new
@@ -28,7 +28,9 @@ class Usher
 
     def dup
       result = super
-      result.grapher = nil
+      result.instance_eval do
+        @grapher = nil
+      end
       result
     end
 
@@ -38,17 +40,17 @@ class Usher
       else
         matching_path = @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
       end
-      
+
       if parent_route
         matching_path = parent_route.find_matching_path(params).merge(matching_path)
         matching_path.route = self
       end
-      
+
       matching_path
     end
-    
+
     # Sets +options+ on a route. Returns +self+.
-    #   
+    #
     #   Request = Struct.new(:path)
     #   set = Usher.new
     #   route = set.add_route('/test')
@@ -66,7 +68,7 @@ class Usher
     end
 
     # Sets route as referenceable from +name+. Returns +self+.
-    #   
+    #
     #   set = Usher.new
     #   route = set.add_route('/test').name(:route)
     #   set.generate_url(:route) => '/test'
@@ -75,16 +77,16 @@ class Usher
       @router.name(name, self)
       self
     end
-    
+
     def match_partially!
       @match_partially = true
       self
     end
-    
+
     def partial_match?
       @match_partially
     end
-    
+
     private
     attr_writer :grapher
 

data/lib/usher/util/generate.rb

@@ -1,35 +1,46 @@
-require 'rack'
+class Usher
+  module Util
+    class Generators
 
-unless Rack::Utils.respond_to?(:uri_escape)
-  module Rack
+      class Generic
 
-    module Utils
+        attr_accessor :usher
 
-      def uri_escape(s)
-        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
-          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
-        }.tr(' ', '+')
-      end
-      module_function :uri_escape
+        def generate(name, params)
+          generate_path_for_base_params(@usher.named_routes[name].find_matching_path(params), params)
+        end
+
+        def generate_path_for_base_params(path, params)
+          raise UnrecognizedException.new unless path
+
+          result = ''
+          path.parts.each do |part|
+            case part
+            when Route::Variable::Glob
+              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+              value.each_with_index do |current_value, index|
+                part.valid!(current_value)
+                result << current_value.to_s
+                result << usher.delimiters.first if index != value.size - 1
+              end
+            when Route::Variable
+              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+              part.valid!(value)
+              result << value.to_s
+            else
+              result << part
+            end
+          end
+          result
+        end
 
-      def uri_unescape(s)
-        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-          [$1.delete('%')].pack('H*')
-        }
       end
-      module_function :uri_unescape
 
-    end
-  end
-end
+      class URL < Generic
 
-class Usher
-  module Util
-    class Generators
-    
-      class URL
-      
-        attr_accessor :usher
+        def initialize
+          require File.join(File.dirname(__FILE__), 'rack-mixins')
+        end
 
         def generate_full(routing_lookup, request, params = nil)
           path = path_for_routing_lookup(routing_lookup, params)
@@ -37,10 +48,75 @@ class Usher
           result << generate_path(path, params)
         end
 
+        # Generates a completed URL based on a +route+ or set of optional +params+
+        #
+        #   set = Usher.new
+        #   route = set.add_named_route(:test_route, '/:controller/:action')
+        #   set.generator.generate(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        #   set.generator.generate(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
+        #   set.generator.generate(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
         def generate(routing_lookup, params = nil)
           generate_path(path_for_routing_lookup(routing_lookup, params), params)
         end
 
+        def generate_path(path, params = nil)
+          params = Array(params) if params.is_a?(String)
+          if params.is_a?(Array)
+            given_size = params.size
+            extra_params = params.last.is_a?(Hash) ? params.pop : nil
+            params = Hash[*path.dynamic_parts.inject([]){|a, dynamic_part| a.concat([dynamic_part.name, params.shift || raise(MissingParameterException.new("got #{given_size}, expected #{path.dynamic_parts.size} parameters"))]); a}]
+            params.merge!(extra_params) if extra_params
+          end
+
+          result = Rack::Utils.uri_escape(generate_path_for_base_params(path, params))
+          unless params.nil? || params.empty?
+            extra_params = generate_extra_params(params, result[??])
+            result << extra_params
+          end
+          result
+        end
+
+        def generation_module
+          build_module!
+          @generation_module
+        end
+
+        def build_module!
+          unless @generation_module
+            @generation_module = Module.new
+            @generation_module.module_eval <<-END_EVAL
+              @@generator = nil
+              def self.generator=(generator)
+                @@generator = generator
+              end
+            END_EVAL
+            @generation_module.generator = self
+
+            @generation_module.module_eval <<-END_EVAL
+              def respond_to?(method_name)
+                if match = Regexp.new('^(.*?)_(path|url)$').match(method_name.to_s)
+                  @@generator.usher.named_routes.key?(match.group(1))
+                else
+                  super
+                end
+              end
+            END_EVAL
+
+
+            usher.named_routes.each do |name, route|
+              @generation_module.module_eval <<-END_EVAL
+                def #{name}_url(name, request, params = nil)
+                  @@generator.generate_full(name, request, options)
+                end
+
+                def #{name}_path(name, params = nil)
+                  @@generator.generate(name, options)
+                end
+              END_EVAL
+            end
+          end
+        end
+
         def generate_start(path, request)
           result = (path.route.generate_with && path.route.generate_with.scheme || request.scheme).dup
           result << '://'
@@ -53,77 +129,42 @@ class Usher
           end
           result
         end
-        
+
         def path_for_routing_lookup(routing_lookup, params = {})
           path = case routing_lookup
           when Symbol
-            route = @usher.named_routes[routing_lookup] 
+            route = @usher.named_routes[routing_lookup]
+            raise UnrecognizedException unless route
             route.find_matching_path(params || {})
           when Route
-            routing_lookup.find_matching_path(params || {})
+            routing_lookup.find_matching_path(params)
           when nil
-            params.is_a?(Hash) ? @usher.path_for_options(params) : raise
+            params.is_a?(Hash) ? usher.path_for_options(params) : raise
           when Route::Path
             routing_lookup
           end
         end
-    
-        # Generates a completed URL based on a +route+ or set of optional +params+
-        #   
-        #   set = Usher.new
-        #   route = set.add_named_route(:test_route, '/:controller/:action')
-        #   set.generate_url(nil, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-        #   set.generate_url(:test_route, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-        #   set.generate_url(route.primary_path, {:controller => 'c', :action => 'a'}) == '/c/a' => true
-        def generate_path(path, params = nil)
-          raise UnrecognizedException.new unless path
 
-          params = Array(params) if params.is_a?(String)
-          if params.is_a?(Array)
-            given_size = params.size
-            extra_params = params.last.is_a?(Hash) ? params.pop : nil
-            params = Hash[*path.dynamic_parts.inject([]){|a, dynamic_part| a.concat([dynamic_part.name, params.shift || raise(MissingParameterException.new("got #{given_size}, expected #{path.dynamic_parts.size} parameters"))]); a}]
-            params.merge!(extra_params) if extra_params
-          end
 
-          result = ''
-          path.parts.each do |part|
-            case part
-            when Route::Variable::Glob
-              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
-              value.each_with_index do |current_value, index|
-                part.valid!(current_value)
-                result << current_value.to_s
-                result << '/' if index != value.size - 1
-              end
-            when Route::Variable
-              value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
-              part.valid!(value)
-              result << value.to_s
-            else
-              result << part
-            end
-          end
-          result = Rack::Utils.uri_escape(result)
+        def generate_extra_params(params, has_question_mark)
+          extra_params_result = ''
 
-          unless params.nil? || params.empty?
-            has_query = result[??]
-            params.each do |k,v|
-              case v
-              when Array
-                v.each do |v_part|
-                  result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
-                end
-              else
-                result << (has_query ? '&' : has_query = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
+          params.each do |k,v|
+            case v
+            when Array
+              v.each do |v_part|
+                extra_params_result << (has_question_mark ? '&' : has_question_mark = true && '?') << Rack::Utils.escape("#{k.to_s}[]") << '=' << Rack::Utils.escape(v_part.to_s)
               end
+            else
+              extra_params_result << (has_question_mark ? '&' : has_question_mark = true && '?') << Rack::Utils.escape(k.to_s) << '=' << Rack::Utils.escape(v.to_s)
             end
           end
-          result
+          extra_params_result
         end
-      
+
       end
-      
+
     end
   end
-end
+end
+

data/lib/usher/util/rack-mixins.rb

@@ -0,0 +1,24 @@
+require 'rack'
+
+unless Rack::Utils.respond_to?(:uri_escape)
+  module Rack
+
+    module Utils
+
+      def uri_escape(s)
+        s.to_s.gsub(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) {
+          '%'<<$1.unpack('H2'*$1.size).join('%').upcase
+        }.tr(' ', '+')
+      end
+      module_function :uri_escape
+
+      def uri_unescape(s)
+        gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+          [$1.delete('%')].pack('H*')
+        }
+      end
+      module_function :uri_unescape
+
+    end
+  end
+end