mongoid-denormalize 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 89273ea3cdebd9a638a98696f6ab82c479eee5c3
-  data.tar.gz: fde78762ab929df91264df24ed978c656e3deb23
+SHA256:
+  metadata.gz: 601856686a5f670b81ae5704ecdfb107c251010190a2c0c4a1df87797a7480df
+  data.tar.gz: e2258b9b466e37ee420e05f6f16c5eda0b1fd18a63d0fceca8961866a174f6f1
 SHA512:
-  metadata.gz: a3a815fc670066d01bad8a47ee1e37353d07c74d1c193d46c6439e53dc5fb2771706c421ff0d8752ebe8376d3fe39aa1ad1057c981ff937c79121b400f3e43c5
-  data.tar.gz: ef2a98a526e9f07d57e934906a224ec13761b016f26280e1acf10220974da66d01bf59285e15d7aced196227c753b7c9d7af4f36298a0079da92fca4c839a770
+  metadata.gz: 6ebddf92b6193919dc47464a2ab2ae9868b5c8a8b49ff2855d954fa226383d13ea5548e2848b845a4b0a04136d789588fda11798f2775a30b2306cae8fdaa059
+  data.tar.gz: 84d082b7e3f53e312d42668791593287e88ecb8c135449109b14755113e0fa7e5d362d45962a4f8f8c8984776b53adb9d2c7b3eac7d2bd868a4a57c752dbb641

data/README.md

@@ -84,6 +84,45 @@ end
 "User2"
 ```
 
+## Options of denormalize
+
+### as
+
+Enables to customize the final field name
+
+```ruby
+  denormalize :name, from: :top, as: :custom_name
+```
+
+It will create the field `custom_name` with the content of `top.name`. Also support an array:
+
+```ruby
+  denormalize :name, :age, from: :top, as: [:custom_name, :custom_age]
+```
+
+### prefix
+
+In somes cases it could be interesting to customize the prefix of the final name, instead of using the basic `from_field`
+
+```ruby
+  denormalize :color, :name, from: :top, prefix: :ancestor
+```
+
+It will create the fields `ancestor_name` and `ancestor_color` with the content of `top.name` and `top.color`.
+
+### child_callback
+
+By default when a child is created the denormalization is executed into `before_save` hook.  
+This option let you change this callback by other, for example:
+
+```ruby
+  denormalize :name, from: :top, child_callback: :before_validation
+
+  validate :top_name, presence: true
+```
+
+It will denormalize field `name` into `before_validation` callback so that we can validate it.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/mongoid-denormalize/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Denormalize
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/mongoid-denormalize.rb

@@ -8,50 +8,84 @@ module Mongoid
 
     module ClassMethods
       def denormalize(*args)
-        options = args.pop
+        *fields, options = args
 
-        unless options.is_a?(Hash) && (from = options[:from]&.to_s)
-          raise ArgumentError, 'Option :from is needed (e.g. delegate :name, from: :user).'
+        unless options.is_a?(Hash) && options[:from]
+          raise ArgumentError, 'Option :from is needed (e.g. denormalize :name, from: :user).'
         end
 
+        fields = Mongoid::Denormalize.get_fields_with_names(fields, options)
+
         # Add fields to model
-        args.each { |field| field "#{from}_#{field}" }
-
-        # Denormalize fields when model is saved and 'from' has changed
-        before_save do
-          if send(from) && send("#{from}_id_changed?")
-            args.each do |field|
-              send("#{from}_#{field}=", send(from).send(field))
-            end
-          end
+        fields.each { |field| field field[:as] }
+
+        # Add hooks
+        Mongoid::Denormalize.add_hook_to_child(self, fields, options)
+        Mongoid::Denormalize.add_hook_to_parent(self, fields, options)
+      end
+    end
+
+    # Check options and return name for each field
+    def self.get_fields_with_names(fields, options)
+      if options.include?(:as)
+        options[:as] = [options[:as]] unless options[:as].is_a?(Array)
+
+        unless fields.size == options[:as].size
+          raise ArgumentError, 'When option :as is used you must pass a name for each field.'
         end
 
-        from_class = (relations[from].class_name || relations[from].name.capitalize).constantize
-        child_model_name = model_name
-        child_inverse_of = relations[from].inverse_of
+        return fields.map.with_index { |field, index| {name: field, as: options[:as][index]} }
+      elsif options.include?(:prefix)
+        return fields.map { |field| {name: field, as: "#{options[:prefix]}_#{field}"} }
+      end
 
-        # When 'from' is updated, update child/childs
-        from_class.send(:after_update) do
-          attributes = {}
-          args.each { |field| attributes["#{from}_#{field}"] = send(field) }
+      fields.map { |field| {name: field, as: "#{options[:from]}_#{field}"} }
+    end
 
-          relation = relations[child_inverse_of.to_s] ||
-                     relations[child_model_name.plural] ||
-                     relations[child_model_name.singular]
+    # Add hook to child class to denormalize fields when parent relation is changed
+    def self.add_hook_to_child(child_class, fields, options)
+      from = options[:from].to_s
 
-          unless relation
-            raise "Option :inverse_of is needed for 'belongs_to :#{from}' into #{child_model_name.name}."
+      child_class.send(options[:child_callback] || 'before_save') do
+        if send(from) && send("#{from}_id_changed?")
+          fields.each do |field|
+            send("#{field[:as]}=", send(from).send(field[:name]))
           end
+        end
+      end
+    end
+
+    # Add hook to parent class to denormalize fields when parent object is updated
+    def self.add_hook_to_parent(child_class, fields, options)
+      from = options[:from].to_s
+
+      parent = (child_class.relations[from].class_name ||
+                child_class.relations[from].name.capitalize).constantize
+
+      relation = parent.relations[child_class.relations[from].inverse_of.to_s] ||
+                 parent.relations[child_class.model_name.plural] ||
+                 parent.relations[child_class.model_name.singular]
+
+      unless relation
+        raise "Option :inverse_of is needed for 'belongs_to :#{from}' into #{child_class}."
+      end
+
+      parent.after_update do
+        attributes = {}
+        fields.each do |field|
+          attributes[field[:as]] = send(field[:name]) if send("#{field[:name]}_changed?")
+        end
+        next if attributes.blank?
 
-          case relation.relation.to_s
-          when 'Mongoid::Relations::Referenced::One'
-            document = send(relation.name)
-            document.collection.update_one({_id: document._id}, {'$set' => attributes}) if document
-          when 'Mongoid::Relations::Referenced::Many'
-            send(relation.name).update_all('$set' => attributes)
-          else
-            raise "Relation type unsupported: #{relation.relation}"
+        case relation.relation.to_s
+        when 'Mongoid::Relations::Referenced::One'
+          if (document = send(relation.name))
+            document.collection.update_one({_id: document._id}, {'$set' => attributes})
           end
+        when 'Mongoid::Relations::Referenced::Many'
+          send(relation.name).update_all('$set' => attributes)
+        else
+          raise "Relation type unsupported: #{relation.relation}"
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-denormalize
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - rjurado01
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-29 00:00:00.000000000 Z
+date: 2018-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Denormalize fields from relations