culturecode_stagehand 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ba8e79e0039e00f41cb0ac4042c677aeed631f5
+  data.tar.gz: 962467e5d04f3303c2a184e796a61ec06dcde83a
+SHA512:
+  metadata.gz: e5aa81f338bacc2eaf0a4926d3b357d92be1ffea5ecd04f4db1365abeeee8729f592c3ee2bfe908d8a76feaaf593632a89b107e7b42e3dac27a37e648f8c98f8
+  data.tar.gz: 8c1fea3d8ac972451119a1e01797d0ea704c0ec2eed20654306ae59f228e6ae76a4515d53a798583cf1ff2b31f85029db4745a0f93817af99ac51f4ee59a77d5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Nicholas Jakobsen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks

data/lib/culturecode_stagehand.rb

@@ -0,0 +1,2 @@
+# Wrapper because Rubygems.org already had a 'stagehand' gem. This avoids needing a :require option in Bundler.
+require "stagehand"

data/lib/stagehand.rb

@@ -0,0 +1,4 @@
+require "stagehand/engine"
+
+module Stagehand
+end

data/lib/stagehand/configuration.rb

@@ -0,0 +1,27 @@
+module Stagehand
+  extend self
+
+  def configuration
+    Configuration
+  end
+
+  module Configuration
+    extend self
+
+    def staging_connection_name
+      Rails.configuration.x.stagehand.staging_connection_name || raise(StagingConnectionNameNotSet)
+    end
+
+    def production_connection_name
+      Rails.configuration.x.stagehand.production_connection_name || raise(ProductionConnectionNameNotSet)
+    end
+
+    def ghost_mode?
+      !!Rails.configuration.x.stagehand.ghost_mode
+    end
+  end
+
+  # EXCEPTIONS
+  class StagingConnectionNameNotSet < StandardError; end
+  class ProductionConnectionNameNotSet < StandardError; end
+end

data/lib/stagehand/controller_extensions.rb

@@ -0,0 +1,27 @@
+module Stagehand
+  module ControllerExtensions
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def use_staging_database(options = {})
+        skip_action_callback :use_production_database, options
+        prepend_around_action :use_staging_database, options
+      end
+
+      def use_production_database(options = {})
+        skip_action_callback :use_staging_database, options
+        prepend_around_action :use_production_database, options
+      end
+    end
+
+    private
+
+    def use_staging_database(&block)
+      Database.with_connection(Configuration.staging_connection_name, &block)
+    end
+
+    def use_production_database(&block)
+      Database.with_connection(Configuration.production_connection_name, &block)
+    end
+  end
+end

data/lib/stagehand/engine.rb

@@ -0,0 +1,19 @@
+module Stagehand
+  class Engine < ::Rails::Engine
+    isolate_namespace Stagehand
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    # These require the rails application to be intialized because configuration variables are used
+    initializer "stagehand.load_modules" do
+      require "stagehand/configuration"
+      require "stagehand/controller_extensions"
+      require "stagehand/staging"
+      require "stagehand/schema"
+      require "stagehand/production"
+      require "stagehand/helpers"
+    end
+  end
+end

data/lib/stagehand/helpers.rb

@@ -0,0 +1,57 @@
+module Stagehand
+  module Key
+    extend self
+
+    def generate(staging_record, options = {})
+      case staging_record
+      when Staging::CommitEntry
+        id = staging_record.record_id || staging_record.id
+        table_name = staging_record.table_name || staging_record.class.table_name
+      when ActiveRecord::Base
+        id = staging_record.id
+        table_name = staging_record.class.table_name
+      else
+        id = staging_record
+        table_name = options[:table_name]
+      end
+
+      raise 'Invalid input' unless table_name && id
+
+      return [table_name, id]
+    end
+  end
+
+  module Database
+    extend self
+
+    @@connection_name_stack = [Rails.env.to_sym]
+
+    def with_connection(connection_name)
+      different = !Configuration.ghost_mode? && current_connection_name != connection_name.to_sym
+
+      @@connection_name_stack.push(connection_name.to_sym)
+      Rails.logger.debug "Connecting to #{current_connection_name}"
+      connect_to(current_connection_name) if different
+
+      yield
+    ensure
+      @@connection_name_stack.pop
+      Rails.logger.debug "Restoring connection to #{current_connection_name}"
+      connect_to(current_connection_name) if different
+    end
+
+    def set_connection_for_model(model, connection_name)
+      connect_to(connection_name, model) unless Configuration.ghost_mode?
+    end
+
+    private
+
+    def connect_to(connection_name, model = ActiveRecord::Base)
+      model.establish_connection(connection_name)
+    end
+
+    def current_connection_name
+      @@connection_name_stack.last
+    end
+  end
+end

data/lib/stagehand/production.rb

@@ -0,0 +1,78 @@
+require 'stagehand/production/controller'
+
+module Stagehand
+  module Production
+    extend self
+
+    # Outputs a symbol representing the status of the staging record as it exists in the production database
+    def status(staging_record)
+      if !exists?(staging_record)
+        :new
+      elsif modified?(staging_record)
+        :modified
+      else
+        :not_modified
+      end
+    end
+
+    def save(staging_record)
+      attributes = staging_record_attributes(staging_record)
+
+      return unless attributes.present?
+
+      is_new = lookup(staging_record).update_all(attributes).zero?
+
+      # Ensure we always return a record, even when updating instead of creating
+      Record.new.tap do |record|
+        record.assign_attributes(attributes)
+        record.save if is_new
+      end
+    end
+
+    def delete(staging_record, table_name = nil)
+      lookup(staging_record, table_name).delete_all
+    end
+
+    def exists?(staging_record, table_name = nil)
+      lookup(staging_record, table_name).exists?
+    end
+
+    # Returns true if the staging record's attributes are different from the production record's attributes
+    # Returns true if the staging_record does not exist on production
+    # Returns false if the staging record is identical to the production record
+    def modified?(staging_record)
+      production_record_attributes(staging_record) != staging_record_attributes(staging_record)
+    end
+
+    # Returns a scope that limits results any occurrences of the specified record.
+    # Record can be specified by passing a staging record, or an id and table_name.
+    def lookup(staging_record, table_name = nil)
+      table_name, id = Stagehand::Key.generate(staging_record, :table_name => table_name)
+      prepare_to_modify(table_name)
+      return Record.where(:id => id)
+    end
+
+    private
+
+    def prepare_to_modify(table_name)
+      raise "Can't prepare to modify production records without knowning the table_name" unless table_name.present?
+      Record.establish_connection(Configuration.production_connection_name) and @connection_established = true unless @connection_established
+      Record.table_name = table_name
+    end
+
+    def production_record_attributes(staging_record)
+      Record.connection.select_one(lookup(staging_record))
+    end
+
+    def staging_record_attributes(staging_record, table_name = nil)
+      table_name, id = Stagehand::Key.generate(staging_record, :table_name => table_name)
+      Stagehand::Staging::CommitEntry.connection.select_one("SELECT * FROM #{table_name} WHERE id = #{id}")
+    end
+
+    # CLASSES
+
+    class Record < ActiveRecord::Base
+      self.record_timestamps = false
+    end
+  end
+end

data/lib/stagehand/production/controller.rb

@@ -0,0 +1,12 @@
+module Stagehand
+  module Production
+    module Controller
+      extend ActiveSupport::Concern
+      include Stagehand::ControllerExtensions
+
+      included do
+        use_production_database
+      end
+    end
+  end
+end

data/lib/stagehand/schema.rb

@@ -0,0 +1,81 @@
+require "stagehand/schema/statements"
+
+module Stagehand
+  module Schema
+    UNTRACKED_TABLES = ['schema_migrations', Stagehand::Staging::CommitEntry.table_name]
+
+    def self.add_stagehand!(options = {})
+      ActiveRecord::Schema.define do
+        unless Stagehand::Staging::CommitEntry.table_exists?
+          create_table :stagehand_commit_entries do |t|
+            t.integer :record_id
+            t.string :table_name
+            t.string :operation, :null => false
+            t.integer :commit_id
+            t.string :session
+          end
+
+          add_index :stagehand_commit_entries, :commit_id
+          add_index :stagehand_commit_entries, :operation
+
+          # Create trigger to initialize session using a function
+          ActiveRecord::Base.connection.execute("DROP TRIGGER IF EXISTS stagehand_session_trigger;")
+          ActiveRecord::Base.connection.execute("
+          CREATE TRIGGER stagehand_session_trigger BEFORE INSERT ON stagehand_commit_entries
+          FOR EACH ROW SET NEW.session = CONNECTION_ID();")
+        end
+
+        table_names = ActiveRecord::Base.connection.tables
+        table_names -= UNTRACKED_TABLES
+        table_names -= Array(options[:except]).collect(&:to_s)
+        table_names &= Array(options[:only]).collect(&:to_s) if options[:only].present?
+
+        table_names.each do |table_name|
+          Stagehand::Schema.drop_trigger(table_name, 'insert')
+          Stagehand::Schema.drop_trigger(table_name, 'update')
+          Stagehand::Schema.drop_trigger(table_name, 'delete')
+
+          Stagehand::Schema.create_trigger(table_name, 'insert', 'NEW')
+          Stagehand::Schema.create_trigger(table_name, 'update', 'NEW')
+          Stagehand::Schema.create_trigger(table_name, 'delete', 'OLD')
+        end
+      end
+    end
+
+    def self.remove_stagehand!(options = {})
+      ActiveRecord::Schema.define do
+        table_names = ActiveRecord::Base.connection.tables
+        table_names &= Array(options[:only]).collect(&:to_s) if options[:only].present?
+
+        table_names.each do |table_name|
+          Stagehand::Schema.drop_trigger(table_name, 'insert')
+          Stagehand::Schema.drop_trigger(table_name, 'update')
+          Stagehand::Schema.drop_trigger(table_name, 'delete')
+        end
+
+        drop_table :stagehand_commit_entries unless options[:only].present?
+      end
+    end
+
+    private
+
+    def self.create_trigger(table_name, trigger_action, record)
+      ActiveRecord::Base.connection.execute("
+        CREATE TRIGGER #{trigger_name(table_name, trigger_action)} AFTER #{trigger_action.upcase} ON #{table_name}
+        FOR EACH ROW
+        BEGIN
+          INSERT INTO stagehand_commit_entries (record_id, table_name, operation)
+          VALUES (#{record}.id, '#{table_name}', '#{trigger_action}');
+        END;
+      ")
+    end
+
+    def self.drop_trigger(table_name, trigger_action)
+      ActiveRecord::Base.connection.execute("DROP TRIGGER IF EXISTS #{trigger_name(table_name, trigger_action)};")
+    end
+
+    def self.trigger_name(table_name, trigger_action)
+      "stagehand_#{trigger_action}_trigger_#{table_name}"
+    end
+  end
+end

data/lib/stagehand/schema/statements.rb

@@ -0,0 +1,24 @@
+module Stagehand
+  module Schema
+    module Statements
+      # Ensure that developers are aware they need to make a determination of whether stagehand should track this table or not
+      def create_table(table_name, options = {})
+        case options.symbolize_keys[:stagehand]
+        when true
+          super
+          Schema.add_stagehand! :only => table_name
+        when false
+          super
+        else
+          raise TableOptionNotSet, "If this table contains data to sync to the production database, pass #{{:stagehand => true}}" unless UNTRACKED_TABLES.include?(table_name)
+          super
+        end
+      end
+    end
+  end
+
+  # EXCEPTIONS
+  class TableOptionNotSet < ActiveRecord::ActiveRecordError; end
+end
+
+ActiveRecord::Base.connection.class.include Stagehand::Schema::Statements

data/lib/stagehand/staging.rb

@@ -0,0 +1,11 @@
+require 'stagehand/staging/commit'
+require 'stagehand/staging/commit_entry'
+require 'stagehand/staging/checklist'
+require 'stagehand/staging/controller'
+require 'stagehand/staging/model'
+require 'stagehand/staging/synchronizer'
+
+module Stagehand
+  module Staging
+  end
+end

data/lib/stagehand/staging/checklist.rb

@@ -0,0 +1,147 @@
+module Stagehand
+  module Staging
+    class Checklist
+      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)
+        entries = Array.wrap(entries)
+        related_entries = []
+
+        entries_to_spider = Array.wrap(entries)
+        while entries_to_spider.present?
+          contained_matching = CommitEntry.contained.matching(entries_to_spider)
+          matching_commit_entries = CommitEntry.where(:commit_id => contained_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 initialize(subject, &confirmation_filter)
+        @subject = subject
+        @confirmation_filter = confirmation_filter
+        @cache = {}
+        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) { compact_entries(affected_entries) }
+      end
+
+      def affected_records
+        cache(:affected_records) { affected_entries.collect(&:record).uniq }
+      end
+
+      def affected_entries
+        cache(:affected_entries) { self.class.related_entries(@subject) }
+      end
+
+      private
+
+      def grouped_required_confirmation_entries
+        cache(:grouped_required_confirmation_entries) do
+          staging_record_start_operation_ids = affected_entries.select do |entry|
+            entry.start_operation? && entry.matches?(@subject)
+          end.collect(&:id)
+
+          # Don't need to confirm entries that were part of a commits kicked off by the staging record
+          entries = affected_entries.reject {|entry| staging_record_start_operation_ids.include?(entry.commit_id) }
+
+          # Don't need to confirm entries that were not part of a commit
+          entries = entries.select(&:commit_id)
+
+          entries = compact_entries(entries)
+          entries = preload_records(entries)
+          entries = filter_entries(entries)
+          entries = group_entries(entries)
+        end
+      end
+
+      def filter_entries(entries)
+        @confirmation_filter ? entries.select {|entry| @confirmation_filter.call(entry.record) } : entries
+      end
+
+      # Returns a list of entries that only includes a single entry for each record.
+      # The type of entry chosen prioritizes creates over updates, and deletes over creates.
+      def compact_entries(entries)
+        compact_entries = group_entries(entries)
+        compact_entries = compact_entries[:delete] + compact_entries[:insert] + compact_entries[:update]
+        compact_entries.uniq!(&:key)
+
+        return compact_entries
+      end
+
+      # Groups entries by their operation
+      def 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 preload_records(entries)
+        entries.group_by(&:table_name).each do |table_name, group_entries|
+          klass = CommitEntry.infer_class(table_name)
+          records = klass.where(:id => group_entries.collect(&:record_id))
+          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
+
+      def cache(key, &block)
+        if @cache.key?(key)
+          @cache[key]
+        else
+          @cache[key] = block.call
+        end
+      end
+
+      def clear_cache
+        @cache.clear
+      end
+    end
+  end
+end

data/lib/stagehand/staging/commit.rb

@@ -0,0 +1,96 @@
+module Stagehand
+  module Staging
+    class Commit
+      def self.all
+        CommitEntry.start_operations.pluck(:id).collect {|id| find(id) }
+      end
+
+      def self.capture(subject_record = nil, &block)
+        start_operation = start_commit(subject_record)
+        block.call
+        return end_commit(start_operation)
+      rescue => e
+        end_commit(start_operation)
+        raise(e)
+      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
+
+        if subject_record
+          start_operation.record_id = subject_record.id
+          start_operation.table_name = subject_record.class.table_name
+        end
+
+        start_operation.save
+
+        return start_operation.reload # Reload to ensure session is set
+      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)
+        end_operation = CommitEntry.end_operations.create(:session => start_operation.session)
+
+        CommitEntry
+          .where(:id => start_operation.id..end_operation.id)
+          .where(:session => start_operation.session)
+          .update_all(:commit_id => start_operation.id)
+
+        return new(start_operation.id)
+      end
+
+      public
+
+      def initialize(start_id)
+        @start_id, @end_id = CommitEntry.control_operations
+          .where(:commit_id => start_id)
+          .where('id >= ?', start_id).limit(2).pluck(:id)
+
+        raise CommitNotFound unless @start_id && @end_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 entries
+        CommitEntry.where(:id => @start_id..@end_id).where(:commit_id => id)
+      end
+    end
+  end
+
+  # EXCEPTIONS
+  class CommitNotFound < StandardError; end
+end

data/lib/stagehand/staging/commit_entry.rb

@@ -0,0 +1,118 @@
+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 :delete_operations,  lambda { where(:operation => DELETE_OPERATION) }
+      scope :with_record,        lambda { where.not(:record_id => nil) }
+      scope :uncontained,        lambda { where(:commit_id => nil) }
+      scope :contained,          lambda { where.not(:commit_id => nil) }
+      scope :not_in_progress,    lambda {
+        joins("LEFT OUTER JOIN (#{ unscoped.select('session, MAX(id) AS start_id').uncontained.start_operations.group('session').to_sql }) AS active_starts
+               ON active_starts.session = stagehand_commit_entries.session AND active_starts.start_id <= stagehand_commit_entries.id")
+       .where("active_starts.start_id IS NULL") }
+
+      def self.matching(object)
+        keys = Array.wrap(object).collect {|entry| Stagehand::Key.generate(entry) }.compact
+        sql = []
+        interpolates = []
+
+        keys.group_by(&:first).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_class(table_name)
+        klass = ActiveRecord::Base.descendants.detect {|klass| klass.table_name == table_name && klass != Stagehand::Production::Record }
+        klass ||= table_name.classify.constantize # Try loading the class if it isn't loaded yet
+
+      rescue NameError
+        raise(IndeterminateRecordClass, "Can't determine class from table name: #{table_name}")
+      end
+
+      def record
+        @record ||= delete_operation? ? build_production_record : record_class.find_by_id(record_id) if content_operation?
+      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 ||= self.class.infer_class(table_name)
+      end
+
+      private
+
+      def build_production_record
+        production_record = Stagehand::Production.lookup(record_id, table_name).first
+        return unless production_record
+
+        production_record = record_class.new(production_record.attributes)
+        production_record.readonly!
+
+        return production_record
+      end
+    end
+  end
+
+  # EXCEPTIONS
+  class IndeterminateRecordClass < StandardError; end
+end

data/lib/stagehand/staging/controller.rb

@@ -0,0 +1,22 @@
+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(subject_record = nil, &block)
+        Staging::Commit.capture(subject_record, &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
+    end
+  end
+end

data/lib/stagehand/staging/model.rb

@@ -0,0 +1,11 @@
+module Stagehand
+  module Staging
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+        Stagehand::Database.set_connection_for_model(self, Configuration.staging_connection_name)
+      end
+    end
+  end
+end

data/lib/stagehand/staging/synchronizer.rb

@@ -0,0 +1,71 @@
+module Stagehand
+  module Staging
+    module Synchronizer
+      extend self
+
+      # Immediately attempt to sync the changes from the block if possible
+      # The block is wrapped in a transaction to prevent changes to records while being synced
+      def sync_now(&block)
+        raise SyncBlockRequired unless block_given?
+
+        ActiveRecord::Base.transaction do
+          checklist = Checklist.new(Commit.capture(&block).entries)
+          sync_checklist(checklist) unless checklist.requires_confirmation?
+        end
+      end
+
+      def auto_sync(delay = 5.seconds)
+        scope = autosyncable_entries.limit(1000)
+
+        loop do
+          puts "Synced #{sync_entries(scope.reload)} entries"
+          sleep(delay) if delay
+        end
+      end
+
+      def sync
+        sync_entries(autosyncable_entries.limit(1000))
+      end
+
+      # Copies all the affected records from the staging database to the production database
+      def sync_record(record)
+        sync_checklist(Checklist.new(record))
+      end
+
+      private
+
+      def sync_checklist(checklist)
+        sync_entries(checklist.syncing_entries)
+        CommitEntry.delete(checklist.affected_entries)
+      end
+
+      def sync_entries(entries)
+        ActiveRecord::Base.transaction do
+          entries.each do |entry|
+            Rails.logger.info "Synchronizing #{entry.table_name} #{entry.record_id}"
+            if entry.delete_operation?
+              Stagehand::Production.delete(entry)
+            elsif entry.save_operation?
+              Stagehand::Production.save(entry)
+            end
+          end
+        end
+
+        return entries.length
+      end
+
+      def autosyncable_entries
+        if Configuration.ghost_mode?
+          CommitEntry
+        else
+          CommitEntry.where(:id =>
+            CommitEntry.select('MAX(id) AS id').content_operations.not_in_progress.group('record_id, table_name').having('count(commit_id) = 0'))
+        end
+      end
+    end
+  end
+
+  # EXCEPTIONS
+
+  class SyncBlockRequired < StandardError; end
+end

data/lib/stagehand/version.rb

@@ -0,0 +1,3 @@
+module Stagehand
+  VERSION = "0.1.0"
+end

data/lib/tasks/stagehand_tasks.rake

@@ -0,0 +1,16 @@
+namespace :stagehand do
+  desc "Polls the commit entries table for changes to sync to production"
+  task :auto_sync, [:delay] => :environment do |t, args|
+    Stagehand::Staging::Synchronizer.auto_sync(args[:delay] ||= 5.seconds)
+  end
+
+  desc "Migrate both databases used by stagehand"
+  task :migrate => :environment do
+    [Rails.configuration.x.stagehand.staging_connection_name,
+     Rails.configuration.x.stagehand.production_connection_name].each do |config_key|
+      puts "Migrating #{config_key}"
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[config_key.to_s])
+      ActiveRecord::Migrator.migrate('db/migrate')
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: culturecode_stagehand
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicholas Jakobsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Simplify the management of a sanbox database that can sync content to
+  a production database. Content changes can be bundled so partial syncs of the database
+  can occur.
+email:
+- nicholas.jakobsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/culturecode_stagehand.rb
+- lib/stagehand.rb
+- lib/stagehand/configuration.rb
+- lib/stagehand/controller_extensions.rb
+- lib/stagehand/engine.rb
+- lib/stagehand/helpers.rb
+- lib/stagehand/production.rb
+- lib/stagehand/production/controller.rb
+- lib/stagehand/schema.rb
+- lib/stagehand/schema/statements.rb
+- lib/stagehand/staging.rb
+- lib/stagehand/staging/checklist.rb
+- lib/stagehand/staging/commit.rb
+- lib/stagehand/staging/commit_entry.rb
+- lib/stagehand/staging/controller.rb
+- lib/stagehand/staging/model.rb
+- lib/stagehand/staging/synchronizer.rb
+- lib/stagehand/version.rb
+- lib/tasks/stagehand_tasks.rake
+homepage: https://github.com/culturecode/stagehand
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Simplify the management of a sanbox database that can sync content to a production
+  database
+test_files: []