roomer 0.0.8

data/lib/roomer/extensions/model.rb

@@ -0,0 +1,72 @@
+module Roomer
+  module Extensions
+    module Model
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Sets the roomer scope for the model and changes the model's table_name_prefix
+        # Sets the table name prefix (schema name) to current_tenant's
+        # If :shared is passed, the global schema will be used as the table name prefix
+        # if :tenanted is pased, the current tenant's schema will be used as the table name prefix
+        # @return [Symbol] :shared or :tenanted
+        def roomer(scope)
+          case scope
+            when :shared
+              @roomer_scope = :shared
+            when :tenanted
+              @roomer_scope = :tenanted
+            else
+              raise "Invalid roomer model scope.  Choose :shared or :tenanted"
+          end
+          roomer_set_table_name_prefix
+        end
+
+        # Confirms if model is shared
+        # @return [True,False]
+        def shared?
+          @roomer_scope == :shared
+        end
+
+        # Confirms if model is scoped by tenant
+        # @return [True,False]
+        def tenanted?
+          @roomer_scope == :tenanted
+        end
+
+        # Resets model's cached table_name and
+        # column information.
+        # This method needs to get called whenever
+        # the current tenant changes
+        def roomer_reset
+          roomer_set_table_name_prefix
+          reset_table_name 
+          reset_column_information
+        end
+
+        protected
+        # Resolves the full table name prefix
+        def roomer_full_table_name_prefix(schema_name)
+          "#{schema_name.to_s}#{Roomer.schema_seperator}"
+        end
+
+        # Sets the model's table name prefix to the current tenant's schema name
+        # Defaults to public if model is marked as tenanted but tenant table
+        # hasn't been populated
+        def roomer_set_table_name_prefix
+          self.table_name_prefix = begin
+            case @roomer_scope
+              when :shared
+                roomer_full_table_name_prefix(Roomer.shared_schema_name)
+              when :tenanted
+                roomer_full_table_name_prefix(Roomer.current_tenant.try(Roomer.tenant_schema_name_column))
+              else
+                ""
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roomer/helpers/generator_helper.rb

@@ -0,0 +1,30 @@
+module Roomer
+  module Helpers
+    module GeneratorHelper
+
+      # Check to see if the model file exists, should be used in a Generator
+      # @return [True,False] 
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+
+      # Returns the path of the model
+      # @return [String] model_path string representing the model location
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+
+      # Reads the --shared option specified when running "rails generate roomer:model"
+      # @return [True,False]
+      def shared?
+        @shared ||= options[:shared]
+      end
+
+      # Fetchs the migration directory for the migrations
+      def migration_dir
+        return Roomer.shared_migrations_directory if shared?
+        return Roomer.tenanted_migrations_directory
+      end
+    end
+  end
+end

data/lib/roomer/helpers/migration_helper.rb

@@ -0,0 +1,7 @@
+module Roomer
+  module Helpers
+    module MigrationHelper
+      # Migration Helper Methods go here
+    end
+  end
+end

data/lib/roomer/helpers/postgres_helper.rb

@@ -0,0 +1,75 @@
+module Roomer
+  module Helpers
+    module PostgresHelper
+
+      # Creates a schema in PostgreSQL
+      # @param [#to_s] schema_name declaring the name of the schema
+      def create_schema(schema_name)
+        ActiveRecord::Base.connection.execute "CREATE SCHEMA \"#{schema_name.to_s}\""
+      end
+
+      # Drops a schema and all it's objects (Cascades)
+      # @param [#to_s] schema_name declaring the name of the schema to drop
+      def drop_schema(schema_name)
+        ActiveRecord::Base.connection.execute("DROP SCHEMA IF EXISTS \"#{schema_name.to_s}\" CASCADE")
+      end
+
+      # lists the schemas available
+      # @return [Array] list of schemas
+      def schemas
+        ActiveRecord::Base.connection.query("SELECT nspname FROM pg_namespace WHERE nspname !~ '^pg_.*'").flatten.map(&:to_s)
+      end
+
+      # Ensures the schema and schema_migrations exist(creates them otherwise) 
+      # and executes the code block
+      # @param [#to_s] schema_name declaring name to ensure
+      # @param [#call] &block code to execute
+      #
+      # Example:
+      #
+      #    ensuring_schema(:global) do
+      #       ActiveRecord::Migrator.migrate('/db/migrate', '20110812012536')
+      #    end
+      def ensuring_schema(schema_name, &block)
+        raise ArgumentError.new("schema_name not present") unless schema_name
+        ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        create_schema(schema_name) unless schemas.include?(schema_name.to_s)
+        ensure_prefix(schema_name) do
+          ensure_schema_migrations
+          yield
+        end
+      end
+
+      # Ensures the same ActiveRecord::Base#table_name_prefix for all the 
+      # models executed in the block
+      # @param [#to_s] A Symbol declaring the table name prefix
+      # @param [#call] code to execute
+      # @note All the Models will have the same prefix, caution is advised
+      #
+      # Example:
+      #
+      #   ensure_prefix(:global) do
+      #      Person.find(1)  # => will execute "SELECT id FROM 'global.person' where 'id' = 1"
+      #   end
+      def ensure_prefix(prefix, &block)
+        @old_prefix = ActiveRecord::Base.table_name_prefix
+        ActiveRecord::Base.table_name_prefix = "#{prefix.to_s}#{Roomer.schema_seperator.to_s}"
+        yield
+        ActiveRecord::Base.table_name_prefix = @old_prefix
+      end
+
+      # Ensures schema_migrations table exists and creates otherwise
+      # @see ActiveRecord::Base.connection#initialize_schema_migrations_table
+      def ensure_schema_migrations
+        ActiveRecord::Base.connection.initialize_schema_migrations_table
+      end
+
+      # Determine if there are any pending migrations in the shared migrations directory
+      # @returns true if migrations are pending
+      def shared_migrations_pending?
+        ActiveRecord::Migrator.new(:up,Roomer.shared_migrations_directory)
+      end
+
+    end
+  end
+end

data/lib/roomer/rails.rb

@@ -0,0 +1,24 @@
+module Roomer
+  class RoomerEngine < ::Rails::Engine
+
+    initializer 'roomer.extensions' do |app|
+      # load model extensions
+      ActiveSupport.on_load(:active_record) do
+        include Roomer::Extensions::Model
+      end
+
+      # load controller extensions
+      ActiveSupport.on_load(:action_controller) do
+        include Roomer::Extensions::Controller
+      end
+    end
+
+    # load all the rake tasks
+    rake_tasks do
+      Dir[File.expand_path("../tasks/*.rake", __FILE__)].each do |file|
+        load file
+      end
+    end
+
+  end
+end

data/lib/roomer/schema.rb

@@ -0,0 +1,63 @@
+require 'active_support/core_ext/object/blank'
+
+module Roomer
+  # Roomer::Schema extends ActiveRecord::Schema
+  # Roomer::Schema is currently only supported by the Postgres database adapter
+
+  class Schema < ActiveRecord::Migration
+    extend Roomer::Helpers::PostgresHelper
+
+    def self.migrations_path(scope=:tenanted)
+      case scope
+        when :shared
+          return Roomer.shared_migrations_directory
+        when :tenanted
+          return Roomer.tenanted_migrations_directory
+        else
+          raise 'Invalid scope parameter'
+      end
+    end
+
+    def self.dump(scope=:tenanted)
+      case scope
+        when :shared
+          schema_name = Roomer.shared_schema_name.to_s
+          filename = Roomer.shared_schema_filename
+        when :tenanted
+          tenant = Tenant.first
+          return if tenant.blank?
+
+          schema_name = Tenant.first.schema_name.to_s
+          filename = Roomer.tenanted_schema_filename
+      end
+      FileUtils.mkdir_p(Roomer.schemas_directory) unless File.exists?(Roomer.schemas_directory)
+      filepath = File.expand_path(File.join(Roomer.schemas_directory, filename))
+      ActiveRecord::Base.connection.schema_search_path = schema_name
+      ActiveRecord::Base.table_name_prefix = "#{schema_name}."
+      Roomer::SchemaDumper.dump(ActiveRecord::Base.connection, File.new(filepath, "w"))
+    end
+
+    def self.load(schema_name, scope=:tenanted)
+      filename = begin
+        if scope == :shared
+          Roomer.shared_schema_filename
+        elsif scope == :tenanted
+          Roomer.tenanted_schema_filename
+        end
+      end
+      filepath = File.expand_path(File.join(Roomer.schemas_directory, filename))
+      return unless File.exists?(filepath)
+
+      ensuring_schema(schema_name) do
+        Object.load(filepath) 
+      end
+    end
+
+    def self.define(info={}, &block)
+      instance_eval(&block)
+      unless info[:version].blank?
+        ActiveRecord::Base.connection.assume_migrated_upto_version(info[:version], migrations_path)
+      end
+    end
+  end
+end

data/lib/roomer/schema_dumper.rb

@@ -0,0 +1,36 @@
+module Roomer
+  class SchemaDumper < ActiveRecord::SchemaDumper
+
+    protected
+    def header(stream)
+      define_params = @version ? ":version => #{@version}" : ""
+      stream.puts <<HEADER
+# It's strongly recommended to check this file into your version control system.
+    
+Roomer::Schema.define(#{define_params}) do
+
+HEADER
+    end
+
+    def indexes(table, stream)
+      if (indexes = @connection.indexes(table)).any?
+        add_index_statements = indexes.map do |index|
+          statement_parts = [ ('add_index ' + index.table.inspect) ]
+          statement_parts << index.columns.inspect
+          statement_parts << (':name => "' + index.columns.first.to_s.split('.').last + '"')
+          statement_parts << ':unique => true' if index.unique
+  
+          index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
+          if index_lengths.present?
+            statement_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect)
+          end
+  
+          '  ' + statement_parts.join(', ')
+        end
+  
+        stream.puts add_index_statements.sort.join("\n")
+        stream.puts
+      end
+    end
+  end
+end

data/lib/roomer/tasks/migrate.rake

@@ -0,0 +1,85 @@
+include Roomer::Helpers::PostgresHelper
+include Roomer::Helpers::GeneratorHelper
+
+namespace :roomer do
+  namespace :shared do
+    desc "Migrates the shared tables. Target specific version with VERSION=x"
+    task :migrate => :environment do
+      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      ensuring_schema(Roomer.shared_schema_name) do
+        ActiveRecord::Migrator.migrate(Roomer.shared_migrations_directory, version)
+      end
+      Roomer::Schema.dump(:shared)
+    end
+
+    desc "Rolls back shared tables. Target specific version with STEP=x"
+    task :rollback => :environment do
+      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+      ensuring_schema(Roomer.shared_schema_name) do
+        ActiveRecord::Migrator.rollback(Roomer.shared_migrations_directory, step)
+      end
+      Roomer::Schema.dump(:shared)
+    end
+
+    namespace :schema do
+      desc "Load shared schema into database"
+      task :load => :environment do
+        Roomer::Schema.load(Roomer.shared_schema_name, :shared)
+      end
+
+      desc "Dumps the shared schema to shared/schema.rb.  This file can be portably used against any DB supported by AR"
+      task :dump => :environment do
+        Roomer::Schema.dump(:shared)
+      end
+    end
+  end
+
+  namespace :tenanted do
+    desc "Migrates the tenanted tables. Target specific version with VERSION=x"
+    task :migrate => :environment do
+      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      Roomer.tenant_model.find(:all).each do |tenant|
+        ensuring_schema(tenant.try(Roomer.tenant_schema_name_column)) do
+          ActiveRecord::Migrator.migrate(Roomer.tenanted_migrations_directory, version)
+        end
+      end
+      Roomer::Schema.dump(:tenanted)
+    end
+
+    desc "Rolls back tenanted tables. Target specific version with STEP=x"
+    task :rollback => :environment do
+      step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+      Roomer.tenant_model.find(:all).each do |tenant|
+        ensuring_schema(tenant.try(Roomer.tenant_schema_name_column)) do
+          ActiveRecord::Migrator.rollback(Roomer.tenanted_migrations_directory, step)
+        end
+      end
+      Roomer::Schema.dump(:tenanted)
+    end
+
+    namespace :schema do
+      desc "Load tenanted schema into database"
+      task :load => :environment do
+        schema_name = ENV['SCHEMA_NAME']
+        raise "No schema name provided.  Try: env SCHEMA_NAME=" if schema_name.blank?
+        Roomer::Schema.load(schema_name)
+      end
+
+      desc "Dumps tenanted schema file to migrate/schema.rb.  This file can be portably used against any DB supported by AR"
+      task :dump => :environment do
+        Roomer::Schema.dump
+      end
+    end
+  end
+
+  desc "Runs shared and tenanted migrations"
+  task :migrate do
+    if ENV["VERSION"].blank?
+      Rake::Task["roomer:shared:migrate"].invoke
+      Rake::Task["roomer:tenanted:migrate"].invoke
+    else
+      Rake::Task["roomer:tenanted:migrate"].invoke
+      Rake::Task["roomer:shared:migrate"].invoke
+    end
+  end
+end

data/lib/roomer/utils.rb

@@ -0,0 +1,68 @@
+module Roomer
+  module Utils
+
+    # Rails DB Migrations Directory
+    # @return [String] full path to the current migrations directory
+    def migrations_directory
+      ActiveRecord::Migrator.migrations_path
+    end
+
+    # Directory where the models are stored
+    # @return [String] path of the directory where the models are stored
+    def model_directory
+      File.join("app","models")
+    end
+
+    # Consutructs the full name for the tenants table with schema 
+    # Example: 'global.tenant'
+    # @return [String] full name of the tenant table
+    def full_tenants_table_name
+      "#{shared_schema_name}#{schema_seperator}#{tenants_table}"
+    end
+
+    # Constructs the full path to the shared schema directory
+    # Example: /Users/Greg/Projects/roomer/db/migrate/global  
+    # @return [String] full path to the shared schema directory
+    def full_shared_schema_migration_path
+      "#{Rails.root}/#{shared_migrations_directory}"
+    end
+
+    # Returns tenant model as a constant
+    # Example: Tenant
+    # @return Object
+    def tenant_model
+      Roomer.tenants_table.to_s.classify.constantize
+    end
+
+    # Sets current tenant from ApplicationController into a Thread
+    # local variable.  Works only with thread-safe Rails as long as
+    # it gets set on every request
+    # @return [Symbol] the current tenant key in the thread
+    def current_tenant=(val)
+      key = :"roomer_current_tenant"
+      Thread.current[key] = val
+      ensure_tenant_model_reset
+    end
+
+    # Fetches the current tenant
+    # @return [Symbol] the current tenant key in the thread
+    def current_tenant
+      key = :"roomer_current_tenant"
+      Thread.current[key]
+    end
+
+    # Reset current tenant
+    # @return [Nil]
+    def reset_current_tenant
+      key = :"roomer_current_tenant"
+      Thread.current[key] = nil
+    end
+
+    # Reset cached data in tenanted models
+    def ensure_tenant_model_reset
+      ActiveRecord::Base.descendants.each do |model|
+        model.roomer_reset if model.tenanted?
+      end
+    end
+  end
+end

data/lib/roomer/version.rb

@@ -0,0 +1,14 @@
+module Roomer
+  module VERSION # :nodoc:
+    unless defined? MAJOR
+      MAJOR  = 0
+      MINOR  = 0
+      TINY   = 8
+      PRE    = nil
+
+      STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+      SUMMARY = "roomer #{STRING}"
+    end
+  end
+end

data/lib/roomer.rb

@@ -0,0 +1,125 @@
+require 'rails'
+require 'active_support'
+require 'active_support/dependencies'
+require 'active_record'
+require 'roomer/version'
+
+module ActiveRecord
+  autoload :Migration,          'active_record/migration'
+end
+
+module Roomer
+  autoload :Utils,              'roomer/utils'
+
+  module Helpers
+    autoload :GeneratorHelper,  'roomer/helpers/generator_helper'
+    autoload :PostgresHelper,   'roomer/helpers/postgres_helper'
+    autoload :MigrationHelper,  'roomer/helpers/migration_helper'
+  end
+
+  module Extensions
+    autoload :Model,            'roomer/extensions/model'
+    autoload :Controller,       'roomer/extensions/controller'
+  end
+
+  autoload :SchemaDumper,       'roomer/schema_dumper'
+  autoload :Schema,             'roomer/schema'
+
+  extend Utils
+
+  # The URL routing strategy. Roomer currently supports two routing strategies (:domain and :path)
+  #  * :domain  -  Using domain name to identify the tenant. This could include a subdomain
+  #  * :path    -  identifying the tenant by the path
+  #  Example:
+  #  Domain
+  #  ------
+  #  http://mytenant.myapp.com - If you tenant has a subdomain under your domain
+  #  http://mytenant.com - If the tenant choose to use their own top level domain name
+  #  http://myapp.mytenant.com If the tenant chooses to use their own subdomain under thier TLD
+  #  Path
+  #  ----
+  #  http://yourapp.com/tenant
+  mattr_accessor :url_routing_strategy
+  @@url_routing_strategy = :domain
+
+  # name of the shared schema where all the shared tables are be present
+  mattr_accessor :shared_schema_name
+  @@shared_schema_name = :global
+
+  # The name of the table where the tenants are stored, this table must 
+  # contain two required columns configured under tenant_url_identifier_column and
+  # tenant_schema_name_column
+  mattr_accessor :tenants_table
+  @@tenants_table = :tenants
+
+  # The column name that stores the url identfier in the tenants tables.
+  # A url idenfier is a unique value that identifies the tenant from the URL.
+  # For e.g: if you use domains and the url is http://mytenant.myapp.com, 
+  # the url identifier would "mytenant"
+  mattr_accessor :tenant_url_identifier_column
+  @@tenant_url_identifier_column = :url_identifier
+
+  # The column name that strores the schema name in the tenants tables. 
+  mattr_accessor :tenant_schema_name_column
+  @@tenant_schema_name_column = :schema_name
+
+  # The schema seperator. This is used when generating the table name. 
+  # The default is set to "."
+  # Example: tenant's table by default will be global.tenants
+  mattr_accessor :schema_seperator
+  @@schema_seperator = '.'
+
+  # Directory where schema files will be stored.
+  mattr_accessor :schemas_directory
+  @@schemas_directory = File.expand_path(File.join("db", "schemas"))
+
+  # Tenanted schema filename.
+  mattr_accessor :tenanted_schema_filename
+  @@tenanted_schema_filename = "tenanted_schema.rb"
+
+  # Shared schema filename.
+  mattr_accessor :shared_schema_filename
+  @@shared_schema_filename = "shared_schema.rb"
+
+  # Use Tentant migrations directory?
+  # Default is set to false 
+  mattr_accessor :use_tenanted_migrations_directory
+  alias_method   :use_tenanted_migrations_directory?,
+                 :use_tenanted_migrations_directory 
+  @@use_tenanted_migrations_directory = false
+
+  # Directory where the tenanted migrations are stored.
+  # This will be used only if use_tenanted_migration_directory is set to
+  # true if not usual rails migraiton directory db/migrate will be used
+  mattr_writer :tenanted_migrations_directory
+  @@tenanted_migrations_directory = File.join(migrations_directory,tenants_table.to_s)
+
+
+  # Directory where shared migrations are stored.
+  mattr_accessor :shared_migrations_directory
+  @@shared_migrations_directory = File.join(migrations_directory,shared_schema_name.to_s)
+
+  # Fetches the migrations directory for Tenanted migrations. 
+  # returns the standard rails migration directory "db/migrate" is the 
+  # use_tenanted_migrations_directory is set to false
+  # @return [String] String representing the tenanted migrations
+  def self.tenanted_migrations_directory
+    if self.use_tenanted_migrations_directory
+      return @@tenanted_migrations_directory
+    end
+    return migrations_directory
+  end
+
+  # Default way to setup Roomer. Run rails generate roomer:install to create
+  # a fresh initializer with all configuration values.
+  # @example
+  #     Roomer.setup do |config|
+  #       config.url_routing_strategy = :domain
+  #     end
+  def self.setup
+    yield self
+  end
+
+end
+
+require 'roomer/rails'

data/roomer.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "roomer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "roomer"
+  s.version     = Roomer::VERSION::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.homepage    = "https://github.com/gosuri/roomer"
+  s.summary     = "Roomer is a multitenant framework for Rails using PostgreSQL"
+  s.description = Roomer::VERSION::SUMMARY
+
+  s.authors     = ["Greg Osuri","Daniel Ceballos"]
+  s.email       = ["gosuri@gmail.com","dceballos@gmail.com"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency  'rails','~> 3.0.9'
+end

data/test/config.rb

@@ -0,0 +1,3 @@
+require 
+TEST_ROOT = File.expand_path(File.dirname(__FILE__))
+

data/test/config.yml

@@ -0,0 +1,7 @@
+postgresql: &postgresql
+  adapter:  postgresql
+  encoding: unicode
+  database: roomer_test
+  username: postgres
+
+

data/test/generators/install_generator_test.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+require "generators/roomer/install/install_generator"
+
+class InstallGeneratorTest < Rails::Generators::TestCase
+  tests Roomer::Generators::InstallGenerator
+  destination File.expand_path("../../tmp", __FILE__)
+  setup :prepare_destination
+
+  test "assert initializer file created" do
+    run_generator
+    assert_file "config/initializers/roomer.rb"
+  end
+end