mholling-subdomain_routes 0.1.0 → 0.2.0

data/README.textile

@@ -1,12 +1,10 @@
-h1. SubdomainRoutes - Adding Subdomains to Rails Routing
-
 The Rails "routing system":http://api.rubyonrails.org/classes/ActionController/Routing.html is a pretty impressive piece of code. There's a fair bit of magic going on to make your routes so easy to define and use in the rest of your Rails application. One area in which the routing system is limited however is its use of subdomains: it's pretty much assumed that your site will be using a single, fixed domain.
 
 There are times where it is preferable to spread a website over multiple subdomains. One common idiom in URL schemes is to separate aspects of the site under different subdomains, representative of those aspect. It many cases a simple, fixed subdomain scheme is desirable: _support.whatever.com_, _forums.whatever.com_, _gallery.whatever.com_ and so on. On some international sites, the subdomain is used to select the language and localization: _en.wikipedia.org_, _fr.wikipedia.org_, _ja.wikipedia.org_. Other schemes allocate each user of the site their own subdomain, so as to personalise the experience (_blogspot.com_ is a good example of this).
 
 A couple of plugins currently exists for Rails developers wishing to incorporate subdomains into their routes. The de facto standard is "SubdomainFu":http://www.intridea.com/2008/6/23/subdomainfu-a-new-way-to-tame-the-subdomain. (I'll admit - I haven't actually used this plugin myself.) There's also "SubdomainAccount":http://github.com/shuber/subdomain_account/tree/master.
 
-I've recently completed work on a subdomain library which fully incorporates subdomains into the rails routing environment - in URL generation, route recognition *and* in route definition, something I don't believe is currently available. As an added bonus, if offers the ability to define routes for _dynamic subdomains_, which are recognised based on the contents of your database, or on other dynamic conditions.
+I've recently completed work on a subdomain library which fully incorporates subdomains into the rails routing environment - in URL generation, route recognition *and* in route definition, something I don't believe is currently available. As an added bonus, if offers the ability to define subdomain routes which are keyed to a model (user, category, etc.) stored in your database.
 
 h2. Installation
 
@@ -76,7 +74,7 @@ support_tickets_path(:subdomain => :www)
 
 Notice that, by necessity, requesting a path still results in an URL if the subdomain of the route is different. If you try and override the subdomain manually, you'll get an error, because the resulting URL would be invalid and would not be recognized. This is a good thing - you don't want to be linking to invalid URLs by mistake!
 
-In other words, <code>url_for</code> and your named routes will *never* generate an invalid URL. This is one major benefit of the SubdomainRoutes gem: it offers a smart way of switching subdomains, requiring them to be specified manually only when absolutely necessary. (It gets even better with dynamic subdomains, which I will describe later.)
+In other words, <code>url_for</code> and your named routes will *never* generate an invalid URL. This is one major benefit of the SubdomainRoutes gem: it offers a smart way of switching subdomains, requiring them to be specified manually only when absolutely necessary.
 
 h2. Mapping Multiple Subdomains
 
@@ -163,125 +161,74 @@ end
 
 Your <code>admin_role_users_path(@role)</code> will automatically generate with the correct _admin_ subdomain if required, and paths such as _/roles/1/users_ will only be recognised when under the _admin_ subdomain. Note that both the block form and the <code>:has_many</code> form of nested resources will work in this manner. (In fact, under the hood, the latter just falls through to the former.) Any other (non-resource) routes you nest under a resource will also inherit the subdomain conditions.
 
-h2. Setting Up Your Development Environment
-
-To develop your app using SudomainRoutes, you'll need to set up your machine to point some test domains to the server on your machine (i.e. to the local loopback address, 127.0.0.1). On a Mac, you can do this by editing <code>/etc/hosts</code>. Let's say you want to use the subdomains _www_, _dvd_, _game_, _book_ and _cd_, with a domain of _reviews.local_. Adding these lines to <code>/etc/hosts</code> will do the trick:
-
-<pre>
-127.0.0.1 reviews.local
-127.0.0.1 www.reviews.local
-127.0.0.1 dvd.reviews.local
-127.0.0.1 game.reviews.local
-127.0.0.1 book.reviews.local
-127.0.0.1 cd.reviews.local
-</pre>
-
-You'll need to flush your DNS cache for these changes to take effect:
-
-<pre>
-dscacheutil -flushcache
-</pre>
-
-Then fire up your <code>script/server</code>, point your browser to _www.reviews.local:3000_ and your app should be up and running. If you're using "Passenger":http://www.modrails.com to "serve your apps in development":http://www.google.com/search?q=rails+passenger+development (and I highly recommend that you do), you'll need to add a Virtual Host to your Apache .conf file. (Don't forget to alias all the subdomains and restart the server.)
-
-If you're using dynamic subdomain routes (covered in my next article), you may want to use a catch-all (wildcard) subdomain. Setting this up is not so easy, since wildcards (like _*.reviews.local_) won't work in your <code>/etc/hosts</code> file. There are a couple of work-around for this:
-
-# Use a "proxy.pac":http://en.wikipedia.org/wiki/Proxy.pac file in your browser so that it proxies _*.reviews.local_ to localhost. How to do this will depend on the browser you're using.
-# Set up a local DNS server with an A record for the domain. This may be a bit involved.
-
-h2. Dynamic Subdomain Recognition
-
-SubdomainRoutes also offers a full complement of features for recognizing subdomain URLS which are not known in advance. (I'll refer to these cases as _dynamic subdomains_.) For example, if you are keying each user of your website to their own subdomain, your routes will need to recognise new subdomains as new users sign up. Another example is if you want to key your URL subdomains to a set of categories (language, city, product type, etc.) which may expand as your site grows. In each case, your subdomains will depend on records in the database.
+h2. Defining Model-Based Subdomain Routes
 
-Let's take a hypothetical example of a blogging site which lets users show and manage their blog under their own subdomains (think _blogspot.com_). Assume our <code>User</code> model has a <code>subdomain</code> attribute which contains the user's custom subdomain. In our routes we'll still use the <code>subdomain</code> mapper, but instead of specifying one or more subdomains, we just specify a <code>:proc</code> option:
+The idea here is to have the subdomain of the URL keyed to an ActiveRecord model. Let's take a hypothetical example of a site which lists items under different categories, each category being represented under its own subdomain. Assume our <code>Category</code> model has a <code>subdomain</code> attribute which contains the category's custom subdomain. In our routes we'll still use the <code>subdomain</code> mapper, but instead of specifying one or more subdomains, we just specify a <code>:model</code> option:
 
 <pre>
 ActionController::Routing::Routes.draw do |map|
-  map.subdomain :proc => :blog do |blog|
-    blog.resources :articles, :has_many => :comments
+  map.subdomain :model => :category do |category|
+    category.resources :items
     ...
   end
 end
-
-ActionController::Routing::Routes.recognize_subdomain :blog do |subdomain|
-  User.exists?(:username => subdomain)
-end
 </pre>
 
-Note the last few lines, which are crucial. Here we are defining a method for recognizing blog subdomains. This is done using a new method, <code>recognize_subdomain</code>, which the gem adds to <code>ActionController::Routing::Routes</code>.
-
-As arguments, the <code>recognize_subdomain</code> method takes a subdomain label, as used in the route (in this case, <code>:blog</code>), and a block. The block should take a single argument (the subdomain to be recognised), and should return true or false depending on whether the subdomain should be recognised for that route. In this case, we simply look up the subdomain in the <code>User</code> model to see if it's in use.
+As before, the namespace and name prefix for all the nested routes will default to the name of the model (you can override these in the options). The routes will match under any subdomain, and that subdomain will be passed to the controller in the <code>params</code> hash as <code>params[:category_id]</code>. For example, a GET request to _dvds.example.com/items_ will go to the <code>Category::ItemsController#index</code> action with <code>params[:category_id]</code> set to <code>"dvds"</code>.
 
-That's all there is to it! Now our blog routes will recognize more subdomains as more users sign up.
+h2. Generating Model-Based Subdomain URLs
 
-How does URL _generation_ work with these routes? Pretty much as you'd expect. Let's say our awesome new blogging site, _awesomeblogs.com_, has only two users, who've selected subdomains _mholling_ and _rails_. In controllers and views, our named routes will work as follows:
+So how does URL _generation_ work with these routes? That's the best bit: just the same way as you're used to! The routes are fully integrated with your named routes, as well as the <code>form_for</code>, <code>redirect_to</code> and <code>polymorphic_path</code> helpers. The only thing you have to do is make sure your model's <code>to_param</code> returns the subdomain field for the user:
 
 <pre>
-# when the current host is mholling.awesomeblogs.com:
-blog_articles_path
-=> "/articles"
-
-blog_articles_path(:subdomain => "rails")
-=> "http://rails.awesomblogs.com/articles"
-
-blog_articles_path(:subdomain => "www")
-#  ActionController::RoutingError: Route failed to generate
-#  (subdomain "www" is invalid)
-
-# when the host is www.awesomeblogs.com:
-blog_articles_path(:subdomain => "rails")
-=> "http://rails.awesomblogs.com/articles"
-
-blog_articles_path
-#  ActionController::RoutingError: Route failed to generate
-#  (subdomain "www" is invalid)
+class Category < ActiveRecord::Base
+  ...
+  alias_method :to_param, :subdomain
+  ...
+end
 </pre>
 
-As you can see, the subdomain recognition method that we defined is being used to check for an invalid subdomain when the URL is being written. Nice!
+Now, in the above example, let's say our site has _dvd_ and _cd_ su categories, with subdomains _dvds_ and _cds_. In our controller:
 
-h3. Caching of Dynamic Subdomain Recognition
+<pre>
+@dvd
+=> #<Category id: 1, subdomain: "dvds", ... >
 
-Internally, the results of the subdomain recognition block are cached. If this weren't done, the block could be run many time per request (once for each route until one is recognised). That would be bad, since in most cases the database will be hit each time the block is called. (Sure, Rails will probably cache the database queries, but you may as well cache as high up the chain as you can.)
+@cd
+=> #<Category id: 2, subdomain: "cds", ... >
 
-The problem then becomes - when does the cache get flushed?  By default, this will occur once per request, which should be fine for many applications. If that's the case, you don't need to do anything.
+# when the current host is dvds.example.com:
+category_items_path(@dvd)
+=> "/items"
 
-To optimise performance however, you can disable the per-request cache flush and do it manually. Set this option in your configuration:
+polymorphic_path [ @dvd, @dvd.items.first ]
+=> "/items/2"
 
-<pre>
-SubdomainRoutes::Config.manual_flush = true
-</pre>
-
-In the above example we might want to choose this route, so that we can flush the cache only when a user is created or destroyed (or changes the subdomain). We could do this easily using an observer:
+category_items_path(@cd)
+=> "http://cds.example.com/items"
 
-<pre>
-class UserObserver < ActiveRecord::Observer
-  observe :user
+polymorphic_path [ @cd, @cd.items.first ]
+=> "http://cds.example.com/items/10"
+</pre>
 
-  after_save(user)
-    if user.subdomain_changed?
-      ActionController::Routing::Routes.subdomain_procs.flush!
-    end
-  end
+As you can see, the first argument for the named routes (and polymorphic paths) feeds directly into the subdomain for the URL. No more passing <code>:subdomain</code> options. Nice!
 
-  after_destroy(user)
-    ActionController::Routing::Routes.subdomain_procs.flush!
-  end
-end
+h2. ActiveRecord Validations
 
-# and in config/environment.rb:
-config.active_record.observers = [ :user_observer ]
-</pre>
+SubdomainRoutes also gives you a couple of utility validations for your ActiveRecord models:
 
-Another way to reduce the number of calls to the subdomain recognition block is by defining the dynamic subdomain route as late in <code>routes.rb</code> as possible. That way, the block will only be called if none of the other routes have resolved.
+* <code>validates_subdomain_format_of</code> ensures a subdomain field uses only legal characters in an allowed format; and
+* <code>validates_subdomain_not_reserved</code> ensures the field does not take a value already in use by your fixed-subdomain routes.
 
-h3. ActiveRecord Validations
+(Undoubtedly, you'll want to throw in a <code>validates_uniqueness_of</code> as well.)
 
-SubdomainRoutes also gives you a utility validation, <code>validates_subdomain_format_of</code>, for your ActiveRecord models. If you're storing a subdomain in a model (as we have been with our <code>User</code> example), you can use this validation to make sure that a subdomain field uses only legal characters and is in an allowed format. (Undoubtedly, you'll want to throw in a <code>validates_uniqueness_of</code> as well.)
+Let's take an example of a site where each user gets a dedicated subdomain. Validations for the <code>subdomain</code> attribute of the <code>User</code> model would be:
 
 <pre>
 class User < ActiveRecord::Base
   ...
   validates_subdomain_format_of :subdomain
+  validates_subdomain_not_reserved :subdomain
   validates_uniqueness_of :subdomain
   ...
 end
@@ -289,35 +236,53 @@ end
 
 The library currently uses a simple regexp to limit subdomains to lowercase alphanumeric characters and dashes (except on either end). If you want to conform more precisely to the URI specs, you can override the <code>SubdomainRoutes.valid_subdomain?</code> method and implement your own.
 
-h2. Using Static and Dynamic Subdomain Routes Together
+h2. Using Fixed and Model-Based Subdomain Routes Together
 
-Let's try using static and dynamic subdomain routes together. Say we want to reserve some subdomains (say _support_ and _admin_) for administrative functions, with the remainder keyed to user accounts. Our routes:
+Let's try using fixed and model-based subdomain routes together. Say we want to reserve some subdomains (say _support_ and _admin_) for administrative functions, with the remainder keyed to user accounts. Our routes:
 
 <pre>
 ActionController::Routing::Routes.draw do |map|
   map.subdomain :support do |support|
     ...
   end
+
   map.subdomain :admin do |admin|
     ...
   end
-  map.subdomain :proc => :user do |user|
+
+  map.subdomain :model => :user do |user|
     ...
   end
 end
+</pre>
 
-ActionController::Routing::Routes.recognize_subdomain :blog do |subdomain|
-  User.exists?(:username => subdomain)
-end
+These routes will co-exist quite happily together. We've made sure our static subdomain routes are listed first though, so that they get matched first. In the <code>User</code> model we'd add the validations above, which in this case would prevent users from taking _www_ or _support_ as a subdomain. (We could also validate for a minimum and maximum length using <code>validates_length_of</code>.)
+
+h2. Setting Up Your Development Environment
+
+To develop your app using SudomainRoutes, you'll need to set up your machine to point some test domains to the server on your machine (i.e. to the local loopback address, 127.0.0.1). On a Mac, you can do this by editing <code>/etc/hosts</code>. Let's say you want to use the subdomains _www_, _dvd_, _game_, _book_ and _cd_, with a domain of _reviews.local_. Adding these lines to <code>/etc/hosts</code> will do the trick:
+
+<pre>
+127.0.0.1 reviews.local
+127.0.0.1 www.reviews.local
+127.0.0.1 dvd.reviews.local
+127.0.0.1 game.reviews.local
+127.0.0.1 book.reviews.local
+127.0.0.1 cd.reviews.local
 </pre>
 
-These routes will co-exist quite happily together. (We've made sure our static subdomain routes are listed first though.) In the User model we'll add an extra validation to prevent users from taking the reserved subdomains:
+You'll need to flush your DNS cache for these changes to take effect:
 
 <pre>
-validates_exclusion_of :subdomain, :in => %w{support admin www}
+dscacheutil -flushcache
 </pre>
 
-(We could also validate for a minimum and maximum length.)
+Then fire up your <code>script/server</code>, point your browser to _www.reviews.local:3000_ and your app should be up and running. If you're using "Passenger":http://www.modrails.com to "serve your apps in development":http://www.google.com/search?q=rails+passenger+development (and I highly recommend that you do), you'll need to add a Virtual Host to your Apache .conf file. (Don't forget to alias all the subdomains and restart the server.)
+
+If you're using model-based subdomain routes (covered next), you may want to use a catch-all (wildcard) subdomain. Setting this up is not so easy, since wildcards (like _*.reviews.local_) won't work in your <code>/etc/hosts</code> file. There are a couple of work-around for this:
+
+# Use a "proxy.pac":http://en.wikipedia.org/wiki/Proxy.pac file in your browser so that it proxies _*.reviews.local_ to localhost. How to do this will depend on the browser you're using.
+# Set up a local DNS server with an A record for the domain. This may be a bit involved.
 
 
 Copyright (c) 2009 Matthew Hollingworth. See LICENSE for details.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :patch: 0
 :major: 0
-:minor: 1
+:minor: 2

data/lib/subdomain_routes/config.rb

@@ -1,6 +1,5 @@
 module SubdomainRoutes
   module Config
     mattr_accessor :domain_length
-    mattr_accessor :manual_flush
   end
 end

data/lib/subdomain_routes/mapper.rb

@@ -4,11 +4,13 @@ module SubdomainRoutes
       module Mapper
         def subdomain(*subdomains, &block)
           options = subdomains.extract_options!
-          name = nil
           if subdomains.empty?
-            if subdomain = options.delete(:proc)
-              subdomain_options = { :subdomains => { :proc => subdomain } }
-              name = subdomain
+            if model = options.delete(:model)
+              raise ArgumentError, "Invalid model name" if model.blank?
+              models = model.to_s.downcase.pluralize
+              model = models.singularize
+              model_id = model.foreign_key.to_sym
+              subdomain_options = { :subdomains => model_id, :name_prefix => "#{model}_", :namespace => "#{model}/" }
             else
               raise ArgumentError, "Please specify at least one subdomain!"
             end
@@ -22,12 +24,12 @@ module SubdomainRoutes
             if subdomains.include? ""
               raise ArgumentError, "Can't specify a nil subdomain unless you set Config.domain_length!" unless Config.domain_length
             end
-            name = subdomains.reject(&:blank?).first
             subdomain_options = { :subdomains => subdomains }
+            name = subdomains.reject(&:blank?).first
+            name = options.delete(:name) if options.has_key?(:name)
+            name = name.to_s.downcase.gsub(/[^(a-z0-9)]/, ' ').squeeze(' ').strip.gsub(' ', '_') unless name.blank?
+            subdomain_options.merge! :name_prefix => "#{name}_", :namespace => "#{name}/" unless name.blank?
           end
-          name = options.delete(:name) if options.has_key?(:name)
-          name = name.to_s.downcase.gsub(/[^(a-z0-9)]/, ' ').squeeze(' ').strip.gsub(' ', '_') unless name.blank?
-          subdomain_options.merge! :name_prefix => "#{name}_", :namespace => "#{name}/" unless name.blank?
           with_options(subdomain_options.merge(options), &block)
         end
         alias_method :subdomains, :subdomain

data/lib/subdomain_routes/request.rb

@@ -4,7 +4,6 @@ module SubdomainRoutes
     
     def subdomain
       subdomain_for_host(host)
-      # TODO: catch HostNotSupplied and TooManySubdomains and deal with them somehow!
     end
   end
 end

data/lib/subdomain_routes/routes.rb

@@ -4,46 +4,32 @@ module SubdomainRoutes
       include SplitHost
       
       def self.included(base)
-        [ :extract_request_environment, :add_route, :clear!, :call ].each { |method| base.alias_method_chain method, :subdomains }
+        [ :extract_request_environment, :add_route ].each { |method| base.alias_method_chain method, :subdomains }
       end
       
       def extract_request_environment_with_subdomains(request)
         extract_request_environment_without_subdomains(request).merge(:subdomain => subdomain_for_host(request.host))
       end
-    
+      
       def add_route_with_subdomains(*args)
         options = args.extract_options!
         if subdomains = options.delete(:subdomains)
           options[:conditions] ||= {}
-          options[:conditions][:subdomains] = subdomains
           options[:requirements] ||= {}
+          options[:conditions][:subdomains] = subdomains
           options[:requirements][:subdomains] = subdomains
         end
         with_options(options) { |routes| routes.add_route_without_subdomains(*args) }
       end
       
-      def subdomain_procs
-        @subdomain_procs ||= SubdomainRoutes::ProcSet.new
-      end
-
-      def recognize_subdomain(name, &block)
-        subdomain_procs.add_recognizer(name, &block)
-      end
-      
-      def clear_with_subdomains!
-        subdomain_procs.clear!
-        clear_without_subdomains!
-      end
-      
-      def call_with_subdomains(*args)
-        subdomain_procs.flush! unless SubdomainRoutes::Config.manual_flush
-        call_without_subdomains(*args)
+      def reserved_subdomains
+        routes.map(&:reserved_subdomains).flatten.uniq
       end
     end
   
     module Route
       def self.included(base)
-        base.alias_method_chain :recognition_conditions, :subdomains
+        [ :recognition_conditions, :segment_keys, :recognition_extraction ].each { |method| base.alias_method_chain method, :subdomains }
       end
       
       def recognition_conditions_with_subdomains
@@ -51,13 +37,27 @@ module SubdomainRoutes
         case conditions[:subdomains]
         when Array
           result << "conditions[:subdomains].include?(env[:subdomain])"
-        when Hash
-          if subdomain = conditions[:subdomains][:proc]
-            result << %Q{ActionController::Routing::Routes.subdomain_procs.recognize(#{subdomain.inspect}, env[:subdomain])}
-          end
+        when Symbol
+          result << "(subdomain = env[:subdomain] unless env[:subdomain].blank?)"
         end
         result
       end
+      
+      def segment_keys_with_subdomains
+        result = segment_keys_without_subdomains
+        result.unshift(:subdomain) if conditions[:subdomains].is_a? Symbol
+        result
+      end
+      
+      def recognition_extraction_with_subdomains
+        result = recognition_extraction_without_subdomains
+        result.unshift "\nparams[#{conditions[:subdomains].inspect}] = subdomain\n" if conditions[:subdomains].is_a? Symbol
+        result
+      end
+      
+      def reserved_subdomains
+        conditions[:subdomains].is_a?(Array) ? conditions[:subdomains] : []
+      end
     end
   end
 end

data/lib/subdomain_routes/split_host.rb

@@ -1,8 +1,5 @@
 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

data/lib/subdomain_routes/url_writer.rb

@@ -1,6 +1,5 @@
 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
@@ -13,7 +12,7 @@ module SubdomainRoutes
     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
+        new_subdomain = options.has_key?(:subdomain) ? options[:subdomain].to_param.to_s.downcase : old_subdomain
         begin
           case subdomains
           when Array
@@ -24,11 +23,11 @@ module SubdomainRoutes
                 new_subdomain = subdomains.first
               end
             end
-          when Hash
-            unless subdomain_procs.recognize(subdomains[:proc], new_subdomain) && (new_subdomain.blank? || SubdomainRoutes.valid_subdomain?(new_subdomain))
+          when Symbol
+            unless new_subdomain.blank? || SubdomainRoutes.valid_subdomain?(new_subdomain)
               raise ActionController::RoutingError, "subdomain #{new_subdomain.inspect} is invalid"
-            end
-          end
+            end            
+          end            
         rescue ActionController::RoutingError => e
           raise ActionController::RoutingError, "Route for #{options.inspect} failed to generate (#{e.message})"
         end

data/lib/subdomain_routes/validations.rb

@@ -1,12 +1,15 @@
 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?:
+  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
-  
+  # end
+    
   module Validations
     module ClassMethods
       def validates_subdomain_format_of(*attr_names)
@@ -19,6 +22,17 @@ module SubdomainRoutes
           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

data/lib/subdomain_routes.rb

@@ -5,10 +5,8 @@ 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/recognition_spec.rb

@@ -57,33 +57,24 @@ describe "subdomain route recognition" do
     end
   end
   
-  context "for a :proc subdomain" do
+  context "for a :model 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"
+      map_subdomain(:model => :user) { |user| user.resources :articles }
     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)
+    
+    context "when a nested route is requested" do
+      before(:each) do
+        @request.host = "mholling.example.com"
+        @request.request_uri = "/articles"
+      end
+      
+      it "should match the route if there is a subdomain" do
         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)
+      it "should put the subdomain into the params as :model_id" do
+        recognize_path(@request)[:user_id].should == "mholling"
       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

@@ -29,7 +29,7 @@ describe "resource" do
       end
     end
     
-    it "should include the subdomains in the routing conditions" do
+    it "should include the subdomains in the routing requirements" do
       ActionController::Routing::Routes.routes.each do |route|
         route.requirements[:subdomains].should == [ "admin" ]
       end

data/spec/routes_spec.rb

@@ -45,9 +45,9 @@ describe "subdomain routes" do
   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 } }
+
+  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
@@ -132,117 +132,40 @@ describe "subdomain routes" do
       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
+        
+  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 add the specified subdomain to the route recognition conditions" do
-      ActionController::Routing::Routes.routes.each do |route|
-        route.conditions[:subdomains].should == [ "admin" ]
-      end
+    it "should singularize a plural model name" do
+      map_subdomain(:model => :cities) { |city| city.options[:subdomains].should == :city_id }
     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/" }
+    
+    it "should accept a string model name" do
+      map_subdomain(:model => "city") { |city| city.options[:subdomains].should == :city_id }
     end
-
-    it "should prefix the value to named routes" do
-      map_subdomain(:proc => :city) { |city| city.options[:name_prefix].should == "city_" }
+    
+    it "should set the model name as a namespace" do
+      map_subdomain(:model => :city) { |city| city.options[:namespace].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
+    it "should prefix the model name to named routes" do
+      map_subdomain(:model => :city) { |city| city.options[:name_prefix].should == "city_" }
     end
   end
 end
 
 describe "ActionController::Routing::Routes" do
   before(:each) do
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
     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
+    map_subdomain(:www, nil) { |www| www.root :controller => "homes", :action => "show" }
   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
+  it "should know a list of its reserved subdomains" do
+    ActionController::Routing::Routes.reserved_subdomains.should == [ "www", "" ]
+    ActionController::Routing::Routes.clear!
+    ActionController::Routing::Routes.reserved_subdomains.should be_empty
   end
 end

data/spec/url_writing_spec.rb

@@ -123,54 +123,44 @@ describe "URL writing" do
       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          
+
+  context "when a :model subdomain is specified" do          
     before(:each) do
-      map_subdomain(:proc => :city) { |city| city.resources :events }
+      map_subdomain(:model => :city) { |city| city.resources :events }
+      class City < ActiveRecord::Base; end
+      @boston = City.new
+      @boston.stub!(:new_record?).and_return(false)
+      @boston.stub!(:to_param).and_return("boston")
     end
-    
-    it "should raise a routing error without a recognize proc" do
+
+    it "should not change the host if the object has the same to_param as the current subdomain" 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)
+         city_events_url(@boston).should == "http://boston.example.com/events"
+        city_events_path(@boston).should == "/events"
       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
+  
+    it "should force the host if the object has a different to_param from the current subdomain" do
+      with_host "example.com" do
+         city_events_url(@boston).should == "http://boston.example.com/events"
+        city_events_path(@boston).should == "http://boston.example.com/events"
       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 an error if the object to_param is an invalid subdomain" do
+      @newyork = City.new
+      @newyork.stub!(:new_record?).and_return(false)
+      @newyork.stub!(:to_param).and_return("new york")
+      with_host "www.example.com" do
+        lambda {  city_events_url(@newyork) }.should raise_error(ActionController::RoutingError)
+        lambda { city_events_path(@newyork) }.should raise_error(ActionController::RoutingError)
       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
+      
+    it "should not allow the subdomain to be manually overridden" do
+      with_host "www.example.com" do
+         city_events_url(@boston, :subdomain => :canberra).should == "http://boston.example.com/events"
+        city_events_path(@boston, :subdomain => :canberra).should == "http://boston.example.com/events"
       end
     end
   end

data/spec/validations_spec.rb

@@ -1,12 +1,29 @@
 describe "ActiveRecord::Base" do
-  it "should have validates_subdomain_format_of which runs SubdomainRoutes.valid_subdomain? against the attributes" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+    SubdomainRoutes::Config.stub!(:domain_length).and_return(2)
     class User < ActiveRecord::Base
       attr_accessor :subdomain
-      User.validates_subdomain_format_of :subdomain
     end
+  end
+
+  it "should have validates_subdomain_format_of which runs SubdomainRoutes.valid_subdomain? against the attributes" do
+    User.validates_subdomain_format_of :subdomain
     SubdomainRoutes.should_receive(:valid_subdomain?).with("mholling").and_return(true)
-    User.new(:subdomain => "mholling").valid?.should be_true
+    User.new(:subdomain => "mholling").should be_valid
     SubdomainRoutes.should_receive(:valid_subdomain?).with("mholling").and_return(nil)
-    User.new(:subdomain => "mholling").valid?.should be_false
+    User.new(:subdomain => "mholling").should_not be_valid
+  end
+  
+  it "should have validates_subdomain_not_reserved which checks the attributes against the fixed-subdomain routes" do
+    User.validates_subdomain_not_reserved :subdomain
+    reserved = [ "", "www", "support", "admin" ]
+    map_subdomain(*reserved) { |map| map.resource :home }
+    reserved.each do |subdomain|
+      User.new(:subdomain => subdomain).should_not be_valid
+    end
+    [ "mholling", "edmondst" ].each do |subdomain|
+      User.new(:subdomain => subdomain).should be_valid
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mholling-subdomain_routes
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Matthew Hollingworth
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-30 00:00:00 -07:00
+date: 2009-06-02 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,9 +38,7 @@ files:
 - 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
@@ -48,8 +46,6 @@ files:
 - 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
@@ -84,8 +80,6 @@ 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

data/lib/subdomain_routes/mailer.rb

@@ -1,17 +0,0 @@
-module SubdomainRoutes
-  module MailerMethods
-    def self.included(base)
-      base.alias_method_chain :create!, :subdomains
-    end
-    
-    def create_with_subdomains!(*args)
-      ActionController::Routing::Routes.subdomain_procs.flush! unless SubdomainRoutes::Config.manual_flush
-      create_without_subdomains!(*args)
-    end
-  end
-end
-
-if defined? ActionMailer::Base
-  ActionMailer::Base.send :include, SubdomainRoutes::MailerMethods
-end
-

data/lib/subdomain_routes/proc_set.rb

@@ -1,33 +0,0 @@
-module SubdomainRoutes
-  class ProcSet
-    extend ActiveSupport::Memoizable
-    
-    def initialize
-      clear!
-    end
-    
-    def add_recognizer(name, &block)
-      @recognizers[name] = block
-    end
-
-    def recognizes?(name)
-      @recognizers.has_key?(name)
-    end
-
-    def recognize(name, subdomain)
-      @recognizers[name].call(subdomain) if recognizes?(name)
-    end
-    
-    memoize :recognize
-    private :flush_cache
-    
-    def flush!
-      flush_cache :recognize
-    end
-    
-    def clear!
-      @recognizers = {}
-      flush!
-    end
-  end
-end

data/spec/mailer_spec.rb

@@ -1,15 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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