goncalossilva-subdomain_routes 0.3.3

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+require 'yaml'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "goncalossilva-subdomain_routes"
+    gem.summary = %Q{A Rails library for incorporating subdomains into route generation and recognition.}
+    gem.description = <<-EOF
+      SubdomainRoutes add subdomain conditions to the Rails routing system. Routes may be restricted to
+      one or many specified subdomains. An URL will be recognised only if the host subdomain matches the
+      subdomain specified in the route. Route generation is also enhanced, so that the subdomain of a
+      generated URL (or path) will be changed if the requested route has a different subdomain to that of
+      the current request. Model-based subdomain routes can also be defined.
+    EOF
+    gem.email = "goncalossilva@gmail.com"
+    gem.homepage = "http://github.com/goncalossilva/subdomain_routes"
+    gem.authors = ["Matthew Hollingworth", "Akihiro Matsumura", "Goncalo Silva"]
+    gem.add_dependency 'actionpack', "~> 2.3.9"
+    gem.has_rdoc = false
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "subdomain_routes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

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

data/history.txt

@@ -0,0 +1,21 @@
+SubdomainRoutes Revision History
+
+Version 0.3.2
+* Remove Deprecation warning for Rails 2.3.9
+
+Version 0.3.1
+* Fixed bug whereby port number was not preserved when a subdomain route changed
+  the subdomain in the host (Matsumara Akihiro, Matthew Hollingworth).
+* Similarly, added fixes to preserve https protocol when host is changed.
+
+Version 0.3.0
+
+* Added this revision history.
+* Added #assert_recognizes_with_host and #assert_generates_with_host methods to
+  ActionController::Assertions::RoutingAssertions, allowing testing of subdomain routes
+  if you're into that sort of thing.
+* Modified ActionController::Routing::Route#significant_keys to include the subdomain
+  option in the case of model-based subdomain routes.
+* Added ability to override default namespace and name prefix for model-based subdomain
+  routes by passing :name option to the map.subdomain call.
+* Updated README to describe how to test with subdomain routes.

data/lib/subdomain_routes.rb

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

data/lib/subdomain_routes/assertions.rb

@@ -0,0 +1,68 @@
+module SubdomainRoutes
+  module RoutingAssertions        
+    include SubdomainRoutes::RewriteSubdomainOptions
+
+    def assert_recognizes_with_host(expected_options, path, extras={}, message=nil)
+      # copied from Rails source, with modification to set the the supplied host on the request
+      if path.is_a? Hash
+        request_method = path[:method]
+        host           = path[:host]
+        path           = path[:path]
+      else
+        request_method = nil
+        host = nil
+      end
+      clean_backtrace do
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        request = recognized_request_for_with_host(path, host, request_method)
+        
+        expected_options = expected_options.clone
+        extras.each_key { |key| expected_options.delete key } unless extras.nil?
+
+        expected_options.stringify_keys!
+        routing_diff = expected_options.diff(request.path_parameters)
+        
+        msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
+            request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
+        assert_block(msg) { request.path_parameters == expected_options }
+      end
+    end
+
+    def assert_generates_with_host(expected_path, options, host, defaults={}, extras = {}, message=nil)
+      if expected_path.is_a? Hash
+        expected_host = expected_path[:host]
+        expected_path = expected_path[:path]
+      else
+        expected_host = nil
+      end
+      rewrite_subdomain_options(options, host)
+      if options.delete(:only_path) == false
+        generated_host = options.delete(:host)
+        msg = expected_host ? 
+          build_message(message, "The route for <?> changed the host to <?> but this did not match expected host <?>", options, generated_host, expected_host) :
+          build_message(message, "The route for <?> changed the host to <?> but the host was not expected to change", options, generated_host)
+        assert_block(msg) { expected_host == generated_host }
+      else
+        msg = build_message(message, "The route for <?> was expected to change the host to <?> but did not change the host", options, expected_host)
+        assert_block(msg) { expected_host == nil }
+      end
+      assert_generates(expected_path, options, defaults, extras, message)
+    end
+
+    private
+
+    def recognized_request_for_with_host(path, host, request_method = nil)
+      path = "/#{path}" unless path.first == '/'
+
+      # Assume given controller
+      request = ActionController::TestRequest.new
+      request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
+      request.path = path
+      request.host = host if host
+      ActionController::Routing::Routes.recognize(request)
+      request
+    end
+  end
+end
+
+ActionController::Assertions::RoutingAssertions.send :include, SubdomainRoutes::RoutingAssertions

data/lib/subdomain_routes/config.rb

@@ -0,0 +1,6 @@
+module SubdomainRoutes
+  module Config
+    mattr_accessor :domain_length
+    mattr_accessor :static_domains
+  end
+end

data/lib/subdomain_routes/mapper.rb

@@ -0,0 +1,43 @@
+module SubdomainRoutes
+  module Routing
+    module RouteSet
+      module Mapper
+        def subdomain(*subdomains, &block)
+          options = subdomains.extract_options!.dup
+          if subdomains.empty?
+            if model = options.delete(:model)
+              raise ArgumentError, "Invalid model name" if model.blank?
+              models = model.to_s.downcase.pluralize
+              model = models.singularize
+              model_id = model.foreign_key.to_sym
+              subdomain_options = { :subdomains => model_id }
+              name = options.has_key?(:name) ? options.delete(:name) : model
+            else
+              raise ArgumentError, "Please specify at least one subdomain!"
+            end
+          else
+            subdomains.map!(&:to_s)
+            subdomains.map!(&:downcase)
+            subdomains.uniq!
+            subdomains.compact.each do |subdomain|
+              raise ArgumentError, "Illegal subdomain format: #{subdomain.inspect}" unless subdomain.blank? || SubdomainRoutes.valid_subdomain?(subdomain)
+            end
+            if subdomains.include? ""
+              raise ArgumentError, "Can't specify a nil subdomain unless you set Config.domain_length!" unless Config.domain_length
+            end
+            subdomain_options = { :subdomains => subdomains }
+            name = subdomains.reject(&:blank?).first
+            name = options.delete(:name) if options.has_key?(:name)
+          end
+          name = name.to_s.downcase.gsub(/[^(a-z0-9)]/, ' ').squeeze(' ').strip.gsub(' ', '_') unless name.blank?
+          subdomain_options.merge! :name_prefix => "#{name}_", :namespace => "#{name}/" unless name.blank?
+          with_options(subdomain_options.merge(options), &block)
+        end
+        alias_method :subdomains, :subdomain
+      end
+    end
+  end
+end
+
+ActionController::Routing::RouteSet::Mapper.send :include, SubdomainRoutes::Routing::RouteSet::Mapper
+

data/lib/subdomain_routes/request.rb

@@ -0,0 +1,11 @@
+module SubdomainRoutes
+  module Request
+    include SplitHost
+    
+    def subdomain
+      subdomain_for_host(host)
+    end
+  end
+end
+
+ActionController::Request.send :include, SubdomainRoutes::Request

data/lib/subdomain_routes/resources.rb

@@ -0,0 +1,49 @@
+module SubdomainRoutes
+  module Resources
+    def self.included(base)
+      base.alias_method_chain :action_options_for, :subdomains
+      base::INHERITABLE_OPTIONS << :subdomains
+    end
+    
+    def action_options_for_with_subdomains(action, resource, *args)
+      action_options_for_without_subdomains(action, resource, *args).merge(:subdomains => resource.options[:subdomains])
+    end
+    private :action_options_for_with_subdomains
+  end
+end
+
+ActionController::Resources.send :include, SubdomainRoutes::Resources
+
+
+
+
+# # 
+# # This alternative also works. It duplicates code in add_route_with_subdomains (in routing.rb) so is not
+# # so good that way, but has the benefit of not modifying ActionController::Resources#action_options_for,
+# # which is a private method.
+# # 
+# module SubdomainRoutes
+#   module Resources
+#     module Resource
+#       def self.included(base)
+#         base.alias_method_chain :conditions, :subdomains
+#         base.alias_method_chain :requirements, :subdomains
+#       end
+#       
+#       def conditions_with_subdomains
+#         @options[:subdomains] ?
+#           conditions_without_subdomains.merge(:subdomains => @options[:subdomains]) :
+#           conditions_without_subdomains
+#       end
+#       
+#       def requirements_with_subdomains(with_id = false)
+#         @options[:subdomains] ?
+#           requirements_without_subdomains(with_id).merge(:subdomains => @options[:subdomains]) :
+#           requirements_without_subdomains(with_id)
+#       end
+#     end
+#   end
+# end
+# 
+# ActionController::Resources::INHERITABLE_OPTIONS << :subdomains
+# ActionController::Resources::Resource.send :include, SubdomainRoutes::Resources::Resource

data/lib/subdomain_routes/routes.rb

@@ -0,0 +1,97 @@
+module SubdomainRoutes
+  module Routing
+    module RouteSet
+      include SplitHost
+
+      def self.included(base)
+        [ :extract_request_environment, :add_route, :raise_named_route_error ].each { |method| base.alias_method_chain method, :subdomains }
+      end
+
+      def extract_request_environment_with_subdomains(request)
+        extract_request_environment_without_subdomains(request).merge(:subdomain => subdomain_for_host(request.host))
+      end
+
+      def add_route_with_subdomains(*args)
+        options = args.extract_options!
+        if subdomains = options.delete(:subdomains)
+          options[:conditions] ||= {}
+          options[:requirements] ||= {}
+          options[:conditions][:subdomains] = subdomains
+          options[:requirements][:subdomains] = subdomains
+        end
+        with_options(options) { |routes| routes.add_route_without_subdomains(*args) }
+      end
+
+      def raise_named_route_error_with_subdomains(options, named_route, named_route_name)
+        unless named_route.conditions[:subdomains].is_a?(Symbol)
+          raise_named_route_error_without_subdomains(options, named_route, named_route_name)
+        else
+          begin
+            options.delete(named_route.conditions[:subdomains])
+            raise_named_route_error_without_subdomains(options, named_route, named_route_name)
+          rescue ActionController::RoutingError => e
+            e.message << " You may also need to specify #{named_route.conditions[:subdomains].inspect} for the subdomain."
+            raise e
+          end
+        end
+      end
+
+      def reserved_subdomains
+        routes.map(&:reserved_subdomains).flatten.uniq
+      end
+    end
+
+    module Route
+      def self.included(base)
+        [ :recognition_conditions, :generation_extraction, :segment_keys, :significant_keys, :recognition_extraction ].each { |method| base.alias_method_chain method, :subdomains }
+      end
+
+      def recognition_conditions_with_subdomains
+        recognition_conditions_without_subdomains.tap do |result|
+          case conditions[:subdomains]
+          when Array
+            result << "conditions[:subdomains].include?(env[:subdomain])"
+          when Symbol
+            result << "(subdomain = env[:subdomain] unless env[:subdomain].blank?)"
+          end
+        end
+      end
+
+      def generation_extraction_with_subdomains
+        results = [ generation_extraction_without_subdomains ]
+        if conditions[:subdomains].is_a?(Symbol)
+          results << "return [nil,nil] unless hash.delete(#{conditions[:subdomains].inspect})"
+        end
+        results.compact * "\n"
+      end
+
+      def segment_keys_with_subdomains
+        segment_keys_without_subdomains.tap do |result|
+          result.unshift(conditions[:subdomains]) if conditions[:subdomains].is_a? Symbol
+        end
+      end
+
+      def significant_keys_with_subdomains
+        significant_keys_without_subdomains.tap do |result|
+          if conditions[:subdomains].is_a? Symbol
+            result << conditions[:subdomains]
+            result.uniq!
+          end
+        end
+      end
+
+      def recognition_extraction_with_subdomains
+        recognition_extraction_without_subdomains.tap do |result|
+          result.unshift "\nparams[#{conditions[:subdomains].inspect}] = subdomain\n" if conditions[:subdomains].is_a? Symbol
+        end
+      end
+
+      def reserved_subdomains
+        conditions[:subdomains].is_a?(Array) ? conditions[:subdomains] : []
+      end
+    end
+  end
+end
+
+ActionController::Routing::RouteSet.send :include, SubdomainRoutes::Routing::RouteSet
+ActionController::Routing::Route.send :include, SubdomainRoutes::Routing::Route

data/lib/subdomain_routes/split_host.rb

@@ -0,0 +1,47 @@
+module SubdomainRoutes
+  class TooManySubdomains < StandardError
+  end
+
+  module SplitHost
+    private
+    
+    def split_host(host)
+      raise HostNotSupplied, "No host supplied!" if host.blank?
+      raise HostNotSupplied, "Can't set subdomain for an IP address!" if host =~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
+      
+      static_domain = Config.static_domains.find { |static_domain| host.include?(static_domain) }
+      
+      if static_domain
+        split_host_by_static_domain(host, static_domain)
+      else
+        split_host_by_domain_length(host)
+      end
+    end
+    
+    def split_host_by_static_domain(host, static_domain)
+      split_host_by_domain_length(host, static_domain.count(".")+1)
+    end
+    
+    def split_host_by_domain_length(host, domain_length = Config.domain_length)
+      parts = host.split('.')
+      if domain_length
+        domain_parts = [ ]
+        domain_length.times { domain_parts.unshift parts.pop }
+        if parts.size > 1
+          raise TooManySubdomains, "Multiple subdomains found: #{parts.join('.')}. (Have you set SubdomainRoutes::Config.domain_length correctly?)"
+        end
+        [ parts.pop.to_s, domain_parts.join('.') ]
+      else
+        [ parts.shift.to_s, parts.join('.') ]
+      end
+    end
+    
+    def domain_for_host(host)
+      split_host(host).last
+    end
+    
+    def subdomain_for_host(host)
+      split_host(host).first
+    end
+  end
+end

data/lib/subdomain_routes/url_writer.rb

@@ -0,0 +1,92 @@
+module SubdomainRoutes
+  class HostNotSupplied < StandardError
+  end
+  
+  module RewriteSubdomainOptions
+    include SplitHost
+    
+    def subdomain_procs
+      ActionController::Routing::Routes.subdomain_procs
+    end
+
+    def rewrite_subdomain_options(options, host, port = nil, protocol = nil)
+      if subdomains = options[:subdomains]
+        old_subdomain, domain = split_host(host)
+        options_subdomain = options.has_key?(:subdomain) ? options[:subdomain].to_param.to_s.downcase : nil
+        new_subdomain = options_subdomain || old_subdomain
+        begin
+          case subdomains
+          when Array
+            unless subdomains.include? new_subdomain
+              if subdomains.size > 1 || options_subdomain
+                raise ActionController::RoutingError, "expected subdomain in #{subdomains.inspect}, instead got subdomain #{new_subdomain.inspect}"
+              else
+                new_subdomain = subdomains.first
+              end
+            end
+          when Symbol
+            new_subdomain = options[subdomains].to_param.to_s.downcase
+            unless new_subdomain.blank? || SubdomainRoutes.valid_subdomain?(new_subdomain)
+              raise ActionController::RoutingError, "subdomain #{new_subdomain.inspect} is invalid"
+            end
+          end            
+        rescue ActionController::RoutingError => e
+          raise ActionController::RoutingError, "Route for #{options.inspect} failed to generate (#{e.message})"
+        end
+        unless new_subdomain == old_subdomain
+          options[:only_path] = false
+          options[:host] = [ new_subdomain, domain ].reject(&:blank?).join('.')
+          options[:port] ||= port if port
+          options[:protocol] ||= protocol if protocol
+        end
+        options.delete(:subdomain)
+      end
+    end
+  end
+    
+  module UrlWriter
+    include RewriteSubdomainOptions
+    
+    def self.included(base)
+      base.alias_method_chain :url_for, :subdomains
+    end
+
+    def url_for_with_subdomains(options)
+      host     = options[:host]     || default_url_options[:host]
+      port     = options[:port]     || default_url_options[:port]
+      protocol = options[:protocol] || default_url_options[:protocol]
+      if options[:subdomains] && host.blank?
+        raise HostNotSupplied, "Missing host to link to! Please provide :host parameter or set default_url_options[:host]"
+      end
+      rewrite_subdomain_options(options, host, port, protocol)
+      url_for_without_subdomains(options)
+    end
+  end
+
+  module UrlRewriter
+    include RewriteSubdomainOptions
+    
+    def self.included(base)
+      base.alias_method_chain :rewrite, :subdomains
+      base::RESERVED_OPTIONS << :subdomain # untested!
+    end
+    
+    def rewrite_with_subdomains(options)
+      host     = options[:host]     || @request.host
+      protocol = options[:protocol] || (@request.ssl? ? @request.protocol : nil)
+      port     = options[:port]     || (@request.port_string =~ /:(\d+)$/ ? $1.to_i : nil)
+      if options[:subdomains] && host.blank?
+        raise HostNotSupplied, "Missing host to link to!"
+      end
+      rewrite_subdomain_options(options, host, port, protocol)
+      rewrite_without_subdomains(options)
+    end
+  end
+end
+
+ActionController::UrlWriter.send :include, SubdomainRoutes::UrlWriter
+ActionController::UrlRewriter.send :include, SubdomainRoutes::UrlRewriter
+
+if defined? ActionMailer::Base
+  ActionMailer::Base.send :include, ActionController::UrlWriter
+end