combinaut_stagehand 1.2.1

data/lib/stagehand/staging/checklist.rb

@@ -0,0 +1,202 @@
+module Stagehand
+  module Staging
+    class Checklist
+      extend Cache
+      include Cache
+
+      def self.related_commits(commit)
+        Commit.find(related_commit_ids(commit))
+      end
+
+      def self.related_commit_ids(commit)
+        related_entries(commit.entries).collect(&:commit_id).select(&:present?).uniq
+      end
+
+      def self.related_entries(entries, relation_filter = nil)
+        entries = Array.wrap(entries)
+        related_entries = []
+
+        entries_to_spider = Array.wrap(entries)
+        while entries_to_spider.present?
+          committed_matching = CommitEntry.committed.matching(entries_to_spider)
+          committed_matching = committed_matching.where(id: committed_matching.select(&relation_filter)) if relation_filter
+
+          matching_commit_entries = CommitEntry.where(:commit_id => committed_matching.select(:commit_id))
+
+          # Spider using content operations. Don't spider control operations to avoid extending the list of results unnecessarily
+          content_operations, control_operations = matching_commit_entries.partition(&:content_operation?)
+          entries_to_spider = content_operations - related_entries
+
+          # Record the spidered entries and the control entries
+          related_entries.concat(entries_to_spider)
+          related_entries.concat(control_operations)
+        end
+
+        # Also include uncontained commit entries that matched
+        related_entries.concat(CommitEntry.uncontained.matching(entries + related_entries))
+        related_entries.uniq!
+
+        return related_entries
+      end
+
+      def self.associated_records(entries, association_filter = nil)
+        records = preload_records(compact_entries(entries)).select(&:record).flat_map do |entry|
+          associated_associations(entry.record_class).flat_map do |association|
+            entry.record.send(association)
+          end
+        end
+
+        records.uniq!
+        records.compact!
+        records.select! {|record| stagehand_class?(record.class) }
+        records.select!(&association_filter) if association_filter
+
+        return records
+      end
+
+      # Returns a list of entries that only includes a single entry for each record.
+      # The entries are prioritized by the list of operations as given by `:priority`.
+      def self.compact_entries(entries, priority: [:delete, :update, :insert])
+        compact_entries = group_entries(entries)
+        compact_entries = compact_entries.values_at(*priority).flatten
+        compact_entries.uniq!(&:key)
+
+        return compact_entries
+      end
+
+      # Groups entries by their operation
+      def self.group_entries(entries)
+        group_entries = Hash.new {|h,k| h[k] = [] }
+        group_entries.merge! entries.group_by(&:operation).symbolize_keys!
+
+        return group_entries
+      end
+
+      def self.preload_records(entries)
+        entries.group_by(&:table_name).each do |table_name, group_entries|
+          klass = CommitEntry.infer_base_class(table_name)
+          records = klass.where(:id => group_entries.collect(&:record_id))
+          records = records.includes(associated_associations(klass))
+          records_by_id = records.collect {|r| [r.id, r] }.to_h
+          group_entries.each do |entry|
+            entry.record = records_by_id[entry.record_id]
+          end
+        end
+
+        return entries
+      end
+
+      private
+
+      def self.associated_associations(klass)
+        cache("#{klass.name}_associated_associations") do
+          reflections = klass.reflect_on_all_associations(:belongs_to)
+
+          reflections.select! do |reflection|
+            begin
+              reflection.check_preloadable!
+              next true
+            rescue ArgumentError
+              next false
+            end
+          end
+
+          reflections.collect(&:name)
+        end
+      end
+
+      def self.stagehand_class?(klass)
+        cache("#{klass.name}_stagehand_class?") { Schema.has_stagehand?(klass.table_name) }
+      end
+
+      public
+
+      def initialize(subject, confirmation_filter: Configuration.checklist_confirmation_filter, association_filter: Configuration.checklist_association_filter, relation_filter: Configuration.checklist_relation_filter)
+        @subject = subject
+        @confirmation_filter = confirmation_filter
+        @association_filter = association_filter
+        @relation_filter = relation_filter
+        affected_entries # Init the affected_entries changes can be rolled back without affecting the checklist
+      end
+
+      def confirm_create
+        cache(:confirm_create) { grouped_required_confirmation_entries[:insert].collect(&:record) }
+      end
+
+      def confirm_delete
+        cache(:confirm_delete) { grouped_required_confirmation_entries[:delete].collect(&:record).compact }
+      end
+
+      def confirm_update
+        cache(:confirm_update) { grouped_required_confirmation_entries[:update].collect(&:record) }
+      end
+
+      # Returns true if there are any changes in the checklist that require confirmation
+      def requires_confirmation?
+        cache(:requires_confirmation?) { grouped_required_confirmation_entries.values.flatten.present? }
+      end
+
+      # Returns a list of records that exist in commits where the staging_record is not in the start operation
+      def requires_confirmation
+        cache(:requires_confirmation) { grouped_required_confirmation_entries.values.flatten.collect(&:record).compact }
+      end
+
+      def syncing_entries
+        cache(:syncing_entries) { self.class.compact_entries(affected_entries, priority: Synchronizer::ENTRY_SYNC_ORDER) }
+      end
+
+      def affected_records
+        cache(:affected_records) { affected_entries.uniq(&:key).collect(&:record).compact }
+      end
+
+      def affected_entries
+        cache(:affected_entries) do
+          from_subject = subject_entries
+          from_subject |= CommitEntry.where(commit_id: subject_entries.select(:commit_id))
+          related = self.class.related_entries(from_subject, @relation_filter)
+          associated = self.class.associated_records(related, @association_filter)
+          associated_related = self.class.related_entries(associated, @relation_filter)
+
+          (from_subject + related + associated_related).uniq
+        end
+      end
+
+      def subject_entries
+        cache(:subject_entries) { CommitEntry.not_in_progress.matching(@subject) }
+      end
+
+      private
+
+      def grouped_required_confirmation_entries
+        cache(:grouped_required_confirmation_entries) do
+          entries = affected_entries.dup
+          subject_entries, subject_records = Array.wrap(@subject).partition {|model| model.is_a?(CommitEntry) }
+
+          # Don't need to confirm entries that were not part of a commit
+          entries.select!(&:commit_id)
+
+          # Don't need to confirm entries that exactly match a subject commit entry
+          entries -= subject_entries
+
+          # Don't need to confirm entries that match the checklist subject records
+          entries.reject! {|entry| entry.matches?(subject_records) }
+
+          # Don't need to confirm entries that are part of a commits whose subject is a checklist subject record
+          staging_record_start_operation_ids = affected_entries.select do |entry|
+            entry.start_operation? && entry.matches?(subject_records)
+          end.collect(&:id)
+          entries.reject! {|entry| staging_record_start_operation_ids.include?(entry.commit_id) }
+
+          entries = self.class.compact_entries(entries, priority: [:delete, :insert, :update])
+          entries = filter_entries(entries)
+          entries = self.class.group_entries(entries)
+        end
+      end
+
+      def filter_entries(entries)
+        return entries unless @confirmation_filter
+        return entries.select {|entry| @confirmation_filter.call(entry.record) if entry.record }
+      end
+    end
+  end
+end

data/lib/stagehand/staging/commit.rb

@@ -0,0 +1,168 @@
+module Stagehand
+  module Staging
+    class Commit
+      def self.all
+        CommitEntry.start_operations.committed.pluck(:commit_id).collect {|id| find(id) }.compact
+      end
+
+      def self.empty
+        all.select(&:empty?)
+      end
+
+      def self.capturing?
+        !!@capturing
+      end
+
+      def self.capture(subject_record = nil, except: [], &block)
+        @capturing = true
+        start_operation = start_commit(subject_record)
+        set_session_commit_id(start_operation.commit_id)
+
+        begin
+          block.call(start_operation)
+        rescue Exception => e # Rescue Exception because we don't want to swallow them by returning from the ensure block
+          raise(e)
+        ensure
+          commit = end_commit(start_operation, except) unless e.is_a?(CommitError) || e.is_a?(ActiveRecord::Rollback)
+          set_session_commit_id(nil) # Stop recording entries to this commit
+          return commit unless e
+        end
+
+      ensure
+        @capturing = false
+      end
+
+      def self.containing(record)
+        find(CommitEntry.contained.matching(record).pluck(:commit_id))
+      end
+
+      def self.find(start_ids)
+        if start_ids.respond_to?(:each)
+          start_ids.to_a.uniq.collect {|id| find(id) }.compact
+        else
+          new(start_ids)
+        end
+      rescue CommitNotFound
+      end
+
+      private
+
+      def self.start_commit(subject_record)
+        start_operation = CommitEntry.start_operations.new
+
+        # Make it easy to set the subject for the duration of the commit block
+        def start_operation.subject=(record)
+          if record&.id
+            raise NonStagehandSubject unless record.has_stagehand?
+            self.assign_attributes :record_id => record.id, :table_name => record.class.table_name
+          end
+          save!
+        end
+
+        start_operation.subject = subject_record
+
+        return start_operation
+      end
+
+      # Sets the commit_id on all the entries between the start and end op.
+      # Returns the commit object for those entries
+      def self.end_commit(start_operation, except)
+        scope = CommitEntry.where(:commit_id => start_operation.id)
+
+        # Remove any commit entries that are supposed to be excluded from the commit
+        if except.present? && Array(except).collect(&:to_s).exclude?(start_operation.table_name)
+          scope.content_operations.where(:table_name => except).update_all(:commit_id => nil)
+        end
+
+        end_operation = scope.end_operations.create
+        entries = scope.to_a
+
+        if entries.count(&:control_operation?) < 2 # Unless we found at least 2 entries (start and end), abort the commit
+          CommitEntry.logger.warn "Commit entries not found for Commit #{start_operation.id}. Was the Commit rolled back in a transaction?"
+          return nil
+        elsif entries.none?(&:content_operation?) # Destroy empty commit
+          scope.delete_all
+          return nil
+        else
+          CommitEntry.where(id: entries.map(&:id)).update_all(:committed => true) # Allow these entries to be considered when spidering and determining auto syncing.
+          return new(start_operation.id)
+        end
+      end
+
+      # Ensure all entries created on this connection from now on match the given commit_id
+      def self.set_session_commit_id(commit_id)
+        CommitEntry.connection.execute <<~SQL
+          SET @stagehand_commit_id = #{commit_id || 'NULL'};
+        SQL
+      end
+
+      public
+
+      def initialize(start_id)
+        @start_id, @end_id = CommitEntry.control_operations
+          .limit(2)
+          .where(:commit_id => start_id)
+          .where('id >= ?', start_id)
+          .reorder(:id => :asc)
+          .pluck(:id)
+
+        return if @start_id && @end_id
+
+        missing = []
+        missing << CommitEntry::START_OPERATION unless @start_id == start_id
+        missing << CommitEntry::END_OPERATION if @start_id == start_id
+
+        raise CommitNotFound, "Couldn't find #{missing.join(', ')} entry for Commit #{start_id}"
+      end
+
+      def id
+        @start_id
+      end
+
+      def include?(record)
+        entries.where(:record_id => record.id, :table_name => record.class.table_name).exists?
+      end
+
+      def hash
+        id
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        id == other.id
+      end
+
+      def subject
+        start_entry.record
+      end
+
+      def start_entry
+        CommitEntry.find(@start_id)
+      end
+
+      def end_entry
+        entries.end_operations.first
+      end
+
+      def empty?
+        entries.content_operations.empty?
+      end
+
+      def destroy
+        entries.delete_all
+      end
+
+      def entries
+        CommitEntry.where(:id => @start_id..@end_id).where(:commit_id => id)
+      end
+    end
+  end
+
+  # EXCEPTIONS
+  class CommitError < StandardError; end
+  class CommitNotFound < CommitError; end
+  class NonStagehandSubject < CommitError; end
+end

data/lib/stagehand/staging/commit_entry.rb

@@ -0,0 +1,180 @@
+module Stagehand
+  module Staging
+    class CommitEntry < ActiveRecord::Base
+      attr_writer :record
+
+      self.table_name = 'stagehand_commit_entries'
+
+      START_OPERATION = 'commit_start'
+      END_OPERATION = 'commit_end'
+      INSERT_OPERATION = 'insert'
+      UPDATE_OPERATION = 'update'
+      DELETE_OPERATION = 'delete'
+
+      CONTROL_OPERATIONS = [START_OPERATION, END_OPERATION]
+      CONTENT_OPERATIONS = [INSERT_OPERATION, UPDATE_OPERATION, DELETE_OPERATION]
+      SAVE_OPERATIONS = [INSERT_OPERATION, UPDATE_OPERATION]
+
+      scope :start_operations,      lambda { where(:operation => START_OPERATION) }
+      scope :end_operations,        lambda { where(:operation => END_OPERATION) }
+      scope :control_operations,    lambda { where(:operation => CONTROL_OPERATIONS) }
+      scope :content_operations,    lambda { where(:operation => CONTENT_OPERATIONS) }
+      scope :save_operations,       lambda { where(:operation => SAVE_OPERATIONS) }
+      scope :insert_operations,     lambda { where(:operation => INSERT_OPERATION) }
+      scope :update_operations,     lambda { where(:operation => UPDATE_OPERATION) }
+      scope :delete_operations,     lambda { where(:operation => DELETE_OPERATION) }
+      scope :with_record,           lambda { where.not(:record_id => nil) }
+      scope :in_progress,           lambda { contained.uncommitted }
+      scope :not_in_progress,       lambda { uncontained.or(committed) }
+      scope :committed,             lambda { where(:committed => true) }
+      scope :uncommitted,           lambda { where.not(:committed => true) }
+      scope :uncontained,           lambda { where(:commit_id => nil) }
+      scope :contained,             lambda { where.not(:commit_id => nil) }
+      scope :no_newer_than,         lambda {|entry| where("id <= ?", entry) }
+      scope :with_uncontained_keys, lambda { uncontained.joins_contained("LEFT OUTER").where("contained.record_id IS NULL") }
+
+      after_create :init_commit_id, if: :start_operation? # Perform this as a callback so it is wrapped in a transaction and nobody gets to see the start entry without a commit_id
+
+      def self.joins_contained(type = "INNER")
+        joins("#{type} JOIN (#{ unscoped.contained.select('record_id, table_name').to_sql}) AS contained
+               ON contained.record_id = #{table_name}.record_id AND contained.table_name = #{table_name}.table_name")
+      end
+
+      def self.matching(object)
+        keys = Array.wrap(object).collect {|entry| Stagehand::Key.generate(entry) }.compact
+        sql = []
+        interpolates = []
+        groups = keys.group_by(&:first)
+
+        # If passed control operation commit entries, ensure they are returned since their keys match the CommitEntry's primary key
+        if commit_entry_group = groups.delete(CommitEntry.table_name)
+          sql << 'id IN (?)'
+          interpolates << commit_entry_group.collect(&:last)
+        end
+
+        groups.each do |table_name, keys|
+          sql << "(table_name = ? AND record_id IN (?))"
+          interpolates << table_name
+          interpolates << keys.collect(&:last)
+        end
+
+        return keys.present? ? where(sql.join(' OR '), *interpolates) : none
+      end
+
+      def self.infer_base_class(table_name)
+        classes = ActiveRecord::Base.descendants
+        classes.select! {|klass| klass.table_name == table_name }
+        classes.reject! {|klass| klass < Stagehand::Database::Probe }
+        return classes.first || table_name.classify.constantize.base_class # Try loading the class if it isn't loaded yet
+      rescue NameError
+        raise(IndeterminateRecordClass, "Can't determine class from table name: #{table_name}")
+      end
+
+      validates_presence_of :record_id, :if => :table_name
+      validates_presence_of :table_name, :if => :record_id
+
+      def record
+        @record ||= delete_operation? ? build_deleted_record : record_class.find_by_id(record_id) if record_id?
+      end
+
+      def control_operation?
+        operation.in?(CONTROL_OPERATIONS)
+      end
+
+      def content_operation?
+        operation.in?(CONTENT_OPERATIONS)
+      end
+
+      def save_operation?
+        operation.in?(SAVE_OPERATIONS)
+      end
+
+      def insert_operation?
+        operation == INSERT_OPERATION
+      end
+
+      def update_operation?
+        operation == UPDATE_OPERATION
+      end
+
+      def delete_operation?
+        operation == DELETE_OPERATION
+      end
+
+      def start_operation?
+        operation == START_OPERATION
+      end
+
+      def end_operation?
+        operation == END_OPERATION
+      end
+
+      def matches?(others)
+        Array.wrap(others).any? {|other| key == Stagehand::Key.generate(other) }
+      end
+
+      def key
+        @key ||= Stagehand::Key.generate(self)
+      end
+
+      def record_class
+        @record_class ||= infer_class
+      rescue IndeterminateRecordClass
+        @record_class ||= self.class.build_missing_model(table_name)
+      end
+
+      def production_record
+        @production_record = Stagehand::Production.find(record_id, table_name) unless defined?(@production_record)
+        return @production_record
+      end
+
+      private
+
+      def init_commit_id
+        update_column(:commit_id, id)
+      end
+
+      def infer_class
+        klass = self.class.infer_base_class(table_name)
+        klass = infer_sti_class(klass) || infer_production_sti_class(klass) || klass if record_id
+        return klass
+      end
+
+      def infer_sti_class(root_class)
+        root_class.find_by_id(record_id)&.class
+      end
+
+      def infer_production_sti_class(root_class)
+        return unless production_record
+        record_type = production_record[root_class.inheritance_column]
+        record_type&.constantize
+      rescue NameError
+        raise(IndeterminateRecordClass, "Can't determine class from table name: #{record_type}")
+      end
+
+      def build_deleted_record
+        return unless production_record
+        deleted_record = production_record.becomes(record_class)
+        deleted_record.readonly!
+        deleted_record.singleton_class.include(DeletedRecord)
+        return deleted_record
+      end
+
+      def self.build_missing_model(table_name)
+        raise MissingTable, "Can't find table specified in entry: #{table_name}" unless Database.staging_connection.tables.include?(table_name)
+        klass = Class.new(ActiveRecord::Base) { self.table_name = table_name }
+        DummyClass.const_set(table_name.classify, klass)
+      end
+    end
+  end
+
+  # UTILITY MODULES
+
+  module DummyClass; end # A namespace for dummy classes of records with an IndeterminateRecordClass
+  module DeletedRecord; end # Serves as a way of tagging an instance to see if it is_a?(Stagehand::DeletedRecord)
+
+  # EXCEPTIONS
+
+  class IndeterminateRecordClass < StandardError; end
+  class MissingTable < StandardError; end
+end

data/lib/stagehand/staging/controller.rb

@@ -0,0 +1,27 @@
+module Stagehand
+  module Staging
+    module Controller
+      extend ActiveSupport::Concern
+      include Stagehand::ControllerExtensions
+
+      included do
+        use_staging_database
+      end
+
+      # Creates a stagehand commit to log database changes associated with the given record
+      def stage_changes(*args, &block)
+        Staging::Commit.capture(*args, &block)
+      end
+
+      # Syncs the given record and all affected records to the production database
+      def sync_record(record)
+        Stagehand::Staging::Synchronizer.sync_record(record)
+      end
+
+      # Syncs the checklist's affected records to the production database
+      def sync_checklist(checklist)
+        Stagehand::Staging::Synchronizer.sync_checklist(checklist)
+      end
+    end
+  end
+end

data/lib/stagehand/staging/model.rb

@@ -0,0 +1,29 @@
+module Stagehand
+  module Staging
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+        Stagehand::Configuration.staging_model_tables << table_name
+      end
+
+      class_methods do
+        def quoted_table_name
+          if connection.prefix_table_name_with_database?(table_name)
+            @prefixed_quoted_table_name ||= connection.quote_table_name(table_name)
+          else
+            super
+          end
+        end
+
+        def connection
+          if Configuration.ghost_mode?
+            super
+          else
+            Stagehand::Database::StagingProbe.connection
+          end
+        end
+      end
+    end
+  end
+end