usher 0.4.8

data/lib/usher/interface/rails2_2_interface.rb

@@ -0,0 +1,135 @@
+require File.join(File.dirname(__FILE__), 'rails2_2_interface', 'mapper')
+
+class Usher
+  module Interface
+    class Rails2_2Interface
+      
+      attr_reader :usher
+      attr_accessor :configuration_file
+
+      def initialize
+        reset!
+      end
+      
+      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 }
+        end
+        @controller_action_route_added = false
+        @controller_route_added = false
+        @usher.reset!
+      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 = @usher.add_route(path, options)
+        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.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}"
+      end
+      
+      def add_named_route(name, route, options = {})
+        @usher.add_route(route, options).name(name)
+      end
+        
+      def route_count
+        @usher.route_count
+      end  
+      
+      def empty?
+        @usher.route_count.zero?
+      end
+      
+      def generate(options, recall = {}, method = :generate, route_name = nil)
+        route = if(route_name)
+          @usher.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)
+        @usher.path_for_options(options)
+      end
+      
+      def named_routes
+        @usher.named_routes
+      end
+
+      def reload
+        @usher.reset!
+        if @configuration_file
+          Kernel.load(@configuration_file)
+        else
+          @usher.add_route ":controller/:action/:id"
+        end
+      end
+
+      def load_routes!
+        reload
+      end
+
+      def draw
+        reset!
+        yield 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 } 
+          @usher.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
+      
+    end
+  end
+end

data/lib/usher/interface/rails2_3_interface.rb

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,27 @@
+class Usher
+  module Interface
+    autoload :Rails2_2Interface, File.join(File.dirname(__FILE__), 'interface', 'rails2_2_interface')
+    autoload :Rails2_3Interface, File.join(File.dirname(__FILE__), 'interface', 'rails2_3_interface')
+    autoload :MerbInterface, File.join(File.dirname(__FILE__), 'interface', 'merb_interface')
+    autoload :RackInterface, File.join(File.dirname(__FILE__), 'interface', 'rack_interface')
+    autoload :EmailInterface, File.join(File.dirname(__FILE__), 'interface', 'email_interface')
+    
+    def self.for(type, &blk)
+      case type
+      when :rails2_2
+        Rails2_2Interface.new(&blk)
+      when :rails2_3
+        Rails2_3Interface.new(&blk)
+      when :merb
+        MerbInterface.new(&blk)
+      when :rack
+        RackInterface.new(&blk)
+      when :email
+        EmailInterface.new(&blk)
+      end
+      
+    end
+    
+    
+  end
+end

data/lib/usher/node.rb

@@ -0,0 +1,138 @@
+require 'fuzzy_hash'
+
+class Usher
+
+  class Node
+    
+    Response = Struct.new(:path, :params)
+    
+    attr_reader :lookup
+    attr_accessor :terminates, :exclusive_type, :parent, :value, :request_methods, :globs_capture_separators
+
+    def initialize(parent, value)
+      @parent = parent
+      @value = value
+      @lookup = Hash.new
+      @exclusive_type = nil
+    end
+
+    def upgrade_lookup
+      @lookup = FuzzyHash.new(@lookup)
+    end
+
+    def depth
+      @depth ||= @parent && @parent.is_a?(Node) ? @parent.depth + 1 : 0
+    end
+    
+    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
+
+    def terminates?
+      @terminates
+    end
+
+    def pp
+      $stdout << " " * depth
+      $stdout << "#{depth}: #{value.inspect} #{!!terminates?}\n"
+      @lookup.each do |k,v|
+        $stdout << " " * (depth + 1)
+        $stdout << "#{k} ==> \n"
+        v.pp
+      end
+    end
+    
+    def add(route)
+      route.paths.each do |path|
+        parts = path.parts.dup
+        request_methods.each do |type|
+          parts.push(Route::RequestMethod.new(type, route.conditions[type])) if route.conditions && route.conditions.key?(type)
+        end
+        
+        current_node = self
+        until parts.size.zero?
+          key = parts.shift
+          target_node = case key
+          when Route::RequestMethod
+            current_node.upgrade_lookup if key.value.is_a?(Regexp)
+            if current_node.exclusive_type == key.type
+              current_node.lookup[key.value] ||= Node.new(current_node, key)
+            elsif current_node.lookup.empty?
+              current_node.exclusive_type = key.type
+              current_node.lookup[key.value] ||= Node.new(current_node, key)
+            else
+              parts.unshift(key)
+              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)
+            elsif key.regex_matcher
+              current_node.upgrade_lookup
+              current_node.lookup[key.regex_matcher] ||= Node.new(current_node, key)
+            else
+              current_node.lookup[nil] ||= Node.new(current_node, key)
+            end  
+          end
+          current_node = target_node
+        end
+        current_node.terminates = path
+      end
+      route
+    end
+    
+    def find(usher, request, path, params = [])
+      if exclusive_type
+        [lookup[request.send(exclusive_type)], lookup[nil]].each do |n|
+          if n && (ret = n.find(usher, request, path.dup, params.dup))
+            return ret
+          end
+        end
+      elsif path.size.zero? && terminates?
+        Response.new(terminates, params)
+      elsif !path.size.zero? && (next_part = lookup[part = path.shift] || lookup[nil])
+        case next_part.value
+        when Route::Variable
+          case next_part.value.type
+          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 || (!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 usher.splitter.delimiter_chars.include?(next_part.parent.value[0])
+                break
+              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
+              else
+                part = path.shift
+              end
+            end
+          when :':'
+            var = next_part.value
+            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(usher, request, path, params)
+      else
+        nil
+      end
+    end
+
+  end
+end

data/lib/usher/route/path.rb

@@ -0,0 +1,24 @@
+class Usher
+  class Route
+    class Path
+  
+      attr_reader :dynamic_parts, :dynamic_map, :dynamic_indicies, :route, :parts, :dynamic_required_keys, :dynamic_keys
+      
+      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}
+      end
+
+      def can_generate_from?(keys)
+        (@dynamic_required_keys - keys).size.zero?
+      end
+    end
+  end
+end

data/lib/usher/route/request_method.rb

@@ -0,0 +1,22 @@
+class Usher
+  class Route
+    class RequestMethod
+  
+      attr_reader :type, :value
+  
+      def initialize(type, value)
+        @type = type
+        @value = value
+      end
+      
+      def hash
+        type.hash + value.hash
+      end
+      
+      def eql?(o)
+        o.is_a?(self.class) && o.type == type && o.value == value
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/usher/route/variable.rb

@@ -0,0 +1,37 @@
+class Usher
+  class Route
+    class Variable
+      attr_reader :type, :name, :validator, :regex_matcher
+      attr_accessor :look_ahead, :globs_capture_separators, :default_value
+      
+      def initialize(type, name, validator = nil, regex_matcher = nil, globs_capture_separators = false)
+        @type = type
+        @name = :"#{name}"
+        @validator = validator
+        @regex_matcher = regex_matcher
+        @globs_capture_separators = globs_capture_separators
+      end
+
+      def to_s
+        "#{type}#{name}"
+      end
+      
+      def valid!(val)
+        case @validator
+        when Proc
+          begin
+            @validator.call(val)
+          rescue Exception => e
+            raise ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}")
+          end
+        else
+          @validator === val or raise(ValidationException.new("#{val} does not conform to #{@validator}, root cause #{e.inspect}"))
+        end if @validator
+      end
+      
+      def ==(o)
+        o && (o.type == @type && o.name == @name && o.validator == @validator)
+      end
+    end
+  end
+end

data/lib/usher/route.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'route', 'path')
+require File.join(File.dirname(__FILE__), 'route', 'variable')
+require File.join(File.dirname(__FILE__), 'route', 'request_method')
+
+class Usher
+  class Route
+    attr_reader :paths, :original_path, :requirements, :conditions, :destination, :named, :generate_with
+    
+    GenerateWith = Struct.new(:scheme, :port, :host)
+    
+    def initialize(original_path, router, conditions, requirements, default_values, generate_with) # :nodoc:
+      @original_path = original_path
+      @router = router
+      @requirements = requirements
+      @conditions = conditions
+      @default_values = default_values
+      @paths = @router.splitter.split(@original_path, @requirements, @default_values).collect {|path| Path.new(self, path)}
+      @generate_with = GenerateWith.new(generate_with[:scheme], generate_with[:port], generate_with[:host]) if generate_with
+    end
+    
+    def grapher
+      unless @grapher
+        @grapher = Grapher.new
+        @grapher.add_route(self)
+      end
+      @grapher
+    end
+
+    def find_matching_path(params)
+      @paths.size == 1 ? @paths.first : grapher.find_matching_path(params)
+    end
+    
+    
+    # Sets +options+ on a route. Returns +self+.
+    #   
+    #   Request = Struct.new(:path)
+    #   set = Usher.new
+    #   route = set.add_route('/test')
+    #   route.to(:controller => 'testing', :action => 'index')
+    #   set.recognize(Request.new('/test')).first.params => {:controller => 'testing', :action => 'index'}
+    def to(options = nil, &block)
+      @destination = (block_given? ? block : options)
+      self
+    end
+
+    # Sets route as referenceable from +name+. Returns +self+.
+    #   
+    #   set = Usher.new
+    #   route = set.add_route('/test').name(:route)
+    #   set.generate_url(:route) => '/test'
+    def name(name)
+      @named = name
+      @router.name(name, self)
+      self
+    end
+
+  end
+end