lethe 0.1.0

data/lib/lethe.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "i18n"
+require_relative "lethe/version"
+require_relative "lethe/configuration"
+require_relative "lethe/target"
+require_relative "lethe/policy"
+require_relative "lethe/definition"
+require_relative "lethe/reference"
+require_relative "lethe/discovery"
+require_relative "lethe/result"
+require_relative "lethe/report"
+require_relative "lethe/rules"
+require_relative "lethe/checker"
+require_relative "lethe/formatters"
+require_relative "lethe/exporter"
+require_relative "lethe/runner"
+require_relative "lethe/rows"
+require_relative "lethe/enums"
+require_relative "lethe/locator"
+require_relative "lethe/plan"
+require_relative "lethe/ledger"
+require_relative "lethe/eraser"
+require_relative "lethe/leftovers"
+require_relative "lethe/sweeper"
+
+# Declares what happens to the data that points at a model, such as User,
+# when that record goes away, and finds the tables nobody declared.
+module Lethe
+  class Error < StandardError; end
+
+  # The definitions file could not be read, or names something that is not a model.
+  class DefinitionError < Error; end
+
+  # Raised by Lethe.check! when the check finds problems.
+  class Unclean < Error
+    attr_reader :report
+
+    def initialize(report)
+      @report = report
+      super(Formatters::Text.new(report).render)
+    end
+  end
+
+  I18n.load_path += Dir[File.join(__dir__, "lethe", "locales", "*.yml")]
+
+  PREPARE_MUTEX = Mutex.new
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    # The definitions declared so far, keyed by subject class name.
+    def definitions
+      @definitions ||= {}
+    end
+
+    # Declares the policies for one subject. Calling it again for the same
+    # subject adds to what was declared before.
+    def define(subject, &block)
+      raise ArgumentError, "Lethe.define needs a block" unless block
+
+      name = subject.is_a?(Module) ? subject.name : subject.to_s
+      raise ArgumentError, "Lethe.define needs a class or a class name" if name.nil? || name.empty?
+
+      definition = definitions[name] ||= Definition.new(name)
+      Definition::Builder.new(definition).instance_exec(&block)
+      definition
+    end
+
+    # Forgets every definition, then loads the definitions file.
+    def load_definitions(path)
+      raise DefinitionError, I18n.t("lethe.errors.no_definitions_file", path: path.to_s) unless File.file?(path)
+
+      reset_definitions!
+      load File.expand_path(path)
+      definitions
+    end
+
+    def reset_definitions!
+      @definitions = {}
+    end
+
+    def reset!
+      reset_definitions!
+      @configuration = nil
+    end
+
+    # Checks every definition against the schema and returns a Report.
+    # models defaults to every loaded Active Record model with a table.
+    def check(definitions: nil, models: nil, connection: nil, strict: false)
+      prepare_application if definitions.nil?
+      definitions ||= self.definitions.values
+      run = lambda do |conn|
+        definitions.flat_map do |definition|
+          Checker.new(definition, models: models, connection: conn, configuration: configuration).call
+        end
+      end
+      results = connection ? run.call(connection) : ActiveRecord::Base.with_connection(&run)
+      Report.new(results, strict: strict)
+    end
+
+    # Like check, but raises Lethe::Unclean when there are problems. For tests.
+    def check!(**options)
+      report = check(**options)
+      raise Unclean, report unless report.clean?
+
+      report
+    end
+
+    # What erasing record would do, step by step, without doing it.
+    # Raises Lethe::Unclean when the record's definition does not pass the check.
+    def plan(record, models: nil)
+      prepare_application
+      definition, report = checked(record.class, models)
+      ActiveRecord::Base.with_connection do |connection|
+        Plan.new(record, definition, report.results, models: models || application_models, connection: connection)
+      end
+    end
+
+    # Erases record as its definition declares, in one transaction, and
+    # returns what it did. Refuses with Lethe::Unclean unless the check passes.
+    def erase!(record, models: nil)
+      plan = plan(record, models: models)
+      ledger = ActiveRecord::Base.with_connection { |connection| Ledger.available?(connection) }
+      if !ledger && plan.definition.policies.any?(&:retention)
+        raise Error, I18n.t("lethe.errors.ledger_required", table: Ledger::TABLE)
+      end
+
+      Eraser.new(plan, configuration: configuration, ledger: ledger).call
+    end
+
+    # After erase!, what still points at the subject in a way its definition
+    # does not allow. Empty when the erasure left nothing behind. For tests.
+    def leftovers(record_or_class, id = nil, models: nil)
+      prepare_application
+      subject = record_or_class.is_a?(Class) ? record_or_class : record_or_class.class
+      id ||= record_or_class.id
+      definition, report = checked(subject, models)
+      Leftovers.new(subject, id, definition, report.results, models: models || application_models).call
+    end
+
+    # Deletes kept rows whose `for:` has passed since their subject was erased.
+    def sweep!(models: nil, now: Time.current)
+      prepare_application
+      ActiveRecord::Base.with_connection do |connection|
+        raise Error, I18n.t("lethe.errors.ledger_required", table: Ledger::TABLE) unless Ledger.available?(connection)
+      end
+      swept = Sweeper.new(definitions.values, models: models || application_models, now: now).call
+      ActiveSupport::Notifications.instrument("sweep.lethe", counts: swept)
+      swept
+    end
+
+    private
+
+    # Inside a Rails application: loads config/lethe.rb the first time it is
+    # needed, unless definitions were loaded or declared already, and loads
+    # every model once, so that development and test see the same
+    # associations as production and CI.
+    def prepare_application
+      return unless defined?(Rails.application) && Rails.application
+
+      PREPARE_MUTEX.synchronize do
+        if definitions.empty?
+          path = Rails.root.join(configuration.definition_path)
+          load_definitions(path) if File.file?(path)
+        end
+        unless @eager_loaded || Rails.application.config.eager_load
+          Rails.application.eager_load!
+          @eager_loaded = true
+        end
+      end
+    end
+
+    def checked(subject, models)
+      definition = definitions[subject.name] || definitions[subject.base_class.name]
+      raise Error, I18n.t("lethe.errors.no_definition", subject: subject.name) unless definition
+
+      report = check(definitions: [definition], models: models)
+      raise Unclean, report unless report.clean?
+
+      [definition, report]
+    end
+  end
+end
+
+require_relative "lethe/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: lethe
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- KAIBYAKU K.K
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: |
+  lethe finds every table and column that points at a model such as User,
+  from foreign keys, associations and column names, and checks that each one
+  has a declared policy for when that user leaves: destroy, scrub, keep or
+  ignore. It reads the schema only and never touches your data.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/generators/lethe/install/install_generator.rb
+- lib/generators/lethe/install/templates/create_lethe_erasures.rb.tt
+- lib/generators/lethe/install/templates/lethe.rb.tt
+- lib/lethe.rb
+- lib/lethe/checker.rb
+- lib/lethe/configuration.rb
+- lib/lethe/definition.rb
+- lib/lethe/discovery.rb
+- lib/lethe/enums.rb
+- lib/lethe/eraser.rb
+- lib/lethe/exporter.rb
+- lib/lethe/formatters.rb
+- lib/lethe/ledger.rb
+- lib/lethe/leftovers.rb
+- lib/lethe/locales/en.yml
+- lib/lethe/locales/ja.yml
+- lib/lethe/locator.rb
+- lib/lethe/plan.rb
+- lib/lethe/policy.rb
+- lib/lethe/railtie.rb
+- lib/lethe/reference.rb
+- lib/lethe/report.rb
+- lib/lethe/result.rb
+- lib/lethe/rows.rb
+- lib/lethe/rules.rb
+- lib/lethe/runner.rb
+- lib/lethe/sweeper.rb
+- lib/lethe/target.rb
+- lib/lethe/tasks/lethe.rake
+- lib/lethe/version.rb
+homepage: https://github.com/kaibyaku-jp/lethe
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/kaibyaku-jp/lethe
+  changelog_uri: https://github.com/kaibyaku-jp/lethe/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Declare what happens to each table when a user leaves, and catch the ones
+  you forgot
+test_files: []