mbleigh-subdomain-fu 0.1.0 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,13 @@
+== 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
+* Removed stray puts

data/{README → README.rdoc}

@@ -1,13 +1,11 @@
-SubdomainFu
-===========
+= 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
-============
+== Installation
 
 SubdomainFu is available both as a traditional plugin and a GemPlugin. To
 install it as a traditional plugin (Rails 2.1 or later):
@@ -19,8 +17,7 @@ To use it as a GemPlugin, add it to your environment.rb:
   config.gem 'mbleigh-subdomain-fu', :source => "http://gems.github.com", :lib => "subdomain-fu"
 
 
-Examples
-========
+== 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
@@ -48,14 +45,12 @@ 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.
 
-Configuration
-=============
+== Configuration
 
 You may need to configure SubdomainFu based on your development setup. The
 configuration required is:
 
-tld_size
---------
+=== TLD Size
 
 A hash for each environment of the size of the top-level domain name. 
 (something.com = 1, localhost = 0, etc.)
@@ -65,16 +60,14 @@ SubdomainFu.tld_sizes = {:development => 0,
                          :test => 0,
                          :production => 1} # set all at once (also the defaults)
                          
-mirrors
--------
+=== 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
-----------------
+=== 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',
@@ -82,21 +75,22 @@ you can set the preferred mirror like so:
 
 SubdomainFu.preferred_mirror = "www"
 
-Now when you create a link to a false subdomain
+Now when you create a link with subdomain => false in the options the subdomain
+will default to the preferred mirror.
 
-Known Issues / Future Work
-==========================
+== Routing
 
-SubdomainFu will eventually integrate with Rails' routing internals to provide
-the ability to specify routes based on the condition of a specific subdomain or
-simply whether a subdomain is present (or a mirror).
+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 routes.rb file:
 
-Resources
-=========
+    map.with_options :conditions => {:subdomain => 'admin} do |admin|
+      admin.resources :posts
+      admin.resources :users
+    end
+
+== Resources
 
-* Acts As Community Project: http://actsascommunity.com/projects/subdomain-fu
 * GitHub Repository: http://github.com/mbleigh/subdomain-fu
-* Lighthouse: http://mbleigh.lighthouseapp.com/projects/13148-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
+Intridea, Inc. (http://www.intridea.com/). Released under the MIT license

data/VERSION.yml

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

data/lib/subdomain-fu.rb

@@ -10,48 +10,62 @@ module SubdomainFu
   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 = %w(www)
-  
+  @@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 a mirror?
+
+  # 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 unless 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)
@@ -65,28 +79,55 @@ module SubdomainFu
       end
     end
   end
-  
+
   # Changes the subdomain of the host to whatever is passed in.
   def self.change_subdomain_of_host(subdomain, host)
     host = SubdomainFu.host_without_subdomain(host)
     host = "#{subdomain}.#{host}" if subdomain
     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)
-    return false if subdomain.nil?
+    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
 
-    (!has_subdomain?(subdomain) && preferred_mirror?(subdomain) && !preferred_mirror?(subdomain_from(host))) || 
+  #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)
@@ -95,15 +136,15 @@ module SubdomainFu
       nil
     end
   end
-  
+
   module Controller
     def self.included(controller)
       controller.helper_method(:current_subdomain)
     end
-    
+
     protected
     def current_subdomain
       SubdomainFu.current_subdomain(request)
     end
   end
-end
+end

data/lib/subdomain_fu/routing_extensions.rb

@@ -10,16 +10,16 @@ module SubdomainFu
 
     def recognition_conditions_with_subdomain
       result = recognition_conditions_without_subdomain
-      result << "conditions[:subdomain] === env[:subdomain].to_s" if conditions[:subdomain] && conditions[:subdomain] != true && conditions[:subdomain] != false
+      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  
+      base.alias_method_chain :extract_request_environment, :subdomain
     end
 
     def extract_request_environment_with_subdomain(request)
@@ -27,8 +27,30 @@ module SubdomainFu
       env.merge(:host => request.host, :domain => request.domain, :subdomain => SubdomainFu.subdomain_from(request.host))
     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
 
@@ -36,4 +58,4 @@ ActionController::Routing::Route.send :include, SubdomainFu::RouteExtensions
 # 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
+end

data/lib/subdomain_fu/url_rewriter.rb

@@ -2,7 +2,7 @@ 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 
+        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)
@@ -11,14 +11,15 @@ module ActionController
     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.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
@@ -26,7 +27,7 @@ module ActionController
     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
@@ -44,4 +45,4 @@ module ActionController
       end
     end
   end
-end
+end

data/rails/init.rb

@@ -1,5 +1,8 @@
-require 'subdomain-fu'
+# Add this path to ruby load path
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'subdomain-fu' unless defined?(SubdomainFu)
 
 ActionController::Base.send :include, SubdomainFu::Controller
 
-RAILS_DEFAULT_LOGGER.info("** SubdomainFu: initialized properly")
+RAILS_DEFAULT_LOGGER.info("** SubdomainFu: initialized properly")

data/spec/spec_helper.rb

@@ -12,20 +12,20 @@ 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
 
@@ -33,10 +33,10 @@ class Paramed
   def initialize(param)
     @param = param
   end
-  
+
   def to_param
     @param || "param"
   end
 end
 
-include ActionController::UrlWriter
+include ActionController::UrlWriter

data/spec/subdomain_fu_spec.rb

@@ -3,6 +3,7 @@ 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
 
@@ -10,42 +11,42 @@ describe "SubdomainFu" 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"
@@ -55,16 +56,16 @@ describe "SubdomainFu" do
       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"
@@ -86,15 +87,15 @@ describe "SubdomainFu" 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
@@ -121,43 +122,43 @@ describe "SubdomainFu" do
       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
   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 "#same_subdomain?" do
     it { SubdomainFu.same_subdomain?("www","www.localhost").should be_true }
     it { SubdomainFu.same_subdomain?("www","localhost").should be_true }
@@ -183,8 +184,34 @@ describe "SubdomainFu" 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
+end

data/spec/url_rewriter_spec.rb

@@ -3,138 +3,147 @@ 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] = "testapp.com"
+    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.testapp.com/something/other" 
+      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.testapp.com").should == "http://testapp.com/something/other" 
+      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.testapp.com").should == "http://www.testapp.com/something/other" 
+      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" do
-      url_for(:controller => "something", :action => "other", :subdomain => "awesome", :only_path => true).should == "http://awesome.testapp.com/something/other" 
+
+    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.testapp.com/needs_subdomain"
+      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.testapp.com"
-      needs_subdomain_url(:subdomain => false).should == "http://testapp.com/needs_subdomain"
+      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.testapp.com"
-      needs_subdomain_url(:subdomain => false).should == "http://www.testapp.com/needs_subdomain"
+      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.testapp.com"
+      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.testapp.com"
-      needs_subdomain_path(:subdomain => "crazy").should == "http://crazy.testapp.com/needs_subdomain"
+      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.testapp.com"
+      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.testapp.com/foos/something"
+      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.testapp.com"
-      foo_path(:id => "something", :subdomain => false).should == "http://testapp.com/foos/something"
+      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.testapp.com/foos/something"
+      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.testapp.com/foos/something"
+      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.testapp.com"
+      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.testapp.com"
-      foo_url(Paramed.new("something")).should == "http://awesome.testapp.com/foos/something"
+      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.testapp.com/foos/something/bars"
+      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.testapp.com/foos/something/bars/else"
+      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.testapp.com"
-      needs_subdomain_url(:subdomain => false).should == "http://www.testapp.com/needs_subdomain"
+      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] = "testapp.com"
-      needs_subdomain_url.should == "http://www.testapp.com/needs_subdomain"
+      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.testapp.com"
-      foo_url(Paramed.new("something")).should == "http://awesome.testapp.com/foos/something"
+      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.testapp.com"
-      needs_subdomain_url(:subdomain => false).should == "http://testapp.com/needs_subdomain"
+      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
+end

metadata

@@ -1,32 +1,33 @@
 --- !ruby/object:Gem::Specification 
 name: mbleigh-subdomain-fu
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Michael Bleigh
+- Peter Boling
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-05-26 00:00:00 -07:00
+date: 2009-08-24 00:00:00 -07: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
+email: michael@intridea.com peter.boling@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README
+extra_rdoc_files: []
+
 files: 
 - CHANGELOG
 - MIT-LICENSE
-- README
+- README.rdoc
 - Rakefile
-- VERSION
+- VERSION.yml
 - lib/subdomain-fu.rb
 - lib/subdomain_fu/routing_extensions.rb
 - lib/subdomain_fu/url_rewriter.rb
@@ -35,8 +36,9 @@ files:
 - spec/spec_helper.rb
 - spec/subdomain_fu_spec.rb
 - spec/url_rewriter_spec.rb
-has_rdoc: false
+has_rdoc: true
 homepage: http://github.com/mbleigh/subdomain-fu
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -57,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: SubdomainFu is a Rails plugin that provides subdomain routing and URL writing helpers.

data/VERSION

@@ -1 +0,0 @@
-0.1.0