gameplan-subdomain-fu 0.5.4

data/CHANGELOG

@@ -0,0 +1,20 @@
+== 2009-09-13
+
+* Added current_domain method
+* Added controller & view usage to readme
+* Added more tests
+* Fixing load paths
+
+== 2009-08-26
+
+* Fixed needs_rewrite? method
+* Added is_mirror? method
+* Added tests, and fixed failing tests
+
+== 2009-08-24
+
+* Merged forks that added lots of features, tests, and fixes
+
+== 2008-06-25
+
+* Removed stray puts

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Michael Bleigh (http://www.mbleigh.com) and 
+                   Intridea, Inc (http://www.intridea.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,110 @@
+= SubdomainFu
+
+SubdomainFu provides a modern implementation of subdomain handling in Rails.
+It takes aspects from account_location, request_routing, and other snippets
+found around the web and combines them to provide a single, simple solution
+for subdomain-based route and url management.
+
+== Installation
+
+SubdomainFu is available both as a traditional plugin and a GemPlugin. To
+install it as a traditional plugin (Rails 2.1 or later):
+
+  script/plugin install git://github.com/mbleigh/subdomain-fu.git
+  
+To use it as a gem, add it to your config/environment.rb:
+
+  config.gem 'subdomain-fu'
+
+
+== Examples
+
+SubdomainFu works inside of Rails's URL Writing mechanisms to provide an easy and seamless
+way to link and otherwise understand cross-subdomain routing. You can use the :subdomain
+option both in named and non-named routes as well as in generated resources routes.
+
+Let's say my domain is 'intridea.com'. Here are some examples of the use of the :subdomain
+option:
+
+  url_for(:controller => "my_controller", 
+          :action => "my_action", 
+          :subdomain => "awesome") # => http://awesome.intridea.com/my_controller/my_action
+
+Now let's say I'm at http://awesome.intridea.com/ and I want back to the root.
+Specifying "false" will remove any current subdomain:
+
+  users_url(:subdomain => false)  # => http://intridea.com/users
+
+Note that this plugin does not honor the :only_path notion of routing when doing
+so would go against the intent of the command. For example, if I were at http://intridea.com
+again:
+
+  users_path(:subdomain => "fun") # => http://fun.intridea.com/users
+  users_path(:subdomain => false) # => /users
+                              
+In this way you can rest assured that you will never misdirect your links to the
+same subdomain when you meant to change it.
+
+== Use in controllers and views
+
+You have access to current_subdomain and current_domain methods.
+
+[current_subdomain] returns all subdomains. For the URL http://awesome.website.stuff.example.com, it will return "awesome.website.stuff"
+
+[current_domain] returns all subdomains except for the subdomain, including the TLD. For the URL http://awesome.website.stuff.example.com, it will return "website.stuff.example.com"
+
+If what you really want is the entire domain, then use <tt>request.domain</tt> in
+your controllers.  The purpose of current_domain is to only strip off the first 
+subdomain, if any, and return what's left.
+
+== Configuration
+
+You may need to configure SubdomainFu based on your development setup. The
+configuration required is:
+
+=== TLD Size
+
+A hash for each environment of the size of the top-level domain name. 
+(something.com = 1, localhost = 0, etc.)
+
+  SubdomainFu.tld_size = 1 # sets for current environment
+  SubdomainFu.tld_sizes = {:development => 0,
+                           :test => 0,
+                           :production => 1} # set all at once (also the defaults)
+                         
+=== Mirrors
+
+Mirrors are the subdomains that are equivalent to no subdomain (i.e. they 'mirror')
+the usage of the root domain.
+
+  SubdomainFu.mirrors = %w(www site we) # Defaults to %w(www)
+
+=== Preferred Mirror
+
+SubdomainFu also understands the notion of a 'preferred mirror', that is, if you
+always want your links going to 'www.yourdomain.com' instead of 'yourdomain.com',
+you can set the preferred mirror like so:
+
+  SubdomainFu.preferred_mirror = "www"
+
+Now when you create a link with <tt>:subdomain => false</tt> in the options the subdomain
+will default to the preferred mirror.
+
+== Routing
+
+SubdomainFu can also work within Rails' routing for subdomain-specific routes. For instance, if you only wanted your administrative tools available in the "admin" subdomain you could add this to your <tt>config/routes.rb</tt> file:
+
+  map.with_options :conditions => {:subdomain => 'admin'} do |admin|
+    admin.resources :posts
+    admin.resources :users
+  end
+    
+In addition to specifying a string, you could also specify <tt>false</tt> to require no subdomain (this includes mirrors that you've set up such as www) or a regular expression to match a range of subdomains.
+
+== Resources
+
+* GitHub Repository: http://github.com/mbleigh/subdomain-fu
+* RDocs: http://rdoc.info/projects/mbleigh/subdomain-fu
+
+Copyright (c) 2008 Michael Bleigh (http://www.mbleigh.com/) and 
+Intridea, Inc. (http://www.intridea.com/). Released under the MIT license

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "subdomain-fu"
+    gemspec.rubyforge_project = 'subdomain-fu'
+    gemspec.summary = "SubdomainFu is a Rails plugin that provides subdomain routing and URL writing helpers."
+    gemspec.email = "michael@intridea.com"
+    gemspec.homepage = "http://github.com/mbleigh/subdomain-fu"
+    gemspec.files =  FileList["[A-Z]*", "{lib,spec,rails}/**/*"] - FileList["**/*.log"]
+    gemspec.description = "SubdomainFu is a Rails plugin to provide all of the basic functionality necessary to handle multiple subdomain applications (such as Basecamp-esque subdomain accounts and more)."
+    gemspec.authors = ["Michael Bleigh"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+
+# These are new tasks
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/the-perfect-gem/"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 0
+:build: 
+:minor: 5
+:patch: 4

data/lib/subdomain-fu.rb

@@ -0,0 +1,163 @@
+require 'subdomain_fu/routing_extensions'
+require 'subdomain_fu/url_rewriter'
+
+module SubdomainFu
+  # The length of the period-split top-level domain for each environment.
+  # For example, "localhost" has a tld_size of zero, and "something.co.uk"
+  # has a tld_size of two.
+  #
+  # To set a tld size for a given environment, just call SubdomainFu.tld_sizes[:environment] = value
+  DEFAULT_TLD_SIZES = {:development => 0, :test => 0, :production => 1}
+  mattr_accessor :tld_sizes
+  @@tld_sizes = DEFAULT_TLD_SIZES.dup
+
+  # Subdomains that are equivalent to going to the website with no subdomain at all.
+  # Defaults to "www" as the only member.
+  DEFAULT_MIRRORS = %w(www)
+  mattr_accessor :mirrors
+  @@mirrors = DEFAULT_MIRRORS.dup
+
+  mattr_accessor :preferred_mirror
+  @@preferred_mirror = nil
+
+  mattr_accessor :override_only_path
+  @@override_only_path = false
+
+  # Returns the TLD Size of the current environment.
+  def self.tld_size
+    tld_sizes[RAILS_ENV.to_sym]
+  end
+
+  # Sets the TLD Size of the current environment
+  def self.tld_size=(value)
+    tld_sizes[RAILS_ENV.to_sym] = value
+  end
+
+  # Is the current subdomain either nil or not a mirror?
+  def self.has_subdomain?(subdomain)
+    subdomain != false && !subdomain.blank? && !SubdomainFu.mirrors.include?(subdomain)
+  end
+
+  def self.is_mirror?(subdomain)
+    subdomain != false && !subdomain.blank? && SubdomainFu.mirrors.include?(subdomain)
+  end
+
+  # Is the subdomain a preferred mirror
+  def self.preferred_mirror?(subdomain)
+    subdomain == SubdomainFu.preferred_mirror || SubdomainFu.preferred_mirror.nil?
+  end
+
+  # Gets the subdomain from the host based on the TLD size
+  def self.subdomain_from(host)
+    return nil if host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host)
+    parts = host.split('.')
+    sub = parts[0..-(SubdomainFu.tld_size+2)].join(".")
+    sub.blank? ? nil : sub
+  end
+
+  # Gets only non-mirror subdomains from the host based on the TLD size
+  def self.non_mirror_subdomain_from(host)
+    sub = subdomain_from(host)
+    has_subdomain?(sub) ? sub : nil
+  end
+
+  def self.host_without_subdomain(host)
+    parts = host.split('.')
+    parts[-(SubdomainFu.tld_size+1)..-1].join(".")
+  end
+
+  # Rewrites the subdomain of the host unless they are equivalent (i.e. mirrors of each other)
+  def self.rewrite_host_for_subdomains(subdomain, host)
+    if needs_rewrite?(subdomain, host)
+      change_subdomain_of_host(subdomain || SubdomainFu.preferred_mirror, host)
+    else
+      if has_subdomain?(subdomain) || preferred_mirror?(subdomain_from(host)) ||
+          (subdomain.nil? && has_subdomain?(subdomain_from(host)))
+        host
+      else
+        change_subdomain_of_host(SubdomainFu.preferred_mirror, host)
+      end
+    end
+  end
+
+  # Changes the subdomain of the host to whatever is passed in.
+  def self.change_subdomain_of_host(subdomain, host)
+    subdomain_string = (subdomain && subdomain.respond_to?(:to_param)) ? subdomain.to_param : subdomain
+
+    host = SubdomainFu.host_without_subdomain(host)
+    host = "#{subdomain_string}.#{host}" if subdomain_string
+    host
+  end
+
+  # Is this subdomain equivalent to the subdomain found in this host string?
+  def self.same_subdomain?(subdomain, host)
+    subdomain = nil unless subdomain
+    (subdomain == subdomain_from(host)) ||
+      (!has_subdomain?(subdomain) && !has_subdomain?(subdomain_from(host)))
+  end
+
+  def self.override_only_path?
+    self.override_only_path
+  end
+
+  def self.needs_rewrite?(subdomain, host)
+    case subdomain
+      when nil
+        #rewrite when there is a preferred mirror set and there is no subdomain on the host
+        return true if self.preferred_mirror && subdomain_from(host).nil?
+        return false
+      when false
+        h = subdomain_from(host)
+        #if the host has a subdomain
+        if !h.nil?
+          #rewrite when there is a subdomain in the host, and it is not a preferred mirror
+          return true if !preferred_mirror?(h)
+          #rewrite when there is a preferred mirror set and the subdomain of the host is not a mirror
+          return true if self.preferred_mirror && !is_mirror?(h)
+          #no rewrite if host already has mirror subdomain
+          #it { SubdomainFu.needs_rewrite?(false,"www.localhost").should be_false }
+          return false if is_mirror?(h)
+        end
+        return self.crazy_rewrite_rule(subdomain, host)
+      else
+        return self.crazy_rewrite_rule(subdomain, host)
+    end
+  end
+
+  #This is a black box of crazy!  So I split some of the simpler logic out into the case statement above to make my brain happy!
+  def self.crazy_rewrite_rule(subdomain, host)
+    (!has_subdomain?(subdomain) && preferred_mirror?(subdomain) && !preferred_mirror?(subdomain_from(host))) ||
+      !same_subdomain?(subdomain, host)
+  end
+
+  def self.current_subdomain(request)
+    subdomain = request.subdomains(SubdomainFu.tld_size).join(".")
+    if has_subdomain?(subdomain)
+      subdomain
+    else
+      nil
+    end
+  end
+
+  #Enables subdomain-fu to more completely replace DHH's account_location plugin
+  def self.current_domain(request)
+    domain = ""
+    domain << request.subdomains[1..-1].join(".") + "." if request.subdomains.length > 1
+    domain << request.domain + request.port_string
+  end
+
+  module Controller
+    def self.included(controller)
+      controller.helper_method(:current_subdomain)
+      controller.helper_method(:current_domain)
+    end
+
+    protected
+    def current_subdomain
+      SubdomainFu.current_subdomain(request)
+    end
+    def current_domain
+      SubdomainFu.current_domain(request)
+    end
+  end
+end

data/lib/subdomain_fu/routing_extensions.rb

@@ -0,0 +1,61 @@
+# Thanks to Jamis Buck for ideas on this stuff
+# http://weblog.jamisbuck.org/2006/10/26/monkey-patching-rails-extending-routes-2
+# This is not yet a working part of SubdomainFu.
+
+module SubdomainFu
+  module RouteExtensions
+    def self.included(base)
+      base.alias_method_chain :recognition_conditions, :subdomain
+    end
+
+    def recognition_conditions_with_subdomain
+      result = recognition_conditions_without_subdomain
+      result << "conditions[:subdomain] === env[:subdomain]" if conditions[:subdomain] && conditions[:subdomain] != true && conditions[:subdomain] != false
+      result << "SubdomainFu.has_subdomain?(env[:subdomain])" if conditions[:subdomain] == true
+      result << "!SubdomainFu.has_subdomain?(env[:subdomain])" if conditions[:subdomain] == false
+      result
+    end
+  end
+
+  module RouteSetExtensions
+    def self.included(base)
+      base.alias_method_chain :extract_request_environment, :subdomain
+    end
+
+    def extract_request_environment_with_subdomain(request)
+      env = extract_request_environment_without_subdomain(request)
+      env.merge(:host => request.host, :domain => request.domain, :subdomain => SubdomainFu.current_subdomain(request))
+    end
+  end
+
+  module MapperExtensions
+    def quick_map(has_unless, *args, &block)
+      options = args.find{|a| a.is_a?(Hash)}
+      namespace_str = options ? options.delete(:namespace).to_s : args.join('_or_')
+      namespace_str += '_' unless namespace_str.blank?
+      mapped_exp = args.map(&:to_s).join('|')
+      conditions_hash = { :subdomain => ( has_unless ? /[^(#{mapped_exp})]/ : /(#{mapped_exp})/) }
+      with_options(:conditions => conditions_hash, :name_prefix => namespace_str, &block)
+    end
+    # Adds methods to Mapper to apply an options with a method. Example
+    #   map.subdomain :blog { |blog| blog.resources :pages }
+    # or
+    #   map.unless_subdomain :blog { |not_blog| not_blog.resources :people }
+    def subdomain(*args, &block)
+      quick_map(false, *args, &block)
+    end
+    def unless_subdomain(*args, &block)
+      quick_map(true, *args, &block)
+    end
+  end
+end
+
+ActionController::Routing::RouteSet::Mapper.send :include, SubdomainFu::MapperExtensions
+ActionController::Routing::RouteSet.send :include, SubdomainFu::RouteSetExtensions
+ActionController::Routing::Route.send :include, SubdomainFu::RouteExtensions
+
+# UrlRewriter::RESERVED_OPTIONS is only available in Rails >= 2.2
+# http://www.portallabs.com/blog/2008/12/02/fixing-subdomain_fu-with-named-routes-rails-22/
+if Rails::VERSION::MAJOR >= 2 and Rails::VERSION::MINOR >= 2
+  ActionController::UrlRewriter::RESERVED_OPTIONS << :subdomain
+end

data/lib/subdomain_fu/url_rewriter.rb

@@ -0,0 +1,48 @@
+module ActionController
+  module UrlWriter
+    def url_for_with_subdomains(options)
+      if SubdomainFu.needs_rewrite?(options[:subdomain], options[:host] || default_url_options[:host]) || options[:only_path] == false
+        options[:only_path] = false if SubdomainFu.override_only_path?
+        options[:host] = SubdomainFu.rewrite_host_for_subdomains(options.delete(:subdomain), options[:host] || default_url_options[:host])
+      else
+        options.delete(:subdomain)
+      end
+      url_for_without_subdomains(options)
+    end
+    alias_method_chain :url_for, :subdomains
+  end
+
+  class UrlRewriter #:nodoc:
+    private
+
+    def rewrite_url_with_subdomains(options)
+      if SubdomainFu.needs_rewrite?(options[:subdomain], (options[:host] || @request.host_with_port)) || options[:only_path] == false
+        options[:only_path] = false if SubdomainFu.override_only_path?
+        options[:host] = SubdomainFu.rewrite_host_for_subdomains(options.delete(:subdomain), options[:host] || @request.host_with_port)
+        # puts "options[:host]: #{options[:host].inspect}"
+      else
+        options.delete(:subdomain)
+      end
+      rewrite_url_without_subdomains(options)
+    end
+    alias_method_chain :rewrite_url, :subdomains
+  end
+
+  if Rails::VERSION::MAJOR >= 2 and Rails::VERSION::MINOR <= 1
+    # hack for http://www.portallabs.com/blog/2008/10/22/fixing-subdomain_fu-with-named-routes/
+    module Routing
+      module Optimisation
+        class PositionalArgumentsWithAdditionalParams
+          def guard_condition_with_subdomains
+            # don't allow optimisation if a subdomain is present - fixes a problem
+            # with the subdomain appearing in the query instead of being rewritten
+            # see http://mbleigh.lighthouseapp.com/projects/13148/tickets/8-improper-generated-urls-with-named-routes-for-a-singular-resource
+            guard_condition_without_subdomains + " && !args.last.has_key?(:subdomain)"
+          end
+
+          alias_method_chain :guard_condition, :subdomains
+        end
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,6 @@
+#Allow whatever Ruby Package tool is being used ot manage load paths.  gem auto adds the gem's lib dir to load path.
+require 'subdomain-fu' unless defined?(SubdomainFu)
+
+ActionController::Base.send :include, SubdomainFu::Controller
+
+RAILS_DEFAULT_LOGGER.info("** SubdomainFu: initialized properly")

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+begin
+  require File.dirname(__FILE__) + '/../../../../spec/spec_helper'
+rescue LoadError
+  puts "You need to install rspec in your base app"
+  exit
+end
+
+plugin_spec_dir = File.dirname(__FILE__)
+ActiveRecord::Base.logger = Logger.new(plugin_spec_dir + "/debug.log")
+
+ActionController::Routing::Routes.draw do |map|
+  map.needs_subdomain '/needs_subdomain', :controller => "fu", :action => "awesome"
+  map.no_subdomain '/no_subdomain', :controller => "fu", :action => "lame"
+  map.needs_awesome '/needs_awesome', :controller => "fu", :action => "lame"
+
+  map.resources :foos do |fu|
+    fu.resources :bars
+  end
+
+  map.connect '/', :controller => "site", :action => "home", :conditions => {:subdomain => false}
+  map.connect '/', :controller => "app", :action => "home", :conditions => {:subdomain => true}
+  map.connect '/', :controller => "mobile", :action => "home", :conditions => {:subdomain => "m"}
+
+  map.connect '/subdomain_here', :controller => "app", :action => "success", :conditions => {:subdomain => true}
+  map.connect '/no_subdomain_here', :controller => "site", :action => "success", :conditions => {:subdomain => false}
+  map.connect '/m_subdomain_here', :controller => "mobile", :action => "success", :conditions => {:subdomain => "m"}
+  map.connect '/numbers_only_here', :controller => "numbers", :action => "success", :conditions => {:subdomain => /[0-9]+/}
+
+  map.connect '/:controller/:action/:id'
+end
+
+class Paramed
+  def initialize(param)
+    @param = param
+  end
+
+  def to_param
+    @param || "param"
+  end
+end
+
+include ActionController::UrlWriter

data/spec/subdomain_fu_spec.rb

@@ -0,0 +1,251 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SubdomainFu" do
+  before do
+    SubdomainFu.tld_sizes = SubdomainFu::DEFAULT_TLD_SIZES.dup
+    SubdomainFu.mirrors = SubdomainFu::DEFAULT_MIRRORS.dup
+    SubdomainFu.preferred_mirror = nil
+  end
+
+  describe "TLD Sizes" do
+    before do
+      SubdomainFu.tld_sizes = SubdomainFu::DEFAULT_TLD_SIZES.dup
+    end
+
+    it { SubdomainFu.tld_sizes.should be_kind_of(Hash) }
+
+    it "should have default values for development, test, and production" do
+      SubdomainFu.tld_sizes[:development].should == 0
+      SubdomainFu.tld_sizes[:test].should        == 0
+      SubdomainFu.tld_sizes[:production].should  == 1
+    end
+
+    it "#tld_size should be for the current environment" do
+      SubdomainFu.tld_size.should == SubdomainFu.tld_sizes[RAILS_ENV.to_sym]
+    end
+
+    it "should be able to be set for the current environment" do
+      SubdomainFu.tld_size = 5
+      SubdomainFu.tld_size.should == 5
+      SubdomainFu.tld_sizes[:test].should == 5
+    end
+  end
+
+  describe "#has_subdomain?" do
+    it "should be true for non-mirrored subdomains" do
+      SubdomainFu.has_subdomain?("awesome").should be_true
+    end
+
+    it "should be false for mirrored subdomains" do
+      SubdomainFu.has_subdomain?(SubdomainFu.mirrors.first).should be_false
+    end
+
+    it "shoud be false for a nil or blank subdomain" do
+      SubdomainFu.has_subdomain?("").should be_false
+      SubdomainFu.has_subdomain?(nil).should be_false
+      SubdomainFu.has_subdomain?(false).should be_false
+    end
+  end
+
+  describe "#subdomain_from" do
+    it "should return the subdomain based on the TLD of the current environment" do
+      SubdomainFu.subdomain_from("awesome.localhost").should == "awesome"
+      SubdomainFu.tld_size = 2
+      SubdomainFu.subdomain_from("awesome.localhost.co.uk").should == "awesome"
+      SubdomainFu.tld_size = 1
+      SubdomainFu.subdomain_from("awesome.localhost.com").should == "awesome"
+      SubdomainFu.tld_size = 0
+    end
+
+    it "should join deep subdomains with a period" do
+      SubdomainFu.subdomain_from("awesome.coolguy.localhost").should == "awesome.coolguy"
+    end
+
+    it "should return nil for no subdomain" do
+      SubdomainFu.subdomain_from("localhost").should be_nil
+    end
+  end
+
+  it "#host_without_subdomain should chop of the subdomain and return the rest" do
+    SubdomainFu.host_without_subdomain("awesome.localhost:3000").should == "localhost:3000"
+    SubdomainFu.host_without_subdomain("something.awful.localhost:3000").should == "localhost:3000"
+  end
+
+  describe "#preferred_mirror?" do
+    describe "when preferred_mirror is false" do
+      before do
+        SubdomainFu.preferred_mirror = false
+      end
+
+      it "should return true for false" do
+        SubdomainFu.preferred_mirror?(false).should be_true
+      end
+    end
+  end
+
+  describe "#rewrite_host_for_subdomains" do
+    it "should not change the same subdomain" do
+      SubdomainFu.rewrite_host_for_subdomains("awesome","awesome.localhost").should == "awesome.localhost"
+    end
+
+    it "should not change an equivalent (mirrored) subdomain" do
+      SubdomainFu.rewrite_host_for_subdomains("www","localhost").should == "localhost"
+    end
+
+    it "should change the subdomain if it's different" do
+      SubdomainFu.rewrite_host_for_subdomains("cool","www.localhost").should == "cool.localhost"
+    end
+
+    it "should remove the subdomain if passed false when it's not a mirror" do
+      SubdomainFu.rewrite_host_for_subdomains(false,"cool.localhost").should == "localhost"
+    end
+
+    it "should not remove the subdomain if passed false when it is a mirror" do
+      SubdomainFu.rewrite_host_for_subdomains(false,"www.localhost").should == "www.localhost"
+    end
+
+    it "should not remove the subdomain if passed nil when it's not a mirror" do
+      SubdomainFu.rewrite_host_for_subdomains(nil,"cool.localhost").should == "cool.localhost"
+    end
+
+    describe "when preferred_mirror is false" do
+      before do
+        SubdomainFu.preferred_mirror = false
+      end
+
+      it "should remove the subdomain if passed false when it is a mirror" do
+        SubdomainFu.rewrite_host_for_subdomains(false,"www.localhost").should == "localhost"
+      end
+
+      it "should not remove the subdomain if passed nil when it's not a mirror" do
+        SubdomainFu.rewrite_host_for_subdomains(nil,"cool.localhost").should == "cool.localhost"
+      end
+    end
+  end
+
+  describe "#change_subdomain_of_host" do
+    it "should change it if passed a different one" do
+      SubdomainFu.change_subdomain_of_host("awesome","cool.localhost").should == "awesome.localhost"
+    end
+
+    it "should remove it if passed nil" do
+      SubdomainFu.change_subdomain_of_host(nil,"cool.localhost").should == "localhost"
+    end
+
+    it "should add it if there isn't one" do
+      SubdomainFu.change_subdomain_of_host("awesome","localhost").should == "awesome.localhost"
+    end
+    
+    it "should use to_param on the object passed to subdomain if it respond to it" do
+      @some_other_object = Paramed.new("p_is_awesome")
+      
+      SubdomainFu.change_subdomain_of_host(@some_other_object,"localhost").should == "p_is_awesome.localhost"
+    end
+    
+  end
+
+  describe "#current_subdomain" do
+    it "should return the current subdomain if there is one" do
+      request = mock("request", :subdomains => ["awesome"])
+      SubdomainFu.current_subdomain(request).should == "awesome"
+    end
+
+    it "should return nil if there's no subdomain" do
+      request = mock("request", :subdomains => [])
+      SubdomainFu.current_subdomain(request).should be_nil
+    end
+
+    it "should return nil if the current subdomain is a mirror" do
+      request = mock("request", :subdomains => ["www"])
+      SubdomainFu.current_subdomain(request).should be_nil
+    end
+
+    it "should return the whole thing (including a .) if there's multiple subdomains" do
+      request = mock("request", :subdomains => ["awesome","rad"])
+      SubdomainFu.current_subdomain(request).should == "awesome.rad"
+    end
+  end
+
+  describe "#current_domain" do
+    it "should return the current domain if there is one" do
+      request = mock("request", :subdomains => [], :domain => "example.com", :port_string => "")
+      SubdomainFu.current_domain(request).should == "example.com"
+    end
+
+    it "should return empty string if there is no domain" do
+      request = mock("request", :subdomains => [], :domain => "", :port_string => "")
+      SubdomainFu.current_domain(request).should == ""
+    end
+
+    it "should return the current domain if there is only one level of subdomains" do
+      request = mock("request", :subdomains => ["www"], :domain => "example.com", :port_string => "")
+      SubdomainFu.current_domain(request).should == "example.com"
+    end
+
+    it "should return everything but the first level of subdomain when there are multiple levels of subdomains" do
+      request = mock("request", :subdomains => ["awesome","rad","cheese","chevy","ford"], :domain => "example.com", :port_string => "")
+      SubdomainFu.current_domain(request).should == "rad.cheese.chevy.ford.example.com"
+    end
+
+    it "should return the domain with port if port is given" do
+      request = mock("request", :subdomains => ["awesome","rad","cheese","chevy","ford"], :domain => "example.com", :port_string => ":3000")
+      SubdomainFu.current_domain(request).should == "rad.cheese.chevy.ford.example.com:3000"
+    end
+  end
+
+  describe "#same_subdomain?" do
+    it { SubdomainFu.same_subdomain?("www","www.localhost").should be_true }
+    it { SubdomainFu.same_subdomain?("www","localhost").should be_true }
+    it { SubdomainFu.same_subdomain?("awesome","www.localhost").should be_false }
+    it { SubdomainFu.same_subdomain?("cool","awesome.localhost").should be_false }
+    it { SubdomainFu.same_subdomain?(nil,"www.localhost").should be_true }
+    it { SubdomainFu.same_subdomain?("www","awesome.localhost").should be_false }
+  end
+
+  describe "#needs_rewrite?" do
+    it { SubdomainFu.needs_rewrite?("www","www.localhost").should be_false }
+    it { SubdomainFu.needs_rewrite?("www","localhost").should be_false }
+    it { SubdomainFu.needs_rewrite?("awesome","www.localhost").should be_true }
+    it { SubdomainFu.needs_rewrite?("cool","awesome.localhost").should be_true }
+    it { SubdomainFu.needs_rewrite?(nil,"www.localhost").should be_false }
+    it { SubdomainFu.needs_rewrite?(nil,"awesome.localhost").should be_false }
+    it { SubdomainFu.needs_rewrite?(false,"awesome.localhost").should be_true }
+    it { SubdomainFu.needs_rewrite?(false,"www.localhost").should be_false }
+    it { SubdomainFu.needs_rewrite?("www","awesome.localhost").should be_true }
+
+    describe "when preferred_mirror is false" do
+      before do
+        SubdomainFu.preferred_mirror = false
+      end
+
+      it { SubdomainFu.needs_rewrite?("www","www.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?("www","localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?("awesome","www.localhost").should be_true }
+      it { SubdomainFu.needs_rewrite?("cool","awesome.localhost").should be_true }
+      it { SubdomainFu.needs_rewrite?(nil,"www.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?(nil,"awesome.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?(false,"awesome.localhost").should be_true }
+      #Only one different from default set of tests
+      it { SubdomainFu.needs_rewrite?(false,"www.localhost").should be_true }
+      it { SubdomainFu.needs_rewrite?("www","awesome.localhost").should be_true }
+    end
+
+    describe "when preferred_mirror is string" do
+      before do
+        SubdomainFu.preferred_mirror = "www"
+      end
+
+      it { SubdomainFu.needs_rewrite?("www","www.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?("awesome","www.localhost").should be_true }
+      # Following is different from default set of tests
+      it { SubdomainFu.needs_rewrite?("www","localhost").should be_true }
+      it { SubdomainFu.needs_rewrite?("cool","awesome.localhost").should be_true }
+      it { SubdomainFu.needs_rewrite?(nil,"www.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?(nil,"awesome.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?(false,"awesome.localhost").should be_true }
+      it { SubdomainFu.needs_rewrite?(false,"www.localhost").should be_false }
+      it { SubdomainFu.needs_rewrite?("www","awesome.localhost").should be_true }
+    end
+
+  end
+end

data/spec/url_rewriter_spec.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SubdomainFu URL Writing" do
+  before do
+    SubdomainFu.tld_size = 1
+    SubdomainFu.mirrors = SubdomainFu::DEFAULT_MIRRORS.dup
+    SubdomainFu.override_only_path = true
+    SubdomainFu.preferred_mirror = nil
+    default_url_options[:host] = "example.com"
+  end
+
+  describe "#url_for" do
+    it "should be able to add a subdomain" do
+      url_for(:controller => "something", :action => "other", :subdomain => "awesome").should == "http://awesome.example.com/something/other"
+    end
+
+    it "should be able to remove a subdomain" do
+      url_for(:controller => "something", :action => "other", :subdomain => false, :host => "awesome.example.com").should == "http://example.com/something/other"
+    end
+
+    it "should not change a mirrored subdomain" do
+      url_for(:controller => "something", :action => "other", :subdomain => false, :host => "www.example.com").should == "http://www.example.com/something/other"
+    end
+
+    it "should should not force the full url with :only_path if override_only_path is false (default)" do
+      SubdomainFu.override_only_path = false
+      url_for(:controller => "something", :action => "other", :subdomain => "awesome", :only_path => true).should == "/something/other"
+    end
+
+    it "should should force the full url, even with :only_path if override_only_path is true" do
+      SubdomainFu.override_only_path = true
+      url_for(:controller => "something", :action => "other", :subdomain => "awesome", :only_path => true).should == "http://awesome.example.com/something/other"
+    end
+  end
+
+  describe "Standard Routes" do
+    it "should be able to add a subdomain" do
+      needs_subdomain_url(:subdomain => "awesome").should == "http://awesome.example.com/needs_subdomain"
+    end
+
+    it "should be able to remove a subdomain" do
+      default_url_options[:host] = "awesome.example.com"
+      needs_subdomain_url(:subdomain => false).should == "http://example.com/needs_subdomain"
+    end
+
+    it "should not change a mirrored subdomain" do
+      default_url_options[:host] = "www.example.com"
+      needs_subdomain_url(:subdomain => false).should == "http://www.example.com/needs_subdomain"
+    end
+
+    it "should should force the full url, even with _path" do
+      needs_subdomain_path(:subdomain => "awesome").should == needs_subdomain_url(:subdomain => "awesome")
+    end
+
+    it "should not force the full url if it's the same as the current subdomain" do
+      default_url_options[:host] = "awesome.example.com"
+      needs_subdomain_path(:subdomain => "awesome").should == "/needs_subdomain"
+    end
+
+    it "should force the full url if it's a different subdomain" do
+      default_url_options[:host] = "awesome.example.com"
+      needs_subdomain_path(:subdomain => "crazy").should == "http://crazy.example.com/needs_subdomain"
+    end
+
+    it "should not force the full url if the current subdomain is nil and so is the target" do
+      needs_subdomain_path(:subdomain => nil).should == "/needs_subdomain"
+    end
+
+    it "should not force the full url if no :subdomain option is given" do
+      needs_subdomain_path.should == "/needs_subdomain"
+      default_url_options[:host] = "awesome.example.com"
+      needs_subdomain_path.should == "/needs_subdomain"
+    end
+  end
+
+  describe "Resourced Routes" do
+    it "should be able to add a subdomain" do
+      foo_path(:id => "something", :subdomain => "awesome").should == "http://awesome.example.com/foos/something"
+    end
+
+    it "should be able to remove a subdomain" do
+      default_url_options[:host] = "awesome.example.com"
+      foo_path(:id => "something", :subdomain => false).should == "http://example.com/foos/something"
+    end
+
+    it "should work when passed in a paramable object" do
+      foo_path(Paramed.new("something"), :subdomain => "awesome").should == "http://awesome.example.com/foos/something"
+    end
+
+    it "should work when passed in a paramable object" do
+      foo_path(Paramed.new("something"), :subdomain => "awesome").should == "http://awesome.example.com/foos/something"
+    end
+
+    it "should work when passed in a paramable object and no subdomain to a _path" do
+      default_url_options[:host] = "awesome.example.com"
+      foo_path(Paramed.new("something")).should == "/foos/something"
+    end
+
+    it "should work when passed in a paramable object and no subdomain to a _url" do
+      default_url_options[:host] = "awesome.example.com"
+      foo_url(Paramed.new("something")).should == "http://awesome.example.com/foos/something"
+    end
+
+    it "should work on nested resource collections" do
+      foo_bars_path(Paramed.new("something"), :subdomain => "awesome").should == "http://awesome.example.com/foos/something/bars"
+    end
+
+    it "should work on nested resource members" do
+      foo_bar_path(Paramed.new("something"),Paramed.new("else"), :subdomain => "awesome").should == "http://awesome.example.com/foos/something/bars/else"
+    end
+  end
+
+  describe "Preferred Mirror" do
+    before do
+      SubdomainFu.preferred_mirror = "www"
+      SubdomainFu.override_only_path = true
+    end
+
+    it "should switch to the preferred mirror instead of no subdomain" do
+      default_url_options[:host] = "awesome.example.com"
+      needs_subdomain_url(:subdomain => false).should == "http://www.example.com/needs_subdomain"
+    end
+
+    it "should switch to the preferred mirror automatically" do
+      default_url_options[:host] = "example.com"
+      needs_subdomain_url.should == "http://www.example.com/needs_subdomain"
+    end
+
+    it "should work when passed in a paramable object and no subdomain to a _url" do
+      default_url_options[:host] = "awesome.example.com"
+      foo_url(Paramed.new("something")).should == "http://awesome.example.com/foos/something"
+    end
+
+    it "should force a switch to no subdomain on a mirror if preferred_mirror is false" do
+      SubdomainFu.preferred_mirror = false
+      default_url_options[:host] = "www.example.com"
+      needs_subdomain_url(:subdomain => false).should == "http://example.com/needs_subdomain"
+    end
+
+    after do
+      SubdomainFu.preferred_mirror = nil
+    end
+  end
+
+  after do
+    SubdomainFu.tld_size = 0
+    default_url_options[:host] = "localhost"
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: gameplan-subdomain-fu
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 4
+  version: 0.5.4
+platform: ruby
+authors: 
+- Michael Bleigh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-12 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: SubdomainFu is a Rails plugin to provide all of the basic functionality necessary to handle multiple subdomain applications (such as Basecamp-esque subdomain accounts and more).
+email: michael@intridea.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/subdomain-fu.rb
+- lib/subdomain_fu/routing_extensions.rb
+- lib/subdomain_fu/url_rewriter.rb
+- rails/init.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/subdomain_fu_spec.rb
+- spec/url_rewriter_spec.rb
+has_rdoc: true
+homepage: http://github.com/mbleigh/subdomain-fu
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: subdomain-fu
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: SubdomainFu is a Rails plugin that provides subdomain routing and URL writing helpers.
+test_files: 
+- spec/spec_helper.rb
+- spec/subdomain_fu_spec.rb
+- spec/url_rewriter_spec.rb