mataki-subdomain_routes 0.3.1

data/VERSION.yml

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

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,5 @@
+module SubdomainRoutes
+  module Config
+    mattr_accessor :domain_length
+  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
+        returning recognition_conditions_without_subdomains 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
+        returning segment_keys_without_subdomains do |result|
+          result.unshift(conditions[:subdomains]) if conditions[:subdomains].is_a? Symbol
+        end
+      end
+      
+      def significant_keys_with_subdomains
+        returning significant_keys_without_subdomains do |result|
+          if conditions[:subdomains].is_a? Symbol
+            result << conditions[:subdomains]
+            result.uniq!
+          end
+        end
+      end
+      
+      def recognition_extraction_with_subdomains
+        returning recognition_extraction_without_subdomains 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,32 @@
+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}$/
+      parts = host.split('.')
+      if Config.domain_length
+        domain_parts = [ ]
+        Config.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

data/lib/subdomain_routes/validations.rb

@@ -0,0 +1,42 @@
+module SubdomainRoutes
+  def self.valid_subdomain?(subdomain)
+    subdomain.to_s =~ /^([a-z]|[a-z][a-z0-9]|[a-z]([a-z0-9]|\-[a-z0-9])*)$/
+  end
+
+  # # Alternatively, we use URI::parse instead. This gives more lenient subdomains however:
+  # def self.valid_subdomain?(subdomain)
+  #   URI.parse "http://#{subdomain}.example.com"
+  # rescue URI::InvalidURIError
+  #   false
+  # end
+    
+  module Validations
+    module ClassMethods
+      def validates_subdomain_format_of(*attr_names)
+        configuration = { :on => :save }
+        configuration.update(attr_names.extract_options!)
+      
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          unless SubdomainRoutes.valid_subdomain?(value)
+            record.errors.add(attr_name, :not_a_valid_subdomain, :default => configuration[:message], :value => value) 
+          end
+        end
+      end
+      
+      def validates_subdomain_not_reserved(*attr_names)
+        configuration = { :on => :save }
+        configuration.update(attr_names.extract_options!)
+      
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          if ActionController::Routing::Routes.reserved_subdomains.include? value
+            record.errors.add(attr_name, :is_a_reserved_subdomain, :default => configuration[:message], :value => value) 
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined? ActiveRecord::Base
+  ActiveRecord::Base.send :extend, SubdomainRoutes::Validations::ClassMethods
+end