ar_doc_store 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 768bd78def2275242d66654ea62177ded6df21eb
-  data.tar.gz: 62c9f288637be16cfbf353b57acbfed050dbbcb8
+  metadata.gz: b25355bb2fb3a6f42bb5881cc6835432c3130022
+  data.tar.gz: 6f3194e9c30f5ba0a18ab6d6a63b12339438890b
 SHA512:
-  metadata.gz: 4c41aea7206dfc929c14c6d6a09e3c7132007f51245b5a754a77c2c352622fd9609b235d1048addaaa41f3ee5b2b2131e1776cb845518032cf0320c6fcca59b5
-  data.tar.gz: f1e58cbec99ea28a87fdcea51242fa5a69d84b01754b5fce69c46ec0244463eb3dc708802b0c533d04fbb4c0c0e00206d47732e1f4996abfbf7d3ce4642335d6
+  metadata.gz: 3f7b11c57e6fe7468e9c46ad852047eb1b8b5549e2db4d03a787d4c7332f1530045f5bbbb603747a2ce53032cd108d5bdaac29e9f76837b317d34ead19c97e2f
+  data.tar.gz: bf923904e616456addce4f123bc92184f094ea2af7832d454eb6d7000e5c7a9967d2d89406ee90d35d643ecd22f378fac36866aef0c3ce7ff8af8b9a9121350e

data/README.md

@@ -228,10 +228,9 @@ end
 
 ## Roadmap
 1. Default values for attributes. (I haven't needed yet...)
-2. Ransackers for embedded model attributes. (I haven't needed yet...)
-3. Refactor the EmbedsOne and EmbedsMany modules to use a Builder class instead of procedural metaprogramming. (Hello Code Climate...)
-4. Currently when you mass-assign values to an embedded model, you need to assign all the values. It basically replaces what is there with what you send in, removing what has :_destroy set. I would be nice if it could do a smarter find or create behavior.
-5. It would be nice if you could use the AR fluent query API on stored attributes, where is knows to replace, say, "name" with "data->>name" but I don't see how to do that, and Ransack provides a nice enough wrapper around ARel to get the job done another way.
+2. Ransackers for embedded model attributes. (I haven't needed yet, but may this summer when the inspiring project goes to phase 2...)
+3. It would be nice if you could use the AR fluent query API on stored attributes, where is knows to replace, say, "name" with "data->>name" but I don't see how to do that, and Ransack provides a nice enough wrapper around ARel to get the job done another way.
+4. Migration support to rename attributes, remove attributes. (I haven't needed yet...)
 
 ## Contributing
 

data/lib/ar_doc_store/attribute_types/array.rb

@@ -5,8 +5,13 @@ module ArDocStore
 
       def build
         key = attribute.to_sym
+        default_value = default
         model.class_eval do
           store_accessor :data, key
+          define_method key, -> {
+            value = read_store_attribute(:data, key)
+            value or default_value
+          }
           define_method "#{key}=".to_sym, -> (value) {
             value = nil if value == ['']
             write_store_attribute(:data, key, value)

data/lib/ar_doc_store/attribute_types/base.rb

@@ -10,10 +10,11 @@ module ArDocStore
       def initialize(model, attribute, options)
         @model, @attribute, @options = model, attribute, options
         @model.virtual_attributes[attribute] = self
+        @default = options.delete(:default)
       end
 
       def build
-        model.store_attributes conversion, predicate, attribute
+        model.store_attributes conversion, predicate, attribute, default
       end
 
     end

data/lib/ar_doc_store/attribute_types/embeds_many.rb

@@ -1,90 +1,101 @@
 module ArDocStore
+  
+  class EmbeddedCollection < Array
+    attr_accessor :parent
+  end
+  
   module AttributeTypes
 
     class EmbedsManyAttribute < Base
+
       def build
         assn_name = attribute.to_sym
         class_name = options[:class_name] || attribute.to_s.classify
         model.store_accessor :data, assn_name
-        create_embeds_many_accessors(assn_name, class_name)
-        create_embeds_many_attributes_method(assn_name)
+        create_reader_for assn_name, class_name
+        create_writer_for assn_name, class_name
+        create_build_method_for assn_name, class_name
+        create_ensure_method_for assn_name
+        create_embeds_many_attributes_method(class_name, assn_name)
         create_embeds_many_validation(assn_name)
       end
       
       private
-
-      def create_embeds_many_accessors(assn_name, class_name)
+      
+      def add_method(method, block)
         model.class_eval do
-          define_method assn_name.to_sym, -> {
-            ivar = "@#{assn_name}"
-            existing = instance_variable_get(ivar)
-            return existing if existing
-            my_class_name = class_name.constantize
-            items = read_store_attribute(:data, assn_name)
-            if items.present? && items.first.respond_to?(:keys)
-              items = items.map { |item| my_class_name.new(item) }
-            end
-            items ||= []
-            instance_variable_set ivar, (items)
-            items
-          }
-          define_method "#{assn_name}=".to_sym, -> (values) {
-            if values && values.respond_to?(:map)
-              items = values.map { |item|
-                my_class_name = class_name.constantize
-                item.is_a?(my_class_name) ? item : my_class_name.new(item)
-              }
-            else
-              items = []
-            end
-            instance_variable_set "@#{assn_name}", write_store_attribute(:data, assn_name, items)
-            # data_will_change!
-          }
-          define_method "build_#{assn_name.to_s.singularize}", -> (attributes=nil) {
-            assns = self.public_send assn_name
-            item = class_name.constantize.new attributes
-            assns << item
-            public_send "#{assn_name}=", assns
-            item
-          }
-
-          define_method "ensure_#{assn_name.to_s.singularize}", -> {
-            public_send "build_#{assn_name.to_s.singularize}" if self.public_send(assn_name).blank?
-          }
-          # TODO: alias here instead of show the same code twice?
-          define_method "ensure_#{assn_name}", -> {
-            public_send "build_#{assn_name.to_s.singularize}" if self.public_send(assn_name).blank?
-          }
+          define_method method, block
         end
       end
-
-      def create_embeds_many_attributes_method(assn_name)
-        model.class_eval do
-          define_method "#{assn_name}_attributes=", -> (values) {
-            values = values && values.values || []
-            models = public_send assn_name
-            new_models = []
-            values.each { |value| 
-              value.symbolize_keys!
-              if value.key?(:id)
-                next if value.key?(:_destroy) && ArDocStore.convert_boolean(value[:_destroy])
-                existing = models.detect { |item| item.id == value[:id] }
-                if existing
-                  new_models << existing.apply_attributes(value)
-                else
-                  # If there was an ID but we can't find it now, do we add it back or ignore it?
-                  # Right now, add it back.
-                  new_models << public_send("build_#{assn_name}", value)
-                end
-              else
-                new_models << public_send("build_#{assn_name}", value)
-              end
+      
+      def create_reader_for(assn_name, class_name)
+        add_method assn_name.to_sym, -> {
+          ivar = "@#{assn_name}"
+          existing = instance_variable_get(ivar)
+          return existing if existing
+          my_class_name = class_name.constantize
+          items = read_store_attribute(:data, assn_name)
+          if items.present? && items.first.respond_to?(:keys)
+            items = ArDocStore::EmbeddedCollection.new items.map { |item| my_class_name.new(item) }
+          end
+          items ||= ArDocStore::EmbeddedCollection.new
+          instance_variable_set ivar, (items)
+          items.parent = self
+          items.map {|item| item.parent = self }
+          items
+        }
+      end
+      def create_writer_for(assn_name, class_name)
+        add_method "#{assn_name}=".to_sym, -> (values) {
+          if values && values.respond_to?(:map)
+            items = ArDocStore::EmbeddedCollection.new values.map { |item|
+              my_class_name = class_name.constantize
+              item = item.is_a?(my_class_name) ? item : my_class_name.new(item)
+              item.id
+              item.parent = self
+              item
             }
-            public_send "#{assn_name}=", new_models
-            # values = values.reject { |item| item[:_destroy] && item[:_destroy].to_bool }
-            # public_send "#{assn_name}=", values
-          }
-        end
+          else
+            items = []
+          end
+          items.parent = self
+          instance_variable_set "@#{assn_name}", write_store_attribute(:data, assn_name, items)
+        }
+      end
+      
+      def create_build_method_for(assn_name, class_name)
+        add_method "build_#{assn_name.to_s.singularize}", -> (attributes=nil) {
+          assns = self.public_send assn_name
+          item = class_name.constantize.new attributes
+          item.id
+          item.parent = self
+          assns << item
+          public_send "#{assn_name}=", assns
+          item
+        }
+      end
+      
+      def create_ensure_method_for(assn_name)
+        method = -> { public_send "build_#{assn_name.to_s.singularize}" if self.public_send(assn_name).blank? }
+        add_method "ensure_#{assn_name.to_s.singularize}", method
+        add_method "ensure_#{assn_name}", method
+      end
+      
+      def create_embeds_many_attributes_method(class_name, assn_name)
+        add_method "#{assn_name}_attributes=", -> (values) {
+          return if values.blank?
+          # if it's a single item then wrap it in an array but how to tell?
+          
+          if values.respond_to?(:each)
+            if values.respond_to?(:values)
+              values = values.values
+            end
+          else
+            values = [values]
+          end
+          models = public_send assn_name
+          public_send "#{assn_name}=", AssignEmbedsManyAttributes.new(self, class_name, assn_name, models, values).models
+        }
       end
 
       def create_embeds_many_validation(assn_name)
@@ -98,5 +109,59 @@ module ArDocStore
 
     end
 
+    class AssignEmbedsManyAttributes
+      attr_reader :models, :assn_name, :parent, :class_name
+      def initialize(parent, class_name, assn_name, models, values)
+        @parent, @class_name, @assn_name, @models, @values = parent, class_name, assn_name, models, values
+        values.each { |value| 
+          value = value.symbolize_keys
+          Rails.logger.info value.inspect
+          if value.key?(:id)
+            Rails.logger.info 'process_existing_model'
+            process_existing_model(value)
+          else
+            Rails.logger.info 'adding new model'
+            add(value)
+          end
+        }
+      end
+      
+      private
+      
+      attr_writer :models, :values
+      attr_reader :values, :assn_name
+      
+      def process_existing_model(value)
+        return false unless value.key?(:id)
+        model = find_model_by_value(value)
+        model && destroy_or_update(model, value) or add(value)
+      end
+      
+      def destroy_or_update(model, value)
+        destroy(model, value) or update_attributes(model, value)
+      end
+      
+      def add(value)
+        models << class_name.constantize.new(value)
+      end
+
+      def destroy(model, value)
+        wants_to_die?(value) && models.delete(model)
+      end
+      
+      def update_attributes(model, value)
+        model.apply_attributes(value)
+      end
+      
+      def wants_to_die?(value)
+        value.key?(:_destroy) && ArDocStore.convert_boolean(value[:_destroy])
+      end
+      
+      def find_model_by_value(value)
+        models.detect { |item| item.id == value[:id] }
+      end
+    end
+
+
   end
 end

data/lib/ar_doc_store/attribute_types/enumeration.rb

@@ -8,10 +8,11 @@ module ArDocStore
         dictionary = options[:values]
         multiple = options[:multiple]
         strict = options[:strict]
+        default_value = default
         model.class_eval do
           
           if multiple
-            attribute key, as: :array
+            attribute key, as: :array, default: default_value
             if strict
               define_method "validate_#{key}" do
                 value = public_send(key)
@@ -19,9 +20,8 @@ module ArDocStore
               end
               validate "validate_#{key}".to_sym
             end
-            # TODO should we do anything for strict option?
           else
-            attribute key, as: :string
+            attribute key, as: :string, default: default_value
             if strict
               validates_inclusion_of key, in: dictionary, allow_blank: true
             end

data/lib/ar_doc_store/attribute_types/uuid.rb

@@ -8,7 +8,6 @@ module ArDocStore
         key = attribute.to_sym
         model.class_eval do
           store_accessor :data, key
-          define_method "#{key}?".to_sym, -> { !!key }
           define_method key, -> {
             value = read_store_attribute(:data, key)
             unless value
@@ -18,18 +17,12 @@ module ArDocStore
             value
           }
           define_method "#{key}=".to_sym, -> (value) {
-            res = nil
-            res = true if value == 'true' || value == true || value == '1' || value == 1
-            res = false if value == 'false' || value == false || value == '0' || value == 0
-            write_store_attribute(:data, key, res)
+            write_store_attribute(:data, key, value)
           }
           add_ransacker(key, 'text')
         end
       end
 
-      def type
-        :boolean
-      end
 
     end
 

data/lib/ar_doc_store/embeddable_model.rb

@@ -4,20 +4,20 @@ module ArDocStore
 
     def self.included(mod)
 
-      mod.send :include, ArDocStore::Storage
-      mod.send :include, ArDocStore::Embedding
-      mod.send :include, InstanceMethods
-      mod.send :extend, ClassMethods
       mod.send :include, ActiveModel::AttributeMethods
       mod.send :include, ActiveModel::Validations
       mod.send :include, ActiveModel::Conversion
       mod.send :extend,  ActiveModel::Naming
       mod.send :include, ActiveModel::Dirty
       mod.send :include, ActiveModel::Serialization
+      mod.send :include, ArDocStore::Storage
+      mod.send :include, ArDocStore::Embedding
+      mod.send :include, InstanceMethods
+      mod.send :extend, ClassMethods
 
       mod.class_eval do
         attr_accessor :_destroy
-        attr_accessor :attributes
+        attr_accessor :attributes, :parent
 
         class_attribute :virtual_attributes
         self.virtual_attributes ||= HashWithIndifferentAccess.new
@@ -33,20 +33,26 @@ module ArDocStore
       
       def initialize(attrs=HashWithIndifferentAccess.new)
         @attributes = HashWithIndifferentAccess.new
+        self.parent = attrs.delete(:parent)
         apply_attributes attrs
       end
       
       def apply_attributes(attrs=HashWithIndifferentAccess.new)
-        return self unless attrs
-        attrs.each { |key, value|
-          key = "#{key}=".to_sym
-          self.public_send(key, value) if methods.include?(key)
-        }
         virtual_attributes.keys.each do |attr|
           @attributes[attr] ||= nil
         end
+        if attrs
+          attrs.each { |key, value|
+            key = "#{key}=".to_sym
+            self.public_send(key, value) if methods.include?(key)
+          }
+        end
         self
       end
+      
+      def save
+        parent && parent.save
+      end
 
       def persisted?
         false
@@ -69,6 +75,10 @@ module ArDocStore
         true
       end
       
+      def to_param
+        id
+      end
+      
     end
     
     module ClassMethods

data/lib/ar_doc_store/storage.rb

@@ -69,23 +69,28 @@ module ArDocStore
         end
       end
 
-      def store_attributes(typecast_method, predicate=nil, attributes=[])
+      def store_attributes(typecast_method, predicate=nil, attributes=[], default_value=nil)
         attributes = [attributes] unless attributes.respond_to?(:each)
         attributes.each do |key|
           store_accessor :data, key
           add_ransacker(key, predicate)
           if typecast_method.is_a?(Symbol)
-            store_attribute_from_symbol typecast_method, key
+            store_attribute_from_symbol typecast_method, key, default_value
           else
             store_attribute_from_class typecast_method, key
           end
         end
       end
 
-      def store_attribute_from_symbol(typecast_method, key)
+      def store_attribute_from_symbol(typecast_method, key, default_value)
         define_method key.to_sym, -> { 
           value = read_store_attribute(:data, key)
-          value.public_send(typecast_method) if value
+          if value
+            value.public_send(typecast_method)
+          elsif default_value
+            write_store_attribute(:data, key, default_value)
+            default_value
+          end
         }
         define_method "#{key}=".to_sym, -> (value) {
           # data_will_change! if @initalized

data/lib/ar_doc_store/version.rb

@@ -1,3 +1,3 @@
 module ArDocStore
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/test/embedding_test.rb

@@ -48,6 +48,20 @@ class EmbeddingTest < MiniTest::Test
     assert_nil building.restrooms.detect {|restroom| restroom.id == restrooms_attributes[:a2][:id] }
   end
   
+  def test_attributes_method_embeds_many_does_not_clobber_existing_embeds_that_are_not_in_array
+    building = Building.new
+    building.restrooms << Restroom.new(door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 })
+    building.restrooms << Restroom.new(door_attributes: { clear_distance: 6, opening_force: 14, clear_space: 44 })
+    building.restrooms << Restroom.new(door_attributes: { clear_distance: 7, opening_force: 15, clear_space: 45 })
+    restrooms_attributes = {
+      a1: { id: building.restrooms[0].id, door_attributes: { clear_distance: 10 } },
+    }
+    building.restrooms_attributes = restrooms_attributes
+    assert_equal 3, building.restrooms.size
+    assert_equal 10, building.restrooms.first.door.clear_distance
+    assert_equal 15, building.restrooms.last.door.opening_force
+  end
+  
   def test_attribute_validity_of_embedded_model_from_model
     b = Building.new
     r = Restroom.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_doc_store
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - David Furber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord