quickery 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5caca192d074a8aa71dd2c6e9bc06a3051b6f7eaec2bc664618af356d41a250d
-  data.tar.gz: 9acfccf220d83aa4c0d521ba13b4040241273d513160a7e2c4b4afccdb32de8a
+  metadata.gz: ef98d8559e4364a5532777fc264d895dab630d914475bf663978798f5fce932c
+  data.tar.gz: ab4eda789c789b451d68a7839e508aef9a4178c039c250207a79d85e09b97ccf
 SHA512:
-  metadata.gz: 3839d48b10faac8d58778c4373440496781a3c52765478b510b1918441fda4aae743097e65ec4a0841fad599f3dfea3b8279062eb406e4a2a0dd0272885774d5
-  data.tar.gz: 29cb2b61d408b61eee767267dce79538aa8039e1de9f85e111f62bb330ad1b395d7c810f4ae2e0065ef1ac37f70094c3e0f564ddda97cf46dde5921432cad066
+  metadata.gz: 62d2462169148384f2bdd6675bfbbc70a0fc5908b63be6c0e14726f75ac678c083e8c9fa8621f4decb857074d130724c9e7ff7b417f0d5e32e2f92a815ee33e5
+  data.tar.gz: 57f167d27cf38b2b4e1753f3ec6fbf81843d6f67e452310041f16acf63daba26ca9202ccc64bda393cca3e1ea30f3acbe6da57ec6b1a6e46b7cb7eedbcd7d1ba

data/README.md

@@ -26,7 +26,7 @@
     bundle install
     ```
 
-## Usage Example 1
+## Usage Example 1 - Mapped Attribute
 
 ```ruby
 # app/models/employee.rb
@@ -63,7 +63,8 @@ end
 
 ```bash
 # bash
-rails generate migration add_branch_company_name_to_employees branch_company_name:string
+rails generate quickery:migration employee branch_company_name:string
+# or: rails generate migration add_branch_company_name_to_employees branch_company_name:string
 bundle exec rake db:migrate
 ```
 
@@ -100,7 +101,10 @@ puts employee.branch_company_name
 # => 'McDonalds'
 ```
 
-If you already have "old" records before you've integrated quickery or if you have new quickery-defined attributes, you can update these stale records by using `recreate_quickery_cache!`. See example below:
+If you already have "old" records before you've integrated quickery or if you have new quickery-defined attributes, you can update these stale records...
+
+1. by using `autoload_unsynced_quickery_attributes!` (see Usage Example 3 below), or...
+2. by using `recreate_quickery_cache!`. See example below:
 
 ```ruby
 # rails console
@@ -109,9 +113,9 @@ Employee.find_each do |employee|
 end
 ```
 
-## Usage Example 2
+## Usage Example 2 - Association via Mapped Attribute
 
-* let `Branch` and `Company` model be the same as the Usage Example 1 above
+* let `Branch` and `Company` models be the same as the Usage Example 1 above
 
 ```ruby
 # app/models/employee.rb
@@ -125,7 +129,8 @@ end
 
 ```bash
 # bash
-rails generate migration add_branch_company_id_to_employees branch_company_id:bigint:index
+rails generate quickery:migration employee branch_company_id:bigint:index
+# or: rails generate migration add_branch_company_id_to_employees branch_company_id:bigint:index
 bundle exec rake db:migrate
 ```
 
@@ -150,6 +155,54 @@ puts Employee.joins(branch: :company).where(companies: { id: company.id })
 # => [#<Employee id: 1>]
 ```
 
+## Usage Example 3 - Autoloading Quickery Attributes
+
+> `autoload_unsynced_quickery_attributes!` below is **ONLY** compatible with optional `*_is_synced` attributes, which can be done by passing `--add_is_synced_attributes` to the `quickery:migration` generator. See example below.
+
+* let `Branch` and `Company` models be the same as the Usage Example 1 above
+
+```ruby
+# app/models/employee.rb
+class Employee < ApplicationRecord
+  belongs_to :branch
+
+  quickery { branch: { company: { id: :branch_company_name } } }
+
+  after_find :autoload_unsynced_quickery_attributes!
+end
+```
+
+```bash
+# bash
+rails generate quickery:migration employee branch_company_name:string --add_is_synced_attributes
+bundle exec rake db:migrate
+```
+
+```ruby
+# rails console
+company = Company.create!(name: 'Jollibee')
+branch = Branch.create!(company: company)
+employee_created_before_quickery_integration = Employee.create!(branch: branch)
+
+puts employee_created_before_quickery_integration.branch_company_name
+# => NoMethodError: undefined method `branch_company_name'
+
+# Let's say the employee record above was created long time ago before Quickery was integrated,
+# and then right now, you added the new quickery-attribute `branch_company_name`.
+
+# Employee record above now then will have "stale" value for `branch_company_name`,
+# because it will have a value of `nil`.
+# But using `after_find :autoload_unsynced_quickery_attributes!` above, all records will
+# then be guaranteed to have up-to-date quickery attributes even if new quickery-attributes
+# will be defined in the future.
+
+puts employee_created_before_quickery_integration.branch_company_name
+# => 'Employee'
+
+# if without `after_find :autoload_unsynced_quickery_attributes!`, the puts just above will instead show
+# => nil
+```
+
 ## Other Usage Examples
 
 ```ruby
@@ -281,19 +334,17 @@ class Employee < ApplicationRecord
 
   # example (you can rename this method):
   def self.quickery_format_values(values)
-    formatted_values = {}
-
     :branch_company_name.tap do |attr|
       # remove trailing white spaces and force-single-space between words, and then capitalise all characters
-      formatted_values[attr] = values[attr].squish.upcase if values.has_key? attr
+      values[attr] = values[attr].squish.upcase if values.has_key? attr
     end
 
     :user_first_name.tap do |attr|
       # only save the first 30 characters of user_first_name string
-      formatted_values[attr] = values[attr][0...30] if values.has_key? attr
+      values[attr] = values[attr][0...30] if values.has_key? attr
     end
 
-    formatted_values
+    values
   end
 end
 ```
@@ -310,6 +361,8 @@ class Employee < ApplicationRecord
     employee.assign_attributes(quickery_with_computed_values(employee, new_values))
   end
 
+  # IMPORTANT: for big tables, `find_each` below can be slow (consider moving into a background job or if possible use the default behaviour which is `update_all`)
+
   def self.quickery_before_association_update(employees, record_to_be_updated, new_values)
     employee.find_each do |employee|
       employee.update!(quickery_with_computed_values(employee, new_values))
@@ -326,22 +379,22 @@ class Employee < ApplicationRecord
 
   # example (you can rename this method):
   def self.quickery_with_computed_values(employee, values)
-    with_computed_values = {}
-
     if values.has_key?(:user_first_name) || values.has_key?(:user_last_name)
+      employee.user_first_name = values[:user_first_name] if values.has_key?(:user_first_name)
+      employee.user_last_name = values[:user_last_name] if values.has_key?(:user_last_name)
       # concatenate first name and last name
-      with_computed_values[:user_full_name] = "#{values[:user_first_name]} #{values[:user_last_name]}".strip
+      values[:user_full_name] = "#{employee.user_first_name} #{employee.user_last_name}".strip
     end
 
     # you can add logic that specifically depends on the record like the following:
     if employee.is_current_employee?
-      if values.has_key? :branch_company_name
+      if values.has_key? :branch_company_id
         # concatenate a unique code for the employee: i.e. a value of "11-5-1239"
-        with_computed_values[:unique_codename] = "#{employee.branch.company.id}-#{employee.branch.id}-#{employee.id}"
+        values[:unique_codename] = "#{employee.branch.company.id}-#{employee.branch.id}-#{employee.id}"
       end
     end
 
-    with_computed_values
+    values
   end
 end
 ```
@@ -352,6 +405,56 @@ end
 
 ## DSL
 
+### Quickery Migration Generator:
+
+`rails generate quickery:migration ...` acts as if you are doing a `rails generate model ...` except that it's ONLY going to generate a migration file, therefore:
+
+* Usage format: `rails generate quickery:migration model_name attribute_name_1:type attribute_name_2:type ...`
+* Optional `--add_is_synced_attributes` can be passed to the command to support "autoloading". See Usage Example 3 above.
+
+#### Example 1
+```
+rails generate quickery:migration employee branch_company_name:string branch_company_id:bigint:index
+```
+
+...will generate:
+
+```
+# db/migrate/TIMESTAMP_add_quickery_branch_company_name_branch_company_id_to_employees.rb
+class AddQuickeryBranchCompanyNameBranchCompanyIdToEmployees < ActiveRecord::Migration[5.2]
+  def change
+    change_table :employees do |t|
+      t.string :branch_company_name
+      t.integer :branch_company_id
+    end
+    add_index :employees, :branch_company_id
+  end
+end
+```
+
+#### Example 2
+
+```
+rails generate quickery:migration employee branch_company_name:string branch_company_id:bigint:index --add_is_synced_attributes
+```
+
+...will generate:
+
+```
+# db/migrate/TIMESTAMP_add_quickery_branch_company_name_branch_company_id_to_employees.rb
+class AddQuickeryBranchCompanyNameBranchCompanyIdToEmployees < ActiveRecord::Migration[5.2]
+  def change
+    change_table :employees do |t|
+      t.string :branch_company_name
+      t.boolean :branch_company_name_is_synced, null: false, default: false
+      t.integer :branch_company_id
+      t.boolean :branch_company_id_is_synced, null: false, default: false
+    end
+    add_index :employees, :branch_company_id
+  end
+end
+```
+
 ### For any subclass of `ActiveRecord::Base`:
 
 * defines a set of "hidden" Quickery `before_create`, `before_update`, and `before_destroy` callbacks needed by Quickery to perform the "syncing" of attribute values
@@ -362,17 +465,17 @@ end
 
 ##### `quickery(mappings)`
 * mappings (Hash)
-  * each mapping will create a `Quickery::QuickeryBuilder` object. i.e:
+  * each mapping will create a `Quickery::QuickeryBuilder` object. i.e:s
     * `{ branch: { name: :branch_name }` will create one `Quickery::QuickeryBuilder`, while
     * `{ branch: { name: :branch_name, id: :branch_id }` will create two `Quickery::QuickeryBuilder`
         * In this particular example, you are required to specify `belongs_to :branch` in this model
-        * Similarly, you are required to specify `belongs_to :company` inside `Branch` model, `belongs_to :country` inside `Company` model; etc...
-* quickery-defined attributes such as say `:branch_company_country_category_name` are updated by Quickery automatically whenever any of it's dependent records across models have been changed. Note that updates in this way do not trigger model callbacks, as I wanted to isolate logic and scope of Quickery by not triggering model callbacks that you already have.
+        * Similarly, depending on your defined mappings, i.e. `{ branch: { company: { country: { name: :branch_company_country_name  } } } }`, you would be required to specify `belongs_to :company` inside `Branch` model, `belongs_to :country` inside `Company` model; etc...
+* quickery-defined attributes such as say `:branch_company_country_category_name` are updated by Quickery automatically whenever any of it's dependent records / dependee-attribute across models have been changed or destroyed. Note that updates in this way do not trigger model callbacks, unless you manually overrode the quickery model methods: `self.quickery_before_association_update` or `self.quickery_before_association_destroy`, and changed the default behaviour to no longer use `update_all`. I use `update_all` by default to improve speed and to bypass validations because attributes that will be updated are just your quickery-defined attributes anyway, and chances are you would not want any validations for these attributes.
 * quickery-defined attributes such as say `:branch_company_country_category_name` are READ-only! Do not update these attributes manually. You can, but it will not automatically update the other end, and thus will break data integrity. If you want to re-update these attributes to match the other end, see `recreate_quickery_cache!` below.
 
 ##### `quickery_builders`
 * returns an `Array` of `Quickery::QuickeryBuilder` objects that have already been defined
-* for more info, see `quickery(&block)` above
+* for more info, see `quickery(mappings)` above
 * you normally do not need to use this method
 
 #### Instance Methods:
@@ -408,10 +511,34 @@ end
     # => { branch_company_country_id: 1, branch_compnay_country_name: 'Ireland' }
     ```
 
+##### `autoload_unsynced_quickery_attributes!`
+* only works in conjuction with `*_is_synced` attributes.
+* this will update the record's "still unsynced" quickery-attributes.
+* if all of the record's quickery-attributes are already "synced", then this method does nothing more
+* intended to be used as callback method for `after_find` to automatically support both 1) "old-records" that before quickery has been integrated, and 2) new quickery-attributes to be defined in the future
+* i.e. you can do something like the following:
+
+    ```ruby
+    class Employee < ApplicationRecord
+      belongs_to :branch
+      quickery branch: { company: { name: :branch_company_name } }
+      after_find :autoload_unsynced_quickery_attributes!
+    end
+
+    an_employee_long_time_ago_before_quickery_was_even_integrated = Employee.first
+
+    puts an_employee_long_time_ago_before_quickery_was_even_integrated.branch_company_name
+    # => 'Jollibee'
+
+    # otherwise, if there is no `after_find :autoload_unsynced_quickery_attributes!`, the `puts` above will instead return
+    # => nil
+    ```
+
 ## TODOs
 * Possibly support two-way mapping of attributes? So that you can do, say... `employee.update!(branch_company_name: 'somenewcompanyname')`
 * Support `has_many` as currently only `belongs_to` is supported. This would then allow us to cache Array of values.
 * Support custom-methods-values like [`persistize`](https://github.com/bebanjo/persistize), if it's easy enough to integrate something similar
+* Provide a better DSL for "Computed Values" and also probably "Formatted Values" as the current example above, though flexible, looks like it has too much code and the method can potentially grow very big; probably separate into a defined method per computed/formatted value?
 
 ## Other Similar Gems
 See [my detailed comparisons](other_similar_gems_comparison.md)
@@ -436,6 +563,8 @@ See [my detailed comparisons](other_similar_gems_comparison.md)
 5. Create new Pull Request
 
 ## Changelog
+* 1.3.0
+  * implemented tracking of which quickery-attributes have already been synced / not yet via additional optional `*_is_synced` attributes; used in conjuction with [`autoload_unsynced_quickery_attributes!`](#autoload_unsynced_quickery_attributes) intentionally to be declared as callback method for `after_find`, which will make sure that new quickery-attributes defined in the future will work immediately for the record, and that the developer won't worry about doing the `recreate_quickery_cache!` anymore, as the record is guaranteed to be always up-to-date.
 * 1.2.0
   * DONE: (TODO) added overrideable methods for custom callback logic (i.e. move update logic instead into a background job)
 * 1.1.0

data/lib/generators/quickery/migration/migration_generator.rb

@@ -0,0 +1,44 @@
+require 'rails/generators/active_record'
+
+module Quickery
+  module Generators
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      desc 'Generate migration for quickery attributes'
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :attributes, required: true, type: :array, desc: 'The quickery-attributes',
+        banner: 'company_name:string company_country_id:integer company_country_name:string ...'
+
+      class_option :add_is_synced_attributes, desc: 'Add extra `*_is_synced` attribute per quickery-attribute', default: nil
+
+      def generate_migration
+        migration_template("migration.rb.erb",
+                           "db/migrate/#{migration_file_name}.rb",
+                           migration_version: migration_version)
+      end
+
+      def migration_name
+        "add_quickery_#{attributes.map(&:name).join("_")}_to_#{name.underscore.pluralize}"
+      end
+
+      def migration_file_name
+        "#{migration_name}"
+      end
+
+      def migration_class_name
+        migration_name.camelize
+      end
+
+      def migration_version
+        if Rails.version.start_with? "5"
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+      # https://github.com/rails/rails/blob/v5.2.1/activerecord/lib/rails/generators/active_record/migration/migration_generator.rb#L62
+      def attributes_with_index
+        attributes.select { |a| !a.reference? && a.has_index? }
+      end
+    end
+  end
+end

data/lib/generators/quickery/migration/templates/migration.rb.erb

@@ -0,0 +1,15 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    change_table :<%= table_name %> do |t|
+<% attributes.each do |attribute| -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% if options[:add_is_synced_attributes] -%>
+      t.boolean :<%= attribute.name %>_is_synced, null: false, default: false
+<% end -%>
+<% end -%>
+    end
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+  end
+end

data/lib/quickery/active_record_extensions/callbacks.rb

@@ -41,6 +41,9 @@ module Quickery
 
                 new_values[depender_column_name] = new_value
               end
+
+              # set to true because on-create, all quickery-attributes are evaluated and assigned
+              new_values[:"#{depender_column_name}_is_synced"] = true if has_attribute? :"#{depender_column_name}_is_synced"
             end
 
             self.class.quickery_before_create_or_update(self, new_values)
@@ -68,6 +71,7 @@ module Quickery
                 end
 
                 new_values[depender_column_name] = new_value
+                new_values[:"#{depender_column_name}_is_synced"] = true if has_attribute? :"#{depender_column_name}_is_synced"
               end
             end
 
@@ -87,10 +91,14 @@ module Quickery
 
                 dependent_records = association_chain_dependee.dependent_records(self)
                 # use the SQL as the uniqueness identifier, so that multiple quickery-attributes dependent-records are updated in one go, instead of updating each
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:dependent_records] ||= dependent_records
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+                records_sql_identifier = dependent_records.to_sql.to_sym
+                dependent_records_attributes_to_be_updated[records_sql_identifier] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:dependent_records] ||= dependent_records
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][depender_column_name.to_sym] = new_value
+                if dependent_records.model.column_names.include? "#{depender_column_name}_is_synced"
+                  dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][:"#{depender_column_name}_is_synced"] = true
+                end
               end
             end
           end
@@ -111,10 +119,15 @@ module Quickery
 
                 dependent_records = association_chain_intermediary.dependent_records(self)
                 # use the SQL as the uniqueness identifier, so that multiple quickery-attributes dependent-records are updated in one go, instead of updating each
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:dependent_records] ||= dependent_records
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+                records_sql_identifier = dependent_records.to_sql.to_sym
+                dependent_records_attributes_to_be_updated[records_sql_identifier] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:dependent_records] ||= dependent_records
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][depender_column_name.to_sym] = new_value
+
+                if dependent_records.model.column_names.include? "#{depender_column_name}_is_synced"
+                  dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][:"#{depender_column_name}_is_synced"] = true
+                end
               end
             end
           end
@@ -143,10 +156,14 @@ module Quickery
 
                 dependent_records = association_chain_dependee.dependent_records(self)
                 # use the SQL as the uniqueness identifier, so that multiple quickery-attributes dependent-records are updated in one go, instead of updating each
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:dependent_records] ||= dependent_records
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+                records_sql_identifier = dependent_records.to_sql.to_sym
+                dependent_records_attributes_to_be_updated[records_sql_identifier] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:dependent_records] ||= dependent_records
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][depender_column_name.to_sym] = new_value
+                if dependent_records.model.column_names.include? "#{depender_column_name}_is_synced"
+                  dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][:"#{depender_column_name}_is_synced"] = true
+                end
               end
             end
           end
@@ -162,10 +179,14 @@ module Quickery
 
                 dependent_records = association_chain_intermediary.dependent_records(self)
                 # use the SQL as the uniqueness identifier, so that multiple quickery-attributes dependent-records are updated in one go, instead of updating each
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:dependent_records] ||= dependent_records
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values] ||= {}.with_indifferent_access
-                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+                records_sql_identifier = dependent_records.to_sql.to_sym
+                dependent_records_attributes_to_be_updated[records_sql_identifier] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:dependent_records] ||= dependent_records
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values] ||= {}.with_indifferent_access
+                dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][depender_column_name.to_sym] = new_value
+                if dependent_records.model.column_names.include? "#{depender_column_name}_is_synced"
+                  dependent_records_attributes_to_be_updated[records_sql_identifier][:new_values][:"#{depender_column_name}_is_synced"] = true
+                end
               end
             end
           end

data/lib/quickery/active_record_extensions/dsl.rb

@@ -19,6 +19,8 @@ module Quickery
           mappings_builder.map_attributes
         end
 
+        private
+
         # subclass overrideable
         def quickery_before_create_or_update(dependent_record, new_values)
           dependent_record.assign_attributes(new_values)
@@ -44,7 +46,7 @@ module Quickery
         end
 
         def determine_quickery_value(depender_column_name)
-          quickery_builder = self.class.quickery_builders[depender_column_name]
+          quickery_builder = self.class.quickery_builders[depender_column_name.to_sym]
 
           raise ArgumentError, "No defined quickery builder for #{depender_column_name}. Defined values are #{self.class.quickery_builders.keys}" unless quickery_builder
 
@@ -59,6 +61,23 @@ module Quickery
           end
           quickery_values
         end
+
+        # only considers quickery-defined attributes that has corresponding *_is_synced attribute
+        def autoload_unsynced_quickery_attributes!
+          model = self.class
+          new_values = {}.with_indifferent_access
+
+          defined_quickery_attribute_names = model.quickery_builders.keys
+
+          defined_quickery_attribute_names.each do |defined_quickery_attribute_name|
+            if has_attribute?(:"#{defined_quickery_attribute_name}_is_synced") && !send(:"#{defined_quickery_attribute_name}_is_synced")
+              new_values[defined_quickery_attribute_name] = determine_quickery_value(defined_quickery_attribute_name)
+              new_values[:"#{defined_quickery_attribute_name}_is_synced"] = true
+            end
+          end
+
+          update_columns(new_values) if new_values.present?
+        end
       end
     end
   end

data/lib/quickery/version.rb

@@ -1,3 +1,3 @@
 module Quickery
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickery
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jules Roman Polidario
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-15 00:00:00.000000000 Z
+date: 2018-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -247,6 +247,8 @@ files:
 - gemfiles/.bundle/config
 - gemfiles/rails_4.gemfile
 - gemfiles/rails_5.gemfile
+- lib/generators/quickery/migration/migration_generator.rb
+- lib/generators/quickery/migration/templates/migration.rb.erb
 - lib/quickery.rb
 - lib/quickery/active_record_extensions.rb
 - lib/quickery/active_record_extensions/callbacks.rb