active_record-journal 0.1.0

data/lib/active_record/journal/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    class Configuration
+      attr_writer :entries_class, :tags_class, :autorecording_enabled
+
+      def entries_class
+        return @entries_class if @entries_class.is_a?(Class)
+
+        @entries_class = @entries_class.constantize
+      end
+
+      def tags_class
+        return @tags_class if @tags_class.is_a?(Class)
+
+        @tags_class = @tags_class.constantize
+      end
+
+      def autorecording_enabled
+        return true if @autorecording_enabled.nil?
+
+        @autorecording_enabled
+      end
+    end
+  end
+end

data/lib/active_record/journal/constants.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    ACTIONS = { reads: %w[read], writes: %w[update create destroy] }.freeze
+    JOURNABLE_OPTIONS = %i[
+      entries_class
+      tags_class
+      on
+      if
+      unless
+      only
+      except
+      mask
+      type
+    ].freeze
+  end
+end

data/lib/active_record/journal/journable/attributes.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    module Journable
+      Attributes = Struct.new(:subject, :rule) do
+        def model
+          subject.class
+        end
+
+        def tracked_keys
+          keys - ignored_keys
+        end
+
+        def ignored_keys
+          if rule.only
+            (keys - rule.only) | default_ignored_keys
+          elsif rule.except
+            default_ignored_keys | rule.except
+          else
+            default_ignored_keys
+          end
+        end
+
+        def keys
+          model.column_names.map(&:to_s)
+        end
+
+        def default_ignored_keys
+          [model.primary_key, model.inheritance_column, model.locking_column].compact
+        end
+      end
+    end
+  end
+end

data/lib/active_record/journal/journable/callback.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    module Journable
+      class Callback
+        attr_reader :action
+
+        def initialize(action)
+          @action = action
+        end
+
+        def to_proc
+          callback = self
+          ->(record) { callback.call(record) }
+        end
+
+        def call(record) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength
+          return unless valid_context?
+
+          override = rules_for(context: context_override, record: record) || {}
+          rules = rules_for(context: record.class.journable_context, record: record)
+
+          rules&.each do |journal, list|
+            list.each do |rule|
+              next unless rules_met?(rule: rule, override: override[journal], record: record)
+
+              attributes = Attributes.new(record, rule).tracked_keys
+              changes = Changes.new(record, action, attributes, rule.mask).call
+              context = context_override || record.class.journable_context
+              record_changes(
+                changes: changes,
+                record: record,
+                entries_class: rule.entries_class,
+                tag: context.tag(rule.tags_class)
+              )
+            end
+          end
+        end
+
+        private
+
+        def record_changes(entries_class:, changes:, record:, tag:)
+          return unless action == 'read' || changes.any?
+
+          entries_class.create!(changes_map: changes, journable: record, journal_tag: tag, action: action)
+        end
+
+        def rules_met?(rule:, override:, record:)
+          rule.conditions_met?(record) &&
+            (override.nil? || override.all? { _1.conditions_met?(record) })
+        end
+
+        def rules_for(context:, record:)
+          context
+            &.rules
+            &.search_by(action: action, subject: record)
+            &.group_by { |r| r.entries_class.model_name.param_key }
+        end
+
+        def valid_context?
+          (configuration.autorecording_enabled || context_override) && !!context_override&.ignore_actions == false
+        end
+
+        def context_override
+          ActiveRecord::Journal.context_override
+        end
+
+        def configuration
+          ActiveRecord::Journal.configuration
+        end
+      end
+    end
+  end
+end

data/lib/active_record/journal/journable/changes.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    module Journable
+      Changes = Struct.new(:subject, :action, :keys, :mask_keys) do
+        def call
+          changes.each_with_object({}) do |(key, value), attrs|
+            attrs[key] = value
+            next unless mask_keys&.include?(key)
+
+            attrs[key] = value.is_a?(Array) ? [nil, nil] : nil
+          end
+        end
+
+        private
+
+        def changes
+          case action
+          when 'create'
+            non_persisted_diff
+          when 'update'
+            persisted_diff
+          when 'destroy'
+            destroy_diff
+          else
+            none
+          end
+        end
+
+        def none
+          {}
+        end
+
+        def destroy_diff
+          subject.attributes.select { |k, v| keys.include?(k) && v.present? }
+        end
+
+        def non_persisted_diff
+          diff.select { |k, v| keys.include?(k) && v.last.present? }
+        end
+
+        def persisted_diff
+          diff.select { |k, _v| keys.include?(k) }
+        end
+
+        def diff
+          subject.changes.any? ? subject.changes : subject.previous_changes
+        end
+      end
+    end
+  end
+end

data/lib/active_record/journal/journable/context.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    module Journable
+      class Context
+        attr_writer :ignore_actions, :generate_tag
+
+        Storage = Struct.new(*ActiveRecord::Journal::ACTIONS.values.flatten.map(&:to_sym), keyword_init: true) do
+          def initialize
+            actions = ActiveRecord::Journal::ACTIONS.values.flatten
+            kwargs = actions.each_with_object({}) { |a, map| map[a.to_sym] = {} }
+            super(**kwargs)
+          end
+
+          def add(action:, journable:, rule:)
+            map = public_send(action)
+            map[journable.model_name.to_s] ||= []
+            map[journable.model_name.to_s] << rule
+          end
+
+          def search_by(action:, subject: nil)
+            map = public_send(action)
+            return unless map
+
+            return map.values.flatten if subject.nil?
+
+            key = map.keys.find { |name| subject.is_a?(name.constantize) }
+            return unless key
+
+            map[key]
+          end
+        end
+
+        def initialize(**tags_args)
+          @tags_args = tags_args
+        end
+
+        def configured_for?(action)
+          rules.search_by(action: action.to_s)&.any? || false
+        end
+
+        def record(journable, type = nil, **with)
+          options = ActiveRecord::Journal::Journable::Options.parse(with, type)
+          rule = ActiveRecord::Journal::Journable::Rule.new(journable, options)
+          options.on.each { |action| rules.add(action: action, journable: journable, rule: rule) }
+        end
+
+        def actions
+          ActiveRecord::Journal.context_override = self
+          yield
+          ActiveRecord::Journal.context_override = nil
+        rescue StandardError
+          ActiveRecord::Journal.context_override = nil
+        end
+
+        def ignore_actions
+          @ignore_actions || false
+        end
+
+        def generate_tag
+          @generate_tag || false
+        end
+
+        def rules
+          @rules ||= Storage.new
+        end
+
+        def tag(tags_class)
+          return @tag if defined?(@tag)
+
+          @tag = tags_class.create!(**@tags_args) if generate_tag
+        end
+      end
+    end
+  end
+end

data/lib/active_record/journal/journable/options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    module Journable
+      class OptionError < StandardError; end
+
+      Options = Struct.new(*ActiveRecord::Journal::JOURNABLE_OPTIONS, keyword_init: true) do
+        def self.parse(kwargs, type)
+          options = Options.new(**kwargs, type: type)
+          options.check_actions!
+          options
+        end
+
+        def initialize(**kwargs) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
+          type = kwargs[:type].to_sym
+          kwargs[:type] = type
+          kwargs[:entries_class] ||= ActiveRecord::Journal.configuration.entries_class
+          kwargs[:tags_class] ||= ActiveRecord::Journal.configuration.tags_class
+          kwargs[:on] = kwargs[:on]&.map(&:to_s) || ActiveRecord::Journal::ACTIONS[type]
+          kwargs[:only] = kwargs[:only]&.map(&:to_s)
+          kwargs[:except] = kwargs[:except]&.map(&:to_s)
+          kwargs[:mask] = kwargs[:mask]&.map(&:to_s)
+          super(**kwargs)
+        end
+
+        def check_actions!
+          on.each do |action|
+            next if ActiveRecord::Journal::ACTIONS[type.to_sym].include?(action)
+
+            raise OptionError, "#{action} is not a valid value for the on option"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/journal/journable/rule.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module ActiveRecord
+  module Journal
+    module Journable
+      class Rule
+        extend Forwardable
+
+        ActiveRecord::Journal::JOURNABLE_OPTIONS.each do |option_name|
+          def_delegator :@options, option_name, option_name
+        end
+
+        def_delegator :@options, :to_h, :to_h
+
+        attr_reader :journable, :options
+
+        def initialize(journable, options)
+          @journable = journable
+          @options = options
+        end
+
+        def conditions_met?(rec)
+          return true unless self.if || self.unless
+
+          assert_value = self.if ? true : false
+          condition = self.if || self.unless
+          assert_condition(condition, rec, assert_value)
+        end
+
+        private
+
+        def evaluate_condition(condition, rec)
+          return condition.call(rec) if condition.respond_to?(:call)
+
+          rec.send(condition)
+        end
+
+        def assert_condition(condition, rec, assert_value)
+          !!evaluate_condition(condition, rec) == assert_value
+        end
+      end
+    end
+  end
+end

data/lib/active_record/journal/journable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'journable/options'
+require_relative 'journable/rule'
+require_relative 'journable/context'
+require_relative 'journable/attributes'
+require_relative 'journable/changes'
+require_relative 'journable/callback'
+
+module ActiveRecord
+  module Journal
+    module Journable
+      def self.extended(subject)
+        subject.class_attribute :journable_context
+
+        subject.after_find(&Callback.new('read'))
+        subject.after_create(&Callback.new('create'))
+        subject.before_update(&Callback.new('update'))
+        subject.before_destroy(&Callback.new('destroy'))
+      end
+
+      ##
+      # Enable & configure the tracking of the read actions
+      def journal_reads(**kwargs)
+        init_journable_context
+        journable_context.record(self, :reads, **kwargs)
+      end
+
+      ##
+      # Enable & configure the tracking of the writes, updates and destroy actions
+      def journal_writes(**kwargs)
+        init_journable_context
+        journable_context.record(self, :writes, **kwargs)
+      end
+
+      private
+
+      def init_journable_context
+        return if @init_journable_context
+
+        self.journable_context = Context.new
+        @init_journable_context = true
+      end
+    end
+  end
+end

data/lib/active_record/journal/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Journal
+    VERSION = '0.1.0'
+  end
+end

data/lib/active_record/journal.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_record/journal/version'
+require 'active_record/journal/constants'
+require 'active_record/journal/configuration'
+require 'active_record/journal/journable'
+
+module ActiveRecord
+  module Journal
+    class Error < StandardError; end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def init
+        yield configuration
+      end
+
+      def tag(**kwargs)
+        context = Journable::Context.new(**kwargs)
+        context.generate_tag = true
+        yield context
+      end
+
+      def context
+        context = Journable::Context.new
+        yield context
+      end
+
+      def ignore
+        context = Journable::Context.new
+        context.ignore_actions = true
+        yield context
+      end
+
+      def context_override
+        # https://ruby-doc.org/core-2.5.0/Thread.html#method-i-thread_variable_get
+        Thread.current.thread_variable_get(:activerecord_journable_context_override)
+      end
+
+      def context_override=(context)
+        # https://ruby-doc.org/core-2.5.0/Thread.html#method-i-thread_variable_set
+        Thread.current.thread_variable_set(:activerecord_journable_context_override, context)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: active_record-journal
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mkiroshdz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem to track changes on active record models
+email:
+- mkirosh@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".env"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Dockerfile
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record-journal.gemspec
+- bin/coverage
+- bin/setup
+- docker-compose.yml
+- lib/active_record/journal.rb
+- lib/active_record/journal/configuration.rb
+- lib/active_record/journal/constants.rb
+- lib/active_record/journal/journable.rb
+- lib/active_record/journal/journable/attributes.rb
+- lib/active_record/journal/journable/callback.rb
+- lib/active_record/journal/journable/changes.rb
+- lib/active_record/journal/journable/context.rb
+- lib/active_record/journal/journable/options.rb
+- lib/active_record/journal/journable/rule.rb
+- lib/active_record/journal/version.rb
+homepage: https://github.com/mkiroshdz/active_record-journal
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/mkiroshdz/active_record-journal
+  source_code_uri: https://github.com/mkiroshdz/active_record-journal
+  changelog_uri: https://github.com/mkiroshdz/active_record-journal/blob/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: A gem to track changes on active record models
+test_files: []