lib/usher/util/generate.rb in usher-0.5.11 vs lib/usher/util/generate.rb in usher-0.5.12

@@ -36,17 +36,60 @@
 
       end
 
       class URL < Generic
 
+        class UrlParts < Struct.new(:path, :request)
+          def scheme
+            @scheme ||= generate_with(:scheme) || (request.respond_to?(:scheme) and request.scheme)
+          end
+
+          def protocol
+            @protocol ||= scheme ? "#{scheme}://" : request.protocol
+          end
+
+          def host
+            @host ||= generate_with(:host) || request.host
+          end
+
+          def port
+            @port ||= generate_with(:port) || request.port
+          end
+
+          def port_string
+            @port_string ||= standard_port? ? '' : ":#{port}"
+          end
+
+          def url            
+            path.route.generate_with.nil? || path.route.generate_with.empty? ?
+              request.url :
+              protocol + host + port_string
+          end
+
+        protected
+
+          def generate_with(property)
+            path.route.generate_with and path.route.generate_with[property]
+          end
+
+          def standard_port?
+            ssl? ? port == 443 : port == 80
+          end
+
+          def ssl?
+            protocol[0..4] == 'https'
+          end
+        end
+
         def initialize
-          require File.join(File.dirname(__FILE__), 'rack-mixins')
+          require File.join('usher', 'util', 'rack-mixins')
         end
 
         def generate_full(routing_lookup, request, params = nil)
           path = path_for_routing_lookup(routing_lookup, params)
-          result = generate_start(path, request)
+
+          result = generate_start(path, request)          
           result << generate_path(path, params)
         end
 
         # Generates a completed URL based on a +route+ or set of optional +params+
         #
@@ -103,16 +146,16 @@
             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)
+                def #{name}_url(options={})
+                  @@generator.generate_full('#{name}'.to_sym, request, options)
                 end
 
-                def #{name}_path(name, params = nil)
-                  @@generator.generate(name, options)
+                def #{name}_path(options={})
+                  @@generator.generate('#{name}'.to_sym, options)
                 end
               END_EVAL
             end
           end
         end
@@ -125,23 +168,17 @@
           else
             '/'
           end
         end
 
-        def generate_start(path, request)
-          result = (path.route.generate_with && path.route.generate_with.scheme || request.scheme).dup
-          result << '://'
-          result << (path.route.generate_with && path.route.generate_with.host) ? path.route.generate_with.host : request.host
-          port = path.route.generate_with && path.route.generate_with.port || request.port
-          if result[4] == ?s
-            result << ':' << port.to_s unless port == 443
-          else
-            result << ':' << port.to_s unless port == 80
-          end
-          result
+        def generate_start(path, request)          
+          url_parts = UrlParts.new(path, request)
+          url = url_parts.url
+
+          (url[-1] == ?/) ? url[0..-2] : url
         end
 
-        def path_for_routing_lookup(routing_lookup, params = {})
+        def path_for_routing_lookup(routing_lookup, params = {})                    
           path = case routing_lookup
           when Symbol
             route = @usher.named_routes[routing_lookup]
             raise UnrecognizedException unless route
             route.find_matching_path(params || {})