anony 1.0.0

data/lib/anony/model_config.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+require_relative "./strategies/destroy"
+require_relative "./strategies/overwrite"
+
+module Anony
+  class ModelConfig
+    # @api private
+    class UndefinedStrategy
+      def valid?
+        false
+      end
+
+      def validate!
+        raise ArgumentError, "Must specify either :destroy or :overwrite strategy"
+      end
+    end
+
+    # @api private
+    # Constructs a new instance of ModelConfig.
+    #
+    # @param [ActiveRecord::Base] model_class The model class the config is attached to.
+    # @yield [block] For configuration of the ModelConfig instance.
+    #
+    # @example
+    #   Anony::ModelConfig.new(Manager) { destroy }
+    def initialize(model_class, &block)
+      @model_class = model_class
+      @strategy = UndefinedStrategy.new
+      @skip_filter = nil
+      instance_exec(&block) if block_given?
+    end
+
+    # @api private
+    # Applies the given strategy, taking into account any filters or conditions.
+    #
+    # @example
+    #   Anony::ModelConfig.new(Manager).apply(Manager.new)
+    def apply(instance)
+      return Result.skipped if @skip_filter && instance.instance_exec(&@skip_filter)
+
+      @strategy.apply(instance)
+    end
+
+    delegate :valid?, :validate!, to: :@strategy
+
+    # Use the deletion strategy instead of anonymising individual fields. This method is
+    # incompatible with the fields strategy.
+    #
+    # This method takes no arguments or blocks.
+    #
+    # @example
+    #   anonymise do
+    #     destroy
+    #   end
+    def destroy
+      raise ArgumentError, ":destroy takes no block" if block_given?
+      unless @strategy.is_a?(UndefinedStrategy)
+        raise ArgumentError, "Cannot specify :destroy when another strategy already defined"
+      end
+
+      @strategy = Strategies::Destroy.new
+    end
+
+    # Use the overwrite strategy to configure rules for individual fields. This method is
+    # incompatible with the destroy strategy.
+    #
+    # This method takes a configuration block. All configuration is applied to
+    # Anony::Strategies::Overwrite.
+    #
+    # @see Anony::Strategies::Overwrite
+    #
+    # @example
+    #   anonymise do
+    #     overwrite do
+    #       hex :first_name
+    #     end
+    #   end
+    def overwrite(&block)
+      unless @strategy.is_a?(UndefinedStrategy)
+        raise ArgumentError, "Cannot specify :overwrite when another strategy already defined"
+      end
+
+      @strategy = Strategies::Overwrite.new(@model_class, &block)
+    end
+
+    # Prevent any anonymisation strategy being applied when the provided block evaluates
+    # to true. The block is executed in the model context.
+    #
+    # @example
+    #   anonymise do
+    #     skip_if { !persisted? }
+    #   end
+    def skip_if(&if_condition)
+      raise ArgumentError, "Block required for :skip_if" unless block_given?
+
+      @skip_filter = if_condition
+    end
+  end
+end

data/lib/anony/result.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+module Anony
+  class Result
+    FAILED = "failed"
+    DESTROYED = "destroyed"
+    OVERWRITTEN = "overwritten"
+    SKIPPED = "skipped"
+
+    attr_reader :status, :fields, :error
+    delegate :failed?, :overwritten?, :skipped?, :destroyed?, to: :status
+
+    def self.failed(error)
+      new(FAILED, error: error)
+    end
+
+    def self.overwritten(fields)
+      new(OVERWRITTEN, fields: fields)
+    end
+
+    def self.skipped
+      new(SKIPPED)
+    end
+
+    def self.destroyed
+      new(DESTROYED)
+    end
+
+    private def initialize(status, fields: [], error: nil)
+      raise ArgumentError, "No error provided" if status == FAILED && error.nil?
+
+      @status = ActiveSupport::StringInquirer.new(status)
+      @fields = fields
+      @error = error
+    end
+  end
+end

data/lib/anony/rspec_shared_examples.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+RSpec.shared_examples "overwritten anonymisable model" do
+  it "has a valid strategy defined" do
+    expect(subject.class).to be_valid_anonymisation
+  end
+
+  it "#anonymise! causes overwrite" do
+    result = subject.anonymise!
+    expect(result).to be_overwritten
+  end
+end
+
+RSpec.shared_examples "skipped anonymisable model" do
+  it "has a valid strategy defined" do
+    expect(subject.class).to be_valid_anonymisation
+  end
+
+  it "#anonymise! is skipped" do
+    result = subject.anonymise!
+    expect(result).to be_skipped
+  end
+
+  it "does not change any fields" do
+    result = subject.anonymise!
+    expect(result.fields).to be_empty
+  end
+end
+
+RSpec.shared_examples "destroyed anonymisable model" do
+  it "has a valid strategy defined" do
+    expect(subject.class).to be_valid_anonymisation
+  end
+
+  it "destroys the model" do
+    expect { subject.anonymise! }.to change(described_class, :count).by(-1)
+  end
+
+  it "labels the model as destroyed" do
+    result = subject.anonymise!
+    expect(result).to be_destroyed
+  end
+end

data/lib/anony/skipped_exception.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Anony
+  class SkippedException < StandardError
+    def initialize
+      super("Anonymisation skipped due to matching skip_if filter")
+    end
+  end
+end

data/lib/anony/strategies/destroy.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Anony
+  module Strategies
+    # The interface for configuring a destroy strategy. This strategy is not compatible
+    # with Anony::Strategies::Overwrite.
+    #
+    # @example
+    #   anonymise do
+    #     destroy
+    #   end
+    class Destroy
+      # Whether the strategy is valid. This strategy takes no configuration, so #valid?
+      # always returns true
+      #
+      # @return [true]
+      def valid?
+        true
+      end
+
+      # Whether the strategy is valid, raising an exception if not. This strategy takes no
+      # configuration, so #validate! always returns true
+      #
+      # @return [true]
+      def validate!
+        true
+      end
+
+      # Apply the Destroy strategy to the model instance. In this case, it calls
+      # `#destroy!`.
+      #
+      # @param [ActiveRecord::Base] instance An instance of the model
+      def apply(instance)
+        instance.destroy!
+        Result.destroyed
+      end
+    end
+  end
+end

data/lib/anony/strategies/overwrite.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative "../field_level_strategies"
+
+module Anony
+  module Strategies
+    # The interface for configuring a field-level strategy. All of the methods here are
+    # made available inside the `overwrite { ... }` block:
+    #
+    # @example
+    #   anonymise do
+    #     overwrite do
+    #       nilable :first_name
+    #       email :email_address
+    #       with_strategy(:last_name) { "last-#{id}" }
+    #     end
+    #   end
+    class Overwrite
+      include FieldLevelStrategies
+
+      # @!visibility private
+      def initialize(model_class, &block)
+        @model_class = model_class
+        @anonymisable_fields = {}
+        instance_eval(&block) if block_given?
+      end
+
+      # A hash containing the fields and their anonymisation strategies.
+      attr_reader :anonymisable_fields
+
+      # Check whether the combination of field-level rules is valid
+      def valid?
+        validate!
+        true
+      rescue FieldException
+        false
+      end
+
+      def validate!
+        raise FieldException, unhandled_fields if unhandled_fields.any?
+      end
+
+      # Apply the Overwrite strategy on the model instance, which applies each of the
+      # configured transformations and updates the :anonymised_at field if it exists.
+      #
+      # @param [ActiveRecord::Base] instance An instance of the model
+      def apply(instance)
+        if !@anonymisable_fields.key?(:anonymised_at) &&
+            @model_class.column_names.include?("anonymised_at")
+          current_datetime(:anonymised_at)
+        end
+
+        @anonymisable_fields.each_key do |field|
+          anonymise_field(instance, field)
+        end
+
+        result_fields = instance.changes.keys.map(&:to_sym).reject { |s| s == :anonymised_at }
+
+        instance.save!
+
+        Result.overwritten(result_fields)
+      end
+
+      # Configure a custom strategy for one or more fields. If a block is given that is used
+      # as the strategy, otherwise the first argument is used as the strategy.
+      #
+      # @param [Proc, Object] strategy Any object which responds to
+      #   `.call(previous_value)`. Not used if a block is provided.
+      # @param [Array<Symbol>] fields A list of one or more fields to apply this strategy to.
+      # @param [Block] &block A block to use as the strategy.
+      # @yieldparam previous [Object] The previous value of the field
+      # @yieldreturn [Object] The value to set on that field.
+      # @raise [ArgumentError] If the combination of strategy, fields and block is invalid.
+      # @raise [DuplicateStrategyException] If more than one strategy is defined for the same field.
+      #
+      # @example With a named class
+      #   class Reverse
+      #     def self.call(previous)
+      #       previous.reverse
+      #     end
+      #   end
+      #
+      #   with_strategy(Reverse, :first_name)
+      #
+      # @example With a constant value
+      #   with_strategy({}, :metadata)
+      #
+      # @example With a block
+      #   with_strategy(:first_name, :last_name) { |previous| previous.reverse }
+      def with_strategy(strategy, *fields, &block)
+        if block_given?
+          fields.unshift(strategy)
+          strategy = block
+        end
+
+        fields = fields.flatten
+
+        raise ArgumentError, "Block or Strategy object required" unless strategy
+        raise ArgumentError, "One or more fields required" unless fields.any?
+
+        guard_duplicate_strategies!(fields)
+
+        fields.each { |field| @anonymisable_fields[field] = strategy }
+      end
+
+      # Helper method to use the :hex strategy
+      # @param [Array<Symbol>] fields A list of one or more fields to apply this strategy to.
+      # @see Strategies::OverwriteHex
+      #
+      # @example
+      #   hex :first_name
+      def hex(*fields, max_length: 36)
+        with_strategy(Strategies::OverwriteHex.new(max_length), *fields)
+      end
+
+      # Configure a list of fields that you don't want to anonymise.
+      #
+      # @param [Array<Symbol>] fields The fields to ignore
+      # @raise [ArgumentError] If trying to ignore a field which is already globally
+      #   ignored in Anony::Config.ignores
+      #
+      # @example
+      #   ignore :external_system_id, :externalised_at
+      def ignore(*fields)
+        already_ignored = fields.select { |field| Config.ignore?(field) }
+
+        if already_ignored.any?
+          raise ArgumentError, "Cannot ignore #{already_ignored.inspect} " \
+                              "(fields already ignored in Anony::Config)"
+        end
+
+        no_op(*fields)
+      end
+
+      private def unhandled_fields
+        anonymisable_columns =
+          @model_class.column_names.map(&:to_sym).
+            reject { |c| Config.ignore?(c) }.
+            reject { |c| c == :anonymised_at }
+
+        handled_fields = @anonymisable_fields.keys
+
+        anonymisable_columns - handled_fields
+      end
+
+      private def anonymise_field(instance, field)
+        return unless @model_class.column_names.include?(field.to_s)
+
+        strategy = @anonymisable_fields.fetch(field)
+        current_value = instance.read_attribute(field)
+
+        instance.write_attribute(field, anonymised_value(instance, strategy, current_value))
+      end
+
+      private def anonymised_value(instance, strategy, current_value)
+        if strategy.is_a?(Proc)
+          instance.instance_exec(current_value, &strategy)
+        elsif strategy.respond_to?(:call)
+          strategy.call(current_value)
+        else
+          strategy
+        end
+      end
+
+      private def guard_duplicate_strategies!(fields)
+        defined_fields = @anonymisable_fields.keys
+        duplicate_fields = defined_fields & fields
+
+        raise DuplicateStrategyException, duplicate_fields if duplicate_fields.any?
+      end
+    end
+  end
+end

data/lib/anony/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anony
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: anony
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- GoCardless Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+- !ruby/object:Gem::Dependency
+  name: gc_ruboconfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+description: 
+email:
+- engineering@gocardless.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- anony.gemspec
+- docs/COMPATIBILITY.md
+- lib/anony.rb
+- lib/anony/anonymisable.rb
+- lib/anony/config.rb
+- lib/anony/cops.rb
+- lib/anony/cops/define_deletion_strategy.rb
+- lib/anony/duplicate_strategy_exception.rb
+- lib/anony/field_exception.rb
+- lib/anony/field_level_strategies.rb
+- lib/anony/model_config.rb
+- lib/anony/result.rb
+- lib/anony/rspec_shared_examples.rb
+- lib/anony/skipped_exception.rb
+- lib/anony/strategies/destroy.rb
+- lib/anony/strategies/overwrite.rb
+- lib/anony/version.rb
+homepage: https://github.com/gocardless/anony
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A small library that defines how ActiveRecord models should be anonymised
+  for deletion purposes.
+test_files: []