goncalossilva-subdomain_routes 0.3.3

data/lib/subdomain_routes/validations.rb

@@ -0,0 +1,42 @@
+module SubdomainRoutes
+  def self.valid_subdomain?(subdomain)
+    subdomain.to_s =~ /^([a-z]|[a-z][a-z0-9]|[a-z]([a-z0-9]|\-[a-z0-9])*)$/
+  end
+
+  # # Alternatively, we use URI::parse instead. This gives more lenient subdomains however:
+  # def self.valid_subdomain?(subdomain)
+  #   URI.parse "http://#{subdomain}.example.com"
+  # rescue URI::InvalidURIError
+  #   false
+  # end
+    
+  module Validations
+    module ClassMethods
+      def validates_subdomain_format_of(*attr_names)
+        configuration = { :on => :save }
+        configuration.update(attr_names.extract_options!)
+      
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          unless SubdomainRoutes.valid_subdomain?(value)
+            record.errors.add(attr_name, :not_a_valid_subdomain, :default => configuration[:message], :value => value) 
+          end
+        end
+      end
+      
+      def validates_subdomain_not_reserved(*attr_names)
+        configuration = { :on => :save }
+        configuration.update(attr_names.extract_options!)
+      
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          if ActionController::Routing::Routes.reserved_subdomains.include? value
+            record.errors.add(attr_name, :is_a_reserved_subdomain, :default => configuration[:message], :value => value) 
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined? ActiveRecord::Base
+  ActiveRecord::Base.send :extend, SubdomainRoutes::Validations::ClassMethods
+end

data/rails/init.rb

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

data/spec/assertions_spec.rb

@@ -0,0 +1,193 @@
+require 'test/unit/testresult'
+require 'spec_helper'
+
+class HomesController < ActionController::Base
+end
+
+describe "routing assertions" do
+  context "for single-subdomain route" do
+    before(:each) do
+      map_subdomain :admin, :name => nil do |admin|
+        admin.resource :home
+      end
+      @options = { :controller => "homes", :action => "show", :subdomains => [ "admin" ] }
+    end
+  
+    context "recognition" do
+      it "should correctly succeed with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "admin.example.com" }) }
+        test.should_not have_errors
+        test.should_not fail
+      end
+    
+      it "should correctly fail with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "www.example.com" } ) }
+        test.should have_errors
+      end
+    end
+  
+    context "generation" do
+      it "should correctly succeed with :host and :path options and a subdomain route which changes the subdomain and no subdomain is specified" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options, "www.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and the wrong subdomain is specified" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options.merge(:subdomain => "other"), "www.example.com") }
+        test.should have_errors
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and the correct subdomain is specified" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options.merge(:subdomain => "admin"), "www.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "admin.example.com" }, @options, "admin.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+      
+      it "should correctly succeed with a path and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "admin.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+    
+      it "should correctly fail with a path and a subdomain route which changes the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "www.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+    end
+  end
+
+  context "for multiple-subdomain route" do
+    before(:each) do
+      @subdomains = [ "admin", "support" ]
+      map_subdomain *(@subdomains + [ { :name => nil } ]) do |media|
+        media.resource :home
+      end
+      @options = { :controller => "homes", :action => "show", :subdomains => @subdomains }
+    end
+  
+    context "recognition" do
+      it "should correctly succeed with a :host option and a subdomain route" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "#{subdomain}.example.com" }) }
+          test.should_not have_errors
+          test.should_not fail
+        end
+      end
+    
+      it "should correctly fail with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "www.example.com" } ) }
+        test.should have_errors
+      end
+    end
+  
+    context "generation" do
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and no subdomain is specified" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options, "www.example.com") }
+          test.should have_errors
+        end
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain and the wrong subdomain is specified" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options.merge(:subdomain => "other"), "www.example.com") }
+          test.should have_errors
+        end
+      end
+      
+      it "should correctly succeed with :host and :path options and a subdomain route which changes the subdomain and a correct subdomain is specified" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options.merge(:subdomain => subdomain), "www.example.com") }
+          test.should_not have_errors
+          test.should_not fail
+        end
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host({ :path => "/home", :host => "#{subdomain}.example.com" }, @options, "#{subdomain}.example.com") }
+          test.should_not have_errors
+          test.should fail
+        end
+      end
+      
+      it "should correctly succeed with a path and a subdomain route which doesn't change the subdomain" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host("/home", @options, "#{subdomain}.example.com") }
+          test.should_not have_errors
+          test.should_not fail
+        end
+      end
+    
+      it "should correctly fail with a path and a subdomain route which changes the subdomain" do
+        @subdomains.each do |subdomain|
+          test = lambda { assert_generates_with_host("/home", @options.merge(:subdomain => subdomain), "www.example.com") }
+          test.should_not have_errors
+          test.should fail
+        end
+      end
+    end
+  end
+
+  context "for model-based subdomain route" do
+    before(:each) do
+      map_subdomain :model => :city, :namespace => nil do |city|
+        city.resource :home
+      end
+      @options = { :controller => "homes", :action => "show", :subdomains => :city_id, :city_id => "canberra" }
+    end
+  
+    context "recognition" do
+      it "should correctly succeed with a :host option and a subdomain route" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "canberra.example.com" }) }
+        test.should_not have_errors
+        test.should_not fail
+      end
+
+      it "should correctly fail with a :host option and a subdomain route for the wrong subdomain" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "boston.example.com" }) }
+        test.should_not have_errors
+        test.should fail
+      end
+    
+      it "should correctly fail with a :host option and a subdomain route for no subdomain" do
+        test = lambda { assert_recognizes_with_host(@options, { :path => "/home", :host => "example.com" }) }
+        test.should have_errors
+      end
+    end
+  
+    context "generation" do
+      it "should correctly succeed with :host and :path options and a subdomain route which changes the subdomain" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "canberra.example.com" }, @options, "boston.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+      
+      it "should correctly fail with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host({ :path => "/home", :host => "canberra.example.com" }, @options, "canberra.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+      
+      it "should correctly succeed with :host and :path options and a subdomain route which doesn't change the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "canberra.example.com") }
+        test.should_not have_errors
+        test.should_not fail
+      end
+          
+      it "should correctly fail with :host and :path options and a subdomain route which changes the subdomain" do
+        test = lambda { assert_generates_with_host("/home", @options, "www.example.com") }
+        test.should_not have_errors
+        test.should fail
+      end
+    end
+  end
+end

data/spec/extraction_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe "subdomain extraction" do
+  include SubdomainRoutes::SplitHost
+
+  it "should add a subdomain method to requests" do
+    request = ActionController::TestRequest.new
+    request.host = "admin.example.com"
+    request.subdomain.should == "admin"
+  end
+  
+  it "should raise an error if no host is supplied" do
+    lambda { split_host(nil) }.should raise_error(SubdomainRoutes::HostNotSupplied)
+  end
+  
+  context "when the domain length is not set" do
+    before(:each) do
+      SubdomainRoutes::Config.stub!(:domain_length).and_return(nil)
+    end
+    
+    it "should always find a subdomain and a domain" do
+               split_host("example.com").should == [ "example", "com" ]
+           split_host("www.example.com").should == [ "www", "example.com" ]
+      split_host("blah.www.example.com").should == [ "blah", "www.example.com" ]
+    end
+    
+    it "should raise an error if a nil subdomain is mapped" do
+      lambda { map_subdomain(nil) }.should raise_error(ArgumentError)
+      lambda { map_subdomain(nil, :www) }.should raise_error(ArgumentError)
+    end
+  end
+  
+  context "when domain length is set" do
+    before(:each) do
+      SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
+    end        
+      
+    it "should find the domain" do
+      domain_for_host("www.example.com").should == "example.com"
+    end
+
+    it "should find the subdomain when it is present" do
+      subdomain_for_host("www.example.com").should == "www"
+    end
+
+    it "should return an empty string when subdomain is absent" do
+      subdomain_for_host("example.com").should == ""
+    end
+  
+    context "and multi-level subdomains are found" do
+      before(:each) do
+        @host = "blah.www.example.com"
+      end
+    
+      it "should raise an error" do
+        lambda { subdomain_for_host(@host) }.should raise_error(SubdomainRoutes::TooManySubdomains)
+      end
+          
+      it "should raise an error when generating URLs" do
+        map_subdomain(:admin) { |admin| admin.resources :users }
+        with_host(@host) do
+          lambda { admin_users_path }.should raise_error(SubdomainRoutes::TooManySubdomains)
+        end
+      end
+    
+      it "should raise an error when recognising URLs" do
+        request = ActionController::TestRequest.new
+        request.host = @host
+        lambda { recognize_path(request) }.should raise_error(SubdomainRoutes::TooManySubdomains)
+      end
+    end
+  end
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe "subdomain route mapping" do
+  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 raise ArgumentError if a nil :model option is specified as the subdomain" do
+    lambda { map_subdomain(:model => "") { } }.should raise_error(ArgumentError)
+  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 :model subdomain" do
+    it "should accept a :model option as the subdomain and turn it into a foreign key symbol" do
+      map_subdomain(:model => :city) { |city| city.options[:subdomains].should == :city_id }
+    end
+
+    it "should singularize a plural model name" do
+      map_subdomain(:model => :cities) { |city| city.options[:subdomains].should == :city_id }
+    end
+    
+    it "should accept a string model name" do
+      map_subdomain(:model => "city") { |city| city.options[:subdomains].should == :city_id }
+    end
+    
+    it "should set the model name as a namespace" do
+      map_subdomain(:model => :city) { |city| city.options[:namespace].should == "city/" }
+    end
+  
+    it "should prefix the model name to named routes" do
+      map_subdomain(:model => :city) { |city| city.options[:name_prefix].should == "city_" }
+    end
+    
+    it "should instead set a namespace to the name if specified" do
+      map_subdomain(:model => :city, :name => :something) { |map| map.options[:namespace].should == "something/" }
+    end
+
+    it "should instead prefix the name to named routes if specified" do
+      map_subdomain(:model => :city, :name => :something) { |map| map.options[:name_prefix].should == "something_" }
+    end
+
+    it "should not set a namespace if name is specified as nil" do
+      map_subdomain(:model => :city, :name => nil) { |map| map.options[:namespace].should be_nil }
+    end
+
+    it "should not set a named route prefix if name is specified as nil" do
+      map_subdomain(:model => :city, :name => nil) { |map| map.options[:name_prefix].should be_nil }
+    end
+  end
+end