mholling-subdomain_routes 0.1.0

data/lib/subdomain_routes/split_host.rb

@@ -0,0 +1,35 @@
+module SubdomainRoutes
+  class TooManySubdomains < StandardError
+    # TODO: should this just be an ActionController::RoutingError instead? Any benefit to having a separate error type?
+    # OK, keep the special codes, but catch and re-case them in UrlWriter.
+    # (The errors are also raised in extract_request_environment...)
+  end
+
+  module SplitHost
+    private
+    
+    def split_host(host)
+      raise HostNotSupplied, "No host supplied!" if host.blank?
+      raise HostNotSupplied, "Can't set subdomain for an IP address!" if host =~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
+      parts = host.split('.')
+      if Config.domain_length
+        domain_parts = [ ]
+        Config.domain_length.times { domain_parts.unshift parts.pop }
+        if parts.size > 1
+          raise TooManySubdomains, "Multiple subdomains found: #{parts.join('.')}. (Have you set SubdomainRoutes::Config.domain_length correctly?)"
+        end
+        [ parts.pop.to_s, domain_parts.join('.') ]
+      else
+        [ parts.shift.to_s, parts.join('.') ]
+      end
+    end
+    
+    def domain_for_host(host)
+      split_host(host).last
+    end
+    
+    def subdomain_for_host(host)
+      split_host(host).first
+    end
+  end
+end

data/lib/subdomain_routes/url_writer.rb

@@ -0,0 +1,86 @@
+module SubdomainRoutes
+  class HostNotSupplied < StandardError
+    # TODO: should this just be an ActionController::RoutingError instead? Any benefit to having a separate error type?
+  end
+  
+  module RewriteSubdomainOptions
+    include SplitHost
+    
+    def subdomain_procs
+      ActionController::Routing::Routes.subdomain_procs
+    end
+
+    def rewrite_subdomain_options(options, host)
+      if subdomains = options[:subdomains]
+        old_subdomain, domain = split_host(host)
+        new_subdomain = options.has_key?(:subdomain) ? options[:subdomain].to_s.downcase : old_subdomain
+        begin
+          case subdomains
+          when Array
+            unless subdomains.include? new_subdomain
+              if subdomains.size > 1 || options.has_key?(:subdomain)
+                raise ActionController::RoutingError, "expected subdomain in #{subdomains.inspect}, instead got subdomain #{new_subdomain.inspect}"
+              else
+                new_subdomain = subdomains.first
+              end
+            end
+          when Hash
+            unless subdomain_procs.recognize(subdomains[:proc], new_subdomain) && (new_subdomain.blank? || SubdomainRoutes.valid_subdomain?(new_subdomain))
+              raise ActionController::RoutingError, "subdomain #{new_subdomain.inspect} is invalid"
+            end
+          end
+        rescue ActionController::RoutingError => e
+          raise ActionController::RoutingError, "Route for #{options.inspect} failed to generate (#{e.message})"
+        end
+        unless new_subdomain == old_subdomain
+          options[:only_path] = false
+          options[:host] = [ new_subdomain, domain ].reject(&:blank?).join('.')
+        end
+        options.delete(:subdomains)
+        options.delete(:subdomain)
+      end
+    end
+  end
+    
+  module UrlWriter
+    include RewriteSubdomainOptions
+    
+    def self.included(base)
+      base.alias_method_chain :url_for, :subdomains
+    end
+
+    def url_for_with_subdomains(options)
+      host = options[:host] || default_url_options[:host]
+      if options[:subdomains] && host.blank?
+        raise HostNotSupplied, "Missing host to link to! Please provide :host parameter or set default_url_options[:host]"
+      end
+      rewrite_subdomain_options(options, host)
+      url_for_without_subdomains(options)
+    end
+  end
+
+  module UrlRewriter
+    include RewriteSubdomainOptions
+    
+    def self.included(base)
+      base.alias_method_chain :rewrite, :subdomains
+      base::RESERVED_OPTIONS << :subdomain
+    end
+    
+    def rewrite_with_subdomains(options)      
+      host = options[:host] || @request.host
+      if options[:subdomains] && host.blank?
+        raise HostNotSupplied, "Missing host to link to!"
+      end
+      rewrite_subdomain_options(options, host)
+      rewrite_without_subdomains(options)
+    end
+  end
+end
+
+ActionController::UrlWriter.send :include, SubdomainRoutes::UrlWriter
+ActionController::UrlRewriter.send :include, SubdomainRoutes::UrlRewriter
+
+if defined? ActionMailer::Base
+  ActionMailer::Base.send :include, ActionController::UrlWriter
+end

data/lib/subdomain_routes/validations.rb

@@ -0,0 +1,28 @@
+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])*)$/
+  # # TODO: could we use URI::parse instead?:
+  #   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
+    end
+  end
+end
+
+if defined? ActiveRecord::Base
+  ActiveRecord::Base.send :extend, SubdomainRoutes::Validations::ClassMethods
+end

data/lib/subdomain_routes.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+
+require 'subdomain_routes/config'
+require 'subdomain_routes/split_host'
+require 'subdomain_routes/mapper'
+require 'subdomain_routes/proc_set'
+require 'subdomain_routes/routes'
+require 'subdomain_routes/resources'
+require 'subdomain_routes/url_writer'
+require 'subdomain_routes/request'
+require 'subdomain_routes/validations'
+require 'subdomain_routes/mailer'

data/spec/extraction_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "subdomain extraction" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+  end
+  
+  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
+
+  describe "configuration" do
+    it "should have a default domain length of nil" do
+      SubdomainRoutes::Config.domain_length.should be_nil
+    end
+  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/mailer_spec.rb

@@ -0,0 +1,15 @@
+describe "ActionMailer::Base" do
+  before(:each) do
+    @mailer_class = Class.new(ActionMailer::Base) { def test; body "test"; end }
+  end
+  it "should flush the subdomain procs cache each time a mailer is created" do
+    ActionController::Routing::Routes.subdomain_procs.should_receive(:flush!)
+    @mailer_class.create_test
+  end
+
+  it "should not flush the subdomain procs cache 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!)
+    @mailer_class.create_test
+  end
+end

data/spec/proc_set_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "subdomain proc set" do
+  before(:each) do
+    @proc_set = SubdomainRoutes::ProcSet.new
+  end
+  
+  context "with a subdomain recognizer" do
+    before(:each) do
+      @city_block = lambda { |city| } # this recognizer block will be stubbed out
+      @proc_set.add_recognizer(:city, &@city_block)
+    end
+
+    it "should indicate what subdomain it recognizes" do
+      @proc_set.recognizes?(:city).should be_true
+      @proc_set.recognizes?(:user).should be_false
+    end
+    
+    it "should run the recognizer" do
+      @city_block.should_receive(:call).with("boston").and_return(true)
+      @proc_set.recognize(:city, "boston").should == true
+    end
+    
+    it "should raise any error that the recognizer raises" do
+      error = StandardError.new
+      @city_block.stub!(:call).and_raise(error)
+      lambda { @proc_set.recognize(:city, "hobart") }.should raise_error { |e| e.should == error }
+    end
+  
+    it "should return nil if it can't recognize the name" do
+      @proc_set.recognize(:user, "mholling").should be_nil
+    end
+
+    it "should call the recognize proc only once for multiple recognitions" do
+      @city_block.should_receive(:call).with("boston").once
+      2.times { @proc_set.recognize(:city, "boston") }
+    end
+    
+    it "should return the cached value according to the arguments" do
+      @city_block.should_receive(:call).with("boston").once.and_return(true)
+      @city_block.should_receive(:call).with("hobart").once.and_return(false)
+      2.times do
+        @proc_set.recognize(:city, "boston").should == true
+        @proc_set.recognize(:city, "hobart").should == false
+      end
+    end
+    
+    it "should call the recognize proc again once the cache is flushed" do
+      @city_block.should_receive(:call).with("boston").twice
+      5.times { @proc_set.recognize(:city, "boston") }
+      @proc_set.flush!
+      5.times { @proc_set.recognize(:city, "boston") }
+    end
+  end
+  
+  it "can be cleared of its procs" do
+    @proc_set.add_recognizer(:city) { |city| }
+    @proc_set.clear!
+    @proc_set.recognizes?(:city).should be_false
+  end
+end

data/spec/recognition_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe "subdomain route recognition" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
+    @request = ActionController::TestRequest.new
+    @request.host = "www.example.com"
+    @request.request_uri = "/items/2"
+  end
+
+  it "should add the host's subdomain to the request environment" do
+    request_environment = ActionController::Routing::Routes.extract_request_environment(@request)
+    request_environment[:subdomain].should == "www"
+  end
+  
+  it "should add an empty subdomain to the request environment if the host has no subdomain" do
+    @request.host = "example.com"
+    request_environment = ActionController::Routing::Routes.extract_request_environment(@request)
+    request_environment[:subdomain].should == ""
+  end
+  
+  context "for a single specified subdomain" do
+    it "should recognise a route if the subdomain matches" do
+      map_subdomain(:www) { |www| www.resources :items }
+      params = recognize_path(@request)
+      params[:controller].should == "www/items"
+      params[:action].should == "show"
+      params[:id].should == "2"
+    end
+  
+    it "should not recognise a route if the subdomain doesn't match" do
+      map_subdomain("admin") { |admin| admin.resources :items }
+      lambda { recognize_path(@request) }.should raise_error(ActionController::RoutingError)
+    end
+  end
+  
+  context "for a nil or blank subdomain" do
+    [ nil, "" ].each do |subdomain|
+      it "should recognise a route if there is no subdomain present" do
+        map_subdomain(subdomain) { |map| map.resources :items }
+        @request.host = "example.com"
+        lambda { recognize_path(@request) }.should_not raise_error
+      end
+    end
+  end
+  
+  context "for multiple specified subdomains" do
+    it "should recognise a route if the subdomain matches" do
+      map_subdomain(:www, :admin, :name => nil) { |map| map.resources :items }
+      lambda { recognize_path(@request) }.should_not raise_error
+    end
+  
+    it "should not recognise a route if the subdomain doesn't match" do
+      map_subdomain(:support, :admin, :name => nil) { |map| map.resources :items }
+      lambda { recognize_path(@request) }.should raise_error(ActionController::RoutingError)
+    end
+  end
+  
+  context "for a :proc subdomain" do
+    before(:each) do
+      @user_block = lambda { |user| } # this block will be stubbed
+      ActionController::Routing::Routes.recognize_subdomain(:user, &@user_block)
+      map_subdomain(:proc => :user) { |user| user.resources :articles }
+      @request.request_uri = "/articles"
+      @request.host = "mholling.example.com"
+    end
+  
+    it "should match the route if the recognize proc returns true or an object" do
+      [ true, Object.new ].each do |value|
+        ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).any_number_of_times.with(:user, "mholling").and_return(value)
+        lambda { recognize_path(@request) }.should_not raise_error
+      end
+    end
+    
+    it "should not match the route if the recognize proc returns false or nil" do
+      [ false, nil ].each do |value|
+        ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).any_number_of_times.with(:user, "mholling").and_return(value)
+        lambda { recognize_path(@request) }.should raise_error(ActionController::RoutingError)
+      end
+    end
+    
+    it "should raise any error that the recognize proc raises" do
+      error = StandardError.new
+      ActionController::Routing::Routes.subdomain_procs.should_receive(:recognize).any_number_of_times.with(:user, "mholling").and_raise(error)
+      lambda { recognize_path(@request) }.should raise_error { |e| e.should == error }
+    end
+  end
+end

data/spec/resources_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe "resource" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
+  end
+  
+  describe "mappings" do
+    it "should pass the specified subdomains to any nested routes" do
+      map_subdomain(:admin) do |admin|
+        admin.resources(:users) { |user| user.options[:subdomains].should == [ "admin" ] }
+        admin.resource(:config) { |config| config.options[:subdomains].should == [ "admin" ] }
+      end
+    end
+  end
+    
+  describe "routes" do
+    before(:each) do
+      map_subdomain(:admin) do |admin|
+        admin.resources :users
+        admin.resource :config
+      end
+    end
+      
+    it "should include the subdomains in the routing conditions" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.conditions[:subdomains].should == [ "admin" ]
+      end
+    end
+    
+    it "should include the subdomains in the routing conditions" do
+      ActionController::Routing::Routes.routes.each do |route|
+        route.requirements[:subdomains].should == [ "admin" ]
+      end
+    end
+  end
+end