activerecord-model-spaces 0.2.0

data/lib/active_record/model_spaces/context.rb

@@ -0,0 +1,184 @@
+require 'active_record/model_spaces/table_names'
+require 'active_record/model_spaces/table_manager'
+require 'active_record/model_spaces/util'
+
+module ActiveRecord
+  module ModelSpaces
+
+    # holds the current and working tables for a ModelSpace
+    class Context
+      include Util
+
+      attr_reader :model_space
+      attr_reader :model_space_key
+      attr_reader :persistor
+      attr_reader :current_model_versions
+      attr_reader :working_model_versions
+
+      def initialize(model_space, model_space_key, persistor)
+        @model_space = model_space
+        @model_space_key = model_space_key.to_sym
+        @persistor = persistor
+        read_versions
+        create_tables
+      end
+
+      def read_versions
+        @current_model_versions = persistor.read_model_space_model_versions(model_space.name, model_space_key)
+        @working_model_versions = {}
+      end
+
+      def create_tables
+        model_space.registered_model_keys.map do |model_name|
+          m = Util.model_from_name(model_name)
+          tm = TableManager.new(m)
+          tm.create_table(base_table_name(m), current_table_name(m))
+        end
+      end
+
+      def self.drop_tables(model_space, model_space_key)
+        model_space.registered_model_keys.map do |model_name|
+          m = Util.model_from_name(model_name)
+          tm = TableManager.new(m)
+
+          all_table_names = (0..model_space.history_versions(m)).map do |v|
+            TableNames.table_name(model_space.name, model_space_key, model_space.base_table_name(m), model_space.history_versions(m), v)
+          end
+
+          all_table_names.each do |table_name|
+            tm.drop_table(table_name)
+          end
+        end
+      end
+
+      # implements the Model.table_name method
+      def table_name(model)
+        version = get_working_model_version(model) || get_current_model_version(model)
+        table_name_from_model_version(model, version)
+      end
+
+      # base table name
+      def base_table_name(model)
+        model_space.base_table_name(model)
+      end
+
+      # table_name for version 0
+      def hoovered_table_name(model)
+        table_name_from_model_version(model, 0)
+      end
+
+      # current table_name, seen by everyone outside of this context
+      def current_table_name(model)
+        table_name_from_model_version(model, get_current_model_version(model))
+      end
+
+      # table_name which would be seen by this context in or after a new_version/updated_version. always returns a name
+      def next_table_name(model)
+        current_version = get_current_model_version(model)
+        next_version = TableNames.next_version(model_space.history_versions(model), current_version)
+        table_name_from_model_version(model, next_version)
+      end
+
+      # table_name of working table, seen by this context in or after new_version/updated_version. null if no new_version/updated_version has been issued/completed
+      def working_table_name(model)
+        table_name_from_model_version(model, get_working_model_version(model)) if get_working_model_version(model)
+      end
+
+      def new_version(model, copy_old_version=false, &block)
+        raise "new_version: a block must be supplied" if !block
+
+        if get_working_model_version(model)
+          block.call # nothing to do
+        else
+          current_version = get_current_model_version(model)
+          next_version = TableNames.next_version(model_space.history_versions(model), current_version)
+
+          tm = TableManager.new(model)
+          ok = false
+          begin
+            btn = base_table_name(model)
+            ctn = current_table_name(model)
+            ntn = next_table_name(model)
+            if next_version != current_version
+              tm.recreate_table(btn, ntn)
+              tm.copy_table(ctn, ntn) if copy_old_version
+            else # no history
+              tm.truncate_table(ntn) if !copy_old_version
+            end
+            set_working_model_version(model, next_version)
+            r = block.call
+            ok = true
+            r
+          ensure
+            delete_working_model_version(model) if !ok
+          end
+        end
+      end
+
+      def updated_version(model, &block)
+        new_version(model, true, &block)
+      end
+
+      # copy all data to the base model-space tables and drop all history tables
+      def hoover
+        raise "can't hoover with active working versions: #{working_model_versions.keys.inspect}" if !working_model_versions.empty?
+
+        model_names = model_space.registered_model_keys
+
+        new_versions = Hash[ model_names.map do |model_name|
+                               m = Util.model_from_name(model_name)
+                               base_name = base_table_name(m)
+                               current_name = current_table_name(m)
+                               hoovered_name = hoovered_table_name(m)
+
+                               tm = TableManager.new(m)
+
+                               # copy to hoovered table
+                               if current_name != hoovered_name
+                                 tm.recreate_table(base_name, hoovered_name)
+                                 tm.copy_table(current_name, hoovered_name)
+                               end
+
+                               # drop history tables
+                               (1..model_space.history_versions(m)).map do |v|
+                                 htn = table_name_from_model_version(m, v)
+                                 tm.drop_table(htn)
+                               end
+
+                               [model_name, 0]
+                             end ]
+        persistor.update_model_space_model_versions(new_versions)
+
+        read_versions
+      end
+
+      def commit
+        persistor.update_model_space_model_versions(model_space.name, model_space_key, current_model_versions.merge(working_model_versions))
+      end
+
+      private
+
+      def table_name_from_model_version(model, version)
+        TableNames.table_name(model_space.name, model_space_key, model_space.base_table_name(model), model_space.history_versions(model), version)
+      end
+
+      def get_current_model_version(model)
+        raise "#{model}: not registered with ModelSpace: #{model_space.name}" if !model_space.is_registered?(model)
+        self.current_model_versions[model_space.registered_model_name(model)] || 0
+      end
+
+      def get_working_model_version(model)
+        raise "#{model}: not registered with ModelSpace: #{model_space.name}" if !model_space.is_registered?(model)
+        self.working_model_versions[model_space.registered_model_name(model)]
+      end
+
+      def set_working_model_version(model, version)
+        self.working_model_versions[model_space.registered_model_name(model)] = version
+      end
+
+      def delete_working_model_version(model)
+        self.working_model_versions.delete(model_space.registered_model_name(model))
+      end
+    end
+  end
+end

data/lib/active_record/model_spaces/model_space.rb

@@ -0,0 +1,121 @@
+require 'set'
+require 'active_support'
+require 'active_record/model_spaces/context'
+require 'active_record/model_spaces/persistor'
+require 'active_record/model_spaces/table_names'
+require 'active_record/model_spaces/util'
+
+module ActiveRecord
+  module ModelSpaces
+
+    class << self
+      attr_accessor :connection
+      attr_accessor :table_name
+    end
+
+    # a ModelSpace has a set of models registered with it,
+    # from which a Context can be created
+    class ModelSpace
+      include Util
+
+      attr_reader :name
+      attr_reader :model_registrations
+
+      def initialize(name)
+        @name = name.to_sym
+        @model_registrations = {}
+      end
+
+      def register_model(model, opts=nil)
+        raise "#{model} is not an ActiveRecord model Class" if !is_active_record_model?(model)
+        opts ||= {}
+        ModelSpaces.check_model_registration_keys(opts.keys)
+        set_model_registration(model, opts.merge(:model=>model))
+        self
+      end
+
+      def deregister_model(model)
+        delete_model_registration(model)
+      end
+
+      def history_versions(model)
+        get_model_registration(model)[:history_versions] || 0
+      end
+
+      def set_base_table_name(model, table_name)
+        get_model_registration(model)[:base_table_name] = table_name
+      end
+
+      def registered_model(model)
+        get_model_registration(model)[:model]
+      end
+
+      def registered_model_name(model)
+        name_from_model(get_model_registration(model)[:model])
+      end
+
+      def base_table_name(model)
+        r = get_model_registration(model)
+        r[:base_table_name] || TableNames.base_table_name(r[:model])
+      end
+
+      def registered_model_keys
+        self.model_registrations.keys
+      end
+
+      def is_registered?(model)
+        !!unchecked_get_model_registration(model)
+      end
+
+      def create_context(model_space_key)
+        Context.new(self, model_space_key, ModelSpaces.create_persistor)
+      end
+
+      def kill_context(model_space_key)
+        Context.drop_tables(self, model_space_key)
+        true
+      end
+
+      private
+
+      def unchecked_get_model_registration(model)
+        mc = all_model_superclasses(model).find do |klass|
+          model_registrations[name_from_model(klass)]
+        end
+        self.model_registrations[name_from_model(mc)] if mc
+      end
+
+      def get_model_registration(model)
+        r = unchecked_get_model_registration(model)
+        raise "model: #{model.to_s} is not registered in ModelSpace: #{name}" if !r
+        r
+      end
+
+      def set_model_registration(model, registration)
+        self.model_registrations[name_from_model(model)] = registration
+      end
+
+      def delete_model_registration(model)
+        self.model_registrations.delete(name_from_model(model))
+      end
+    end
+
+    private
+
+    module_function
+
+    MODEL_REGISTRATION_KEYS = [:history_versions, :base_table_name].to_set
+
+    def check_model_registration_keys(keys)
+      unknown_keys = (keys.map(&:to_sym).to_set - MODEL_REGISTRATION_KEYS).to_a
+      raise "unknown keys: #{unknown_keys.inspect}" if !unknown_keys.empty?
+    end
+
+    # get a persistor given a connection... returns an instance of
+    # ActiveRecord::ModelSpaces::AdapterNamePersistor
+    def create_persistor
+      Persistor.new(ModelSpaces.connection || ActiveRecord::Base.connection, ModelSpaces.table_name)
+    end
+
+  end
+end

data/lib/active_record/model_spaces/persistor.rb

@@ -0,0 +1,72 @@
+require 'active_record/model_spaces/util'
+
+module ActiveRecord
+  module ModelSpaces
+
+    # manages ModelSpace persistence...
+    class Persistor
+      include Util
+
+      attr_reader :connection
+      attr_reader :table_name
+
+      def initialize(connection, table_name)
+        @connection = connection
+        @table_name = table_name || "model_spaces_tables"
+        create_model_spaces_table(@connection, @table_name)
+      end
+
+      # list all persisted prefixes for a given model space
+      def list_keys(model_space_name)
+        connection.select_rows("select model_space_key from #{table_name} where model_space_name='#{model_space_name}'").map{|r| r.first}
+      end
+
+      # returns a map of {ModelName => version} entries for a given model-space and model_space_key
+      def read_model_space_model_versions(model_space_name, model_space_key)
+        connection.select_all("select model_name, version from #{table_name} where model_space_name='#{model_space_name}' and model_space_key='#{model_space_key}'").reduce({}){|h,r| h[r["model_name"]] = r["version"].to_i ; h}
+      end
+
+      # update
+      def update_model_space_model_versions(model_space_name, model_space_key, new_model_versions)
+        ActiveRecord::Base.transaction do
+          old_model_versions = read_model_space_model_versions(model_space_name, model_space_key)
+
+          new_model_versions.map do |model_or_name, new_version|
+            model_name = name_from_model(model_or_name)
+            old_version = old_model_versions[model_name]
+
+            if old_version && new_version && old_version != new_version && new_version != 0
+
+              connection.execute("update #{table_name} set version=#{new_version} where model_space_name='#{model_space_name}' and model_space_key='#{model_space_key}' and model_name='#{model_name}'")
+
+            elsif !old_version && new_version && new_version != 0
+
+              connection.execute("insert into #{table_name} (model_space_name, model_space_key, model_name, version) values ('#{model_space_name}', '#{model_space_key}', '#{model_name}', #{new_version})")
+
+            elsif old_version && ( !new_version || new_version == 0 )
+
+              connection.execute("delete from #{table_name} where model_space_name='#{model_space_name}' and model_space_key='#{model_space_key}' and model_name='#{model_name}'")
+            end
+          end
+          true
+        end
+      end
+
+      # create the model_spaces table if it doesn't exist
+      def create_model_spaces_table(connection, tn)
+        if !connection.table_exists?(tn)
+          connection.instance_eval do
+            create_table(tn) do |t|
+              t.string :model_space_name, :null=>false
+              t.string :model_space_key, :null=>false
+              t.string :model_name, :null=>false
+              t.integer :version, :null=>false, :default=>0
+            end
+            add_index tn, [:model_space_name, :prefix, :model_name], :unique=>true
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/active_record/model_spaces/registry.rb

@@ -0,0 +1,195 @@
+require 'active_record'
+require 'active_record/model_spaces/model_space'
+
+module ActiveRecord
+  module ModelSpaces
+
+    class Registry
+      include Util
+
+      attr_reader :model_spaces
+      attr_reader :model_spaces_by_models
+      attr_reader :enforce_context
+
+      def initialize
+        reset!
+      end
+
+      # drop all model_space and model registrations. will cause any with_model_space_context
+      # to most likely bork horribly
+      def reset!
+        @model_spaces = {}
+        @model_spaces_by_models = {}
+      end
+
+      def register_model(model, model_space_name, opts={})
+        old_ms = unchecked_get_model_space_for_model(model)
+        old_ms.deregister_model(model) if old_ms
+
+        new_ms = register_model_space(model_space_name).register_model(model, opts)
+        register_model_space_for_model(model, new_ms)
+      end
+
+      def set_base_table_name(model, table_name)
+        ms = unchecked_get_model_space_for_model(model)
+        raise "model #{model} is not (yet) registered to a ModelSpace. do in_model_space before set_table_name or use the :base_table_name option of in_model_space" if !ms
+        ms.set_base_table_name(model, table_name)
+      end
+
+      def base_table_name(model)
+        get_model_space_for_model(model).base_table_name(model)
+      end
+
+      def set_enforce_context(v)
+        @enforce_context = !!v
+      end
+
+      def table_name(model)
+        ctx = enforce_context ? get_context_for_model(model) : unchecked_get_context_for_model(model)
+        if ctx
+          ctx.table_name(model)
+        else
+          get_model_space_for_model(model).base_table_name(model)
+        end
+      end
+
+      def current_table_name(model)
+        get_context_for_model(model).current_table_name(model)
+      end
+
+      def working_table_name(model)
+        get_context_for_model(model).working_table_name(model)
+      end
+
+      # create a new version of the model
+      def new_version(model, &block)
+        get_context_for_model(model).new_version(model, &block)
+      end
+
+      # create an updated version of the model
+      def updated_version(model, &block)
+        get_context_for_model(model).updated_version(model, &block)
+      end
+
+      def hoover(model)
+        get_context_for_model(model).hoover
+      end
+
+      # execute a block with a ModelSpace context.
+      # only a single context can be active for a given ModelSpace on any Thread at
+      # any time, though different ModelSpaces may have active contexts concurrently
+      def with_context(model_space_name, model_space_key, &block)
+
+        ms = get_model_space(model_space_name)
+        raise "no such model space: #{model_space_name}" if !ms
+
+        current_ctx = merged_context[ms.name]
+
+        if current_ctx && current_ctx.model_space_key==model_space_key.to_sym
+
+          block.call # same context is already active
+
+        elsif current_ctx
+
+          raise "ModelSpace: #{model_space_name}: context with key #{current_ctx.model_space_key} already active"
+
+        else
+
+          old_merged_context = self.send(:merged_context)
+          ctx = ms.create_context(model_space_key)
+          context_stack << ctx
+          begin
+            self.merged_context = merge_context_stack
+
+            r = block.call
+            ctx.commit
+            r
+          ensure
+            context_stack.pop
+            self.merged_context = old_merged_context
+          end
+
+        end
+      end
+
+      def kill_context(model_space_name, model_space_key)
+        get_model_space(model_space_name).kill_context(model_space_key)
+      end
+
+      # return the key of the active context for the given model_space, or nil
+      # if there is no active context
+      def active_key(model_space_name)
+        ms = get_model_space(model_space_name)
+        raise "no such model space: #{model_space_name}" if !ms
+
+        ctx = merged_context[ms.name]
+
+        ctx.model_space_key if ctx
+      end
+
+      private
+
+      def register_model_space(model_space_name)
+        model_spaces[model_space_name.to_sym] ||= ModelSpace.new(model_space_name.to_sym)
+      end
+
+      def get_model_space(model_space_name)
+        model_spaces[model_space_name.to_sym]
+      end
+
+      def register_model_space_for_model(model, model_space)
+        model_spaces_by_models[name_from_model(model)] = model_space
+      end
+
+      def unchecked_get_model_space_for_model(model)
+        mc = all_model_superclasses(model).find do |klass|
+          model_spaces_by_models[name_from_model(klass)]
+        end
+        model_spaces_by_models[name_from_model(mc)] if mc
+      end
+
+      def get_model_space_for_model(model)
+        ms = unchecked_get_model_space_for_model(model)
+        raise "model: #{model} is not registered to any ModelSpace" if !ms
+        ms
+      end
+
+      CONTEXT_STACK_KEY = "ActiveRecord::ModelSpaces.context_stack"
+
+      def context_stack
+        Thread.current[CONTEXT_STACK_KEY] ||= []
+      end
+
+      MERGED_CONTEXT_KEY = "ActiveRecord::ModelSpaces.merged_context"
+
+      def merged_context
+        Thread.current[MERGED_CONTEXT_KEY] || {}
+      end
+
+      def merged_context=(mc)
+        Thread.current[MERGED_CONTEXT_KEY] = mc
+      end
+
+      # merge all entries in the context stack into a map
+      def merge_context_stack
+        context_stack.reduce({}) do |m, ctx|
+          raise "ModelSpace: #{ctx.model_space.name}: already has an active context" if m[ctx.model_space.name]
+          m[ctx.model_space.name] = ctx
+          m
+        end
+      end
+
+      def unchecked_get_context_for_model(model)
+        ms = unchecked_get_model_space_for_model(model)
+        merged_context[ms.name] if ms
+      end
+
+      def get_context_for_model(model)
+        ms = get_model_space_for_model(model)
+        ctx = merged_context[ms.name]
+        raise "ModelSpace: '#{ms.name}' has no current context" if !ctx
+        ctx
+      end
+    end
+  end
+end