joshbuddy-usher 0.0.2

data/lib/usher/route/path.rb

@@ -0,0 +1,20 @@
+class Usher
+  class Route
+    class Path
+  
+      attr_reader :dynamic_parts, :dynamic_map, :dynamic_indicies, :route, :dynamic_set, :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_set = Set.new(@dynamic_map.keys)
+      end
+  
+    end
+  end
+end

data/lib/usher/route/separator.rb

@@ -0,0 +1,21 @@
+class Usher
+  class Route
+
+    class Separator
+      private
+      def initialize(sep)
+        @sep = sep
+        @sep_to_s = "#{sep}"
+      end
+
+      public
+      def to_s
+        @sep_to_s
+      end
+
+      Dot = Separator.new(:'.')
+      Slash = Separator.new(:/)
+    end
+
+  end
+end

data/lib/usher/route/splitter.rb

@@ -0,0 +1,93 @@
+class Usher
+  class Route
+    class Splitter
+      
+      ScanRegex = /([:\*]?[0-9a-z_]+|\/|\.|\(|\))/
+      UrlScanRegex = /\/|\.|\w+/
+      
+      attr_reader :paths
+      
+      def initialize(path, requirements = {}, transformers = {})
+        @parts = Splitter.split(path, requirements, transformers)
+        @paths = calc_paths(@parts)
+      end
+
+      def self.url_split(path)
+        parts = path[0] == ?/ ? [] : [Separator::Slash]
+        ss = StringScanner.new(path)
+          while !ss.eos?
+            part = ss.scan(UrlScanRegex)
+            case part[0]
+            when ?.
+              parts << Separator::Dot
+            when ?/
+              parts << Separator::Slash
+            else
+              parts << part
+            end
+          end if path && !path.empty?
+        parts
+      end
+      
+      def self.split(path, requirements = {}, transformers = {})
+        parts = path[0] == ?/ ? [] : [Separator::Slash]
+        ss = StringScanner.new(path)
+        groups = [parts]
+        current_group = parts
+        while !ss.eos?
+          part = ss.scan(ScanRegex)
+          case part[0]
+          when ?*, ?:
+            type = part.slice!(0).chr.to_sym
+            current_group << Variable.new(type, part, :validator => requirements[part.to_sym], :transformer => transformers[part.to_sym])
+          when ?.
+            current_group << Separator::Dot
+          when ?/
+            current_group << Separator::Slash
+          when ?(
+            new_group = []
+            groups << new_group
+            current_group << new_group
+            current_group = new_group
+          when ?)
+            groups.pop
+            current_group = groups.last
+          else
+            current_group << part
+          end
+        end unless !path || path.empty?
+        parts
+      end
+
+      private
+      def calc_paths(parts)
+        paths = []
+        optional_parts = []
+        parts.each_index {|i| optional_parts << i if parts[i].is_a?(Array)}
+        if optional_parts.size.zero?
+          [parts]
+        else
+          (0...(2 << (optional_parts.size - 1))).each do |i|
+            current_paths = [[]]
+            parts.each_index do |part_index|
+              part = parts[part_index]
+              if optional_parts.include?(part_index) && (2 << (optional_parts.index(part_index)-1) & i != 0)
+                new_sub_parts = calc_paths(part)
+                current_paths_size = current_paths.size
+                (new_sub_parts.size - 1).times {|i| current_paths << current_paths[i % current_paths_size].dup }
+                current_paths.each_index do |current_path_idx|
+                  current_paths[current_path_idx].push(*new_sub_parts[current_path_idx % new_sub_parts.size])
+                end
+              elsif !optional_parts.include?(part_index)
+                current_paths.each { |current_path| current_path << part }
+              end
+            end
+            paths.push(*current_paths)
+          end
+          paths
+        end
+      end
+      
+    end
+  end
+end

data/lib/usher/route/variable.rb

@@ -0,0 +1,22 @@
+class Usher
+  class Route
+    class Variable
+      attr_reader :type, :name, :validator, :transformer
+      
+      def initialize(type, name, opts = {})
+        @type = type
+        @name = :"#{name}"
+        @validator = opts[:validator]
+        @transformer = opts[:transformer]
+      end
+
+      def to_s
+        "#{type}#{name}"
+      end
+  
+      def ==(o)
+        o && (o.type == @type && o.name == @name && o.validator == @validator)
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+class Usher::Interface::Rails2Interface::Mapper
+  include ActionController::Resources
+end
+ActionController::Routing.module_eval "remove_const(:Routes); Routes = Usher::Interface.for(:rails2);"

data/spec/generate_spec.rb

@@ -0,0 +1,61 @@
+require 'lib/usher'
+
+route_set = Usher.new
+
+describe "Usher URL generation" do
+  
+  before(:each) do
+    route_set.reset!
+  end
+  
+  it "should generate a simple URL" do
+    route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'action')
+    route_set.generate_url(:sample, {}).should == '/sample'
+  end
+  
+  it "should generate a simple URL with a single variable" do
+    route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample')
+    route_set.generate_url(:sample, {:action => 'action'}).should == '/sample/action'
+  end
+  
+  it "should generate a simple URL with a single variable (thats not a string)" do
+    route_set.add_named_route(:sample, '/sample/:action/:id', :controller => 'sample')
+    route_set.generate_url(:sample, {:action => 'action', :id => 123}).should == '/sample/action/123'
+  end
+  
+  it "should generate a simple URL with a glob variable" do
+    route_set.add_named_route(:sample, '/sample/*action', :controller => 'sample')
+    route_set.generate_url(:sample, {:action => ['foo', 'baz']}).should == '/sample/foo/baz'
+  end
+  
+  it "should generate a mutliple vairable URL from a hash" do
+    route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
+    route_set.generate_url(:sample, {:first => 'zoo', :second => 'maz'}).should == '/sample/zoo/maz'
+  end
+
+  it "should generate a mutliple vairable URL from an array" do
+    route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
+    route_set.generate_url(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
+  end
+
+  it "should generate append extra hash variables to the end" do
+    route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
+    route_set.generate_url(:sample, {:first => 'maz', :second => 'zoo', :third => 'zanz'}).should == '/sample/maz/zoo?third=zanz'
+  end
+
+  it "should generate append extra hash variables to the end using [] syntax if its an array" do
+    route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
+    route_set.generate_url(:sample, {:first => 'maz', :second => 'zoo', :third => ['zanz', 'susie']}).should == '/sample/maz/zoo?third%5B%5D=zanz&third%5B%5D=susie'
+  end
+
+  it "should generate a mutliple vairable URL from an array" do
+    route_set.add_named_route(:sample, '/sample/:first/:second', :controller => 'sample')
+    route_set.generate_url(:sample, ['maz', 'zoo']).should == '/sample/maz/zoo'
+  end
+
+  it "should generate a simple URL with a format" do
+    route_set.add_named_route(:sample, '/sample/:action.:format', :controller => 'sample')
+    route_set.generate_url(:sample, {:action => 'action', :format => 'html'}).should == '/sample/action.html'
+  end
+
+end

data/spec/node/lookup_spec.rb

@@ -0,0 +1,53 @@
+require 'lib/usher'
+
+
+describe "String/regexp lookup table" do
+
+  it "should accept strings and retrieve based on them" do
+    l = Usher::Node::Lookup.new
+    l['asd'] = 'qwe'
+    l['asd'].should == 'qwe'
+  end
+  
+  it "should accept regexs too" do
+    l = Usher::Node::Lookup.new
+    l[/asd.*/] = 'qwe'
+    l['asdqweasd'].should == 'qwe'
+  end
+
+  it "should prefer string to regex matches" do
+    l = Usher::Node::Lookup.new
+    l['asd'] = 'qwe2'
+    l[/asd.*/] = 'qwe'
+    l['asd'].should == 'qwe2'
+  end
+
+  it "should allow nil keys" do
+    l = Usher::Node::Lookup.new
+    l[nil] = 'qwe2'
+    l['asd'] = 'qwe'
+    l['asd'].should == 'qwe'
+    l[nil].should == 'qwe2'
+  end
+
+  it "should be able to delete by value for hash" do
+    l = Usher::Node::Lookup.new
+    l[nil] = 'qwe2'
+    l['asd'] = 'qwe'
+    l['asd'].should == 'qwe'
+    l[nil].should == 'qwe2'
+    l.delete_value('qwe2')
+    l[nil].should == nil
+  end
+
+  it "should be able to delete by value for hash" do
+    l = Usher::Node::Lookup.new
+    l[/qwe.*/] = 'qwe2'
+    l['asd'] = 'qwe'
+    l['asd'].should == 'qwe'
+    l['qweasd'].should == 'qwe2'
+    l.delete_value('qwe2')
+    l['qweasd'].should == nil
+  end
+
+end

data/spec/path_spec.rb

@@ -0,0 +1,42 @@
+require 'lib/usher'
+
+route_set = Usher.new
+
+S = Usher::Route::Separator::Slash
+D = Usher::Route::Separator::Dot
+
+describe "Usher route adding" do
+
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "should be empty after a reset" do
+    route_set.add_route('/sample', :controller => 'sample')
+    route_set.empty?.should == false
+    route_set.reset!
+    route_set.empty?.should == true
+  end
+  
+  it "shouldn't care about routes without a controller" do
+    proc { route_set.add_route('/bad/route') }.should_not raise_error
+  end
+
+  it "should add every kind of optional route possible" do
+    route_set.add_route('/a/b(/c)(/d(/e))')
+    route_set.routes.first.paths.collect{|a| a.parts }.should == [
+      [S, "a", S, "b"],
+      [S, "a", S, "b", S, "c"],
+      [S, "a", S, "b", S, "d"],
+      [S, "a", S, "b", S, "d", S, "e"], 
+      [S, "a", S, "b", S, "c", S, "d"], 
+      [S, "a", S, "b", S, "c", S, "d", S, "e"]
+    ]
+    
+  end
+
+  it "should allow named routes to be added" do
+    route_set.add_named_route(:route, '/bad/route', :controller => 'sample').should == route_set.named_routes[:route]
+  end
+
+end

data/spec/rack/dispatch_spec.rb

@@ -0,0 +1,36 @@
+require 'lib/compat'
+require 'lib/usher'
+
+route_set = Usher::Interface.for(:rack)
+
+def build_request_mock(path, method, params)
+  request = mock "Request"
+  request.should_receive(:path).any_number_of_times.and_return(path)
+  request.should_receive(:method).any_number_of_times.and_return(method)
+  params = params.with_indifferent_access
+  request.should_receive(:path_parameters=).any_number_of_times.with(params)
+  request.should_receive(:path_parameters).any_number_of_times.and_return(params)
+  request
+end
+
+def build_app_mock(params)
+  request = mock "App"
+  request.should_receive(:call).any_number_of_times.with(params)
+  request
+end
+
+SampleController = Object.new
+
+describe "Usher (for rack) route dispatching" do
+
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "should dispatch a simple request" do
+    env = {'REQUEST_URI' => '/sample', 'REQUEST_METHOD' => 'get', 'usher.params' => {}}
+    route_set.add('/sample', :controller => 'sample', :action => 'action').to(build_app_mock(env.dup))
+    route_set.call(env)
+  end
+  
+end

data/spec/rails/generate_spec.rb

@@ -0,0 +1,28 @@
+require 'lib/compat'
+require 'lib/usher'
+
+route_set = Usher::Interface.for(:rails2)
+
+describe "Usher (for rails) URL generation" do
+  
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "should fill in the controller from recall" do
+    route_set.add_route(':controller/:action/:id')
+    route_set.generate({:action => 'thingy'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/sample/thingy'
+  end
+
+  it "should skip the action if not provided" do
+    route_set.add_route(':controller/:action/:id')
+    route_set.generate({:controller => 'thingy'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/thingy'
+  end
+
+  it "should pick the correct param from optional parts" do
+    route_set.add_route(':controller/:action(.:format)')
+    route_set.generate({:action => 'thingy', :format => 'html'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/sample/thingy.html'
+    route_set.generate({:action => 'thingy'}, {:controller => 'sample', :action => 'index', :id => 123}, :generate).should == '/sample/thingy'
+  end
+
+end

data/spec/rails/path_spec.rb

@@ -0,0 +1,16 @@
+require 'lib/compat'
+require 'lib/usher'
+
+route_set = Usher::Interface.for(:rails2)
+
+describe "Usher (for rails) route adding" do
+
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "shouldn't allow routes without a controller to be added" do
+    proc { route_set.add_route('/bad/route') }.should raise_error
+  end
+
+end

data/spec/rails/recognize_spec.rb

@@ -0,0 +1,79 @@
+require 'lib/compat'
+require 'lib/usher'
+require 'action_controller'
+
+route_set = Usher::Interface.for(:rails2)
+
+def build_request_mock(path, method, params)
+  request = mock "Request"
+  request.should_receive(:path).any_number_of_times.and_return(path)
+  request.should_receive(:method).any_number_of_times.and_return(method)
+  params = params.with_indifferent_access
+  request.should_receive(:path_parameters=).any_number_of_times.with(params)
+  request.should_receive(:path_parameters).any_number_of_times.and_return(params)
+  request
+end
+
+SampleController = Object.new
+
+describe "Usher (for rails) route recognition" do
+
+  before(:each) do
+    route_set.reset!
+  end
+
+  it "should recognize a simple request" do
+    route_set.add_route('/sample', :controller => 'sample', :action => 'action')
+    route_set.recognize(build_request_mock('/sample', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
+  end
+
+  it "should interpolate action :index" do
+    route_set.add_route('/sample', :controller => 'sample')
+    route_set.recognize(build_request_mock('/sample', 'get', {:controller => 'sample', :action => 'index'})).should == SampleController
+  end
+
+  it "should correctly distinguish between multiple request methods" do
+    route_set.add_route('/sample', :controller => 'not_sample', :conditions => {:method => :get})
+    correct_route = route_set.add_route('/sample', :controller => 'sample', :conditions => {:method => :post})
+    route_set.add_route('/sample', :controller => 'not_sample', :conditions => {:method => :put})
+    route_set.recognize(build_request_mock('/sample', :post, {:controller => 'sample', :action => 'index'})).should == SampleController
+  end
+
+  it "should prefer the static route to the dynamic route" do
+    route_set.add_route('/sample/:action', :controller => 'not_sample')
+    route_set.add_route('/sample/test', :controller => 'sample', :action => 'action')
+    route_set.recognize(build_request_mock('/sample/test', 'get', {:controller => 'sample', :action => 'action'})).should == SampleController
+  end
+  
+  it "should raise based upon an invalid param" do
+    route_set.add_named_route(:sample, '/sample/:action', :controller => 'sample', :requirements => {:action => /\d+/})
+    proc { route_set.recognize(build_request_mock('/sample/asdqwe', :post, {})) }.should raise_error
+  end
+  
+  it "should raise based upon an invalid route" do
+    route_set.add_named_route(:sample, '/sample', :controller => 'sample', :action => 'test')
+    proc { route_set.recognize(build_request_mock('/test/asdqwe', :post, {})) }.should raise_error(ActionController::RoutingError)
+  end
+  
+  it "should add /:controller and /:controller/:action if /:controller/:action/:id is added" do
+    route_set.add_route('/:controller/:action/:id')
+    route_set.route_count.should == 3
+  end
+  
+  it "should correctly recognize a format (dynamic path path with . delimiter)" do
+    route_set.add_route('/:controller/:action/:id.:format')
+    route_set.recognize(build_request_mock('/sample/test/123.html', 'get', {:controller => 'sample', :action => 'test', :id => '123', :format => 'html'})).should == SampleController
+  end
+  
+  it "should support root nodes" do
+    route_set.add_route('/', :controller => 'sample')
+    route_set.recognize(build_request_mock('/', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
+  end
+  
+  it "should default action to 'index' when controller (and not index) is specified" do
+    route_set.add_route('/:controller/:action')
+    route_set.recognize(build_request_mock('/sample', :get, {:controller => 'sample', :action => 'index'})).should == SampleController
+  end
+  
+  
+end