active_record_auditable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff588e17ec1c5f91e07018334f37b9e3073fb8ebcfa0782625c3f59729758c7d
+  data.tar.gz: eb559e570cb5295a111bfecd26541e6d8625739578eb119aeda3d9391d9eb759
+SHA512:
+  metadata.gz: c3ecf7ac5c7b6cae5319b6877ae5c2919e9f87e0de4ceae07a79b93f4fa2855f77a79b67aabf33716d20753dac5d755468933e16e7da04bf7474369ad61093d3
+  data.tar.gz: 7c419488a1cf65effe3863e0a30513fdb2bf8cb0d5c7a3ea1851afca29183733dbb311479eb0842487203cd570ae4588a6049d2cc5162afeb6bb3752c97bd01c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright kaspernj
+
+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/README.md

@@ -0,0 +1,41 @@
+# ActiveRecordAuditable
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "active_record_auditable"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install active_record_auditable
+```
+
+```bash
+rails active_record_auditable:install:migrations
+```
+
+Sometimes you need to do something like this in `config/initializers/active_record_auditable.rb`:
+```ruby
+Rails.configuration.to_prepare do
+  ActiveRecordAuditable::Audit.class_eval do
+    belongs_to :user, default: -> { Current.user }, optional: true
+  end
+end
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/assets/config/active_record_auditable_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/active_record_auditable .css

data/app/assets/stylesheets/active_record_auditable/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/active_record_auditable/application_controller.rb

@@ -0,0 +1,4 @@
+module ActiveRecordAuditable
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/active_record_auditable/application_helper.rb

@@ -0,0 +1,4 @@
+module ActiveRecordAuditable
+  module ApplicationHelper
+  end
+end

data/app/jobs/active_record_auditable/application_job.rb

@@ -0,0 +1,4 @@
+module ActiveRecordAuditable
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/active_record_auditable/application_mailer.rb

@@ -0,0 +1,6 @@
+module ActiveRecordAuditable
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/active_record_auditable/application_record.rb

@@ -0,0 +1,5 @@
+module ActiveRecordAuditable
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/active_record_auditable/audit.rb

@@ -0,0 +1,16 @@
+class ActiveRecordAuditable::Audit < ActiveRecordAuditable::BaseAudit
+  self.table_name = "audits"
+
+  belongs_to :audit_auditable_type, class_name: "ActiveRecordAuditable::AuditAuditableType"
+  belongs_to :auditable, optional: true, polymorphic: true
+
+  scope :where_type, ->(type) { joins(:audit_auditable_type).where(audit_auditable_types: {name: type}) }
+
+  before_validation :set_audit_auditable_type
+
+private
+
+  def set_audit_auditable_type
+    self.audit_auditable_type = ActiveRecordAuditable::AuditAuditableType.find_or_create_by!(name: auditable_type) if !audit_auditable_type && auditable_type?
+  end
+end

data/app/models/active_record_auditable/audit_action.rb

@@ -0,0 +1,5 @@
+class ActiveRecordAuditable::AuditAction < ApplicationRecord
+  self.table_name = "audit_actions"
+
+  has_many :audits, class_name: "ActiveRecordAuditable::Audit", dependent: :restrict_with_error
+end

data/app/models/active_record_auditable/audit_auditable_type.rb

@@ -0,0 +1,5 @@
+class ActiveRecordAuditable::AuditAuditableType < ApplicationRecord
+  self.table_name = "audit_auditable_types"
+
+  has_many :audits, class_name: "ActiveRecordAuditable::Audit", dependent: :restrict_with_error
+end

data/app/models/active_record_auditable/base_audit.rb

@@ -0,0 +1,23 @@
+class ActiveRecordAuditable::BaseAudit < ActiveRecordAuditable::ApplicationRecord
+  self.abstract_class = true
+
+  def self.inherited(child)
+    super
+
+    child.include ActiveRecordAuditable::ActsAsJson
+
+    child.acts_as_json :audited_changes
+    child.acts_as_json :extra_liquid_variables
+    child.acts_as_json :params
+  end
+
+  belongs_to :audit_action, class_name: "ActiveRecordAuditable::AuditAction"
+
+  scope :where_action, ->(action) { joins(:audit_action).where(audit_actions: {action:}) }
+
+  delegate :action, to: :audit_action
+
+  def action=(action_name)
+    self.audit_action = ActiveRecordAuditable::AuditAction.find_or_create_by!(action: action_name)
+  end
+end

data/app/models/concerns/active_record_auditable/acts_as_json.rb

@@ -0,0 +1,49 @@
+module ActiveRecordAuditable::ActsAsJson
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def acts_as_json(attribute_name) # rubocop:disable Metrics/PerceivedComplexity
+      return if ActiveRecordAuditable::Audit.connection.class.name.include?("SQLite")
+
+      serialize attribute_name, coder: JSON
+
+      validate do
+        value = __send__(attribute_name)
+
+        if value.is_a?(String)
+          begin
+            JSON.parse(value)
+          rescue JSON::ParserError
+            errors.add(attribute_name, :invalid)
+          end
+        end
+      end
+
+      define_method(attribute_name) do
+        value = super()
+
+        if value.is_a?(String) && value.present?
+          JSON.parse(value)
+        else
+          value
+        end
+      rescue JSON::ParserError
+        super()
+      end
+
+      define_method(:"#{attribute_name}=") do |new_value|
+        if new_value.is_a?(Hash)
+          super(JSON.generate(new_value))
+        elsif new_value.is_a?(String) && new_value.blank?
+          super(nil)
+        else
+          super(new_value)
+        end
+      rescue JSON::ParserError
+        super(new_value)
+      end
+    end
+  end
+end

data/app/services/active_record_auditable/application_service.rb

@@ -0,0 +1,2 @@
+class ActiveRecordAuditable::ApplicationService < ServicePattern::Service
+end

data/app/services/active_record_auditable/audit_classes.rb

@@ -0,0 +1,19 @@
+class ActiveRecordAuditable::AuditClasses < ActiveRecordAuditable::ApplicationService
+  def perform
+    Rails.application.eager_load!
+    succeed!(audit_classes:)
+  end
+
+  def audit_classes
+    @audit_classes ||= begin
+      audit_classes = []
+      audit_classes << ActiveRecordAuditable::Audit
+
+      ActiveRecordAuditable::BaseAudit.descendants.each do |klass|
+        audit_classes << klass
+      end
+
+      audit_classes
+    end
+  end
+end

data/app/services/active_record_auditable/create_audits_table_for_model_class.rb

@@ -0,0 +1,28 @@
+class ActiveRecordAuditable::CreateAuditsTableForModelClass < ActiveRecordAuditable::ApplicationService
+  arguments :model_class
+  argument :create_table_args, default: nil
+  argument :extra_table_actions, default: nil
+  argument :id_type, default: nil
+
+  def perform
+    create_args = create_table_args || {}
+
+    type_args = {}
+    type_args[:type] = id_type if id_type
+
+    ActiveRecord::Migration.new.create_table table_name, **create_args do |t|
+      t.references model_class.model_name.param_key.to_sym, null: false, **type_args
+      t.json :audited_changes
+      t.references :audit_action, foreign_key: true, null: false, **type_args
+      t.json :params
+      extra_table_actions.call(t) if extra_table_actions
+      t.timestamps
+    end
+
+    succeed!
+  end
+
+  def table_name
+    @table_name ||= "#{model_class.table_name.singularize}_audits"
+  end
+end

data/app/services/active_record_auditable/migrate_audits_from_shared_table.rb

@@ -0,0 +1,70 @@
+class ActiveRecordAuditable::MigrateAuditsFromSharedTable < ActiveRecordAuditable::ApplicationService
+  arguments :model_class
+
+  def perform
+    while audits_in_general_table_exists?
+      sql = "SELECT * FROM audits WHERE auditable_type = '#{model_class.name}' LIMIT 1000"
+      records = model_class.connection.execute(sql).to_a(as: :hash)
+
+      insert_sql = "INSERT INTO `#{new_table_name}` ("
+      insert_sql << "`#{model_class.model_name.param_key}_id`"
+      delete_sql = "DELETE FROM `audits` WHERE `#{id_column_name}` IN ("
+      records_count = 0
+
+      records.first.keys.each do |key|
+        next if key == "auditable_id" || key == "auditable_type" || key == "audit_auditable_type_id"
+
+        key = "current_user_id" if key == "user_id"
+        insert_sql << ", `#{key}`"
+      end
+
+
+      insert_sql << ") VALUES "
+      inserts = []
+
+      records.each_with_index do |data, data_index|
+        delete_sql << ", " if data_index > 0
+        delete_sql << model_class.connection.quote(data.fetch(id_column_name))
+
+        insert_sql << ", " if data_index > 0
+        insert_sql << "("
+        insert_sql << model_class.connection.quote(data.fetch("auditable_id"))
+
+        data.each do |key, value|
+          next if key == "auditable_id" || key == "auditable_type" || key == "audit_auditable_type_id"
+
+          insert_sql << ", "
+          insert_sql << model_class.connection.quote(value)
+        end
+
+        insert_sql << ")"
+        records_count += 1
+
+        break if insert_sql.bytesize >= 5.megabytes
+      end
+
+      delete_sql << ")"
+
+      ActiveRecordAuditable::Audit.transaction do
+        create_result = ActiveRecordAuditable::Audit.connection.execute(insert_sql)
+        delete_result = ActiveRecordAuditable::Audit.connection.execute(delete_sql)
+      end
+    end
+
+    succeed!
+  end
+
+  def audits_in_general_table_exists?
+    sql = "SELECT 1 FROM audits WHERE auditable_type = '#{model_class.name}' LIMIT 1"
+    results = model_class.connection.execute(sql).first
+    results&.length&.positive?
+  end
+
+  def id_column_name
+    @id_column_name ||= model_class.primary_key
+  end
+
+  def new_table_name
+    @new_table_name ||= "#{model_class.table_name.singularize}_audits"
+  end
+end

data/app/views/layouts/active_record_auditable/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Active record auditable</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "active_record_auditable/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+ActiveRecordAuditable::Engine.routes.draw do
+end

data/db/migrate/20240307212702_create_audit_actions.rb

@@ -0,0 +1,8 @@
+class CreateAuditActions < ActiveRecord::Migration[7.1]
+  def change
+    create_table :audit_actions do |t|
+      t.string :action, index: {unique: true}, null: false
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240307212756_create_audit_auditable_types.rb

@@ -0,0 +1,8 @@
+class CreateAuditAuditableTypes < ActiveRecord::Migration[7.1]
+  def change
+    create_table :audit_auditable_types do |t|
+      t.string :name, index: {unique: true}, null: false
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240307212826_create_audits.rb

@@ -0,0 +1,12 @@
+class CreateAudits < ActiveRecord::Migration[7.1]
+  def change
+    create_table :audits do |t|
+      t.references :audit_action, foreign_key: true, null: false
+      t.references :audit_auditable_type, foreign_key: true, null: false
+      t.references :auditable, null: false, polymorphic: true
+      t.references :user, polymorphic: true
+      t.json :audited_changes
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20240609073430_add_params_to_audits.rb

@@ -0,0 +1,5 @@
+class AddParamsToAudits < ActiveRecord::Migration[7.1]
+  def change
+    add_column :audits, :params, :json
+  end
+end

data/lib/active_record_auditable/audited.rb

@@ -0,0 +1,153 @@
+module ActiveRecordAuditable::Audited
+  def self.__cached_audit_table_names
+    @__cached_audit_table_names ||= begin
+      result = {}
+      ActiveRecordAuditable::Audit.connection.tables.filter { |table_name| table_name.ends_with?("_audits") }.each do |table_name|
+        result[table_name] = true
+      end
+      result
+    end
+  end
+
+  def self.included(base)
+    dedicated_table_name = "#{base.table_name.singularize}_audits"
+    dedicated_table_exists = __dedicated_table_exists?(base, dedicated_table_name)
+
+    if dedicated_table_exists
+      table_name = dedicated_table_name
+      audit_class = __dedicated_audit_class(base, table_name)
+      audit_class_name = "#{base.name}::Audit"
+      inverse_of = base.model_name.param_key.to_sym
+      as = inverse_of
+    else
+      table_name = "audits"
+      audit_class = ActiveRecordAuditable::Audit
+      audit_class_name = "ActiveRecordAuditable::Audit"
+      inverse_of = :auditable
+      as = :auditable
+    end
+
+    base.has_one :create_audit, # rubocop:disable Rails/HasManyOrHasOneDependent
+      -> { joins(:audit_action).where(audit_actions: {action: "create"}) },
+      as: as,
+      class_name: audit_class_name,
+      inverse_of: inverse_of
+    base.has_many :audits, # rubocop:disable Rails/HasManyOrHasOneDependent
+      as: as,
+      class_name: audit_class_name,
+      inverse_of: inverse_of
+
+    base.has_one :create_audit, # rubocop:disable Rails/HasManyOrHasOneDependent
+      -> { joins(:audit_action).where(audit_actions: {action: "create"}) },
+      class_name: audit_class_name,
+      inverse_of: inverse_of
+    base.has_many :audits, # rubocop:disable Rails/HasManyOrHasOneDependent
+      class_name: audit_class_name,
+      inverse_of: inverse_of
+
+    base.after_create do
+      create_audit!(action: :create)
+    end
+
+    base.after_update do
+      create_audit!(action: :update)
+    end
+
+    base.after_destroy do
+      create_audit!(action: :destroy, audited_changes: attributes)
+    end
+
+    base.scope :without_audit, lambda { |action|
+      audit_class = base.reflections["audits"].klass
+      audit_foreign_key = base.reflections["audits"].foreign_key
+
+      audit_query = audit_class
+        .select(1)
+        .joins(:audit_action)
+        .where(audit_actions: {action:})
+        .where("#{audit_class.table_name}.#{audit_foreign_key} = #{base.table_name}.#{base.primary_key}")
+        .limit(1)
+
+      audit_query = audit_query.where(auditable_type: base.model_name.name) unless dedicated_table_exists
+      where("NOT EXISTS (#{audit_query.to_sql})")
+    }
+  end
+
+  def self.__dedicated_table_exists?(base, dedicated_table_name)
+    ActiveRecordAuditable::Audited.__cached_audit_table_names.key?(dedicated_table_name)
+  rescue ActiveRecord::StatementInvalid
+    false
+  end
+
+  def self.__dedicated_audit_class(base, table_name)
+    if base.const_defined?("Audit")
+      base.const_get("Audit")
+    else
+      audit_class = Class.new(ActiveRecordAuditable::BaseAudit)
+      audit_class.class_eval do
+        self.table_name = table_name
+
+        belongs_to base.model_name.param_key.to_sym, optional: true
+        belongs_to :auditable, class_name: base.name, foreign_key: :"#{base.model_name.param_key}_id", optional: true
+
+        def self.base_model
+          reflections["auditable"].klass
+        end
+
+        def auditable_type
+          self.class.reflections["auditable"].class_name
+        end
+      end
+
+      base.const_set("Audit", audit_class)
+
+      ActiveRecordAuditable::AuditAction.has_many(audit_class.model_name.plural.to_sym, class_name: audit_class.name)
+      ActiveRecordAuditable::AuditAuditableType.has_many(audit_class.model_name.plural.to_sym, class_name: audit_class.name)
+
+      audit_class
+    end
+  end
+
+  def audit_monitor
+    @@audit_monitor ||= Monitor.new # rubocop:disable Style/ClassVars
+  end
+
+  def create_audit!(action:, audited_changes: saved_changes_for_audit, **args)
+    audit_data = {
+      audit_action: find_or_create_auditable_action(action),
+      audited_changes:
+    }
+
+    audit_class = self.class.reflections["audits"].klass
+
+    if audit_class == ActiveRecordAuditable::Audit
+      audit_data[:audit_auditable_type_id] = find_or_create_auditable_type.id
+      audit_data[:auditable_id] = id
+      audit_data[:auditable_type] = self.model_name.name
+    else
+      audit_data[:"#{self.class.model_name.param_key}_id"] = id
+    end
+
+    audit_class.create!(audit_data.merge(args))
+  end
+
+  def find_or_create_auditable_action(action)
+    audit_monitor.synchronize do
+      return ActiveRecordAuditable::AuditAction.find_or_create_by!(action:)
+    end
+  end
+
+  def find_or_create_auditable_type
+    audit_monitor.synchronize do
+      return ActiveRecordAuditable::AuditAuditableType.find_or_create_by!(name: self.class.name)
+    end
+  end
+
+  def saved_changes_for_audit
+    saved_changes_for_audit = {}
+    saved_changes.each do |attribute_name, from_and_to|
+      saved_changes_for_audit[attribute_name] = from_and_to[1]
+    end
+    saved_changes_for_audit
+  end
+end

data/lib/active_record_auditable/engine.rb

@@ -0,0 +1,5 @@
+module ActiveRecordAuditable
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveRecordAuditable
+  end
+end

data/lib/active_record_auditable/version.rb

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

data/lib/active_record_auditable.rb

@@ -0,0 +1,7 @@
+require "active_record_auditable/version"
+require "active_record_auditable/engine"
+require "service_pattern"
+
+module ActiveRecordAuditable
+  autoload :Audited, "#{__dir__}/active_record_auditable/audited"
+end

data/lib/tasks/active_record_auditable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :active_record_auditable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: active_record_auditable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kaspernj
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: service_pattern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.10
+description: Audits for your records.
+email:
+- kasper@diestoeckels.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/active_record_auditable_manifest.js
+- app/assets/stylesheets/active_record_auditable/application.css
+- app/controllers/active_record_auditable/application_controller.rb
+- app/helpers/active_record_auditable/application_helper.rb
+- app/jobs/active_record_auditable/application_job.rb
+- app/mailers/active_record_auditable/application_mailer.rb
+- app/models/active_record_auditable/application_record.rb
+- app/models/active_record_auditable/audit.rb
+- app/models/active_record_auditable/audit_action.rb
+- app/models/active_record_auditable/audit_auditable_type.rb
+- app/models/active_record_auditable/base_audit.rb
+- app/models/concerns/active_record_auditable/acts_as_json.rb
+- app/services/active_record_auditable/application_service.rb
+- app/services/active_record_auditable/audit_classes.rb
+- app/services/active_record_auditable/create_audits_table_for_model_class.rb
+- app/services/active_record_auditable/migrate_audits_from_shared_table.rb
+- app/views/layouts/active_record_auditable/application.html.erb
+- config/routes.rb
+- db/migrate/20240307212702_create_audit_actions.rb
+- db/migrate/20240307212756_create_audit_auditable_types.rb
+- db/migrate/20240307212826_create_audits.rb
+- db/migrate/20240609073430_add_params_to_audits.rb
+- lib/active_record_auditable.rb
+- lib/active_record_auditable/audited.rb
+- lib/active_record_auditable/engine.rb
+- lib/active_record_auditable/version.rb
+- lib/tasks/active_record_auditable_tasks.rake
+homepage: https://github.com/kaspernj/active_record_auditable
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kaspernj/active_record_auditable
+  source_code_uri: https://github.com/kaspernj/active_record_auditable
+  changelog_uri: https://github.com/kaspernj/active_record_auditable/blob/master/CHANGELOG.md
+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: []
+rubygems_version: 3.4.19
+signing_key: 
+specification_version: 4
+summary: Audits for your records.
+test_files: []