joshbuddy-usher 0.4.3 → 0.4.5

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
+:patch: 5
 :major: 0
 :minor: 4
-:patch: 3

data/lib/usher/generate.rb

@@ -0,0 +1,82 @@
+class Usher
+  class Generators
+    
+    class URL
+    
+      def initialize(usher)
+        @usher = usher
+      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(routing_lookup, params = nil, options = nil)
+        delimiter = options && options.key?(:delimiter) ? options.delete(:delimiter) : @usher.delimiters.first
+
+        path = case routing_lookup
+        when Symbol
+          route = @usher.named_routes[routing_lookup] 
+          params.is_a?(Hash) ? route.find_matching_path(params) : route.paths.first
+        when Route
+          params.is_a?(Hash) ? routing_lookup.find_matching_path(params) : routing_lookup.paths.first
+        when nil
+          params.is_a?(Hash) ? @usher.path_for_options(params) : raise
+        when Route::Path
+          routing_lookup
+        end
+
+        raise UnrecognizedException.new unless path
+
+        params = Array(params) if params.is_a?(String)
+        if params.is_a?(Array)
+          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)]); a}]
+          params.merge!(extra_params) if extra_params
+        end
+
+        result = ''
+        path.parts.each do |part|
+          case part
+          when Route::Variable
+            value = (params && params.delete(part.name)) || part.default_value || raise(MissingParameterException.new)
+            case part.type
+            when :*
+              value.each_with_index do |current_value, index|
+                current_value = current_value.to_s unless current_value.is_a?(String)
+                part.valid!(current_value)
+                result << current_value
+                result << delimiter if index != value.size - 1
+              end
+            when :':'
+              value = value.to_s unless value.is_a?(String)
+              part.valid!(value)
+              result << value
+            end
+          else
+            result << part
+          end
+        end
+        result = URI.escape(result)
+
+        if params && !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 && '?') << CGI.escape("#{k.to_s}[]") << '=' << CGI.escape(v_part.to_s)
+              end
+            else
+              result << (has_query ? '&' : has_query = true && '?') << CGI.escape(k.to_s) << '=' << CGI.escape(v.to_s)
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/usher/grapher.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 class Usher
   class Grapher
 
@@ -11,29 +9,53 @@ class Usher
       @significant_keys = nil
       @orders = Hash.new{|h,k| h[k] = Hash.new{|h2, k2| h2[k2] = []}}
       @key_count = Hash.new(0)
+      @cache = {}
     end
 
     def add_route(route)
       route.paths.each do |path|
-        unless path.dynamic_set.size.zero?
-          path.dynamic_set.each do |k|
-            @orders[path.dynamic_set.size][k] << path
+        unless path.dynamic_keys.size.zero?
+          path.dynamic_keys.each do |k|
+            @orders[path.dynamic_keys.size][k] << path
             @key_count[k] += 1
           end
+          
+          dynamic_parts_with_defaults = path.dynamic_parts.select{|part| part.default_value }.map{|dp| dp.name}
+          dynamic_parts_without_defaults = path.dynamic_parts.select{|part| !part.default_value }.map{|dp| dp.name}
+
+          (1...(2 ** (dynamic_parts_with_defaults.size))).each do |i|
+            current_set = dynamic_parts_without_defaults.dup
+            dynamic_parts_with_defaults.each_with_index do |dp, index|
+              current_set << dp unless (index & i) == 0
+            end
+
+            current_set.each do |k|
+              @orders[current_set.size][k] << path
+              @key_count[k] += 1
+            end
+          end
         end
       end
     end
 
     def significant_keys
-      @significant_keys ||= Set.new(@key_count.keys)
+      @significant_keys ||= @key_count.keys.uniq
     end
 
     def find_matching_path(params)
       unless params.empty?
-        set = Set.new(params.keys) & significant_keys
+        set = params.keys & significant_keys
+        if cached = @cache[set] 
+          return cached
+        end
         set.size.downto(1) do |o|
           set.each do |k|
-            @orders[o][k].each { |r| return r if r.dynamic_set.subset?(set) }
+            @orders[o][k].each { |r| 
+              if r.can_generate_from?(set)
+                @cache[set] = r
+                return r
+              end
+            }
           end
         end
         nil

data/lib/usher/interface/email_interface.rb

@@ -22,7 +22,7 @@ class Usher
       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 })
+          response.path.route.destination.call(response.params.inject({}){|h,(k,v)| h[k]=v.to_s; h })
         end
       end
 

data/lib/usher/interface/rack_interface.rb

@@ -13,6 +13,7 @@ class Usher
       
       def initialize(&blk)
         @routes = Usher.new(:request_methods => RequestMethods)
+        @generator = Usher::Generators::URL.new(@routes)
         instance_eval(&blk) if blk
       end
       
@@ -26,8 +27,14 @@ class Usher
 
       def call(env)
         response = @routes.recognize(Request.new(env['REQUEST_URI'], env['REQUEST_METHOD'].downcase, env['HTTP_HOST'], env['SERVER_PORT'].to_i, env['rack.url_scheme']))
-        env['usher.params'] = response.params.inject({}){|h,(k,v)| h[k]=v; h }
-        response.path.route.params.first.call(env)
+        params = {}
+        response.params.each{ |hk| params[hk.first] = hk.last}
+        env['usher.params'] = params
+        response.path.route.destination.call(env)
+      end
+
+      def generate(route, params = nil, options = nil)
+        @generator.generate(route, params, options)
       end
 
     end

data/lib/usher/interface/{rails2_interface → rails2_2_interface}/mapper.rb

@@ -1,6 +1,6 @@
 class Usher
   module Interface
-    class Rails2Interface
+    class Rails2_2Interface
       
       class Mapper #:doc:
         def initialize(set) #:nodoc:

data/lib/usher/interface/{rails2_interface.rb → rails2_2_interface.rb}

@@ -1,10 +1,10 @@
 $:.unshift File.dirname(__FILE__)
 
-require 'rails2_interface/mapper'
+require 'rails2_2_interface/mapper'
 
 class Usher
   module Interface
-    class Rails2Interface
+    class Rails2_2Interface
       
       attr_reader :usher
       attr_accessor :configuration_file
@@ -15,6 +15,7 @@ class Usher
       
       def reset!
         @usher ||= Usher.new
+        @url_generator ||= Usher::Generators::URL.new(@usher)
         @module ||= Module.new
         @module.instance_methods.each do |selector|
           @module.class_eval { remove_method selector }
@@ -39,14 +40,14 @@ class Usher
 
         path[0, 0] = '/' unless path[0] == ?/
         route = @usher.add_route(path, options)
-        raise "your route must include a controller" unless route.primary_path.dynamic_set.include?(:controller) || route.params.first.include?(:controller)
+        raise "your route must include a controller" unless route.paths.first.dynamic_keys.include?(:controller) || route.destination.include?(:controller)
         route
       end
       
       def recognize(request)
         node = @usher.recognize(request)
         params = node.params.inject({}){|h,(k,v)| h[k]=v; h }
-        request.path_parameters = (node.params.empty? ? node.path.route.params.first : node.path.route.params.first.merge(params)).with_indifferent_access
+        request.path_parameters = (node.params.empty? ? node.path.route.destination : node.path.route.destination.merge(params)).with_indifferent_access
         "#{request.path_parameters[:controller].camelize}Controller".constantize
       rescue
         raise ActionController::RoutingError, "No route matches #{request.path.inspect} with #{request.inspect}"
@@ -73,7 +74,7 @@ class Usher
           unless options.key?(:action)
             options[:action] = ''
           end
-          route_for_options(merged_options)
+          path_for_options(merged_options)
         end
         case method
         when :generate
@@ -87,11 +88,11 @@ class Usher
       end
       
       def generate_url(route, params)
-        @usher.generate_url(route, params)
+        @url_generator.generate(route, params)
       end
       
-      def route_for_options(options)
-        @usher.route_for_options(options)
+      def path_for_options(options)
+        @usher.path_for_options(options)
       end
       
       def named_routes

data/lib/usher/interface/rails2_3_interface.rb

@@ -0,0 +1,137 @@
+$:.unshift File.dirname(__FILE__)
+
+class Usher
+  module Interface
+    class Rails2_3Interface
+      
+      attr_reader :configuration_files
+      
+      def named_routes
+        @router.named_routes
+      end
+      
+      def add_named_route(name, route, options = {})
+        @router.add_route(route, options).name(name)
+      end
+
+      def add_route(path, options = {})
+        if !@controller_action_route_added && path =~ %r{^/?:controller/:action/:id$}
+          add_route('/:controller/:action', options.dup)
+          @controller_action_route_added = true 
+        end
+
+        if !@controller_route_added && path =~ %r{^/?:controller/:action$}
+          add_route('/:controller', options.merge({:action => 'index'}))
+          @controller_route_added = true 
+        end
+        
+        options[:action] = 'index' unless options[:action]
+
+        path[0, 0] = '/' unless path[0] == ?/
+        route = @router.add_route(path, options).to(options)
+        
+        raise "your route must include a controller" unless (route.paths.first.dynamic_keys.include?(:controller) || route.destination.include?(:controller))
+        route
+      end
+      
+      def initialize
+        reset!
+      end
+      
+      def add_configuration_file(file)
+        @configuration_files << file
+      end
+      
+      def reload!
+        if configuration_files.any?
+          configuration_files.each { |config| load(config) }
+        else
+          add_route ":controller/:action/:id"
+        end
+        
+      end
+      alias_method :reload, :reload!
+
+      def route_count
+        routes.size
+      end
+
+      def routes
+        @router.routes
+      end
+
+      def call(env)
+        request = ActionController::Request.new(env)
+        app = recognize(request)
+        app.call(env).to_a
+      end
+      
+      def recognize(request)
+        response = @router.recognize(request)
+        request.path_parameters = (response.params.empty? ? response.path.route.destination : response.path.route.destination.merge(response.params.inject({}){|h,(k,v)| h[k]=v; h })).with_indifferent_access
+        response.params.each { |pair| request.path_parameters[pair.first] = pair.last }
+        "#{request.path_parameters[:controller].camelize}Controller".constantize
+      end
+      
+      def reset!
+        @router = Usher.new
+        @url_generator = Usher::Generators::URL.new(@router)
+        @configuration_files = []
+        @module ||= Module.new
+        @controller_route_added = false
+        @controller_action_route_added = false
+      end
+      
+      def draw
+        reset!
+        yield ActionController::Routing::RouteSet::Mapper.new(self)
+        install_helpers
+      end
+      
+      def install_helpers(destinations = [ActionController::Base, ActionView::Base], regenerate_code = false)
+        #*_url and hash_for_*_url
+        Array(destinations).each do |d| d.module_eval { include Helpers } 
+          @router.named_routes.keys.each do |name|
+            @module.module_eval <<-end_eval # We use module_eval to avoid leaks
+              def #{name}_url(options = {})
+                ActionController::Routing::UsherRoutes.generate(options, {}, :generate, :#{name})
+              end
+            end_eval
+          end
+          d.__send__(:include, @module)
+        end
+      end
+
+      def generate(options, recall = {}, method = :generate, route_name = nil)
+        route = if(route_name)
+          @router.named_routes[route_name]
+        else
+          merged_options = options
+          merged_options[:controller] = recall[:controller] unless options.key?(:controller)
+          unless options.key?(:action)
+            options[:action] = ''
+          end
+          path_for_options(merged_options)
+        end
+        case method
+        when :generate
+          merged_options ||= recall.merge(options)
+          url = generate_url(route, merged_options)
+          url.slice!(-1) if url[-1] == ?/
+          url 
+        else
+          raise "method #{method} not recognized"
+        end
+      end
+      
+      def generate_url(route, params)
+        @url_generator.generate(route, params)
+      end
+      
+      def path_for_options(options)
+        @router.path_for_options(options)
+      end
+      
+    end
+  end
+end

data/lib/usher/interface.rb

@@ -2,15 +2,18 @@ $:.unshift File.dirname(__FILE__)
 
 class Usher
   module Interface
-    autoload :Rails2Interface, 'interface/rails2_interface'
+    autoload :Rails2_2Interface, 'interface/rails2_2_interface'
+    autoload :Rails2_3Interface, 'interface/rails2_3_interface'
     autoload :MerbInterface, 'interface/merb_interface'
     autoload :RackInterface, 'interface/rack_interface'
     autoload :EmailInterface, 'interface/email_interface'
     
     def self.for(type, &blk)
       case type
-      when :rails2
-        Rails2Interface.new(&blk)
+      when :rails2_2
+        Rails2_2Interface.new(&blk)
+      when :rails2_3
+        Rails2_3Interface.new(&blk)
       when :merb
         MerbInterface.new(&blk)
       when :rack

data/lib/usher/node.rb

@@ -1,6 +1,6 @@
 $:.unshift File.dirname(__FILE__)
 
-require 'fuzzy_hash'
+require '/Users/josh/Development/fuzzy_hash/lib/fuzzy_hash'
 
 class Usher
 
@@ -89,10 +89,10 @@ class Usher
       route
     end
     
-    def find(request, path, params = [])
+    def find(usher, request, path, params = [])
       if exclusive_type
         [lookup[request.send(exclusive_type)], lookup[nil]].each do |n|
-          if n && (ret = n.find(request, path.dup, params.dup))
+          if n && (ret = n.find(usher, request, path.dup, params.dup))
             return ret
           end
         end
@@ -105,15 +105,15 @@ class Usher
           when :*
             params << [next_part.value.name, []] unless params.last && params.last.first == next_part.value.name
             loop do
-              if (next_part.value.look_ahead === part || (!part.is_a?(Symbol) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
+              if (next_part.value.look_ahead === part || (!usher.splitter.delimiter_chars.include?(part[0]) && next_part.value.regex_matcher && !next_part.value.regex_matcher.match(part)))
                 path.unshift(part)
-                path.unshift(next_part.parent.value) if next_part.parent.value.is_a?(Symbol)
+                path.unshift(next_part.parent.value) if usher.splitter.delimiter_chars.include?(next_part.parent.value[0])
                 break
-              else
-                unless part.is_a?(Symbol) && !next_part.value.globs_capture_separators
-                  next_part.value.valid!(part)
-                  params.last.last << part
-                end
+              elsif next_part.value.globs_capture_separators
+                params.last.last << part
+              elsif !usher.splitter.delimiter_chars.include?(part[0])
+                next_part.value.valid!(part)
+                params.last.last << part
               end
               if path.size.zero?
                 break
@@ -122,15 +122,15 @@ class Usher
               end
             end
           when :':'
-            next_part.value.valid!(part)
             var = next_part.value
-            params << [next_part.value.name, part]
-            until (path.first == var.look_ahead) || path.empty?
-              params.last.last << path.shift.to_s 
+            var.valid!(part)
+            params << [var.name, part]
+            until (var.look_ahead === path.first) || path.empty?
+              params.last.last << path.shift 
             end
           end
         end
-        next_part.find(request, path, params)
+        next_part.find(usher, request, path, params)
       else
         nil
       end