active_version 1.0.0

data/lib/active_version/adapters/active_record/revisions.rb

@@ -0,0 +1,49 @@
+module ActiveVersion
+  module Adapters
+    module ActiveRecord
+      module Revisions
+        extend ActiveSupport::Concern
+
+        included do
+          # Add has_revisions method to ActiveRecord::Base
+        end
+
+        module ClassMethods
+          # Declare that a model has revisions
+          def has_revisions(options = {})
+            include ActiveVersion::Revisions::HasRevisions
+            extend ActiveVersion::Revisions::SQLBuilder::ClassMethods
+
+            # Delegate to the concern implementation so callbacks/options are
+            # installed consistently for the DSL path.
+            ActiveVersion::Revisions::HasRevisions::ClassMethods
+              .instance_method(:has_revisions)
+              .bind_call(self, options)
+
+            # Register revision class
+            revision_class_name = "#{name}Revision"
+            if const_defined?(revision_class_name)
+              revision_class = const_get(revision_class_name)
+              if options[:table_name] && revision_class.respond_to?(:table_name=)
+                revision_class.table_name = options[:table_name].to_s
+              end
+              ActiveVersion.registry.register_version_class(self, :revisions, revision_class)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Include revisions adapter in ActiveRecord::Base
+ActiveSupport.on_load(:active_record) do
+  include ActiveVersion::Adapters::ActiveRecord::Revisions
+end
+
+# If ActiveRecord::Base is already loaded, include immediately
+if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:include)
+  unless ActiveRecord::Base.included_modules.include?(ActiveVersion::Adapters::ActiveRecord::Revisions)
+    ActiveSupport.on_load(:active_record) { include ActiveVersion::Adapters::ActiveRecord::Revisions }
+  end
+end

data/lib/active_version/adapters/active_record/translations.rb

@@ -0,0 +1,45 @@
+module ActiveVersion
+  module Adapters
+    module ActiveRecord
+      module Translations
+        extend ActiveSupport::Concern
+
+        included do
+          # Add has_translations method to ActiveRecord::Base
+        end
+
+        module ClassMethods
+          # Declare that a model has translations
+          def has_translations(options = {})
+            include ActiveVersion::Translations::HasTranslations
+
+            # Store options
+            ActiveVersion.registry.register(self, :translations, options)
+
+            # Register translation class
+            translation_class_name = "#{name}Translation"
+            if const_defined?(translation_class_name)
+              translation_class = const_get(translation_class_name)
+              if options[:table_name] && translation_class.respond_to?(:table_name=)
+                translation_class.table_name = options[:table_name].to_s
+              end
+              ActiveVersion.registry.register_version_class(self, :translations, translation_class)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Include translations adapter in ActiveRecord::Base
+ActiveSupport.on_load(:active_record) do
+  include ActiveVersion::Adapters::ActiveRecord::Translations
+end
+
+# If ActiveRecord::Base is already loaded, include immediately
+if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:include)
+  unless ActiveRecord::Base.included_modules.include?(ActiveVersion::Adapters::ActiveRecord::Translations)
+    ActiveSupport.on_load(:active_record) { include ActiveVersion::Adapters::ActiveRecord::Translations }
+  end
+end

data/lib/active_version/adapters/active_record.rb

@@ -0,0 +1,10 @@
+require "active_version/adapters/active_record/base"
+
+module ActiveVersion
+  module Adapters
+    module ActiveRecord
+      # ActiveRecord-specific adapter implementations
+      # This module will be extended with Translations, Revisions, and Audits
+    end
+  end
+end

data/lib/active_version/adapters/sequel/versioning.rb

@@ -0,0 +1,282 @@
+require "json"
+
+module ActiveVersion
+  module Adapters
+    module Sequel
+      # Sequel plugin that provides ActiveVersion-style model DSL and lifecycle hooks.
+      module Versioning
+        DEFAULT_CONFIG = {
+          revision_model: nil,
+          audit_model: nil,
+          translation_model: nil,
+          foreign_key: nil,
+          tracked_columns: [],
+          translation_columns: []
+        }.freeze
+
+        def self.apply(model, **options)
+          configure(model, **options)
+        end
+
+        def self.configure(model, **options)
+          base = model.instance_variable_get(:@active_version_sequel_config) || {}
+          model.instance_variable_set(:@active_version_sequel_config, DEFAULT_CONFIG.merge(base).merge(options))
+        end
+
+        module ClassMethods
+          def active_version(**options)
+            ActiveVersion::Adapters::Sequel::Versioning.configure(self, **options)
+          end
+
+          def active_version_config
+            config = instance_variable_get(:@active_version_sequel_config)
+            return config if config
+
+            if superclass.respond_to?(:active_version_config)
+              superclass.active_version_config.dup
+            else
+              ActiveVersion::Adapters::Sequel::Versioning::DEFAULT_CONFIG.dup
+            end
+          end
+
+          def has_versioning?(version_type)
+            case version_type.to_sym
+            when :revisions then !active_version_config[:revision_model].nil?
+            when :audits then !active_version_config[:audit_model].nil?
+            when :translations then !active_version_config[:translation_model].nil?
+            else false
+            end
+          end
+        end
+
+        module InstanceMethods
+          def active_version_foreign_key
+            self.class.active_version_config[:foreign_key] || :"#{model_name.singular}_id"
+          end
+
+          def active_version_tracked_columns
+            self.class.active_version_config[:tracked_columns].map(&:to_sym)
+          end
+
+          def active_version_translation_columns
+            columns = self.class.active_version_config[:translation_columns]
+            columns = active_version_tracked_columns if columns.nil? || columns.empty?
+            columns.map(&:to_sym)
+          end
+
+          def active_version_revisions_dataset
+            model = self.class.active_version_config[:revision_model]
+            return nil unless model
+
+            model.where(active_version_foreign_key => pk)
+          end
+
+          def active_version_audits_dataset
+            model = self.class.active_version_config[:audit_model]
+            return nil unless model
+
+            model.where(active_version_foreign_key => pk)
+          end
+
+          def active_version_translations_dataset
+            model = self.class.active_version_config[:translation_model]
+            return nil unless model
+
+            model.where(active_version_foreign_key => pk)
+          end
+
+          def active_version_revisions
+            dataset = active_version_revisions_dataset
+            return [] unless dataset
+
+            dataset.order(:version).all
+          end
+
+          def active_version_audits
+            dataset = active_version_audits_dataset
+            return [] unless dataset
+
+            dataset.order(:version).all
+          end
+
+          def active_version_translations
+            dataset = active_version_translations_dataset
+            return [] unless dataset
+
+            dataset.order(:locale).all
+          end
+
+          def active_version_translation(locale)
+            dataset = active_version_translations_dataset
+            return nil unless dataset
+
+            dataset.where(locale: locale.to_s.downcase).first
+          end
+
+          def active_version_translate(attr, locale:)
+            translation = active_version_translation(locale)
+            return self[attr] unless translation
+
+            translated_value = translation[attr]
+            (translated_value.nil? || translated_value.to_s.empty?) ? self[attr] : translated_value
+          end
+
+          def active_version_set_translation!(locale:, **attrs)
+            locale_value = locale.to_s.downcase
+            model = self.class.active_version_config[:translation_model]
+            raise ActiveVersion::ConfigurationError, "translation_model is not configured for #{self.class.name}" unless model
+
+            payload = attrs.transform_keys(&:to_sym).slice(*active_version_translation_columns)
+            existing = active_version_translation(locale_value)
+
+            if existing
+              existing.update(payload)
+              ActiveVersion::Instrumentation.instrument_translation_updated(existing, self)
+              existing
+            else
+              created = model.create(payload.merge(active_version_foreign_key => pk, :locale => locale_value))
+              ActiveVersion::Instrumentation.instrument_translation_created(created, self)
+              created
+            end
+          end
+
+          def active_version_destroy_translation!(locale:)
+            translation = active_version_translation(locale)
+            return false unless translation
+
+            ActiveVersion::Instrumentation.instrument_translation_destroyed(translation, self)
+            translation.delete
+            true
+          end
+
+          def before_update
+            @active_version_previous_snapshot = active_version_previous_snapshot_from_db
+            super
+          end
+
+          def before_destroy
+            @active_version_previous_snapshot = active_version_snapshot
+            super
+          end
+
+          def after_create
+            super
+            active_version_create_revision_and_audit!(:create, previous_snapshot: nil)
+          end
+
+          def after_update
+            super
+            active_version_create_revision_and_audit!(:update, previous_snapshot: @active_version_previous_snapshot)
+            @active_version_previous_snapshot = nil
+          end
+
+          def after_destroy
+            super
+            active_version_create_destroy_audit!(@active_version_previous_snapshot)
+          ensure
+            @active_version_previous_snapshot = nil
+          end
+
+          private
+
+          def pk
+            self[self.class.primary_key]
+          end
+
+          def model_name
+            self.class.name.split("::").last.downcase
+          end
+
+          def active_version_snapshot
+            active_version_tracked_columns.each_with_object({}) do |column, out|
+              out[column] = self[column]
+            end
+          end
+
+          def active_version_previous_snapshot_from_db
+            persisted = self.class.where(self.class.primary_key => pk).first
+            return active_version_snapshot unless persisted
+
+            active_version_tracked_columns.each_with_object({}) do |column, out|
+              out[column] = persisted[column]
+            end
+          end
+
+          def active_version_change_set(previous_snapshot)
+            current = active_version_snapshot
+            previous = previous_snapshot || Hash.new(nil)
+            current.each_with_object({}) do |(column, value), out|
+              old_value = previous[column]
+              next if old_value == value
+
+              out[column.to_s] = [old_value, value]
+            end
+          end
+
+          def active_version_next_version
+            max_revision = active_version_revisions_dataset&.max(:version) || 0
+            max_audit = active_version_audits_dataset&.max(:version) || 0
+            [max_revision, max_audit].max + 1
+          end
+
+          def active_version_create_revision_and_audit!(action, previous_snapshot:)
+            change_set = active_version_change_set(previous_snapshot)
+            return if action.to_s == "update" && change_set.empty?
+
+            version = active_version_next_version
+            active_version_insert_revision!(version)
+            active_version_insert_audit!(action: action, version: version, changes: change_set)
+          end
+
+          def active_version_create_destroy_audit!(previous_snapshot)
+            return unless self.class.active_version_config[:audit_model]
+
+            previous = previous_snapshot || active_version_snapshot
+            change_set = previous.each_with_object({}) do |(column, value), out|
+              out[column.to_s] = [value, nil]
+            end
+            version = active_version_next_version
+            active_version_insert_audit!(action: "destroy", version: version, changes: change_set)
+          end
+
+          def active_version_insert_revision!(version)
+            revision_model = self.class.active_version_config[:revision_model]
+            return unless revision_model
+
+            payload = active_version_snapshot.merge(
+              active_version_foreign_key => pk,
+              :version => version
+            )
+
+            revision = revision_model.create(payload)
+            ActiveVersion::Instrumentation.instrument_revision_created(revision, self)
+            revision
+          rescue => e
+            ActiveVersion::Instrumentation.instrument_revision_write_failed(self, error: e)
+            raise
+          end
+
+          def active_version_insert_audit!(action:, version:, changes:)
+            audit_model = self.class.active_version_config[:audit_model]
+            return unless audit_model
+
+            payload = {
+              active_version_foreign_key => pk,
+              :version => version,
+              :action => action,
+              :audited_changes => JSON.generate(changes),
+              :audited_context => JSON.generate(ActiveVersion.context || {})
+            }
+
+            audit = audit_model.create(payload)
+            ActiveVersion::Instrumentation.instrument_audit_created(audit, self)
+            audit
+          rescue => e
+            ActiveVersion::Instrumentation.instrument_audit_write_failed(self, error: e, action: action)
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_version/adapters/sequel.rb

@@ -0,0 +1,9 @@
+module ActiveVersion
+  module Adapters
+    module Sequel
+      # Namespace for Sequel integration.
+    end
+  end
+end
+
+require "active_version/adapters/sequel/versioning"

data/lib/active_version/adapters.rb

@@ -0,0 +1,5 @@
+module ActiveVersion
+  module Adapters
+    # Base namespace for ActiveRecord adapters
+  end
+end

data/lib/active_version/audits/audit_record/callbacks.rb

@@ -0,0 +1,180 @@
+module ActiveVersion
+  module Audits
+    module AuditRecord
+      # Callback methods for setting audit attributes
+      module Callbacks
+        extend ActiveSupport::Concern
+
+        private
+
+        def set_version_number
+          auditable_column = nil
+          begin
+            source_class = self.class.source_class
+            version_column = ActiveVersion.column_mapper.column_for(source_class, :audits, :version)
+            auditable_column = ActiveVersion.column_mapper.column_for(source_class, :audits, :auditable)
+          rescue NameError
+            version_column = ActiveVersion.config.audit_version_column
+            auditable_column = ActiveVersion.config.audit_auditable_column
+          end
+
+          # Skip if version is already set (e.g., from audit_writer)
+          # Version should always be a positive integer when set, so check if it's not nil
+          return if !self[version_column].nil?
+
+          type_column = auditable_column.to_s.end_with?("_type") ? auditable_column.to_s : "#{auditable_column}_type"
+          identity_columns = source_identity_columns(auditable_column)
+
+          if action == "create"
+            self[version_column] = 1
+          else
+            auditable_type_value = self[type_column]
+            return if auditable_type_value.nil? || identity_columns.any? { |column| self[column].nil? }
+
+            scope = self.class.where(type_column => auditable_type_value)
+            identity_columns.each do |column|
+              scope = scope.where(column => self[column])
+            end
+            max_version = scope.maximum(version_column).to_i
+            self[version_column] = max_version + 1
+          end
+        end
+
+        def set_audit_user
+          user_column = begin
+            ActiveVersion.column_mapper.column_for(self.class.source_class, :audits, :user)
+          rescue NameError
+            ActiveVersion.config.audit_user_column
+          end
+          return unless user_column
+
+          # Try to get user from RequestStore first (like audited)
+          user = ActiveVersion::RequestStore.audited_user if defined?(ActiveVersion::RequestStore)
+          user ||= begin
+            user_method = ActiveVersion.config.current_user_method
+            if respond_to?(user_method, true)
+              send(user_method)
+            end
+          end
+
+          if user
+            self[user_column] = user.respond_to?(:id) ? user.id : user
+            # Set polymorphic type if user is polymorphic
+            if user_column.to_s.end_with?("_id") && user.respond_to?(:class)
+              type_column = user_column.to_s.gsub("_id", "_type")
+              self[type_column] = user.class.name if self.class.column_names.include?(type_column)
+            end
+          end
+        end
+
+        def set_request_uuid
+          uuid_column = begin
+            ActiveVersion.column_mapper.column_for(self.class.source_class, :audits, :request_uuid)
+          rescue NameError
+            ActiveVersion.config.audit_request_uuid_column
+          end
+          return unless uuid_column && self.class.column_names.include?(uuid_column.to_s)
+
+          # Try RequestStore first, then generate UUID
+          self[uuid_column] = ActiveVersion::RequestStore.request_uuid if defined?(ActiveVersion::RequestStore)
+          self[uuid_column] ||= SecureRandom.uuid if self[uuid_column].blank?
+        end
+
+        def set_remote_address
+          address_column = begin
+            ActiveVersion.column_mapper.column_for(self.class.source_class, :audits, :remote_address)
+          rescue NameError
+            ActiveVersion.config.audit_remote_address_column
+          end
+          return unless address_column && self.class.column_names.include?(address_column.to_s)
+
+          # Try RequestStore first
+          if defined?(ActiveVersion::RequestStore)
+            self[address_column] = ActiveVersion::RequestStore.remote_address
+          end
+        end
+
+        def set_audited_context
+          context_column = begin
+            ActiveVersion.column_mapper.column_for(self.class.source_class, :audits, :context)
+          rescue NameError
+            ActiveVersion.config.audit_context_column
+          end
+          return unless context_column
+
+          # Context should already be set during creation via write_audit
+          # This callback ensures it's set if it wasn't set during creation
+          return if self[context_column].present?
+
+          # Fallback: use global context if no context was set
+          global_context = ActiveVersion.context || {}
+          self[context_column] = global_context if global_context.any?
+        end
+
+        def instrument_audit_created
+          auditable_column = ActiveVersion.column_mapper.column_for(self.class.source_class, :audits, :auditable)
+          auditable_record = nil
+
+          if respond_to?(auditable_column)
+            auditable_record = send(auditable_column)
+          end
+
+          # If association didn't return a record, try to load it directly
+          unless auditable_record
+            type_column = auditable_column.to_s.end_with?("_type") ? auditable_column.to_s : "#{auditable_column}_type"
+            identity_columns = source_identity_columns(auditable_column)
+            identity_map = source_identity_map_for_lookup(identity_columns, auditable_column)
+            auditable_type_value = self[type_column]
+
+            if identity_map.values.none?(&:nil?) && auditable_type_value
+              # Handle dynamically created classes
+              if auditable_type_value.nil?
+                # Try superclass for dynamically created classes
+                source_class = self.class.source_class
+                auditable_type_value = source_class.superclass&.name if source_class.superclass
+              end
+
+              if auditable_type_value
+                auditable_klass = auditable_type_value.constantize
+                auditable_record = if identity_map.size > 1
+                  auditable_klass.find_by(identity_map)
+                else
+                  auditable_klass.find_by(id: identity_map.values.first)
+                end
+              end
+            end
+          end
+
+          ActiveVersion::Instrumentation.instrument_audit_created(self, auditable_record)
+        rescue ::NameError, ::NoMethodError, ActiveRecord::RecordNotFound
+          # Association not set up yet or record not found, still instrument with nil
+          ActiveVersion::Instrumentation.instrument_audit_created(self, nil)
+        end
+
+        def source_identity_columns(auditable_column)
+          configured = if self.class.respond_to?(:source_identity_columns)
+            self.class.source_identity_columns
+          end
+          Array(configured.presence || "#{auditable_column}_id").map(&:to_s)
+        end
+
+        def source_identity_map_for_lookup(identity_columns, auditable_column)
+          prefix = "#{auditable_column}_"
+
+          identity_columns.index_with do |column|
+            self[column]
+          end.each_with_object({}) do |(column, value), acc|
+            source_column = if column == "#{auditable_column}_id"
+              "id"
+            elsif column.start_with?(prefix)
+              column.delete_prefix(prefix)
+            else
+              column
+            end
+            acc[source_column] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_version/audits/audit_record/serializers.rb

@@ -0,0 +1,49 @@
+require "json"
+require "yaml"
+
+module ActiveVersion
+  module Audits
+    module AuditRecord
+      module Serializers
+        class Identity
+          def load(value) = value
+          def dump(value) = value
+        end
+
+        class Json
+          def load(value)
+            return {} if value.nil?
+            return value unless value.is_a?(String)
+
+            JSON.parse(value)
+          rescue JSON::ParserError
+            value
+          end
+
+          def dump(value)
+            return value unless value.is_a?(Hash) || value.is_a?(Array)
+
+            JSON.generate(value)
+          end
+        end
+
+        class Yaml
+          PERMITTED_CLASSES = [Time, Date, DateTime, Symbol].freeze
+
+          def load(value)
+            return {} if value.nil?
+            return value unless value.is_a?(String)
+
+            YAML.safe_load(value, permitted_classes: PERMITTED_CLASSES, aliases: false)
+          rescue Psych::SyntaxError, Psych::DisallowedClass, Psych::AliasesNotEnabled, ArgumentError
+            value
+          end
+
+          def dump(value)
+            value.to_yaml
+          end
+        end
+      end
+    end
+  end
+end