mholling-subdomain_routes 0.1.0

data/spec/routes_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+describe "subdomain routes" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
+  end
+    
+  it "should check the validity of each subdomain" do
+    SubdomainRoutes.should_receive(:valid_subdomain?).twice.and_return(true, true)
+    lambda { map_subdomain(:www, :www1) { } }.should_not raise_error
+  end
+  
+  it "should check the validity of each subdomain and raise an error if any are invalid" do
+    SubdomainRoutes.should_receive(:valid_subdomain?).twice.and_return(true, false)
+    lambda { map_subdomain(:www, :www!) { } }.should raise_error(ArgumentError)
+  end
+  
+  it "should check not the validity of a nil subdomain" do
+    SubdomainRoutes.should_not_receive(:valid_subdomain?)
+    map_subdomain(nil) { }
+  end
+  
+  it "should accept a nil subdomain" do
+    map_subdomain(nil) { |map| map.options[:subdomains].should == [ "" ] }
+  end
+
+  it "should accept a blank subdomain" do
+    map_subdomain("") { |map| map.options[:subdomains].should == [ "" ] }
+  end
+
+  it "should accept a single specified subdomain" do
+    map_subdomain(:admin) { |admin| admin.options[:subdomains].should == [ "admin" ] }
+  end
+  
+  it "should accept strings or symbols as subdomains" do
+    map_subdomain(:admin)  { |admin| admin.options[:subdomains].should == [ "admin" ] }
+    map_subdomain("admin") { |admin| admin.options[:subdomains].should == [ "admin" ] }
+  end
+
+  it "should accept multiple subdomains" do
+    map_subdomain(:admin, :support) { |map| map.options[:subdomains].should == [ "admin", "support" ] }
+  end
+
+  it "should downcase the subdomains" do
+    map_subdomain(:Admin, "SUPPORT") { |map| map.options[:subdomains].should == [ "admin", "support" ] }
+  end
+  
+  it "should accept a :proc option as the subdomain" do
+    map_subdomain(:proc => :name) { |name| name.options[:subdomains].should == { :proc => :name } }
+  end
+
+  it "should raise ArgumentError if no subdomain is specified" do
+    lambda { map_subdomain }.should raise_error(ArgumentError)
+  end
+  
+  it "should not include repeated subdomains in the options" do
+    map_subdomain(:admin, :support, :admin) { |map| map.options[:subdomains].should == [ "admin", "support" ] }
+  end
+  
+  it "should be invoked by map.subdomains as well as map.subdomain" do
+    ActionController::Routing::Routes.draw do |map|
+      map.subdomains(:admin, :support) { |sub| sub.options[:subdomains].should == [ "admin", "support" ] }
+    end
+  end
+  
+  [ [ :admin ], [ :support, :admin ] ].each do |subdomains|
+    context "mapping #{subdomains.size} subdomains" do
+      it "should set the first subdomain as a namespace" do
+        map_subdomain(*subdomains) { |map| map.options[:namespace].should == "#{subdomains.first}/" }
+      end
+
+      it "should prefix the first subdomain to named routes" do
+        map_subdomain(*subdomains) { |map| map.options[:name_prefix].should == "#{subdomains.first}_" }
+      end
+      
+      it "should instead set a namespace to the name if specified" do
+        args = subdomains + [ :name => :something ]
+        map_subdomain(*args) { |map| map.options[:namespace].should == "something/" }
+      end
+
+      it "should instead prefix the name to named routes if specified" do
+        args = subdomains + [ :name => :something ]
+        map_subdomain(*args) { |map| map.options[:name_prefix].should == "something_" }
+      end
+
+      it "should not set a namespace if name is specified as nil" do
+        args = subdomains + [ :name => nil ]
+        map_subdomain(*args) { |map| map.options[:namespace].should be_nil }
+      end
+
+      it "should not set a named route prefix if name is specified as nil" do
+        args = subdomains + [ :name => nil ]
+        map_subdomain(*args) { |map| map.options[:name_prefix].should be_nil }
+      end
+    end
+  end
+  
+  it "should strip bad characters from the namespace and name prefix" do
+    map_subdomain("just-do-it") { |map| map.options[:namespace].should == "just_do_it/" }
+    map_subdomain("just-do-it") { |map| map.options[:name_prefix].should == "just_do_it_" }
+    map_subdomain(nil, :name => "just-do-it") { |map| map.options[:namespace].should == "just_do_it/" }
+    map_subdomain(nil, :name => "just-do-it") { |map| map.options[:name_prefix].should == "just_do_it_" }
+    map_subdomain(nil, :name => "Just do it!") { |map| map.options[:namespace].should == "just_do_it/" }
+    map_subdomain(nil, :name => "Just do it!") { |map| map.options[:name_prefix].should == "just_do_it_" }
+  end
+  
+  context "mapping the nil subdomain" do
+    it "should not set a namespace" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none) { |map| map.options[:namespace].should be_nil }
+      end
+    end
+
+    it "should not set a named route prefix" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none) { |map| map.options[:name_prefix].should be_nil }
+      end
+    end
+  end
+  
+  context "mapping nil and other subdomains" do
+    it "should set the first non-nil subdomain as a namespace" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none, :www) { |map| map.options[:namespace].should == "www/" }
+      end
+    end
+
+    it "should prefix the first non-nil subdomain to named routes" do
+      [ nil, "" ].each do |none|
+        map_subdomain(none, :www) { |map| map.options[:name_prefix].should == "www_" }
+      end
+    end
+  end
+  
+  context "for a single specified subdomain" do
+    before(:each) do
+      map_subdomain(:admin) do |map|
+        map.resources :articles, :has_many => :comments
+        map.foobar "foobar", :controller => "foo", :action => "bar"
+        map.named_route "foobaz", "foobaz", :controller => "foo", :action => "baz"
+        map.connect "/:controller/:action/:id"
+      end
+    end
+
+    it "should add the specified subdomain to the route recognition conditions" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.conditions[:subdomains].should == [ "admin" ]
+      end
+    end
+
+    it "should add the subdomain to the route generation requirements" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.requirements[:subdomains].should == [ "admin" ]
+      end
+    end
+  end
+
+  context "for multiple specified subdomains" do
+    before(:each) do
+      map_subdomain(:support, :admin) do |map|
+        map.resources :articles, :has_many => :comments
+        map.foobar "foobar", :controller => "foo", :action => "bar"
+        map.named_route "foobaz", "foobaz", :controller => "foo", :action => "baz"
+        map.connect "/:controller/:action/:id"
+      end
+    end
+
+    it "should add the specified subdomain to the route recognition conditions" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.conditions[:subdomains].should == [ "support", "admin" ]
+      end
+    end
+
+    it "should not add a subdomain to the route generation requirements" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.requirements[:subdomains].should == [ "support", "admin" ]
+      end
+    end
+  end
+      
+  context "for a :proc subdomain" do
+    it "should set the value a namespace" do
+      map_subdomain(:proc => :city) { |city| city.options[:namespace].should == "city/" }
+    end
+
+    it "should prefix the value to named routes" do
+      map_subdomain(:proc => :city) { |city| city.options[:name_prefix].should == "city_" }
+    end
+  
+    it "should set a namespace to the name if specified" do
+      map_subdomain(:proc => :city, :name => :something) { |city| city.options[:namespace].should == "something/" }
+    end
+
+    it "should prefix the name to named routes if specified" do
+      map_subdomain(:proc => :city, :name => :something) { |city| city.options[:name_prefix].should == "something_" }
+    end
+
+    it "should add the specified proc to the route recognition conditions" do
+      map_subdomain(:proc => :city) { |city| city.resources :events }
+      ActionController::Routing::Routes.routes.each do |route|
+        route.conditions[:subdomains].should == { :proc => :city }
+      end
+    end
+      
+    it "should add the specified proc to the route generation requirements" do
+      map_subdomain(:proc => :city) { |city| city.resources :events }
+      ActionController::Routing::Routes.routes.each do |route|
+        route.requirements[:subdomains].should == { :proc => :city }
+      end
+    end
+  end
+end
+
+describe "ActionController::Routing::Routes" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+  end
+
+  it "should allow a subdomain recognition method to be added" do
+    ActionController::Routing::Routes.subdomain_procs.recognizes?(:city).should be_false
+    ActionController::Routing::Routes.recognize_subdomain(:city) { |city| city == "perth" }
+    ActionController::Routing::Routes.subdomain_procs.recognizes?(:city).should be_true
+  end
+
+  it "should allow subdomain recognition methods to be cleared" do
+    ActionController::Routing::Routes.recognize_subdomain(:city) { |city| city == "perth" }
+    ActionController::Routing::Routes.clear!
+    ActionController::Routing::Routes.subdomain_procs.recognizes?(:city).should be_false
+  end
+  
+  it "should flush the cache when called" do
+    ActionController::Routing::Routes.subdomain_procs.should_receive(:flush!)
+    begin
+      ActionController::Routing::Routes.call(ActionController::TestRequest.new.env)
+    rescue ActionController::RoutingError # no routes defined so the call will raise a routing error
+    end
+  end
+  
+  it "should not flush the cache when called if SubdomainRoutes::Config.manual_flush is set" do
+    SubdomainRoutes::Config.stub!(:manual_flush).and_return(true)
+    ActionController::Routing::Routes.subdomain_procs.should_not_receive(:flush!)
+    begin
+      ActionController::Routing::Routes.call(ActionController::TestRequest.new.env)
+    rescue ActionController::RoutingError # no routes defined so the call will raise a routing error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+require 'spec'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+require 'active_record' # only required for testing optional features, not required by the gem
+require 'action_mailer' # only required for testing optional features, not required by the gem
+
+require 'subdomain_routes'
+
+Spec::Runner.configure do |config|
+end
+require 'action_controller/test_process'
+require 'action_view/test_case'
+
+ActiveSupport::OptionMerger.send(:define_method, :options) { @options }
+
+def map_subdomain(*subdomains, &block)
+  ActionController::Routing::Routes.draw do |map|
+    map.subdomain(*subdomains, &block)
+  end
+end
+
+def recognize_path(request)
+  ActionController::Routing::Routes.recognize_path(request.path, ActionController::Routing::Routes.extract_request_environment(request))
+end
+
+def in_controller_with_host(host, &block)
+  variables = instance_variables.inject([]) do |array, name|
+    array << [ name, instance_variable_get(name) ]
+  end
+  Class.new(ActionView::TestCase::TestController) do
+    include Spec::Matchers
+  end.new.instance_eval do
+    request.host = host
+    variables.each { |name, value| instance_variable_set(name, value) }
+    instance_eval(&block)
+  end
+end
+
+def in_object_with_host(host, &block)
+  variables = instance_variables.inject([]) do |array, name|
+    array << [ name, instance_variable_get(name) ]
+  end
+  Class.new do
+    include Spec::Matchers
+    include ActionController::UrlWriter
+  end.new.instance_eval do
+    self.class.default_url_options = { :host => host }
+    variables.each { |name, value| instance_variable_set(name, value) }
+    instance_eval(&block)
+  end
+end
+
+def with_host(host, &block)
+  in_controller_with_host(host, &block)
+  in_object_with_host(host, &block)
+end
+
+ActiveRecord::Base.class_eval do
+  alias_method :save, :valid?
+  def self.columns() @columns ||= []; end
+  
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type, null)
+  end
+end

data/spec/url_writing_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe "URL writing" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
+  end
+  
+  { "nil" => nil, "an IP address" => "207.192.69.152" }.each do |host_type, host|
+    context "when the host is #{host_type}" do
+      it "should raise an error when a subdomain route is requested" do
+        map_subdomain(:www) { |www| www.resources :users }
+        with_host(host) { lambda { www_users_path }.should raise_error(SubdomainRoutes::HostNotSupplied) }
+      end
+      
+      context "and a non-subdomain route is requested" do
+        before(:each) do
+          ActionController::Routing::Routes.draw { |map| map.resources :users }
+        end
+
+        it "should not raise an error when the route is a path" do
+          with_host(host) do
+            lambda { users_path }.should_not raise_error
+          end
+        end
+      end
+    end
+  end
+
+  [ [ "single", :admin, "admin.example.com" ],
+    [    "nil",    nil,       "example.com" ] ].each do |type, subdomain, host|
+    context "when a #{type} subdomain is specified" do
+      before(:each) do
+        map_subdomain(subdomain, :name => nil) { |map| map.resources :users }
+      end
+  
+      it "should not change the host for an URL if the host subdomain matches" do
+        with_host(host) { users_url.should == "http://#{host}/users" }
+      end
+    
+      it "should change the host for an URL if the host subdomain differs" do
+        with_host("other.example.com") { users_url.should == "http://#{host}/users" }
+      end
+
+      it "should not force the host for a path if the host subdomain matches" do
+        with_host(host) { users_path.should == "/users" }
+      end
+
+      it "should force the host for a path if the host subdomain differs" do
+        with_host("other.example.com") { users_path.should == "http://#{host}/users" }
+      end
+  
+      context "and a subdomain different from the host subdomain is explicitly requested" do
+        it "should change the host if the requested subdomain matches" do
+          with_host("other.example.com") { users_path(:subdomain => subdomain).should == "http://#{host}/users" }
+        end
+    
+        it "should raise a routing error if the requested subdomain doesn't match" do
+          with_host(host) do
+            lambda { users_path(:subdomain => :other) }.should raise_error(ActionController::RoutingError)
+          end
+        end
+      end
+      
+      context "and the current host's subdomain is explicitly requested" do
+        it "should not force the host for a path if the subdomain matches" do
+          with_host(host) { users_path(:subdomain => subdomain).should == "/users" }
+        end
+      end
+    end
+  end
+  
+  [ [               "", [ :books, :dvds ], [ "books.example.com", "dvds.example.com" ] ],
+    [ " including nil",     [ nil, :www ], [       "example.com",  "www.example.com" ] ] ].each do |qualifier, subdomains, hosts|
+    context "when multiple subdomains#{qualifier} are specified" do
+      before(:each) do
+        args = subdomains + [ :name => nil ]
+        map_subdomain(*args) { |map| map.resources :items }
+      end
+          
+      it "should not change the host for an URL if the host subdomain matches" do
+        hosts.each do |host|
+          with_host(host) { items_url.should == "http://#{host}/items" }
+        end
+      end
+  
+      it "should not force the host for a path if the host subdomain matches" do
+        hosts.each do |host|
+          with_host(host) { items_path.should == "/items" }
+        end
+      end
+  
+      it "should raise a routing error if the host subdomain doesn't match" do
+        with_host "other.example.com" do
+          lambda {  item_url }.should raise_error(ActionController::RoutingError)
+          lambda { item_path }.should raise_error(ActionController::RoutingError)
+        end
+      end
+    
+      context "and a subdomain different from the host subdomain is explicitly requested" do
+        it "should change the host if the requested subdomain matches" do
+          [ [ subdomains.first, hosts.first, hosts.last ],
+            [ subdomains.last, hosts.last, hosts.first ] ].each do |subdomain, new_host, old_host|
+            with_host(old_host) { items_path(:subdomain => subdomain).should == "http://#{new_host}/items" }
+          end
+        end
+          
+        it "should raise a routing error if the requested subdomain doesn't match" do
+          [ [ hosts.first, hosts.last ],
+            [ hosts.last, hosts.first ] ].each do |new_host, old_host|
+            with_host(old_host) do
+              lambda { items_path(:subdomain => :other) }.should raise_error(ActionController::RoutingError)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  it "should downcase a supplied subdomain" do
+    map_subdomain(:www1, :www2, :name => nil) { |map| map.resources :users }
+    [ [ :Www1, "www1" ], [ "Www2", "www2" ] ].each do |mixedcase, lowercase|
+      with_host("www.example.com") { users_url(:subdomain => mixedcase).should == "http://#{lowercase}.example.com/users" }
+    end
+  end
+  
+  context "when a :proc subdomain is specified" do          
+    before(:each) do
+      map_subdomain(:proc => :city) { |city| city.resources :events }
+    end
+    
+    it "should raise a routing error without a recognize proc" do
+      with_host "boston.example.com" do
+        lambda {  city_events_url }.should raise_error(ActionController::RoutingError)
+        lambda { city_events_path }.should raise_error(ActionController::RoutingError)
+      end
+    end
+    
+    context "and a recognize proc is defined" do
+      before(:each) do
+        ActionController::Routing::Routes.recognize_subdomain(:city) { |city| } # this block will be stubbed
+      end
+      
+      it "should not change the host if the recognize proc returns true" do
+        with_host "boston.example.com" do
+          ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).twice.with(:city, "boston").and_return(true)
+          city_events_url.should == "http://boston.example.com/events"
+          city_events_path.should == "/events"
+        end
+      end
+    
+      it "should raise a routing error if the recognize proc returns false" do
+        with_host "www.example.com" do
+          ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).twice.with(:city, "www").and_return(false)
+          lambda { city_events_url  }.should raise_error(ActionController::RoutingError)
+          lambda { city_events_path }.should raise_error(ActionController::RoutingError)
+        end
+      end
+    
+      it "should force the host if the recognize proc returns false but a matching subdomain is supplied" do
+        with_host "www.example.com" do
+          ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).twice.with(:city, "boston").and_return(true)
+           city_events_url(:subdomain => :boston).should == "http://boston.example.com/events"
+          city_events_path(:subdomain => :boston).should == "http://boston.example.com/events"
+        end
+      end
+    
+      it "should raise a routing error if the recognize proc returns false and a non-matching subdomain is supplied" do
+        with_host "www.example.com" do
+          ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).twice.with(:city, "hobart").and_return(false)
+          lambda {  city_events_url(:subdomain => :hobart) }.should raise_error(ActionController::RoutingError)
+          lambda { city_events_path(:subdomain => :hobart) }.should raise_error(ActionController::RoutingError)
+        end
+      end
+    end
+  end
+end

data/spec/validations_spec.rb

@@ -0,0 +1,12 @@
+describe "ActiveRecord::Base" do
+  it "should have validates_subdomain_format_of which runs SubdomainRoutes.valid_subdomain? against the attributes" do
+    class User < ActiveRecord::Base
+      attr_accessor :subdomain
+      User.validates_subdomain_format_of :subdomain
+    end
+    SubdomainRoutes.should_receive(:valid_subdomain?).with("mholling").and_return(true)
+    User.new(:subdomain => "mholling").valid?.should be_true
+    SubdomainRoutes.should_receive(:valid_subdomain?).with("mholling").and_return(nil)
+    User.new(:subdomain => "mholling").valid?.should be_false
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: mholling-subdomain_routes
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthew Hollingworth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.1
+    version: 
+description: SubdomainRoutes add subdomain conditions to the Rails routing system. Routes may be restricted to one or many specified subdomains. An URL will be recognised only if the host subdomain matches the subdomain specified in the route. Route generation is also enhanced, so that the subdomain of a generated URL (or path) will be changed if the requested route has a different subdomain to that of the current request. Dynamic subdomain routes can also be defined.
+email: mdholling@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- lib/subdomain_routes.rb
+- lib/subdomain_routes/config.rb
+- lib/subdomain_routes/mailer.rb
+- lib/subdomain_routes/mapper.rb
+- lib/subdomain_routes/proc_set.rb
+- lib/subdomain_routes/request.rb
+- lib/subdomain_routes/resources.rb
+- lib/subdomain_routes/routes.rb
+- lib/subdomain_routes/split_host.rb
+- lib/subdomain_routes/url_writer.rb
+- lib/subdomain_routes/validations.rb
+- spec/extraction_spec.rb
+- spec/mailer_spec.rb
+- spec/proc_set_spec.rb
+- spec/recognition_spec.rb
+- spec/resources_spec.rb
+- spec/routes_spec.rb
+- spec/spec_helper.rb
+- spec/url_writing_spec.rb
+- spec/validations_spec.rb
+has_rdoc: false
+homepage: http://github.com/mholling/subdomain_routes
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Rails library for incorporating subdomains into route generation and recognition.
+test_files: 
+- spec/extraction_spec.rb
+- spec/mailer_spec.rb
+- spec/proc_set_spec.rb
+- spec/recognition_spec.rb
+- spec/resources_spec.rb
+- spec/routes_spec.rb
+- spec/spec_helper.rb
+- spec/url_writing_spec.rb
+- spec/validations_spec.rb