joshbuddy-usher 0.0.2

data/History.txt

@@ -0,0 +1,3 @@
+== 0.0.1
+
+Initial release as gem

data/Manifest.txt

@@ -0,0 +1,35 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/compat.rb
+lib/usher.rb
+lib/usher/exceptions.rb
+lib/usher/grapher.rb
+lib/usher/interface.rb
+lib/usher/interface/merb_interface.rb
+lib/usher/interface/rack_interface.rb
+lib/usher/interface/rack_interface/mapper.rb
+lib/usher/interface/rack_interface/route.rb
+lib/usher/interface/rails2_interface.rb
+lib/usher/interface/rails2_interface/mapper.rb
+lib/usher/node.rb
+lib/usher/node/lookup.rb
+lib/usher/route.rb
+lib/usher/route/http.rb
+lib/usher/route/path.rb
+lib/usher/route/separator.rb
+lib/usher/route/splitter.rb
+lib/usher/route/variable.rb
+rails/init.rb
+spec/generate_spec.rb
+spec/node/lookup_spec.rb
+spec/path_spec.rb
+spec/rack/dispatch_spec.rb
+spec/rails/generate_spec.rb
+spec/rails/path_spec.rb
+spec/rails/recognize_spec.rb
+spec/recognize_spec.rb
+spec/spec.opts
+spec/split_spec.rb
+usher.gemspec

data/README.rdoc

@@ -0,0 +1,63 @@
+= Usher 
+
+Tree-based router for Ruby on Rails.
+
+This is a tree-based router (based on Ilya Grigorik suggestion). Turns out looking up in a hash and following a tree is faster than Krauter's massive regex approach, so why not? I said, Heck Yes, and here we are.
+
+== Route format
+
+Here are some examples of routes recognized by usher (so far)
+
+  _Route_                  _Matches_
+  /path/to/something       /path/to/something
+  /path/:variable/more     /path/foo/more, /path/bar/more ...
+  /show/*tags              /show/hot /show/hot/coffee /show/some/more/hot/coffee ...
+  /route(/help)            /route, /route/help
+  /route(.:format)         /route, /route.xml, /route.html ...
+
+== Rails
+
+  script/plugin install git://github.com/joshbuddy/usher.git
+
+== Rack
+
+=== rackup.ru
+
+  require 'usher'
+  app = proc do |env|
+    body = "Hi there #{env['usher.params'][:name]}"
+    [
+      200,          # Status code
+      {             # Response headers
+        'Content-Type' => 'text/plain',
+        'Content-Length' => body.size.to_s,
+      },
+      [body]        # Response body
+    ]
+  end
+  
+  routes = Usher::Interface.for(:rack)
+  routes.add('/hello/:name').to(app)
+  run routes
+
+------------
+
+  >> curl http://127.0.0.1:3000/hello/samueltanders
+  << Hi there samueltanders
+
+== DONE
+
+* add support for () optional parts
+
+== TODO
+
+* Add support for arbitrary HTTP header checks
+* Make it integrate with merb
+* Make it integrate with rails3
+* Create decent DSL for use with rack
+* Emit exceptions inline with relevant interfaces
+* More RDoc! (optionally cowbell)
+
+Looks about 20-50% faster than the router Rails ships with for non-trivial cases.
+
+(Let me show you to your request)

data/Rakefile

@@ -0,0 +1,27 @@
+require 'hoe'
+require 'spec'
+require 'spec/rake/spectask'
+require 'lib/usher'
+
+Hoe.new('usher', Usher::Version) do |p|
+  p.author = 'Joshua Hull'
+  p.email = 'joshbuddy@gmail.com'
+  p.summary = 'Tree-based router'
+  p.developer('Joshua Hull', 'joshbuddy@gmail.com')
+end
+
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+end
+
+task :cultivate do
+  system "touch Manifest.txt; rake check_manifest | grep -v \"(in \" | patch"
+  system "rake debug_gem | grep -v \"(in \" > `basename \\`pwd\\``.gemspec"
+end

data/lib/compat.rb

@@ -0,0 +1 @@
+require 'activesupport'

data/lib/usher.rb

@@ -0,0 +1,135 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'strscan'
+require 'set'
+require 'usher/node'
+require 'usher/route'
+require 'usher/grapher'
+require 'usher/interface'
+require 'usher/exceptions'
+
+class Usher
+  attr_reader :tree, :named_routes, :route_count, :routes
+  
+  SymbolArraySorter = proc {|a,b| a.hash <=> b.hash}
+  Version = '0.0.2'
+    
+  def empty?
+    @route_count.zero?
+  end
+
+  def lookup
+    @tree.lookup
+  end
+
+  def reset!
+    @tree = Node.root(self)
+    @named_routes = {}
+    @routes = []
+    @route_count = 0
+    Grapher.instance.reset!
+  end
+  alias clear! reset!
+  
+  def initialize(mode = :rails)
+    @mode = mode
+    reset!
+  end
+
+  def add_named_route(name, path, options = {})
+    add_route(path, options).name(name)
+  end
+
+  def name(name, route)
+    @named_routes[name] = route.primary_path
+  end
+
+  def add_route(path, options = {})
+    transformers = options.delete(:transformers) || {}
+    conditions = options.delete(:conditions) || {}
+    requirements = options.delete(:requirements) || {}
+    options.delete_if do |k, v|
+      if v.is_a?(Regexp)
+        requirements[k] = v 
+        true
+      end
+    end
+    
+    route = Route.new(path, self, {:transformers => transformers, :conditions => conditions, :requirements => requirements}).to(options)
+    
+    @tree.add(route)
+    @routes << route
+    Grapher.instance.add_route(route)
+    @route_count += 1
+    route
+  end
+
+  def recognize(request)
+    @tree.find(request)
+  end
+
+  def route_for_options(options)
+    Grapher.instance.find_matching_path(options)
+  end
+  
+  def generate_url(route, params)
+    path = case route
+    when Symbol
+      @named_routes[route]
+    when nil
+      route_for_options(params)
+    else
+      route
+    end
+    
+    params_hash = {}
+    param_list = case params
+    when Hash
+      params_hash = params
+      path.dynamic_parts.collect{|k| params_hash.delete(k.name)}
+    when Array
+      params
+    else
+      Array(params)
+    end
+
+    generated_path = ""
+    
+    sep_p = nil
+    path.parts.each do |p|
+      case p
+      when Route::Variable
+        case p.type
+        when :*
+          generated_path << sep_p.to_s << param_list.shift * '/'
+        else
+          (dp = param_list.shift) && generated_path << sep_p.to_s << dp.to_s
+        end
+      when Route::Separator
+        sep_p = p
+      else
+        generated_path << sep_p.to_s << p.to_s
+      end
+    end
+    unless params_hash.blank?
+      has_query = generated_path[??]
+      params_hash.each do |k,v|
+        case v
+        when Array
+          v.each do |v_part|
+            generated_path << (has_query ? '&' : has_query = true && '?')
+            generated_path << CGI.escape("#{k.to_s}[]")
+            generated_path << '='
+            generated_path << CGI.escape(v_part.to_s)
+          end
+        else
+          generated_path << (has_query ? '&' : has_query = true && '?')
+          generated_path << CGI.escape(k.to_s)
+          generated_path << '='
+          generated_path << CGI.escape(v.to_s)
+        end
+      end
+    end
+    generated_path
+  end
+end

data/lib/usher/exceptions.rb

@@ -0,0 +1,4 @@
+class Usher
+  class UnrecognizedException < RuntimeError
+  end
+end

data/lib/usher/grapher.rb

@@ -0,0 +1,44 @@
+require 'singleton'
+
+class Usher
+  class Grapher
+    include Singleton
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @significant_keys = nil
+      @orders = Hash.new{|h,k| h[k] = Hash.new{|h2, k2| h2[k2] = []}}
+      @key_count = Hash.new(0)
+    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
+            @key_count[k] += 1
+          end
+        end
+      end
+    end
+
+    def significant_keys
+      @significant_keys ||= Set.new(@key_count.keys)
+    end
+
+    def find_matching_path(params)
+      unless params.empty?
+        set = Set.new(params.keys) & significant_keys
+        set.size.downto(1) do |o|
+          set.each do |k|
+            @orders[o][k].each { |r| return r if r.dynamic_set.subset?(set) }
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/usher/interface.rb

@@ -0,0 +1,22 @@
+$:.unshift File.dirname(__FILE__)
+
+class Usher
+  module Interface
+    
+    def self.for(type)
+      case type
+      when :rails2
+        require 'interface/rails2_interface'
+        Rails2Interface.new
+      when :merb
+        require 'interface/merb_interface'
+        MerbInterface.new
+      when :rack
+        require 'interface/rack_interface'
+        RackInterface.new
+      end
+    end
+    
+    
+  end
+end

data/lib/usher/interface/merb_interface.rb

@@ -0,0 +1,63 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'merb-core'
+require 'merb-core/dispatch/router/behavior'
+
+class Usher
+  module Interface
+    class MerbInterface
+      
+      # merb does everything with class methods.
+
+      @root_behavior   = ::Merb::Router::Behavior.new.defaults(:action => "index")
+
+      class << self
+        attr_accessor :root_behavior
+        
+        UsherRoutes = Usher.new
+        
+        def prepare(first = [], last = [], &block)
+          @routes = []
+          root_behavior._with_proxy(&block)
+          @routes = first + @routes + last
+          compile
+          self
+        end
+        
+        def compile
+          routes.each do |r| 
+            r.segments
+          end
+          
+          #puts r.inspect; UsherRoutes.add_route(r) }
+          #routes.each {|r| }
+        end
+        
+        def named_routes
+          UsherRoutes.named_routes
+        end
+        
+        def routes
+          UsherRoutes.routes
+        end
+
+        def route_for(request)
+          p request
+          p UsherRoutes.tree
+          UsherRoutes.recognize(request)
+        end
+        
+      end
+      
+      #class BootLoader < ::Merb::BootLoader
+      #end
+
+      def load_into_merb!
+        ::Merb.send(:remove_const, "Router")
+        ::Merb.const_set("Router", Usher::Interface::MerbInterface)
+        #::Merb::BootLoader.const_set("Router", Usher::Interface::Merb::BootLoader)
+      end
+      
+    end
+  end
+end

data/lib/usher/interface/rack_interface.rb

@@ -0,0 +1,31 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rack_interface/route'
+
+class Usher
+  module Interface
+    class RackInterface
+      
+      Request = Struct.new(:path, :method)
+      
+      def initialize
+        @routes = Usher.new
+      end
+      
+      def add(path, options = {})
+        @routes.add_route(path, options)
+      end
+
+      def reset!
+        @routes.reset!
+      end
+
+      def call(env)
+        (path, params) = @routes.recognize(Request.new(env['REQUEST_URI'], env['REQUEST_METHOD']))
+        env['usher.params'] = params.inject({}){|h,(k,v)| h[k]=v; h }
+        path.route.params.call(env)
+      end
+
+    end
+  end
+end

data/lib/usher/interface/rack_interface/route.rb

@@ -0,0 +1,9 @@
+class Usher
+  module Interface
+    class RackInterface
+      module Route
+        
+      end
+    end
+  end
+end