joshbuddy-usher 0.0.2

data/lib/usher/interface/rails2_interface.rb

@@ -0,0 +1,133 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rails2_interface/mapper'
+
+class Usher
+  module Interface
+    class Rails2Interface
+      
+      attr_reader :usher
+      attr_accessor :configuration_file
+
+      def initialize
+        reset!
+      end
+      
+      def reset!
+        @usher ||= Usher.new
+        @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]
+        
+        route = @usher.add_route(path, options)
+        raise "your route must include a controller" unless route.primary_path.dynamic_set.include?(:controller) || route.params.include?(:controller)
+        route
+      end
+      
+      def recognize(request)
+        (path, params_list) = @usher.recognize(request)
+        params = params_list.inject({}){|h,(k,v)| h[k]=v; h }
+        request.path_parameters = (params_list.empty? ? path.route.params : path.route.params.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] = nil
+          end
+          route_for_options(merged_options)
+        end
+        case method
+        when :generate
+          merged_options ||= recall.merge(options)
+          generate_url(route, merged_options)
+        else
+          raise "method #{method} not recognized"
+        end
+      end
+      
+      def generate_url(route, params)
+        @usher.generate_url(route, params)
+      end
+      
+      def route_for_options(options)
+        @usher.route_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_interface/mapper.rb

@@ -0,0 +1,44 @@
+class Usher
+  module Interface
+    class Rails2Interface
+      
+      class Mapper #:doc:
+        def initialize(set) #:nodoc:
+          @set = set
+        end
+
+        def connect(path, options = {})
+          @set.add_route(path, options)
+        end
+
+        def root(options = {})
+          if options.is_a?(Symbol)
+            if source_route = @set.named_routes[options]
+              options = source_route.conditions.blank? ? 
+                source_route.options.merge({ :conditions => source_route.conditions }) : source_route.options
+            end
+          end
+          named_route(:root, '/', options)
+        end
+
+        def named_route(name, path, options = {})
+          @set.add_named_route(name, path, options)
+        end
+
+        def namespace(name, options = {}, &block)
+          if options[:namespace]
+            with_options({:path_prefix => "#{options.delete(:path_prefix)}/#{name}", :name_prefix => "#{options.delete(:name_prefix)}#{name}_", :namespace => "#{options.delete(:namespace)}#{name}/" }.merge(options), &block)
+          else
+            with_options({:path_prefix => name, :name_prefix => "#{name}_", :namespace => "#{name}/" }.merge(options), &block)
+          end
+        end
+
+        def method_missing(route_name, *args, &proc) #:nodoc:
+          super unless args.length >= 1 && proc.nil?
+          @set.add_named_route(route_name, *args)
+        end
+      end
+
+    end
+  end
+end

data/lib/usher/node.rb

@@ -0,0 +1,149 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'node/lookup'
+
+class Usher
+
+  class Node
+    
+    ConditionalTypes = [:protocol, :domain, :port, :query_string, :remote_ip, :user_agent, :referer, :method]
+    
+    attr_reader :lookup
+    attr_accessor :terminates, :exclusive_type, :parent, :value
+
+    def initialize(parent, value)
+      @parent = parent
+      @value = value
+      @lookup = Lookup.new
+      @exclusive_type = nil
+      @has_globber = find_parent{|p| p.value && p.value.is_a?(Route::Variable)}
+    end
+
+    def depth
+      unless @depth
+        @depth = 0
+        p = self
+        while (p = p.parent) && p.is_a?(Node)
+          @depth += 1
+        end
+      end
+      @depth
+    end
+    
+    def self.root(route_set)
+      self.new(route_set, nil)
+    end
+
+    def has_globber?
+      @has_globber
+    end
+
+    def terminates?
+      @terminates
+    end
+
+    def find_parent(&blk)
+      if @parent.nil? || !@parent.is_a?(Node)
+        nil
+      elsif yield @parent
+        @parent
+      else #keep searching
+        @parent.find_parent(&blk)
+      end
+    end
+
+    def replace(src, dest)
+      @lookup.replace(src, dest)
+    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
+        ConditionalTypes.each do |type|
+          parts.push(Route::Http.new(type, route.conditions[type])) if route.conditions[type]
+        end
+        
+        current_node = self
+        until parts.size.zero?
+          key = parts.shift
+          target_node = case key
+          when Route::Http
+            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::Http.new(current_node.exclusive_type, nil))
+            end
+          else
+            if current_node.exclusive_type
+              parts.unshift(key)
+              current_node.lookup[nil] ||= Node.new(current_node, Route::Http.new(current_node.exclusive_type, nil))
+            else
+              current_node.lookup[key.is_a?(Route::Variable) ? nil : key] ||= Node.new(current_node, key)
+            end
+          end
+          current_node = target_node
+        end
+        current_node.terminates = path
+      end
+      route
+    end
+    
+    def find(request, path = Route::Splitter.url_split(request.path), params = [])
+      part = path.shift unless path.size.zero?
+      if @exclusive_type
+        path.unshift part
+        [@lookup[request.send(@exclusive_type)], @lookup[nil]].each do |n|
+          ret = n.find(request, path.dup, params.dup) if n
+          ret and return ret
+        end
+      elsif path.size.zero? && !part
+        if terminates?
+          [terminates, params]
+        else
+          nil
+        end
+      elsif next_part = @lookup[part]
+        next_part.find(request, path, params)
+      elsif next_part = @lookup[nil]
+        if next_part.value.is_a?(Route::Variable)
+          case t = next_part.value.transformer
+          when Proc
+            part = t.call(part)
+          when Symbol
+            part = part.send(t)
+          end
+          part = 
+          raise "#{part} does not conform to #{next_part.value.validator}" if next_part.value.validator && (not next_part.value.validator === part)
+          case next_part.value.type
+          when :*
+            params << [next_part.value.name, []]
+            params.last.last << part unless next_part.is_a?(Route::Separator)
+          when :':'
+            params << [next_part.value.name, part]
+          end
+        end
+        next_part.find(request, path, params)
+      elsif has_globber? && p = find_parent{|p| !p.is_a?(Route::Separator)} && p.value.is_a?(Route::Variable) && p.value.type == :*
+        params.last.last << part unless part.is_a?(Route::Separator)
+        find(request, path, params)
+      else
+        nil
+      end
+    end
+
+  end
+end

data/lib/usher/node/lookup.rb

@@ -0,0 +1,78 @@
+class Usher
+  class Node
+    class Lookup
+      
+      def initialize
+        @hash = {}
+        @regexes = []
+        @hash_reverse = {}
+        @regexes_reverse = {}
+      end
+      
+      def empty?
+        @hash.empty? && @regexes.empty?
+      end
+      
+      def keys
+        @hash.keys + @regexes.collect{|r| r.first}
+      end
+      
+      def values
+        @hash.values + @regexes.collect{|r| r.last}
+      end
+      
+      def each
+        @hash.each{|k,v| yield k,v }
+        @regexes.each{|v| yield v.first, v.last }
+      end
+      
+      def delete_value(value)
+        @hash.delete(@hash_reverse[value]) || ((rr = @regexes_reverse[value]) && @regexes.delete_at(rr[0]))
+      end
+      
+      def []=(key, value)
+        case key
+        when Regexp
+          @regexes << [key, value]
+          @regex_test = nil
+          @regexes_reverse[value] = [@regexes.size - 1, key, value]
+        else
+          @hash[key] = value
+          @hash_reverse[value] = key
+        end
+      end
+      
+      def replace(src, dest)
+        if @hash_reverse.key?(src)
+          key = @hash_reverse[src]
+          @hash[key] = dest
+          @hash_reverse.delete(src)
+          @hash_reverse[dest] = key
+        elsif @regexes_reverse.key?(src)
+          key = @regexes_reverse[src]
+          @regexes[rkey[0]] = [rkey[1], dest]
+          @regexes_reverse.delete(src)
+          @regexes_reverse[dest] = [rkey[0], rkey[1], dest]
+        end
+      end
+      
+      def [](key)
+        @hash[key] || regex_lookup(key)
+      end
+      
+      private
+      def regex_test
+        @regex_test ||= Regexp.union(*@regexes.collect{|r| r[0]})
+      end
+      
+      def regex_lookup(key)
+        if !@regexes.empty? && key.is_a?(String) && data = regex_test.match(key)
+          (data_array = data.to_a).each_index do |i|
+            break @regexes[i].last if data_array.at(i)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/usher/route.rb

@@ -0,0 +1,33 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'route/path'
+require 'route/splitter'
+require 'route/separator'
+require 'route/variable'
+require 'route/http'
+
+class Usher
+  class Route
+    attr_reader :paths, :original_path, :requirements, :conditions, :params, :primary_path
+    
+    def initialize(original_path, router, options = {})
+      @original_path = original_path
+      @router = router
+      @requirements = options.delete(:requirements)
+      @conditions = options.delete(:conditions)
+      @transformers = options.delete(:transformers)
+      @paths = Splitter.new(@original_path, @requirements, @transformers).paths.collect {|path| Path.new(self, path)}
+      @primary_path = @paths.first
+    end
+
+    def to(options)
+      @params = options
+      self
+    end
+
+    def name(name)
+      @router.name(name, self)
+    end
+
+  end
+end

data/lib/usher/route/http.rb

@@ -0,0 +1,21 @@
+class Usher
+  class Route
+    class Http
+  
+      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?(Http) && o.type == type && o.value == value
+      end
+    end
+  end
+end