domain_switcher 0.1.0

data/README.rdoc

@@ -0,0 +1,11 @@
+= DomainSwitcher
+
+Rack based domain switcher with configuration
+
+* Add a website and a domain object in the context
+* Switch cache namespace
+* Switch cookie domain
+
+== Usage for Rails 2.3:
+
+  config.middleware.use 'DomainSwitcher::Middleware'

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = true
+end
+
+task :default => :spec

data/init.rb

@@ -0,0 +1 @@
+require 'domain_switcher'

data/lib/domain_switcher/cache.rb

@@ -0,0 +1,36 @@
+module DomainSwitcher
+  module Cache
+    
+    def self.init
+      $domain_switcher_cache_systems = {}
+    end
+
+    def self.switch(website)
+      namespace = website.cache_prefix || website.symbol
+
+      if (c = RAILS_CACHE)
+        if !$domain_switcher_cache_systems.key?(namespace)
+          Rails.logger.info "DomainSwitcher: Create new cache system for namespace : #{c.class} | #{namespace}" 
+
+          # MemcachedStore => Tested and working with Memcached gem only
+          $domain_switcher_cache_systems[namespace] = if ActiveSupport::Cache::MemCacheStore === c
+            d = RAILS_CACHE.instance_variable_get('@data')
+            if d.prefix_key == namespace
+              Rails.logger.info "DomainSwitcher: Use existing cache => namespace is the same: #{namespace}"
+              RAILS_CACHE
+            else
+              c.class.new(d.instance_variable_get('@servers'), d.instance_variable_get('@options').merge(:namespace => namespace, :prefix_key => namespace))
+            end
+          elsif c.is_a? ActiveSupport::Cache::FileStore
+            c.class.new("tmp/cache/#{namespace}")
+          else
+            c
+          end
+        end
+        ActionController::Caching.send(:class_variable_set, :@@cache_store, (Thread.current[:domain_switcher_cache] = $domain_switcher_cache_systems[namespace]))
+      end
+
+    end
+
+  end
+end

data/lib/domain_switcher/config_builder.rb

@@ -0,0 +1,40 @@
+module DomainSwitcher
+  module ConfigBuilder
+
+    # Create a bunch of method for the configuration hash
+    def build_config!(hash)
+      raise "Build config only accept hashes and not #{conf.class}" unless Hash === hash
+      
+      # From: https://github.com/kwi/awesome_conf
+      m = Module.new do
+        instance_methods.each { |selector| remove_method(selector) }
+
+        hash.each do |k, v|
+          const_set('AC_' + k.to_s, v)
+          module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+            def #{k}
+              #{'AC_'+ k.to_s}
+            end
+          END_EVAL
+          
+          if TrueClass === v or FalseClass === v
+            module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+              def #{k}?
+                #{v ? true : false}
+              end
+            END_EVAL
+          end
+        end
+
+      end
+
+      extend m
+    end
+
+    # Do nothing when a method is missing
+    def method_missing(m)
+      nil
+    end
+
+  end  
+end

data/lib/domain_switcher/config_loader.rb

@@ -0,0 +1,59 @@
+require 'yaml'
+
+module DomainSwitcher
+  class ConfigLoader
+    
+    attr_reader :websites
+    attr_reader :domains
+
+    def initialize(config_file = 'config/websites.yml')
+      begin
+        @conf = YAML::load_file(config_file)
+      rescue ArgumentError => e
+        raise ArgumentError.new("DomainSwitcher: Malformed config file (#{config_file}): #{e}")
+      end
+      raise ArgumentError.new("DomainSwitcher: Empty config file (#{config_file})") if !@conf or @conf.size == 0
+
+      @websites = []
+      @domains = []
+      parse_conf!      
+    end
+    
+  private
+    def parse_conf!
+      @conf.each do |website, conf|
+        domains = conf.delete('domains')
+        default_domain = conf.delete('default_domain')
+        raise "DomainSwitcher: Website without domain: #{website}" if !domains or domains.size == 0
+        raise "DomainSwitcher: Website without default domain: #{website}" if !default_domain
+        
+        website = Website.new(conf['name'], website, conf)
+        
+        domains.each do |d|
+          if String === d
+            website << Domain.new(website, d, conf.merge(conf))
+          else # It's an hash like this: {"www.website1.com"=>{"name"=>"Website 1 override", "width"=>900}}
+            raise "DomainSwitcher: Bad indentation in the config file" if d.size != 1
+            website << Domain.new(website, d.first.first, d.first.last.merge(conf))
+          end
+        end
+
+        # Set the default domain for the website
+        website.default_domain = website.domains.find {|d| d.domain == default_domain } || website.domains.first
+
+        # Collect websites and domains
+        @websites << website
+        @domains += website.domains
+      end      
+    end
+
+  public
+    def default_website
+      @default_website ||= @websites.find { |w| w.default? } || @websites.first
+    end
+
+    def default_domain
+      @default_domain ||= @domains.find { |d| d.default? } || @domains.first
+    end    
+  end
+end

data/lib/domain_switcher/cookie.rb

@@ -0,0 +1,10 @@
+module DomainSwitcher
+  module Cookie
+    
+    def self.switch(domain, env)
+      env['rack.session.options'].update(:domain => domain.cookie_domain)
+      env
+    end
+
+  end
+end

data/lib/domain_switcher/domain.rb

@@ -0,0 +1,19 @@
+module DomainSwitcher
+  class Domain
+    include ConfigBuilder
+
+    attr_reader :website
+    attr_reader :domain
+
+    def initialize(website, domain, conf = {})
+      @website = website
+      @domain = domain
+      build_config!(conf)
+    end
+    
+    def cookie_domain
+      @cookie_domain ||= domain.split('.').last(2).join('.')
+    end
+
+  end
+end

data/lib/domain_switcher/helper.rb

@@ -0,0 +1,13 @@
+module DomainSwitcher
+  module Helper
+    
+    def domain
+      Thread.current[:domain_switcher_domain]
+    end
+    
+    def website
+      Thread.current[:domain_switcher_website]
+    end
+    
+  end
+end

data/lib/domain_switcher/middleware.rb

@@ -0,0 +1,29 @@
+module DomainSwitcher
+  class Middleware
+
+    def initialize(app, config = nil)
+      @app = app
+      @config = config || DomainSwitcher::ConfigLoader.new
+      @scanner = DomainSwitcher::Scanner.new(@config.domains)
+      
+      DomainSwitcher::Cache.init
+    end
+
+    def call(env)
+      domain = @scanner.scan_domain(env['HTTP_HOST']) || @config.default_domain
+
+      Rails.logger.debug "DomainSwitcher: Switch context for domain: #{domain.domain} (#{domain.website.name})"
+
+      if Thread.current[:domain_switcher_domain] != domain
+        Thread.current[:domain_switcher_domain] = domain
+        Thread.current[:domain_switcher_website] = domain.website
+
+        DomainSwitcher::Cache::switch(domain.website)
+        env = DomainSwitcher::Cookie::switch(domain, env)
+      end
+      
+      @app.call(env)
+    end
+
+  end
+end

data/lib/domain_switcher/rails.rb

@@ -0,0 +1,12 @@
+# Override the default Rails.cache method in order to user the current memcache store
+module Rails
+  class << self
+    def cache
+      Thread.current[:domain_switcher_cache] || RAILS_CACHE
+    end
+  end
+end
+
+ActionController::Base.send   :include, DomainSwitcher::Helper
+ActiveRecord::Base.send       :include, DomainSwitcher::Helper
+ActionView::Base.send         :include, DomainSwitcher::Helper

data/lib/domain_switcher/scanner.rb

@@ -0,0 +1,19 @@
+module DomainSwitcher
+  class Scanner
+
+    @@domain_cache = {}
+    
+    def initialize(domains)
+      @domains = domains
+
+      domains.each do |d|
+        @@domain_cache[d.domain] = d
+      end
+    end
+
+    def scan_domain(host)
+      @@domain_cache[host]
+    end
+    
+  end
+end

data/lib/domain_switcher/website.rb

@@ -0,0 +1,22 @@
+module DomainSwitcher
+  class Website
+    include ConfigBuilder
+
+    attr_reader :name
+    attr_reader :symbol
+    attr_reader :domains
+    attr :default_domain, true
+    
+    def initialize(name, symbol, conf = {}, domains = [])
+      @name = name
+      @symbol = symbol
+      @domains = domains
+      build_config!(conf)
+    end
+    
+    def <<(domain)
+      @domains << domain
+    end
+
+  end
+end

data/lib/domain_switcher.rb

@@ -0,0 +1,15 @@
+module DomainSwitcher
+  autoload :Middleware,    'domain_switcher/middleware'
+  autoload :ConfigLoader,  'domain_switcher/config_loader'
+  autoload :ConfigBuilder, 'domain_switcher/config_builder'
+  autoload :Website,       'domain_switcher/website'
+  autoload :Domain,        'domain_switcher/domain'
+  autoload :Helper,        'domain_switcher/helper'
+  autoload :Scanner,       'domain_switcher/scanner'
+  autoload :Cache,         'domain_switcher/cache'
+  autoload :Cookie,        'domain_switcher/cookie'
+  autoload :Logger,        'domain_switcher/logger'
+end
+
+current_path = File.dirname(__FILE__)
+require File.join(current_path, 'domain_switcher/rails')

data/spec/config/websites.yml

@@ -0,0 +1,27 @@
+website1:
+  name: Website 1
+  default_domain: www.website1.com
+  cache_prefix: first
+  domains:
+    - www.website1.com:
+        width: 900
+        name: Website 1 override
+    - www.website1-other-domain.com:
+        cookie_domain: www.website1-other-domain.com
+    - www.website1-other-domain-again.com
+    - www.website1-other-domain-again-again.com
+  width: 800
+  bool: true
+  bool2: false
+    
+website2:
+  name: Website2
+  default: true
+  default_domain: fr.website2.com
+  cookie_domain: 'website2cookie.com'
+  domains:
+    - www.website2.com:
+        default: true
+    - fr.website2.com
+  lang: fr
+  false_meth: false

data/spec/config/websites_bad_indentation.yml

@@ -0,0 +1,24 @@
+website1:
+  name: Website 1
+  default_domain: www.website1.com
+  domains:
+    - www.website1.com:
+      width: 900
+      name: Website 1 override
+    - www.website1-other-domain.com:
+        cookie_domain: www.website1-other-domain.com
+    - www.website1-other-domain-again.com
+    - www.website1-other-domain-again-again.com
+  width: 800
+  bool: true
+  bool2: false
+    
+website2:
+  name: Website2
+  default: true
+  default_domain: fr.website2.com
+  domains:
+    - www.website2.com:
+      default: true
+    - fr.website2.com
+  lang: fr

data/spec/config/websites_broken.yml

@@ -0,0 +1,5 @@
+bouahh
+  - broken_file:
+    broken:
+      - yes
+      malformed

data/spec/domain_switcher/config_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe :config_loader do
+
+  context "With incorrect conf file" do
+    it "Raise correctly on empty" do
+      e = nil
+      begin
+        DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites_empty.yml'))
+      rescue Exception => e
+      end
+      e.to_s.index('DomainSwitcher: Empty config file').should_not be_nil
+    end
+
+    it "Raise correctly on not found config file" do
+      e = nil
+      begin
+        DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites_not_existing.yml'))
+      rescue Exception => e
+      end
+      e.to_s.index('No such file or directory').should_not be_nil
+    end
+
+    it "Raise correctly on malformed config file" do
+      e = nil
+      begin
+        DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites_broken.yml'))
+      rescue ArgumentError => e
+      end
+      e.to_s.index('DomainSwitcher: Malformed config file').should_not be_nil
+    end
+    
+    it "Raise correctly on bad indentation config file" do
+      e = nil
+      begin
+        DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites_bad_indentation.yml'))
+      rescue Exception => e
+      end
+      e.to_s.index('DomainSwitcher: Bad indentation in the config file').should_not be_nil
+    end
+  end
+  
+  context 'With a correct file' do
+    before :all do
+      @config = DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites.yml'))
+    end
+    
+    it "load correctly all domains" do
+      @config.domains.size.should == 6
+      @config.domains.collect(&:domain).uniq.size.should == 6
+      @config.domains.first.domain.should == 'www.website1.com'
+    end
+
+    it "load correctly all websites" do
+      @config.websites.size.should == 2
+      @config.websites.collect(&:symbol).uniq.size.should == 2
+      @config.websites.first.symbol.should == 'website1'
+    end
+
+    it "set correctly default domain" do
+      @config.websites[0].default_domain.domain.should == 'www.website1.com'
+      @config.websites[1].default_domain.domain.should == 'fr.website2.com'
+      @config.default_domain.domain.should == 'www.website2.com'
+    end
+
+    it "set correctly default website" do
+      @config.default_website.symbol.should == 'website2'
+    end
+
+    it "conf variables are well set" do
+      @config.default_website.name.should == 'Website2'
+      @config.default_website.default.should == true
+      @config.default_website.lang.should == 'fr'
+    end
+
+    it "boolean conf variables are well set" do
+      @config.default_website.default?.should == true
+      @config.default_website.false_meth?.should == false
+    end
+    
+    it "cookie domain can be overrided" do
+      @config.default_domain.cookie_domain.should == 'website2cookie.com'
+    end
+
+  end
+end

data/spec/domain_switcher/domain_switcher_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe :domain_switcher do
+
+  before :all do
+    @conf = DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites.yml'))
+    @app = DomainSwitcher::Middleware.new(Proc.new {|b| [200, 'OK']}, @conf)
+  end
+
+  it "not create a new memcache connection if namespace is the same" do
+    @app.call({'HTTP_HOST' => 'www.website1.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    Thread.current[:domain_switcher_cache].instance_variable_get('@data') == RAILS_CACHE
+  end
+  
+  it "switch on default when nothing is found" do
+    @app.call({'HTTP_HOST' => 'nothing', 'rack.session.options' => {:domain => :test, :something => true}})
+    Thread.current[:domain_switcher_domain].should == @conf.default_domain
+    Thread.current[:domain_switcher_website].should == @conf.default_website
+  end
+
+  it "correctly switch" do
+    @app.call({'HTTP_HOST' => 'www.website1.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    Thread.current[:domain_switcher_domain].domain.should == 'www.website1.com'
+    Thread.current[:domain_switcher_website].symbol.should == 'website1'
+  end
+
+  it "correctly switch the cookie domain" do
+    env = {'HTTP_HOST' => 'www.website1.com', 'rack.session.options' => {:domain => :test, :something => true}}
+    @app.call(env)
+    env['rack.session.options'][:domain].should == 'website1.com'
+  end
+
+  it "correctly switch the cache namespace" do
+    @app.call({'HTTP_HOST' => 'www.website1.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    Rails.cache.instance_variable_get('@data').prefix_key.should == 'first'
+    @app.call({'HTTP_HOST' => 'www.website2.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    Rails.cache.instance_variable_get('@data').prefix_key.should == 'website2'
+    @app.call({'HTTP_HOST' => 'www.website1.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    Rails.cache.instance_variable_get('@data').prefix_key.should == 'first'
+  end
+
+
+end

data/spec/domain_switcher/helper_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe :helper do
+
+  before :all do
+    @conf = DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites.yml'))
+    @app = DomainSwitcher::Middleware.new(Proc.new {|b| [200, 'OK']}, @conf)
+  end
+
+  it "Check helper" do
+    @app.call({'HTTP_HOST' => 'www.website1.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    ActionController::Base.new.website.symbol.should == 'website1'
+    ActionController::Base.new.website.should == Thread.current[:domain_switcher_website]
+    ActionController::Base.new.domain.should == Thread.current[:domain_switcher_domain]
+    
+    @app.call({'HTTP_HOST' => 'www.website2.com', 'rack.session.options' => {:domain => :test, :something => true}})
+    ActionController::Base.new.website.symbol.should == 'website2'
+    ActionController::Base.new.website.should == Thread.current[:domain_switcher_website]
+    ActionController::Base.new.domain.should == Thread.current[:domain_switcher_domain]
+    ActionView::Base.new.website.should == Thread.current[:domain_switcher_website]
+    ActiveRecord::Base.new.domain.should == Thread.current[:domain_switcher_domain]    
+  end
+
+end

data/spec/domain_switcher/scanner_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe :scanner do
+  
+  before :all do
+    @config = DomainSwitcher::ConfigLoader.new(File.join(File.dirname(__FILE__), '../config/websites.yml'))
+    @scanner = DomainSwitcher::Scanner.new(@config.domains)
+  end
+  
+  it "return nil when not existing" do
+    @scanner.scan_domain(nil).should == nil
+    @scanner.scan_domain('something_not_existing').should == nil
+  end
+
+  it "return correct domain when existing" do
+    @scanner.scan_domain('www.website2.com').should_not be_nil
+    @scanner.scan_domain('www.website2.com').domain == 'www.website2.com'
+    @scanner.scan_domain('fr.website2.com').domain == 'fr.website2.com'
+    @scanner.scan_domain('www.website1-other-domain-again.com').domain == 'www.website1-other-domain-again.com'
+    @scanner.scan_domain('www.website1.com').domain == 'www.website1.com'
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rspec'
+require 'logger'
+
+module ActionController
+  class Base
+  end
+  
+  module Caching
+  end
+end
+
+module ActionView
+  class Base
+  end
+end
+
+module ActiveRecord
+  class Base
+  end
+end
+
+module ActiveSupport
+  module Cache
+    class MemCacheStore
+      def initialize(*args)
+        @data = Memcached.new(*args)
+      end
+    end
+    
+    class Memcached  
+      def initialize(servers, options = {})
+        @servers = servers
+        @options = options
+      end
+      
+      def prefix_key
+        @options[:prefix_key]
+      end
+
+    end
+    
+    class FileStore
+    end
+  end
+end
+
+module Rails
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end  
+end
+
+RAILS_CACHE = ActiveSupport::Cache::MemCacheStore.new(['localhost'], {:test_options => true, :prefix_key => 'first'})
+
+require File.dirname(__FILE__) + '/../init.rb'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: domain_switcher
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Guillaume Luccisano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-24 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id001
+description: Rack based domain switcher with configuration
+email: guillaume@justin.tv
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/domain_switcher/cache.rb
+- lib/domain_switcher/config_builder.rb
+- lib/domain_switcher/config_loader.rb
+- lib/domain_switcher/cookie.rb
+- lib/domain_switcher/domain.rb
+- lib/domain_switcher/helper.rb
+- lib/domain_switcher/middleware.rb
+- lib/domain_switcher/rails.rb
+- lib/domain_switcher/scanner.rb
+- lib/domain_switcher/website.rb
+- lib/domain_switcher.rb
+- spec/config/websites.yml
+- spec/config/websites_bad_indentation.yml
+- spec/config/websites_broken.yml
+- spec/config/websites_empty.yml
+- spec/domain_switcher/config_spec.rb
+- spec/domain_switcher/domain_switcher_spec.rb
+- spec/domain_switcher/helper_spec.rb
+- spec/domain_switcher/scanner_spec.rb
+- spec/spec_helper.rb
+- Rakefile
+- README.rdoc
+- init.rb
+has_rdoc: true
+homepage: http://www.justin.tv
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 19
+      segments: 
+      - 1
+      - 3
+      - 4
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: domain_switcher
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Rack based domain switcher with configuration
+test_files: []
+