subdomain_router 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@subdomain_router --create

data/Gemfile

@@ -0,0 +1,16 @@
+source 'http://rubygems.org'
+
+gem 'rails'
+
+group :development do
+  # SPECS
+  gem 'rspec'
+
+  # DOCS
+  gem 'yard'
+  gem 'redcarpet'
+
+  # DEVELOPMENT
+  gem 'bundler'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,107 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.3)
+      actionpack (= 3.2.3)
+      mail (~> 2.4.4)
+    actionpack (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+    activerecord (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    git (1.2.5)
+    hike (1.2.1)
+    i18n (0.6.0)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    journey (1.0.3)
+    json (1.6.6)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.18)
+    multi_json (1.3.2)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.3)
+      actionmailer (= 3.2.3)
+      actionpack (= 3.2.3)
+      activerecord (= 3.2.3)
+      activeresource (= 3.2.3)
+      activesupport (= 3.2.3)
+      bundler (~> 1.0)
+      railties (= 3.2.3)
+    railties (3.2.3)
+      actionpack (= 3.2.3)
+      activesupport (= 3.2.3)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    redcarpet (2.1.1)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+    yard (0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler
+  rails
+  redcarpet
+  rspec
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Tim Morgan
+
+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.md

@@ -0,0 +1,160 @@
+Subdomain Router
+================
+
+A Ruby on Rails addition that adds dynamic subdomain routing to your web app.
+
+|             |                                 |
+|:------------|:--------------------------------|
+| **Author**  | Tim Morgan                      |
+| **Version** | 1.0 (Apr 20, 2012)              |
+| **License** | Released under the MIT license. |
+
+About
+-----
+
+This gem consists of two components: A routing constraint that can be used in
+your `routes.rb` file to limit certain endpoints to dynamic subdomains (or vice
+versa), and a monkey-patch to the `url_for` method that allows it to
+intelligently generate URLs with subdomains.
+
+The most common use case for this is if you have each of your users choose a
+subdomain when they sign up, and then you route to different user accounts based
+on their subdomain. (Think Heroku for example.)
+
+Sorry about the monkey-patching by the way. :( You should probably inspect the
+patch closely if you are using any other `url_for` hooks.
+
+### Testing multiple subdomains in development
+
+Typically in development you access your website by going to
+"http://localhost:3000" (or perhaps "http://0.0.0.0:3000"). Neither of these
+URLs is compatible with subdomains, however.
+
+Fortunately there exists an easy solution that requires no changes to your
+`/etc/hosts` file. The domain "lvh.me" points to 127.0.0.1, so by going to
+"http://lvh.me:3000", you can access your local Rails instance. And it works
+with subdomains: "http://custom.lvh.me:3000" will work just as well.
+
+Installation
+------------
+
+### Gem installation
+
+To use this gem, add to your Gemfile:
+
+```` ruby
+gem 'subdomain_router'
+````
+
+### Configuration
+
+You will need to configure SubdomainRouter before you can use it. The
+configuration code can be placed anywhere you feel is appropriate
+(`config/application.rb`, a file in `config/initializers`, etc.) as long as it
+runs when your web app starts up.
+
+```` ruby
+SubdomainRouter::Config.default_subdomain = 'www'
+SubdomainRouter::Config.domain = 'mywebsite.com'
+SubdomainRouter::Config.tld_components = 1
+SubdomainRouter::Config.subdomain_matcher = ->(subdomain, request) { ... }
+````
+
+The configuration options are described below.
+
+| Option              | Description                                                                                                                                                                                                        |
+|:--------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `default_subdomain` | The subdomain to use when no dynamic subdomain is specified. This is the subdomain people would use when visiting your site for the first time (default "www" and "" for test.)                                    |
+| `domain`            | The domain name. In development, it is by default `lvh.me` (see the _About_ section). In test, it is by default `test.host`. In production, it should be the domain name of your site.                             |
+| `tld_components`    | The number of components in the TLD. If you have a `.com` website, this is 1. If you have a `.co.uk` website, it would be 2. In development and test, it should be 1 (default 1).                                  |
+| `subdomain_matcher` | A `Proc` that takes a subdomain (as a `String`) and an `ActionDispatch::Request` object, and returns `true` if it is a valid dynamic subdomain, or `false` otherwise. A response of `false` would result in a 404. |
+
+So as you can see, sensible defaults are provided for most options. At a
+minimum, you need to set `subdomain_matcher` in all environments and `domain` in
+production.
+
+These configuration variables are shared by some others in Rails. For DRY
+purposes, you can reuse the configuration values:
+
+```` ruby
+Rails.application.config.action_dispatch.tld_length = SubdomainRouter::Config.tld_components
+
+# if you use cookies
+Rails.application.config.session_store :cookie_store, domain: ".#{SubdomainRouter::Config.domain}", expire_after: 2.weeks, key: '_mysite_session'
+````
+
+### Code additions
+
+In your `ApplicationController`, add the following:
+
+```` ruby
+include SubdomainRouter::Controller
+````
+
+In your routes file, group all of the routes you _do_ want to be accessible from
+dynamic subdomains into a block like so:
+
+```` ruby
+constraints SubdomainRouter::Constraint do
+  # [...]
+end
+````
+
+Then group all of the routes you want accessible from the default subdomain into
+a similar block:
+
+```` ruby
+constraints(subdomain: SubdomainRouter::Config.default_subdomain) do
+  # [...]
+end
+````
+
+This should be all you need. See the next section to learn how to use the
+monkey-patched `url_for`.
+
+Usage
+-----
+
+Aside from implementing the `subdomain_matcher` proc above, the only other thing
+you will need to is provide subdomain information to all of your links. Since
+`url_for` powers the URL methods (e.g., `posts_url`), the following information
+applies to them equally.
+
+For every call to `link_to` or `url_for` in your views, you will need to think
+about how the link will work with subdomains. There are three possibilities:
+
+* **Leave the subdomain untouched.** A link to `/bar` at `www.foo.com` will go
+  to `www.foo.com/bar`. A link to `/bar` at `custom.foo.com` will go to
+  `custom.foo.com/bar`.
+* **Go to the default subdomain.** A link to `/bar` at `www.foo.com` will go to
+  `www.foo.com/bar`. A link to `/bar` at `custom.foo.com` will go to
+  `www.foo.com/bar`.
+* **Go to a specific subdomain.** A link to `/bar` at `www.foo.com` will go to
+  `custom.foo.com/bar`. A link to `/bar` at `another.foo.com` will go to
+  `custom.foo.com/bar`.
+
+So, if you want to **leave the subdomain untouched**, either omit the
+`:subdomain` option from your call to `url_for`, or set it to `nil`:
+
+```` ruby
+url_for(controller: 'posts', action: 'index') # implied subdomain: nil
+posts_url(subdomain: nil) # explicitly specifying
+````
+
+If you want to **go to the default subdomain**, set the `:subdomain` option to
+`false`:
+
+```` ruby
+url_for(controller: 'testimonials', action: 'index', subdomain: false)
+testimonials_url(subdomain: false)
+````
+
+If you want to **go to a specific subdomain**, specify it using the `:subdomain`
+option:
+
+```` ruby
+url_for(controller: 'profile', action: 'show', subdomain: user.subdomain)
+profile_url(subdomain: user.subdomain)
+````
+
+See {SubdomainRouter::Controller#url_for} for more.

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "subdomain_router"
+  gem.homepage = "http://github.com/RISCfuture/subdomain_router"
+  gem.license = "MIT"
+  gem.summary = %Q{Use dynamic subdomains in your Rails website}
+  gem.description = %Q{This adds a routing constraint and controller methods to allow dynamic subdomain-based routing.}
+  gem.email = "gemcutter@timothymorgan.info"
+  gem.authors = ["Tim Morgan"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task default: :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new('doc') do |doc|
+  doc.options << '-m' << 'markdown' << '-M' << 'redcarpet'
+  doc.options << '--protected' << '--no-private'
+  doc.options << '-r' << 'README.md'
+  doc.options << '-o' << 'doc'
+  doc.options << '--title' << 'Subdomain Router Documentation'
+
+  doc.files = %w( lib/**/* README.md )
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/subdomain_router.rb

@@ -0,0 +1,84 @@
+# Module for working with dynamic subdomain routing.
+
+module SubdomainRouter
+
+  # Controller mixin that adds subdomain management features.
+
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method(:url_for) if respond_to?(:helper_method)
+    end
+
+    # Adds to the `url_for` method the ability to route to different subdomains.
+    # Thus, all URL generation (including smart route methods) gains the
+    # `:subdomain` options.
+    #
+    # For more information, see the Rails documentation.
+    #
+    # @param [Hash] options Options for the URL.
+    # @option options [String, nil, false] :subdomain The subdomain to route to.
+    #   If `false`, uses the default subdomain (e.g., "www"). If `nil`, uses the
+    #   current subdomain.
+    # @return [String] The generated URL.
+    # @raise [ArgumentError] If the `:subdomain` option is invalid.
+
+    def url_for(options={})
+      return super unless options.is_a?(Hash)
+
+      case options[:subdomain]
+        when nil
+          options.delete :subdomain
+          super options
+        when false, String
+          subdomain = options.delete(:subdomain) || Config.default_subdomain
+          host = options[:host] || (respond_to?(:request) && request.host) || Config.domain
+          host_parts = host.split('.').last(Config.tld_components + 1)
+          host_parts.unshift subdomain
+          host_parts.delete_if &:blank?
+          super options.merge(host: host_parts.join('.'))
+        else
+          raise ArgumentError, ":subdomain must be nil, false, or a string"
+      end
+    end
+  end
+
+  # A routing constraint that restricts routes to only valid dynamic subdomains.
+  #
+  # @example
+  #   get 'home' => 'accounts#show', constraint: SubdomainRouter::Constraint
+
+  module Constraint
+
+    # Determines if a given request has a custom user subdomain.
+    #
+    # @param [ActionDispatch::Request] request An HTTP request.
+    # @return [true, false] Whether the request subdomain matches a known user
+    #   subdomain.
+
+    def matches?(request)
+      return false unless request.subdomains.size == 1
+      return false if request.subdomains.first == Config.default_subdomain
+      return subdomain?(request)
+    end
+    module_function :matches?
+
+    private
+
+    def subdomain?(request)
+      subdomain = request.subdomains.first.downcase
+      Config.subdomain_matcher.(subdomain, request)
+    end
+    module_function :subdomain?
+  end
+
+  # Subdomain routing configuration object.
+
+  Config = Struct.new(:default_subdomain, :domain, :tld_components, :subdomain_matcher).new
+  Config.default_subdomain = Rails.env.test? ? '' : 'www'
+  Config.domain = 'lvh.me' if Rails.env.development?
+  Config.domain = 'test.host' if Rails.env.test?
+  Config.tld_components = 1
+  Config.subdomain_matcher = ->(subdomain, request) { false }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'bundler'
+Bundler.require :development
+Bundler.require
+require 'action_controller'
+require 'subdomain_router'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+SubdomainRouter::Config.default_subdomain = ''
+SubdomainRouter::Config.tld_components = 1
+SubdomainRouter::Config.domain = 'test.host'
+
+RSpec.configure do |config|
+  
+end

data/spec/subdomain_router_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+class UrlForController < ActionController::Metal
+  include SubdomainRouter::Controller
+end
+
+class UrlForMailer
+  include SubdomainRouter::Controller
+end
+
+describe SubdomainRouter::Controller do
+  before :all do
+    @controller = UrlForController.new
+  end
+
+  describe "#url_for" do
+    it "should call the superclass unless a hash is given" do
+      @controller.url_for('foo').should eql('foo')
+    end
+
+    context "[given host]" do
+      before :each do
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'test.host'))
+      end
+
+      it "should leave the domain untouched if :subdomain => nil" do
+        @controller.url_for(host: 'foo.bar').should eql(host: 'foo.bar')
+        @controller.url_for(host: 'sd.foo.bar').should eql(host: 'sd.foo.bar')
+        @controller.url_for(host: 'baz.bat.foo.bar').should eql(host: 'baz.bat.foo.bar')
+      end
+
+      it "should replace the subdomain if :subdomain is given" do
+        @controller.url_for(host: 'foo.bar', subdomain: 'sd').should eql(host: 'sd.foo.bar')
+        @controller.url_for(host: 'baz.foo.bar', subdomain: 'sd').should eql(host: 'sd.foo.bar')
+        @controller.url_for(host: 'baz.bat.foo.bar', subdomain: 'sd').should eql(host: 'sd.foo.bar')
+      end
+
+      it "should use the default subdomain if :subdomain is false" do
+        @controller.url_for(host: 'foo.bar', subdomain: false).should eql(host: 'foo.bar')
+        @controller.url_for(host: 'baz.foo.bar', subdomain: false).should eql(host: 'foo.bar')
+        @controller.url_for(host: 'baz.bat.foo.bar', subdomain: false).should eql(host: 'foo.bar')
+      end
+    end
+
+    context "[request host]" do
+      it "should leave the domain untouched if :subdomain => nil" do
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'foo.bar'))
+        @controller.url_for(subdomain: nil).should eql({})
+
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'sd.foo.bar'))
+        @controller.url_for(subdomain: nil).should eql({})
+
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'baz.bat.foo.bar'))
+        @controller.url_for(subdomain: nil).should eql({})
+      end
+
+      it "should replace the subdomain if :subdomain is given" do
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'foo.bar'))
+        @controller.url_for(subdomain: 'sd').should eql(host: 'sd.foo.bar')
+
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'baz.foo.bar'))
+        @controller.url_for(subdomain: 'sd').should eql(host: 'sd.foo.bar')
+
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'baz.bat.foo.bar'))
+        @controller.url_for(subdomain: 'sd').should eql(host: 'sd.foo.bar')
+      end
+
+      it "should use the default subdomain if :subdomain is false" do
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'foo.bar'))
+        @controller.url_for(subdomain: false).should eql(host: 'foo.bar')
+
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'baz.foo.bar'))
+        @controller.url_for(subdomain: false).should eql(host: 'foo.bar')
+
+        @controller.stub!(:request).and_return(mock('ActionDispatch::Request', host: 'baz.bat.foo.bar'))
+        @controller.url_for(subdomain: false).should eql(host: 'foo.bar')
+      end
+    end
+
+    context "[no host]" do
+      before :all do
+        @mailer = UrlForMailer.new
+      end
+
+      before :each do
+        pending "Need to find a way to test this without building up a whole Rails app"
+      end
+      
+      it "should leave the domain untouched if :subdomain => nil" do
+        # no host provided = exception
+        -> { @mailer.url_for(controller: 'users', action: 'new', subdomain: nil) }.should raise_error(ArgumentError)
+      end
+
+      it "should replace the subdomain if :subdomain is given" do
+        @mailer.url_for(controller: 'users', action: 'new', subdomain: 'sd').should eql('http://sd.test.host/users/new')
+      end
+
+      it "should use the default subdomain if :subdomain is false" do
+        @mailer.url_for(controller: 'users', action: 'new', subdomain: false).should eql('http://test.host/users/new')
+      end
+    end
+  end
+end
+
+describe SubdomainRouter::Constraint do
+  describe ".matches?" do
+    before :each do
+      @env = {}
+      @request = mock('ActionDispatch::Request', env: @env)
+    end
+
+    it "should return false if there is more than one subdomain" do
+      @request.stub!(:subdomains).and_return(%w( foo bar ))
+      SubdomainRouter::Constraint.matches?(@request).should be_false
+    end
+
+    it "should return false if there is no subdomain" do
+      @request.stub!(:subdomains).and_return([])
+      SubdomainRouter::Constraint.matches?(@request).should be_false
+    end
+
+    it "should return false if the subdomain is equal to the default subdomain" do
+      SubdomainRouter::Config.default_subdomain = 'www'
+      @request.stub!(:subdomains).and_return(%w( www ))
+      SubdomainRouter::Constraint.matches?(@request).should be_false
+    end
+
+    it "should return false if the subdomain does not belong to any user" do
+      @request.stub!(:subdomains).and_return(%w( not-found ))
+      SubdomainRouter::Constraint.matches?(@request).should be_false
+    end
+
+    it "should return true if the subdomain belongs to a user and save the user to the env" do
+      SubdomainRouter::Config.subdomain_matcher = ->(subdomain, request) { subdomain == 'valid' }
+      @request.stub!(:subdomains).and_return([ 'valid' ])
+      SubdomainRouter::Constraint.matches?(@request).should be_true
+    end
+
+    it "should downcase the subdomain" do
+      SubdomainRouter::Config.subdomain_matcher = ->(subdomain, request) { subdomain == 'valid' }
+      @request.stub!(:subdomains).and_return([ 'VALID' ])
+      SubdomainRouter::Constraint.matches?(@request).should be_true
+    end
+  end
+end

data/subdomain_router.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "subdomain_router"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Morgan"]
+  s.date = "2012-04-23"
+  s.description = "This adds a routing constraint and controller methods to allow dynamic subdomain-based routing."
+  s.email = "gemcutter@timothymorgan.info"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/subdomain_router.rb",
+    "spec/spec_helper.rb",
+    "spec/subdomain_router_spec.rb"
+  ]
+  s.homepage = "http://github.com/RISCfuture/subdomain_router"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "Use dynamic subdomains in your Rails website"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<redcarpet>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<redcarpet>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<redcarpet>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: subdomain_router
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This adds a routing constraint and controller methods to allow dynamic
+  subdomain-based routing.
+email: gemcutter@timothymorgan.info
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/subdomain_router.rb
+- spec/spec_helper.rb
+- spec/subdomain_router_spec.rb
+- subdomain_router.gemspec
+homepage: http://github.com/RISCfuture/subdomain_router
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4479704525159209868
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Use dynamic subdomains in your Rails website
+test_files: []