remont 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ffe65eff0fe907d7834a94e028001396ad17937b313cb9197475b66c4938c33
-  data.tar.gz: 7247441b4f59709a8c877da6ae9a9679f27c02916ca553f0f7f9d9f2808c9805
+  metadata.gz: cc06eb6d1dddd55ec43542c7ce574c3e4b2f775230d4005aa4e72a2352ce24df
+  data.tar.gz: 403813fb176d0c028075298808a897f149de6116bacb89e7bf92dce5633d743f
 SHA512:
-  metadata.gz: 60ae2dc780851f4bef7436e65b2143cfd5b8454b2cd5f3dc512985f32ab061f59eed24ff769e34fc26adabe43a7346aaf411b824d8e9979153b7fac342792e05
-  data.tar.gz: 745d82eac997e1bda274f2e5fc20f3f6b10b69043efe0de83746804725fea5b7a5b5bf99c585d9f866ca88e6bd9d1c1a901855c6b7cc034f4ebf1846b56e9446
+  metadata.gz: 71af67ff58ba821f6c12ca67ceb038024c88536afbeb1173c7cce0b34cca9fca63da47e9543932a2f744f508fb8c1aca7c4656ef9706c188956f658689ed1244
+  data.tar.gz: bf33a5f1ccbf9b88c0ce06852ec12fda9898c0186dfe1f5cb5a09408f680cb4e04eade3519791f1ac6dae5fd850105fb92ba645ec9b18bca2a4838126d5c7cdb

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Remont Change Log
+
+## 0.1.1 (Mar 23rd, 2022)
+
+- Add support for adding script path argument to the rake task (@cukoreva)
+- Add support for configuring processing status attribute per schema (@vr4b4c)

data/README.md

@@ -21,14 +21,12 @@ Add `config/initializers/remont.rb`
 ```ruby
 Remont.setup do |config|
   config.process_timestamp_attribute = :processed_at
-  config.script_path = 'db/remont.rb'
 end
 ```
 
-| Option                        | Default value    | Description                                |
-| ---                           | :---:            | ---                                        |
-| `process_timestamp_attribute` | `:processed_at`  | processing status attribute identifier     |
-| `script_path`                 | `'db/remont.rb'` | entry point for the schema processing task |
+| Option                        | Default value    | Description                            |
+| ---                           | :---:            | ---                                    |
+| `process_timestamp_attribute` | `nil`            | processing status attribute identifier |
 
 On successful record processing, `process_timestamp_attribute` on the record will be set to the current processing time (`Time.now.getlocal`).
 
@@ -38,11 +36,10 @@ In the following example, the intention is to simulate anonymization of the `use
 ```ruby
 # config/initializers/remont.rb
 Remont.setup do |config|
-  config.process_timestamp_attribute = :anonyzmied_at
-  config.script_path = 'db/anonymize.rb'
+  config.process_timestamp_attribute = :anonymized_at
 end
 ```
-- define processing script
+- define the processing script
 ```ruby
 # db/anonymize.rb
 schema model: User  do
@@ -53,8 +50,12 @@ schema model: Order do
   attribute(:billing_address) { '23 Wall Street, NY' }
 end
 ```
-- and run `bundle exec rake remont`
+- and run `remont` rake task with the path to the processing script
+```bash
+bundle exec rake "remont[db/anonymize.rb]"
+```
 
+Passing the script path to the rake task is mandatory.
 Running the rake task would result in updating `email` (and `anonymized_at`) column for each row in the `users` table, and `billing_address` column for each row in the `orders` table.
 
 ### Schema
@@ -77,14 +78,29 @@ schema model: Order do
   scope { |scope| scope.where(status: :active) }
 end
 ```
+### Recording the processing end time
+Library supports an option to store the processing end time of a record. Enable the behavior by configuring a processing status attribute identifier for the schema. Configure the attribute identifier
+- globally (`Remont::Config#process_timestamp_attribute`, for all schemas)
+- or individually per schema (in the schema DSL, overrides the global setting)
+```ruby
+schema model: User, process_timestamp_attribute: :anonymized_at do
+end
+
+schema model: Order do
+  with_process_timestamp_attribute :anonymized_at
+end
+```
+
+Set process status attribute to `nil` to disable the behavior.
 ### Skipping the processed records
-In some cases, it's desirable to skip already processed records. You can opt-in to this behavior by declaring `without_processed` within the `schema` block. When declared, the processing dataset query will be extended with a condition that excludes already processed records (ie. `where(Remont.process_timestamp_attribute => nil)`)
+In some cases, it's desirable to skip already processed records. You can enable this behavior by declaring `without_processed` within the `schema` block. When declared, the processing dataset query will be extended with a condition that excludes already processed records.
 ```ruby
 schema model: User do
   without_processed
   # ...
 end
 ```
+Configure processing status attribute before declaring the `without_processed`. An error will be raised otherwise.
 ### Callbacks
 Custom pre-processing or post-processing behavior can be declared using `before` and `after` callbacks.
 ```ruby

data/lib/remont/config.rb

@@ -1,16 +1,10 @@
 module Remont
   class Config
-    DEFAULT_SCRIPT_PATH = 'db/remont.rb'.freeze
-
     # @return [Symbol]
     attr_accessor :process_timestamp_attribute
 
-    # @return [String]
-    attr_accessor :script_path
-
     def initialize
-      @process_timestamp_attribute = :processed_at
-      @script_path = DEFAULT_SCRIPT_PATH
+      @process_timestamp_attribute = nil
     end
   end
 end

data/lib/remont/record_processor.rb

@@ -2,11 +2,11 @@ module Remont
   class RecordProcessor
     NOOP = proc {}
 
-    # @param [Array<Remont::Attribute>] attributes
+    # @param [Remont::Schema] schema
     # @param [Proc] before
     # @param [Proc] after
-    def initialize(attributes, before, after)
-      @attributes = attributes
+    def initialize(schema, before, after)
+      @schema = schema
       @before = before || NOOP
       @after = after || NOOP
     end
@@ -25,12 +25,13 @@ module Remont
 
     private
 
-    attr_reader :attributes
+    attr_reader :schema
     attr_reader :before
     attr_reader :after
 
     def processed_attributes(record)
-      attributes
+      schema
+        .attributes
         .select { |attribute| record.send(attribute.name).present? }
         .reduce(default_processed_attributes) do |memo, attribute|
           memo.merge(attribute.name => attribute.process(record.send(attribute.name), record))
@@ -38,10 +39,10 @@ module Remont
     end
 
     def default_processed_attributes
-      return {} unless Remont.config.process_timestamp_attribute
+      return {} unless schema.process_timestamp_attribute
 
       {
-        Remont.config.process_timestamp_attribute => Time.now.getlocal
+        schema.process_timestamp_attribute => Time.now.getlocal
       }
     end
   end

data/lib/remont/schema.rb

@@ -1,16 +1,23 @@
 module Remont
   class Schema
-    DEFAULT_SCOPE = proc { |scope| scope }
-    WITHOUT_PROCESSED = proc { |scope| scope.where(Remont.config.process_timestamp_attribute => nil) }
+    MISSING_PROCESSING_STATUS_ATTR = "Processing status attribute isn't configured".freeze
+
+    # @return [Array<Remont::Attribute>]
+    attr_reader :attributes
+
+    # @return [Nil, String, Symbol]
+    attr_reader :process_timestamp_attribute
 
     # @param [Hash] opts
     # @option [Class] :model
     # @option [Proc] :scope
+    # @option [String, Symbol] :process_timestamp_attribute
     # @param [Proc] block
     def initialize(opts = {}, &block)
       @model = opts.fetch(:model)
-      @model_scope = opts.fetch(:scope, DEFAULT_SCOPE)
-      @without_processed_scope = DEFAULT_SCOPE
+      @model_scope = opts.fetch(:scope, default_scope)
+      @without_processed_scope = default_scope
+      @process_timestamp_attribute = opts.fetch(:process_timestamp_attribute, Remont.config.process_timestamp_attribute)
       @before_cb = nil
       @after_cb = nil
       @attributes = []
@@ -20,7 +27,17 @@ module Remont
 
     # @return [Remont::Schema]
     def without_processed
-      @without_processed_scope = WITHOUT_PROCESSED
+      raise MISSING_PROCESSING_STATUS_ATTR if @process_timestamp_attribute.nil?
+
+      @without_processed_scope = proc { |scope| scope.where(process_timestamp_attribute => nil) }
+
+      self
+    end
+
+    # @param [String, Symbol] attr_name
+    # @return [Remont::Schema]
+    def with_process_timestamp_attribute(attr_name)
+      @process_timestamp_attribute = attr_name
 
       self
     end
@@ -70,12 +87,11 @@ module Remont
     attr_reader :model
     attr_reader :without_processed_scope
     attr_reader :model_scope
-    attr_reader :attributes
     attr_reader :before_cb
     attr_reader :after_cb
 
     def processor
-      @processor ||= RecordProcessor.new(attributes, before_cb, after_cb)
+      @processor ||= RecordProcessor.new(self, before_cb, after_cb)
     end
 
     def records_for_processing
@@ -83,5 +99,9 @@ module Remont
         without_processed_scope.call(model.all)
       )
     end
+
+    def default_scope
+      proc { |scope| scope }
+    end
   end
 end

data/lib/remont/tasks/remont.rake

@@ -1,5 +1,13 @@
 desc 'Run schema processing'
-task remont: :environment do
-  path = Rails.root.join(Remont.config.script_path)
+task :remont, [:script_path] => :remont_env do |_, args|
+  script_path = args[:script_path]
+  abort 'Missing script path' unless script_path
+
+  path = Rails.root.join(script_path)
   Remont::Script.new(path).run!
 end
+
+task :remont_env do # rubocop:disable Rails/RakeEnvironment
+  Rake::Task['environment'].invoke
+rescue StandardError # rubocop:disable Lint/SuppressedException
+end

data/lib/remont/version.rb

@@ -1,3 +1,3 @@
 module Remont
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remont
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Rails Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-08 00:00:00.000000000 Z
+date: 2022-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord