usher 0.4.8 → 0.5.1

data/lib/usher/route/path.rb

@@ -2,23 +2,62 @@ class Usher
   class Route
     class Path
   
-      attr_reader :dynamic_parts, :dynamic_map, :dynamic_indicies, :route, :parts, :dynamic_required_keys, :dynamic_keys
+      attr_accessor :route
+      attr_reader :parts
       
       def initialize(route, parts)
-        @route = route
-        @parts = parts
-        @dynamic_indicies = []
-        @parts.each_index{|i| @dynamic_indicies << i if @parts[i].is_a?(Variable)}
-        @dynamic_parts = @parts.values_at(*@dynamic_indicies)
-        @dynamic_map = {}
-        @dynamic_parts.each{|p| @dynamic_map[p.name] = p }
-        @dynamic_keys = @dynamic_map.keys
-        @dynamic_required_keys = @dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name}
+        self.route = route
+        self.parts = parts
+      end
+
+      def dynamic_indicies
+        unless dynamic? && @dynamic_indicies
+          @dynamic_indicies = []
+          parts.each_index{|i| @dynamic_indicies << i if parts[i].is_a?(Variable)}
+        end
+        @dynamic_indicies
+      end
+
+      def dynamic_parts
+        @dynamic_parts ||= parts.values_at(*dynamic_indicies) if dynamic?
+      end
+
+      def dynamic_map
+        unless dynamic? && @dynamic_map
+          @dynamic_map = {}
+          dynamic_parts.each{|p| @dynamic_map[p.name] = p }
+        end
+        @dynamic_map
+      end
+      
+      def dynamic_keys
+        @dynamic_keys ||= dynamic_map.keys if dynamic?
+      end
+      
+      def dynamic_required_keys
+        @dynamic_required_keys ||= dynamic_parts.select{|dp| !dp.default_value}.map{|dp| dp.name} if dynamic?
+      end
+      
+      def dynamic?
+        @dynamic
       end
 
       def can_generate_from?(keys)
-        (@dynamic_required_keys - keys).size.zero?
+        (dynamic_required_keys - keys).size.zero?
+      end
+      
+      # Merges paths for use in generation
+      def merge(other_path)
+        new_parts = parts + other_path.parts
+        Path.new(route, new_parts)
       end
+      
+      private 
+      def parts=(parts)
+        @parts = parts
+        @dynamic = @parts.any?{|p| p.is_a?(Variable)}
+      end
+      
     end
   end
 end

data/lib/usher/route/util.rb

@@ -0,0 +1,65 @@
+class Usher
+  class Route
+
+    module Util
+
+      class Group < Array
+        attr_accessor :group_type
+        attr_accessor :parent
+
+        def inspect
+          "#{group_type}->#{super}"
+        end
+
+        def initialize(group_type, parent)
+          @group_type = group_type
+          @parent = parent
+        end
+      end
+
+      def self.cartesian_product!(lval, rval)
+        product = []
+        (lval.size * rval.size).times do |index|
+          val = []
+          val.push(*lval[index % lval.size])
+          val.push(*rval[index % rval.size])
+          product << val
+        end
+        lval.replace(product)
+      end
+
+      def self.expand_path(parts)
+        if parts.is_a?(Array)
+          paths = [[]]
+          
+          unless parts.respond_to?(:group_type)
+            new_parts = Group.new(:any, nil)
+            parts.each{|p| new_parts << p}
+            parts = new_parts
+          end
+          
+          case parts.group_type
+          when :all
+            parts.each do |p|
+              cartesian_product!(paths, expand_path(p))
+            end
+          when :any
+            parts.each do |p|
+              cartesian_product!(paths, expand_path(p))
+            end
+            paths.unshift([])
+          when :one
+            cartesian_product!(paths, parts.collect do |p|
+              expand_path(p)
+            end)
+          end
+          paths.each{|p| p.compact!; p.flatten! }
+          paths
+        else
+          [[parts]]
+        end
+
+      end
+    end
+  end
+end

data/lib/usher/route/variable.rb

@@ -2,19 +2,14 @@ class Usher
   class Route
     class Variable
       attr_reader :type, :name, :validator, :regex_matcher
-      attr_accessor :look_ahead, :globs_capture_separators, :default_value
+      attr_accessor :look_ahead, :default_value
       
-      def initialize(type, name, validator = nil, regex_matcher = nil, globs_capture_separators = false)
-        @type = type
-        @name = :"#{name}"
+      def initialize(name, regex_matcher = nil, validator = nil)
+        @name = name.to_s.to_sym
         @validator = validator
         @regex_matcher = regex_matcher
-        @globs_capture_separators = globs_capture_separators
-      end
-
-      def to_s
-        "#{type}#{name}"
       end
+      private :initialize
       
       def valid!(val)
         case @validator
@@ -22,7 +17,7 @@ class Usher
           begin
             @validator.call(val)
           rescue Exception => e
-            raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
+            raise ValidationException.new("#{val} does not conform to #{@g}, root cause #{e.inspect}")
           end
         else
           @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}"))
@@ -30,8 +25,24 @@ class Usher
       end
       
       def ==(o)
-        o && (o.type == @type && o.name == @name && o.validator == @validator)
+        o && (o.class == self.class && o.name == @name && o.validator == @validator)
+      end
+      
+      class Single < Variable
+        def to_s
+          ":#{name}"
+        end
       end
+
+      class Glob < Variable
+        def to_s
+          "*#{name}"
+        end
+      end
+
+      Greedy = Class.new(Variable)
+      
     end
+    
   end
 end

data/lib/usher/splitter.rb

@@ -3,156 +3,19 @@ require 'strscan'
 class Usher
   class Splitter
     
-    def self.for_delimiters(delimiters, valid_regex)
-      delimiters_regex = delimiters.collect{|d| Regexp.quote(d)} * '|'
-      SplitterInstance.new(
-        delimiters,
-        Regexp.new('((:|\*)?' + valid_regex + '|' + delimiters_regex + '|\(|\)|\||\{)'),
-        Regexp.new("[#{delimiters.collect{|d| Regexp.quote(d)}}]|[^#{delimiters.collect{|d| Regexp.quote(d)}}]+")
-      )
+    def self.for_delimiters(router, valid_regex)
+      SplitterInstance.new(Regexp.new("[#{router.delimiters.collect{|d| Regexp.quote(d)}.join}]|[^#{router.delimiters.collect{|d| Regexp.quote(d)}.join}]+"))
     end
-    
-    attr_reader :paths
 
     class SplitterInstance
-      
-      attr_reader :delimiter_chars
-      
-      def initialize(delimiters, split_regex, url_split_regex)
-        @delimiters = delimiters
-        @delimiter_chars = delimiters.collect{|d| d[0]}
-        @split_regex = split_regex
+    
+      def initialize(url_split_regex)
         @url_split_regex = url_split_regex
       end
       
       def url_split(path)
         path.scan(@url_split_regex)
       end
-
-      def split(path, requirements = nil, default_values = nil)
-        parts = Group.new(:all, nil)
-        ss = StringScanner.new(path)
-        current_group = parts
-        while !ss.eos?
-          part = ss.scan(@split_regex)
-          case part[0]
-          when ?*, ?:
-            type = part.slice!(0).chr.to_sym
-            current_group << Usher::Route::Variable.new(type, part, requirements && requirements[part.to_sym])
-          when ?{
-            pattern = ''
-            count = 1
-            variable = ss.scan(/[:\*]([^,]+),/)
-            until count.zero?
-              regex_part = ss.scan(/\{|\}|[^\{\}]+/)
-              case regex_part[0]
-              when ?{
-                count += 1
-              when ?}
-                count -= 1
-              end
-              pattern << regex_part
-            end
-            pattern.slice!(pattern.length - 1)
-            regex = Regexp.new(pattern)
-            if variable
-              variable_type = variable.slice!(0).chr.to_sym
-              variable_name = variable[0, variable.size - 1].to_sym
-              current_group << Usher::Route::Variable.new(variable_type, variable_name, requirements && requirements[variable_name], regex)
-            else
-              current_group << regex
-            end
-          when ?(
-            new_group = Group.new(:any, current_group)
-            current_group << new_group
-            current_group = new_group
-          when ?)
-            current_group = current_group.parent.type == :one ? current_group.parent.parent : current_group.parent
-          when ?|
-            unless current_group.parent.type == :one
-              detached_group = current_group.parent.pop
-              new_group = Group.new(:one, detached_group.parent)
-              detached_group.parent = new_group
-              detached_group.type = :all
-              new_group << detached_group
-              new_group.parent << new_group
-            end
-            current_group.parent << Group.new(:all, current_group.parent)
-            current_group = current_group.parent.last
-          else
-            current_group << part
-          end
-        end unless !path || path.empty?
-        paths = calc_paths(parts)
-        paths.each do |path|
-          path.each_with_index do |part, index|
-            if part.is_a?(Usher::Route::Variable)
-              part.default_value = default_values[part.name] if default_values
-              
-              case part.type
-              when :*
-                part.look_ahead = path[index + 1, path.size].find{|p| !p.is_a?(Usher::Route::Variable) && !@delimiter_chars.include?(p[0])} || nil
-              when :':'
-                part.look_ahead = path[index + 1, path.size].find{|p| @delimiter_chars.include?(p[0])} || @delimiters.first
-              end
-            end
-          end
-        end
-        paths
-      end
-
-      private
-
-      def cartesian_product!(lval, rval)
-        product = []
-        (lval.size * rval.size).times do |index|
-          val = []
-          val.push(*lval[index % lval.size])
-          val.push(*rval[index % rval.size])
-          product << val
-        end
-        lval.replace(product)
-      end
-
-      def calc_paths(parts)
-        if parts.is_a?(Group)
-          paths = [[]]
-          case parts.type
-          when :all
-            parts.each do |p|
-              cartesian_product!(paths, calc_paths(p))
-            end
-          when :any
-            parts.each do |p|
-              cartesian_product!(paths, calc_paths(p))
-            end
-            paths.unshift([])
-          when :one
-            cartesian_product!(paths, parts.collect do |p|
-              calc_paths(p)
-            end)
-          end
-          paths.each{|p| p.compact!; p.flatten! }
-          paths
-        else
-          [[parts]]
-        end
-
-      end
-    end
-    
-    class Group < Array
-      attr_accessor :type
-      attr_accessor :parent
-      
-      def inspect
-        "#{type}->#{super}"
-      end
-      
-      def initialize(type, parent)
-        @type = type
-        @parent = parent
-      end
     end
     
   end

data/lib/usher/util.rb

@@ -0,0 +1,6 @@
+class Usher
+  module Util
+    autoload :Generators, File.join(File.dirname(__FILE__), 'util', 'generate')
+    autoload :Parser, File.join(File.dirname(__FILE__), 'util', 'parser')
+  end
+end

data/lib/usher/util/generate.rb

@@ -0,0 +1,129 @@
+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
+
+class Usher
+  module Util
+    class Generators
+    
+      class URL
+      
+        attr_accessor :usher
+
+        def generate_full(routing_lookup, request, params = nil)
+          path = path_for_routing_lookup(routing_lookup, params)
+          result = generate_start(path, request)
+          result << generate_path(path, params)
+        end
+
+        def generate(routing_lookup, params = nil)
+          generate_path(path_for_routing_lookup(routing_lookup, params), params)
+        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
+        end
+        
+        def path_for_routing_lookup(routing_lookup, params = {})
+          path = case routing_lookup
+          when Symbol
+            route = @usher.named_routes[routing_lookup] 
+            route.find_matching_path(params || {})
+          when Route
+            routing_lookup.find_matching_path(params || {})
+          when nil
+            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)
+
+          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)
+              end
+            end
+          end
+          result
+        end
+      
+      end
+      
+    end
+  end
+end