cell 0.1.2 → 0.2.0

data/lib/cell/migration.rb

@@ -1,201 +0,0 @@
-#
-# This is the messiest part of Cell, I think by necessity.
-#
-# A migration has two execution modes, global and targeted, with correspond to "db:migrate" and
-# "cell:db:migrate"
-#
-# "global" is ran with a "db:migrate", which means no Tenant is activated.  DDL commands here are
-# directed to either 'public' or 'cell_prototype'
-#
-# "targeted" is ran with a tenant activated (cell:db:migrate), and all DDL commands are directed to
-# the current tenant's schema.
-#
-# In 'rails db:migrate' (global mode), we actually execute each migration twice: once with a
-# pass_context set to :global, where ONLY commands in a 'global {}' block are executed, and then
-# with pass_context set to :prototype, where ONLY commands outside of a 'global {}' block are
-# executed.
-#
-# ContextTracker keeps up with this.
-
-require 'cell/meta'
-require 'cell/schema'
-require 'cell/clone_schema'
-
-
-module Cell
-  module Migration
-
-    # OK, ContextTracker keeps up with:
-    #   * The context in which this migration is being ran, e.g. the :global first pass, the
-    #     :prototype second pass, OR the :targeted per tenant pass.
-    #   * If it's in a global block or not, which determines if actions are actually executed
-    #   * If force_execution is set, which is for the benefit of playing back CommandRecorder
-    #     commands.
-    module ContextTracker
-      mattr_accessor :pass_context
-      mattr_accessor :global_block
-      mattr_accessor :force_execution
-
-      def execute_ddl?
-        force_execution ||
-        (pass_context == :global    &&  global_block) ||
-        (pass_context == :prototype && !global_block) ||
-        (pass_context == :target    && !global_block)
-      end
-
-      # When the CommandRecorder's commands are executed, they're rewritten to go through
-      # force_call, because the "effective set of commands" have already been determined by the
-      # CommandRecorder run.
-      def force_call(*args, &block)
-        saved, self.force_execution = self.force_execution, true
-        send(*args, &block)
-      ensure
-        self.force_execution = saved
-      end
-
-      def with_context(context, search_path, exclusive: false)
-        Cell::Meta::with_schema(search_path, exclusive: exclusive) do
-          begin
-            saved, self.pass_context = self.pass_context, context
-            yield
-          ensure
-            self.pass_context = saved
-          end
-        end
-      end
-
-      def global
-        saved, self.global_block = self.global_block, true
-        yield
-      ensure
-        self.global_block = saved
-      end
-    end
-
-
-    # This module intercepts create_table and drop_table, and updates the list of global tables
-    # in ::ActiveRecord::InternalMetadata['cell.global'].
-    module MetadataIntercept
-      def create_table(name, *args, &block)
-        super.tap do
-          ::Cell::Meta.add_global_table(name) if pass_context == :global
-        end
-      end
-
-      def drop_table(name, *args, &block)
-        super.tap do
-          ::Cell::Meta.remove_global_table(name) if pass_context == :global
-        end
-      end
-    end
-
-    # We intercept every method given, and only execute it if appropriate according to execute_ddl?
-    def self.intercept(methods)
-      methods.each do |method|
-        define_method(method) do |*args, &block|
-          super(*args, &block) if execute_ddl?
-        end
-      end
-    end
-
-    # This sucks.  In the future, we may want to pull these from
-    # SchemaStatements
-    intercept %i(add_belongs_to add_column add_foreign_key add_index
-                 add_index_sort_order add_reference add_timestamps
-                 change_column change_column_default change_column_null
-                 change_table change_table_comment create_join_table
-                 create_table drop_join_table drop_table
-                 initialize_schema_migrations_table remove_belongs_to
-                 remove_column remove_columns remove_foreign_key remove_index
-                 remove_reference remove_timestamps rename_column
-                 rename_column_indexes rename_index rename_table
-                 rename_table_indexes table_alias_for table_comment) +
-              %i(enable_extension disable_extension truncate) +
-              %i(execute)
-
-    def global_schema
-      Cell::Meta.global_schema
-    end
-
-    def prototype_schema
-      Cell::Meta.prototype_schema
-    end
-
-    def tenant_schema
-      target.schema_name
-    end
-
-    def target
-      Cell::Model.current
-    end
-
-    def targeted?
-      !! target
-    end
-
-    # This is our super-special initialization function.
-    def initialize_cell!
-      CloneSchema.install_function!
-      execute "CREATE SCHEMA #{connection.quote_schema_name(prototype_schema)}"
-    end
-
-    def exec_migration(con, direction)
-      if ! targeted?
-        with_context(:global, global_schema) do
-          super
-        end
-
-        with_context(:prototype, prototype_schema) do
-          super
-        end
-      else
-        with_context(:target, tenant_schema, exclusive: true) do
-          super
-        end
-      end
-    end
-
-    ActiveSupport.on_load(:active_record) do
-      ActiveRecord::Migration.prepend(::Cell::Migration::MetadataIntercept)
-      ActiveRecord::Migration.prepend(::Cell::Migration::ContextTracker)
-      ActiveRecord::Migration.prepend(::Cell::Migration)
-    end
-
-
-    # Patches to CommandRecorder, which let us roll back.
-    module CommandRecorderFilter
-      # This maybe should've been attr_reader in CommandRecorder
-      def commands=(*)
-        # If this is actually used, we're fucked.
-        fail "The problem with monkey patching is..."
-      end
-
-      def commands
-        @commands.select do |command|
-          command[0]
-        end.map do |command|
-          [:force_call, [command[1], *command[2]], command[3]]
-        end
-      end
-
-      # saves the state of a recorded command with the context it was in.
-      def add_command(command)
-        @commands << [execute_ddl?, *command]
-      end
-
-      # We override #record to proxy through add_command
-      def record(*command, &block)
-        if @reverting
-          add_command inverse_of(*command, &block)
-        else
-          add_command (command << block)
-        end
-      end
-
-      ActiveSupport.on_load(:active_record) do
-        ::ActiveRecord::Migration::CommandRecorder.prepend(::Cell::Migration::ContextTracker)
-        ::ActiveRecord::Migration::CommandRecorder.prepend(::Cell::Migration::CommandRecorderFilter)
-      end
-    end
-  end
-end

data/lib/cell/model_extensions.rb

@@ -1,85 +0,0 @@
-# These are added to ActiveRecord::Base, regardless if they're the tenant model or not.
-
-# There are two big tricks here:
-#  1. Assigning a "tenant" attribute to every model that is loaded from the db, or created while a
-#     tenant is active.
-#  2. Making sure the object is validated and saved with the proper tenant activated, even if the
-#     tenant has changed since the object was created
-#
-# So you can load an object from "tenant_a", switch to "tenant_b", and if you save or validate the
-# object, it'll do so while switched to "tenant_a", and then restore.
-
-require 'cell/meta'
-
-module Cell
-  module ModelExtensions
-
-    # Say we have a model 'u', that is from an old Tenant, loading an association like 'u.books'
-    # should swap into u.tenant while fetching.
-    module AssociationExtensions
-      def load_target
-        owner._activate_tenant do
-          super
-        end
-      end
-    end
-
-
-    module ClassMethods
-      def global_model?
-        ::Cell::Meta.global_model?(self)
-      end
-
-      # When a model's schema is lazy-loaded, we want to make sure our view of the DB allows us to
-      # get introspection data.
-      def load_schema!
-        ::Cell::Meta.with_structural_schema do
-          return super
-        end
-      end
-    end
-
-    attr_reader :tenant
-
-    def _assign_tenant
-      unless self.class.global_model?
-        @tenant = Cell::Model.current
-      end
-    end
-
-    def _activate_tenant(&block)
-      if tenant && tenant != ::Cell::Model.current
-        tenant.use(&block)
-      else
-        yield
-      end
-    end
-
-    # undocumented, but makes sure validations are ran in the context of the object's tenant, e.g.,
-    # uniqueness.
-    def run_validations!
-      _activate_tenant do
-        super
-      end
-    end
-
-    def self.prepended(cls)
-      class << cls
-        prepend ClassMethods
-      end
-
-      cls.after_initialize :_assign_tenant
-      cls.around_save :_activate_tenant
-    end
-
-    def self.install!
-      ActiveSupport.on_load(:active_record) do
-        ::ActiveRecord::Base.prepend(::Cell::ModelExtensions)
-        ::ActiveRecord::Associations::Association.prepend(::Cell::ModelExtensions::AssociationExtensions)
-        ::ActiveRecord::Associations::CollectionAssociation.prepend(::Cell::ModelExtensions::AssociationExtensions)
-      end
-    end
-  end
-end
-
-Cell::ModelExtensions.install!