quickery 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e91a2705cab309764e0f8a789d22462727389884c0a2e1aeed60b3a943f68bb1
-  data.tar.gz: c8e6c59c8f35df9c27418de44e9f86eaadf24d793a469244408180d90348c528
+  metadata.gz: 20c5125563b48a48ba73907330199cf2b7d330e0e78bc3449db1ba92f29783aa
+  data.tar.gz: 047cc01e20747481b825ca1d4f26dfe34ba4ab31429a005be4b8767cf51b6e12
 SHA512:
-  metadata.gz: 2450b89db93db6e347eda4e8fd688f70746fe7925c375f0901ac6406e47553261e511f836de2452052702b252f98757bcab6d40ae7f378d2a52166cd780a01a9
-  data.tar.gz: 546af2185f0631a2f7e4533233e97ee0c04ab86171e01c6737bd250881d9f1805808646e8c4f234839c943d168dd62339c999e9c7ef49464f1c5764e2cef7861
+  metadata.gz: 7cdc80db27ccdbe249a2592bc0e537cd0cf4a8c2146afcc0a306ffadd01cb7a76e1181492d6e44795bd94862c23d7e1aadbaf42e19962f99f1ee4b2985ebdb21
+  data.tar.gz: 72f951760cd8737b117d1f11865cb2cc4c6b4ba5c427d86dcdffa704a2025d51432d45c69b0226eb0b2c42c20dd241ab93909dc8a83d8b4d51e8113db4eaeed8

data/README.md

@@ -17,7 +17,7 @@
 1. Add the following to your `Gemfile`:
 
     ```ruby
-    gem 'quickery', '~> 0.1'
+    gem 'quickery', '~> 1.0'
     ```
 
 2. Run:
@@ -37,22 +37,13 @@ class Employee < ApplicationRecord
 
   belongs_to :branch
 
-  quickery do
-    # TL;DR: the following line means:
-    #   make sure that this record's `branch_company_name` attribute will always have
-    #   the same value as branch.company.name and updates the value accordingly if it changes
-    branch.company.name == :branch_company_name
-
-    # feel free to rename :branch_company_name as you wish; it's just like any other attribute anyway
-    # the == is a custom overloaded operator; it does not mean "is equal" but means "should equal to"
-    # branch.company.name is a fluid expression that defines the attribute dependency
-    #   `branch` and `company` does not mean `branch` and `company` record
-
-    # you may add more inside this quickery-block: i.e:
-    #   branch.name == :branch_name
-    #   branch.id == :branch_id
-    #   branch.company.country.name == :branch_company_country_name
-  end
+  # TL;DR: the following line means:
+  #   make sure that this record's `branch_company_name` attribute will always have the same value as
+  #   branch.company.name and auto-updates the value if it (or any associated record in between) changes
+
+  quickery branch: { company: { name: :branch_company_name } }
+
+  # feel free to rename :branch_company_name as you wish; it's just like any other attribute anyway
 end
 
 # app/models/branch.rb
@@ -126,17 +117,15 @@ end
 # app/models/employee.rb
 class Employee < ApplicationRecord
   belongs_to :branch
-  belongs_to :company, foreign_key: :branch_company_id
+  belongs_to :company, foreign_key: :branch_company_id, optional: true
 
-  quickery do
-    branch.company.id == :branch_company_id
-  end
+  quickery { branch: { company: { id: :branch_company_id } } }
 end
 ```
 
 ```bash
 # bash
-rails generate migration add_branch_company_id_to_employees branch_company_id:bigint
+rails generate migration add_branch_company_id_to_employees branch_company_id:bigint:index
 bundle exec rake db:migrate
 ```
 
@@ -149,31 +138,72 @@ employee = Employee.create!(branch: branch)
 puts employee.branch_company_id
 # => 1
 
+puts employee.company
+# => #<Company id: 1 name: 'Jollibee'>
+
 puts Employee.where(company: company)
 # => [#<Employee id: 1>]
 
 # as you may notice, the query above is a lot simpler and faster instead of doing it normally like below (if not using Quickery)
-# you may however still use belongs_to `:through` to achieve the simplified query like above, but it's still a lot slower because of JOINS
+# you may however still use `has_many :through` to achieve a simplified code: `company.employees`, but it's still a lot slower because of JOINS
 puts Employee.joins(branch: :company).where(companies: { id: company.id })
 # => [#<Employee id: 1>]
 ```
 
+## Other Usage Examples
+
+```ruby
+# app/models/employee.rb
+class Employee < ApplicationRecord
+  # multiple-attributes and/or multiple-associations; as many, and as deep as you wish
+  quickery(
+    branch: {
+      name: :branch_name,
+      address: :branch_address,
+      company: {
+        name: :branch_company_name
+      }
+    },
+    user: {
+      first_name: :user_first_name,
+      last_name: :user_last_name
+    }
+  )
+end
+```
+
+```ruby
+# app/models/employee.rb
+class Employee < ApplicationRecord
+  # `quickery` can be called multiple times
+  quickery { branch: { name: :branch_name } }
+  quickery { branch: { address: :branch_address } }
+  quickery { branch: { company: { name: :branch_company_name } } }
+  quickery { user: { first_name: :user_first_name } }
+  quickery { user: { last_name: :user_last_name } }
+end
+```
+
+## Gotchas
+* Quickery makes use of Rails model callbacks such as `before_save`. This meant that data-integrity holds unless `update_columns` or `update_column` is used which bypasses model callbacks, or unless any manual SQL update is performed.
+* Quickery does not automatically update old records existing in the database that were created before you integrate Quickery, or before you add new/more Quickery-attributes for that model. One solution is [`recreate_quickery_cache!`](#recreate_quickery_cache) below.
+
 ## DSL
 
 ### 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
+
 #### Class Methods:
 
-##### `quickery(&block)`
-* returns a `Quickery::AssociationBuilder` object
-* block is executed in the context of the `Quickery::AssociationBuilder` object,
-  which means that you cannot access the model instance inside the block, as you are not supposed to.
-* inside the block you may define "quickery-defined attribute mappings";
-  each mapping will create a `Quickery::QuickeryBuilder` object. i.e:
-    * `branch.company.country.category.name == :branch_company_country_category_name`
-        * You are required to specify `belongs_to :branch` association in this model.
+##### `quickery(mappings)`
+* mappings (Hash)
+  * each mapping will create a `Quickery::QuickeryBuilder` object. i.e:
+    * `{ 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...
-* each `Quickery::AssociationBuilder` defines a set of "hidden" `before_save`, `before_update`, `before_destroy`, and `before_create` callbacks across all models specified in the quickery-defined attribute association chain.
+* defines a set of "hidden" Quickery `before_save`, `before_update`, `before_destroy`, and `before_create` callbacks across all models specified in the quickery-defined attribute association chain.
 * 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.
 * 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.
 
@@ -207,7 +237,9 @@ puts Employee.joins(branch: :company).where(companies: { id: company.id })
 
 ## TODOs
 * Possibly support two-way mapping of attributes? So that you can do, say... `employee.update!(branch_company_name: 'somenewcompanyname')`
-* Improve "updates" across the quickery-defined model callbacks, by grouping attributes that will be updated and update in one go, instead of independently updating per each quickery-defined attribute
+* 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
+* Support background-processing like in [`flattery`](https://github.com/evendis/flattery)
 
 ## Other Similar Gems
 See [my detailed comparisons](other_similar_gems_comparison.md)
@@ -232,6 +264,9 @@ See [my detailed comparisons](other_similar_gems_comparison.md)
 5. Create new Pull Request
 
 ## Changelog
+* 1.0.0
+  * Done (TODO): DSL changed from quickery (block) into quickery (hash). Thanks to @xire28 and @sshaw_ in my [reddit post](https://www.reddit.com/r/ruby/comments/9dlcc5/i_just_published_a_new_gem_quickery_an/) for the suggestion.
+  * Done (TODO): Now updates in one go, instead of updating record per quickery-attribute, thereby greatly improving speed.
 * 0.1.4
   * add `railstie` as dependency to fix undefined constant error
 * 0.1.3

data/lib/quickery.rb

@@ -1,5 +1,6 @@
 Dir[__dir__ + '/quickery/*.rb'].each {|file| require file }
 Dir[__dir__ + '/quickery/active_record_extensions/*.rb'].each {|file| require file }
+Dir[__dir__ + '/quickery/errors/*.rb'].each {|file| require file }
 
 module Quickery
   # Your code goes here...

data/lib/quickery/active_record_extensions.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+
+module Quickery
+  module ActiveRecordExtensions
+    class << self
+      def included(base)
+        base.include Quickery::ActiveRecordExtensions::DSL
+        base.include Quickery::ActiveRecordExtensions::Callbacks
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include Quickery::ActiveRecordExtensions
+end

data/lib/quickery/active_record_extensions/callbacks.rb

@@ -0,0 +1,175 @@
+module Quickery
+  module ActiveRecordExtensions
+    module Callbacks
+      class << self
+        def included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+          base.class_eval do
+            before_create :quickery_before_create_callback
+            before_update :quickery_before_update_callback
+            before_destroy :quickery_before_destroy_callback
+          end
+        end
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        private
+
+        def quickery_before_create_callback
+          model = self.class
+          changed_attributes = changes.keys
+
+          if model.quickery_association_chain_dependers.present?
+            model.quickery_association_chain_dependers.each do |association_chain_depender|
+              quickery_builder = association_chain_depender.quickery_builder
+              depender_column_name = quickery_builder.depender_column_name
+              dependee_column_name = quickery_builder.dependee_column_name
+
+              if changed_attributes.include? association_chain_depender.belongs_to.foreign_key
+                if send(association_chain_depender.belongs_to.foreign_key).nil?
+                  new_value = nil
+                else
+                  dependee_record = association_chain_depender.dependee_record(self)
+                  new_value = dependee_record.send(dependee_column_name)
+                end
+
+                assign_attributes(depender_column_name => new_value)
+              end
+            end
+          end
+        end
+
+        def quickery_before_update_callback
+          model = self.class
+          changed_attributes = changes.keys
+
+          if model.quickery_association_chain_dependers.present?
+            model.quickery_association_chain_dependers.each do |association_chain_depender|
+              quickery_builder = association_chain_depender.quickery_builder
+              depender_column_name = quickery_builder.depender_column_name
+              dependee_column_name = quickery_builder.dependee_column_name
+
+              if changed_attributes.include? association_chain_depender.belongs_to.foreign_key
+                if send(association_chain_depender.belongs_to.foreign_key).nil?
+                  new_value = nil
+                else
+                  dependee_record = association_chain_depender.dependee_record(self)
+                  new_value = dependee_record.send(dependee_column_name)
+                end
+
+                assign_attributes(depender_column_name => new_value)
+              end
+            end
+          end
+
+          dependent_records_attributes_to_be_updated = {}
+
+          if model.quickery_association_chain_dependees.present?
+            model.quickery_association_chain_dependees.each do |association_chain_dependee|
+              quickery_builder = association_chain_dependee.quickery_builder
+              depender_column_name = quickery_builder.depender_column_name
+              dependee_column_name = quickery_builder.dependee_column_name
+
+              if changed_attributes.include? dependee_column_name
+                new_value = send(dependee_column_name)
+
+                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] ||= {}
+                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] ||= {}
+                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+              end
+            end
+          end
+
+          if model.quickery_association_chain_intermediaries.present?
+            model.quickery_association_chain_intermediaries.each do |association_chain_intermediary|
+              quickery_builder = association_chain_intermediary.quickery_builder
+              depender_column_name = quickery_builder.depender_column_name
+              dependee_column_name = quickery_builder.dependee_column_name
+
+              if changed_attributes.include? association_chain_intermediary.belongs_to.foreign_key
+                if send(association_chain_intermediary.belongs_to.foreign_key).nil?
+                  new_value = nil
+                else
+                  dependee_record = association_chain_intermediary.dependee_record(self)
+                  new_value = dependee_record.send(dependee_column_name)
+                end
+
+                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] ||= {}
+                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] ||= {}
+                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+              end
+            end
+          end
+
+          dependent_records_attributes_to_be_updated.each do |sql_identifier, hash|
+            dependent_records = hash.fetch(:dependent_records)
+            new_values = hash.fetch(:new_values)
+
+            dependent_records.update_all(new_values)
+          end
+        end
+
+        def quickery_before_destroy_callback
+          model = self.class
+
+          dependent_records_attributes_to_be_updated = {}
+
+          if model.quickery_association_chain_dependees.present?
+            model.quickery_association_chain_dependees.each do |association_chain_dependee|
+              quickery_builder = association_chain_dependee.quickery_builder
+              depender_column_name = quickery_builder.depender_column_name
+              dependee_column_name = quickery_builder.dependee_column_name
+
+              if attributes.keys.include? dependee_column_name
+                new_value = nil
+
+                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] ||= {}
+                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] ||= {}
+                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+              end
+            end
+          end
+
+          if model.quickery_association_chain_intermediaries.present?
+            model.quickery_association_chain_intermediaries.each do |association_chain_intermediary|
+              quickery_builder = association_chain_intermediary.quickery_builder
+              depender_column_name = quickery_builder.depender_column_name
+              dependee_column_name = quickery_builder.dependee_column_name
+
+              if attributes.keys.include? association_chain_intermediary.belongs_to.foreign_key
+                new_value = nil
+
+                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] ||= {}
+                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] ||= {}
+                dependent_records_attributes_to_be_updated[dependent_records.to_sql.to_sym][:new_values][depender_column_name.to_sym] = new_value
+              end
+            end
+          end
+
+          dependent_records_attributes_to_be_updated.each do |sql_identifier, hash|
+            dependent_records = hash.fetch(:dependent_records)
+            new_values = hash.fetch(:new_values)
+
+            dependent_records.update_all(new_values)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quickery/active_record_extensions/dsl.rb

@@ -1,17 +1,21 @@
-require 'active_support'
-
 module Quickery
   module ActiveRecordExtensions
     module DSL
-      def self.included(base)
-        base.extend ClassMethods
-        base.include InstanceMethods
+      class << self
+        def included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+        end
       end
 
       module ClassMethods
-        def quickery(&block)
-          association_builder = AssociationBuilder.new(model: self)
-          association_builder.instance_exec(&block)
+        attr_accessor :quickery_association_chain_dependers
+        attr_accessor :quickery_association_chain_dependees
+        attr_accessor :quickery_association_chain_intermediaries
+
+        def quickery(mappings)
+          mappings_builder = MappingsBuilder.new(model: self, mappings: mappings.with_indifferent_access)
+          mappings_builder.map_attributes
         end
       end
 
@@ -21,8 +25,6 @@ module Quickery
             new_value = determine_quickery_value(depender_column_name)
             update_columns(depender_column_name => new_value)
           end
-
-          true
         end
 
         def determine_quickery_value(depender_column_name)
@@ -30,14 +32,10 @@ module Quickery
 
           raise ArgumentError, "No defined quickery builder for #{depender_column_name}. Defined values are #{self.class.quickery_builders.keys}" unless quickery_builder
 
-          dependee_record = quickery_builder.first_association_builder._quickery_dependee_record(self)
+          dependee_record = quickery_builder.association_chains.first.dependee_record(self)
           dependee_record.send(quickery_builder.dependee_column_name)
         end
       end
     end
   end
 end
-
-ActiveSupport.on_load(:active_record) do
-  include Quickery::ActiveRecordExtensions::DSL
-end

data/lib/quickery/association_chain.rb

@@ -0,0 +1,106 @@
+module Quickery
+  class AssociationChain
+    attr_accessor :quickery_builder
+    attr_reader :model
+    attr_reader :parent_association_chain
+    attr_reader :child_association_chain
+    attr_reader :name
+    attr_reader :dependee_column_name
+    attr_reader :belongs_to
+
+    def initialize(model:, parent_association_chain: nil, name: nil)
+      @model = model
+      @parent_association_chain = parent_association_chain
+      @name = name
+    end
+
+    def build_children_association_chains(names_left:)
+      current_name = names_left.first
+
+      reflections = @model.reflections
+      column_names = @model.column_names
+      belongs_to_association_names = reflections.map{ |key, value| value.macro == :belongs_to ? key : nil }.compact
+
+      if belongs_to_association_names.include? current_name
+        @belongs_to = reflections[current_name]
+        @child_association_chain = AssociationChain.new(
+          model: belongs_to.class_name.constantize,
+          parent_association_chain: self,
+          name: current_name,
+        )
+        @child_association_chain.build_children_association_chains(names_left: names_left[1..-1])
+        return self
+
+      elsif column_names.include? current_name
+        @dependee_column_name = current_name
+        return self
+
+      else
+        raise Quickery::Errors::InvalidAssociationOrAttributeError.new(current_name)
+      end
+    end
+
+    def child_association_chains(include_self: false, association_chains: [])
+      association_chains << self if include_self
+
+      if @child_association_chain.nil?
+        association_chains
+      else
+        association_chains << @child_association_chain
+        return @child_association_chain.child_association_chains(association_chains: association_chains)
+      end
+    end
+
+    def parent_association_chains(include_self: false, association_chains: [])
+      association_chains << self if include_self
+
+      if @parent_association_chain.nil?
+        association_chains
+      else
+        association_chains << @parent_association_chain
+        @parent_association_chain.parent_association_chains(association_chains: association_chains)
+      end
+    end
+
+    def joins_arg(current_joins_arg = nil)
+      if @parent_association_chain.nil?
+        current_joins_arg
+      else
+        if current_joins_arg.nil?
+          @parent_association_chain.joins_arg(@name.to_sym)
+        else
+          @parent_association_chain.joins_arg({ @name.to_sym => current_joins_arg })
+        end
+      end
+    end
+
+    def dependee_record(from_record)
+      raise ArgumentError, 'argument should be an instance of @model' unless from_record.is_a? model
+
+      child_association_chains(include_self: true).inject(from_record) do |from_record, association_chain|
+        if association_chain.belongs_to
+          from_record.send(association_chain.belongs_to.name)
+        else
+          from_record
+        end
+      end
+    end
+
+    def dependent_records(from_record)
+      primary_key_value = from_record.send(from_record.class.primary_key)
+      most_parent_model = parent_association_chains.last.model
+
+      records = most_parent_model.all
+
+      unless (joins_arg_tmp = joins_arg).nil?
+        records = records.joins(joins_arg_tmp)
+      end
+
+      records = records.where(
+        model.table_name => {
+          model.primary_key => primary_key_value
+        }
+      )
+    end
+  end
+end

data/lib/quickery/callbacks_builder.rb

@@ -2,105 +2,38 @@ module Quickery
   class CallbacksBuilder
     attr_reader :quickery_builder
 
-    def initialize(quickery_builder:, should_add_callbacks: true)
+    def initialize(quickery_builder:)
       @quickery_builder = quickery_builder
-      add_callbacks if should_add_callbacks
     end
 
-    private
-
-    def add_callbacks
-      add_callback_to_depender_model
-      add_callback_to_dependee_model
-      add_callback_to_each_intermediate_model
+    def build_callbacks
+      build_callback_to_depender_model
+      build_callback_to_dependee_model
+      build_callback_to_each_intermediate_model
     end
 
-    # add callback to immediately sync value after a record has been created / updated
-    def add_callback_to_depender_model
-      first_association_builder = @quickery_builder.first_association_builder
-      depender_column_name = @quickery_builder.depender_column_name
-      dependee_column_name = @quickery_builder.dependee_column_name
-
-      first_association_builder.model.class_exec do
-
-        # before create or update
-        before_save do
-          if changes.keys.include? first_association_builder.belongs_to.foreign_key
-            if send(first_association_builder.belongs_to.foreign_key).nil?
-              new_value = nil
-            else
-              dependee_record = first_association_builder._quickery_dependee_record(self)
-              new_value = dependee_record.send(dependee_column_name)
-            end
+    private
 
-            assign_attributes(depender_column_name => new_value)
-          end
-        end
-      end
+    # add callback to immediately sync value after a record has been created / updated
+    def build_callback_to_depender_model
+      first_association_chain = @quickery_builder.association_chains.first
+      first_association_chain.model.quickery_association_chain_dependers ||= []
+      first_association_chain.model.quickery_association_chain_dependers << first_association_chain
     end
 
     # add callback to sync changes when dependee_column has been updated
-    def add_callback_to_dependee_model
-      last_association_builder = @quickery_builder.last_association_builder
-      depender_column_name = @quickery_builder.depender_column_name
-      dependee_column_name = @quickery_builder.dependee_column_name
-
-      last_association_builder.model.class_exec do
-
-        before_update do
-          if changes.keys.include? dependee_column_name
-            new_value = send(dependee_column_name)
-
-            dependent_records = last_association_builder._quickery_dependent_records(self)
-            dependent_records.update_all(depender_column_name => new_value)
-          end
-        end
-
-        before_destroy do
-          if attributes.keys.include? dependee_column_name
-            new_value = nil
-
-            dependent_records = last_association_builder._quickery_dependent_records(self)
-            dependent_records.update_all(depender_column_name => new_value)
-          end
-        end
-      end
+    def build_callback_to_dependee_model
+      last_association_chain = @quickery_builder.association_chains.last
+      last_association_chain.model.quickery_association_chain_dependees ||= []
+      last_association_chain.model.quickery_association_chain_dependees << last_association_chain
     end
 
     # also add callbacks to sync changes when intermediary associations have been changed (this does not include first and last builder)
-    def add_callback_to_each_intermediate_model
-      last_association_builder = @quickery_builder.last_association_builder
-      depender_column_name = @quickery_builder.depender_column_name
-      dependee_column_name = @quickery_builder.dependee_column_name
-
-      last_association_builder._quickery_get_parent_builders(include_self: true)[1..-2].each do |association_builder|
-        intermediate_model = association_builder.model
-
-        intermediate_model.class_exec do
-
-          before_update do
-            if changes.keys.include? association_builder.belongs_to.foreign_key
-              if send(association_builder.belongs_to.foreign_key).nil?
-                new_value = nil
-              else
-                dependee_record = association_builder._quickery_dependee_record(self)
-                new_value = dependee_record.send(dependee_column_name)
-              end
-
-              dependent_records = association_builder._quickery_dependent_records(self)
-              dependent_records.update_all(depender_column_name => new_value)
-            end
-          end
-
-          before_destroy do
-            if attributes.keys.include? association_builder.belongs_to.foreign_key
-              new_value = nil
-
-              dependent_records = last_association_builder._quickery_dependent_records(self)
-              dependent_records.update_all(depender_column_name => new_value)
-            end
-          end
-        end
+    def build_callback_to_each_intermediate_model
+      last_association_chain = @quickery_builder.association_chains.last
+      last_association_chain.parent_association_chains(include_self: true)[1..-2].each do |association_chain|
+        association_chain.model.quickery_association_chain_intermediaries ||= []
+        association_chain.model.quickery_association_chain_intermediaries << association_chain
       end
     end
   end

data/lib/quickery/errors/invalid_association_or_attribute_error.rb

@@ -0,0 +1,10 @@
+module Quickery
+  module Errors
+    class InvalidAssociationOrAttributeError < StandardError
+      def initialize(name)
+        message = "#{name} is not a valid association or attribute name"
+        super(message)
+      end
+    end
+  end
+end

data/lib/quickery/mappings_builder.rb

@@ -0,0 +1,38 @@
+module Quickery
+  class MappingsBuilder
+    attr_reader :model
+    attr_reader :mappings
+
+    def initialize(model:, mappings:)
+      @model = model
+      @mappings = mappings
+    end
+
+    # https://stackoverflow.com/questions/9647997/converting-a-nested-hash-into-a-flat-hash
+    def flat_hash(hash, k = [])
+      return {k => hash} unless hash.is_a?(Hash)
+      hash.inject({}){ |h, v| h.merge! flat_hash(v[-1], k + [v[0]]) }
+    end
+
+    def map_attributes
+      flat_hash(@mappings).each do |names, depender_column_name|
+        first_association_chain = AssociationChain.new(model: model)
+        first_association_chain.build_children_association_chains(names_left: names)
+
+        all_association_chains = first_association_chain.child_association_chains(include_self: true)
+        dependee_column_name = all_association_chains.last.dependee_column_name
+
+        quickery_builder = QuickeryBuilder.new(
+          model: @model,
+          association_chains: all_association_chains,
+          dependee_column_name: dependee_column_name,
+          depender_column_name: depender_column_name,
+        )
+
+        quickery_builder.add_to_model
+        quickery_builder.add_to_association_chains
+        quickery_builder.create_model_callbacks
+      end
+    end
+  end
+end

data/lib/quickery/quickery_builder.rb

@@ -3,28 +3,32 @@ module Quickery
     attr_reader :model
     attr_reader :depender_column_name
     attr_reader :dependee_column_name
-    attr_reader :first_association_builder
-    attr_reader :last_association_builder
-    attr_reader :callbacks_builder
+    attr_reader :association_chains
 
-    def initialize(dependee_column_name:, last_association_builder:)
+    def initialize(model:, association_chains:, dependee_column_name:, depender_column_name:)
+      @model = model
+      @association_chains = association_chains
       @dependee_column_name = dependee_column_name
-      @last_association_builder = last_association_builder
-      @first_association_builder = last_association_builder._quickery_get_parent_builders.last
-      @model = @first_association_builder.model
-    end
-
-    def ==(depender_column_name)
       @depender_column_name = depender_column_name
+    end
 
-      @callbacks_builder = CallbacksBuilder.new(quickery_builder: self)
-
+    def add_to_model
       define_quickery_builders_in_model_class unless @model.respond_to? :quickery_builders
-
       # include this to the list of quickery builders defined for this model
       @model.quickery_builders[depender_column_name] = self
     end
 
+    def add_to_association_chains
+      association_chains.each do |association_chain|
+        association_chain.quickery_builder = self
+      end
+    end
+
+    def create_model_callbacks
+      @callbacks_builder = CallbacksBuilder.new(quickery_builder: self)
+      @callbacks_builder.build_callbacks
+    end
+
     private
 
     def define_quickery_builders_in_model_class

data/lib/quickery/version.rb

@@ -1,3 +1,3 @@
 module Quickery
-  VERSION = '0.1.4'
+  VERSION = '1.0.0'
 end

data/other_similar_gems_comparison.md

@@ -7,6 +7,7 @@
     * supports `has_many` and `belongs_to` while Quickery only supports `belongs_to` (currently)
   * Cons against Quickery:
     * It is not documented, but you'll need to do `Rails.application.eager_load!` first or something similar, to first load all the models as otherwise defined `persistize` across the models will be autoloaded, and therefore will not work properly. Quickery already does this eager loading of models out of the box. For more info, see [lib/quickery/railtie.rb](lib/quickery/railtie.rb)
+    * batch-update in one go for multiple quickery-defined attributes instead of updating each attribute/method
     * loops through each children records and update each attribute which can get very slow with lots of children associated records, and therefore as many number of SQL UPDATE queries vs Quickery which uses `update_all` which is just one update query, and does not loop through children records:
 
       ```ruby
@@ -113,6 +114,7 @@
     * allows "updates" as a background process
   * Cons against Quickery:
     * Rails 5 is not part of its supported list in their github page. And just to try it out on a Rails 5 app, `Flattery::ValueProvider` did not seem to work, because values are not pushed to the `:notes`'s `:category_name` values.
+    * batch-update in one go for multiple quickery-defined attributes instead of updating each
     * Using Rails 4, does not support nested associated dependencies for `belongs_to`:
 
       ```ruby

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickery
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Jules Roman Polidario
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-13 00:00:00.000000000 Z
+date: 2018-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -248,9 +248,13 @@ files:
 - gemfiles/rails_4.gemfile
 - gemfiles/rails_5.gemfile
 - lib/quickery.rb
+- lib/quickery/active_record_extensions.rb
+- lib/quickery/active_record_extensions/callbacks.rb
 - lib/quickery/active_record_extensions/dsl.rb
-- lib/quickery/association_builder.rb
+- lib/quickery/association_chain.rb
 - lib/quickery/callbacks_builder.rb
+- lib/quickery/errors/invalid_association_or_attribute_error.rb
+- lib/quickery/mappings_builder.rb
 - lib/quickery/quickery_builder.rb
 - lib/quickery/railtie.rb
 - lib/quickery/version.rb

data/lib/quickery/association_builder.rb

@@ -1,108 +0,0 @@
-module Quickery
-  class AssociationBuilder
-    attr_reader :model
-    attr_reader :parent_builder
-    attr_reader :child_builder
-    attr_reader :inverse_association_name
-    attr_reader :belongs_to
-
-    def initialize(model:, parent_builder: nil, inverse_association_name: nil)
-      @model = model
-      @parent_builder = parent_builder
-      @inverse_association_name = inverse_association_name
-      @reflections = model.reflections
-      @belongs_to_association_names = @reflections.map{ |key, value| value.macro == :belongs_to ? key : nil }.compact
-      @column_names = model.column_names
-    end
-
-    # we need to prepend _quickery to all methods, to make sure no conflicts with association names that are dynamically invoked through `method_missing` below
-
-    def _quickery_get_child_builders(include_self: false, builders: [])
-      builders << self if include_self
-
-      if @child_builder.nil?
-        builders
-      else
-        builders << @child_builder
-        return @child_builder._quickery_get_child_builders(builders: builders)
-      end
-    end
-
-    def _quickery_get_parent_builders(include_self: false, builders: [])
-      builders << self if include_self
-
-      if @parent_builder.nil?
-        builders
-      else
-        builders << @parent_builder
-        @parent_builder._quickery_get_parent_builders(builders: builders)
-      end
-    end
-
-    def _quickery_get_joins_arg(current_joins_arg = nil)
-      if @parent_builder.nil?
-        current_joins_arg
-      else
-        if current_joins_arg.nil?
-          @parent_builder._quickery_get_joins_arg(@inverse_association_name.to_sym)
-        else
-          @parent_builder._quickery_get_joins_arg({ @inverse_association_name.to_sym => current_joins_arg })
-        end
-      end
-    end
-
-    def _quickery_dependent_records(record_to_be_saved)
-      primary_key_value = record_to_be_saved.send(record_to_be_saved.class.primary_key)
-      most_parent_model = _quickery_get_parent_builders.last.model
-
-      records = most_parent_model.all
-
-      unless (joins_arg = _quickery_get_joins_arg).nil?
-        records = records.joins(joins_arg)
-      end
-
-      records = records.where(
-        model.table_name => {
-          model.primary_key => primary_key_value
-        }
-      )
-    end
-
-    def _quickery_dependee_record(record_to_be_saved)
-      raise ArgumentError, 'argument should be an instance of @model' unless record_to_be_saved.is_a? model
-
-      _quickery_get_child_builders(include_self: true).inject(record_to_be_saved) do |record, association_builder|
-        if association_builder.belongs_to
-          record.send(association_builder.belongs_to.name)
-        else
-          record
-        end
-      end
-    end
-
-    private
-
-    def method_missing(method_name, *args, &block)
-      method_name_str = method_name.to_s
-      if @belongs_to_association_names.include? method_name_str
-        @belongs_to = @reflections[method_name_str]
-        @child_builder = AssociationBuilder.new(model: belongs_to.class_name.constantize, parent_builder: self, inverse_association_name: method_name_str)
-      elsif @column_names.include? method_name_str
-        QuickeryBuilder.new(dependee_column_name: method_name_str, last_association_builder: self)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing(method_name, include_private = false)
-      method_name_str = method_name.to_s
-      if @belongs_to_association_names.include? method_name_str
-        true
-      elsif @column_names.include? method_name_str
-        true
-      else
-        super
-      end
-    end
-  end
-end