ar_doc_store 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8976a8f0c31fe24e9670d9cb702c42e2e6bc2dab
-  data.tar.gz: f4cd0ed1f6623495a63a211b4d435b3541ac2594
+  metadata.gz: 768bd78def2275242d66654ea62177ded6df21eb
+  data.tar.gz: 62c9f288637be16cfbf353b57acbfed050dbbcb8
 SHA512:
-  metadata.gz: 015565bb5727c8156169edde09e3155cdb59f95907244e1d25821f36897ed0503669a3370c34891cfb12beaf6423c2513d4de0ab7732428e963e93d61250b132
-  data.tar.gz: 551012c6c8a78f4cc5378213073743637de2c99b2d2f84acedffbe7231bd7a5ceca47dc73f94ee602199ab23293e670b790dda8a3fbf5795a16f2eb396276241
+  metadata.gz: 4c41aea7206dfc929c14c6d6a09e3c7132007f51245b5a754a77c2c352622fd9609b235d1048addaaa41f3ee5b2b2131e1776cb845518032cf0320c6fcca59b5
+  data.tar.gz: f1e58cbec99ea28a87fdcea51242fa5a69d84b01754b5fce69c46ec0244463eb3dc708802b0c533d04fbb4c0c0e00206d47732e1f4996abfbf7d3ce4642335d6

data/lib/ar_doc_store.rb

@@ -1,8 +1,5 @@
 require "ar_doc_store/version"
 require "ar_doc_store/storage"
-require "ar_doc_store/embedding/embeds_one"
-require "ar_doc_store/embedding/embeds_many"
-require "ar_doc_store/embedding/core"
 require "ar_doc_store/embedding"
 require "ar_doc_store/model"
 require "ar_doc_store/embeddable_model"
@@ -13,6 +10,9 @@ require "ar_doc_store/attribute_types/enumeration"
 require "ar_doc_store/attribute_types/float"
 require "ar_doc_store/attribute_types/integer"
 require "ar_doc_store/attribute_types/string"
+require "ar_doc_store/attribute_types/uuid"
+require "ar_doc_store/attribute_types/embeds_one"
+require "ar_doc_store/attribute_types/embeds_many"
 
 module ArDocStore
   @mappings = Hash.new
@@ -26,4 +26,20 @@ module ArDocStore
   def self.mappings
     @mappings
   end
+  
+  def self.convert_boolean(bool)
+    if bool.is_a?(String)
+      return true if bool == true || bool =~ (/^(true|t|yes|y|1)$/i)
+      return false if bool == false || bool.blank? || bool =~ (/^(false|f|no|n|0)$/i)
+    elsif bool.is_a?(Integer)
+      return bool > 0
+    elsif bool.is_a?(TrueClass)
+      return true
+    elsif bool.is_a?(FalseClass)
+      return false
+    else
+      return nil
+    end
+  end
 end
+

data/lib/ar_doc_store/attribute_types/base.rb

@@ -9,6 +9,7 @@ module ArDocStore
 
       def initialize(model, attribute, options)
         @model, @attribute, @options = model, attribute, options
+        @model.virtual_attributes[attribute] = self
       end
 
       def build

data/lib/ar_doc_store/attribute_types/boolean.rb

@@ -8,9 +8,7 @@ module ArDocStore
           store_accessor :data, key
           define_method "#{key}?".to_sym, -> { !!key }
           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
+            res = ArDocStore.convert_boolean(value)
             write_store_attribute(:data, key, res)
           }
           add_ransacker(key, 'bool')

data/lib/ar_doc_store/attribute_types/embeds_many.rb

@@ -0,0 +1,102 @@
+module ArDocStore
+  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_embeds_many_validation(assn_name)
+      end
+      
+      private
+
+      def create_embeds_many_accessors(assn_name, class_name)
+        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?
+          }
+        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
+            }
+            public_send "#{assn_name}=", new_models
+            # values = values.reject { |item| item[:_destroy] && item[:_destroy].to_bool }
+            # public_send "#{assn_name}=", values
+          }
+        end
+      end
+
+      def create_embeds_many_validation(assn_name)
+        model.class_eval do
+          validate_method = "validate_embedded_record_for_#{assn_name}"
+          define_method validate_method, -> { validate_embeds_many assn_name }
+          validate validate_method
+        end        
+      end
+      
+
+    end
+
+  end
+end

data/lib/ar_doc_store/{embedding → attribute_types}/embeds_one.rb

@@ -1,36 +1,19 @@
 module ArDocStore
-  module Embedding
-    module EmbedsOne
-      
-      def self.included(base)
-        base.send :extend, ClassMethods
-        base.send :include, InstanceMethods
-      end
-    
-      module InstanceMethods
-      
-        def validate_embeds_one(assn_name)
-          record = public_send(assn_name)
-          embed_valid?(assn_name, record) if record
-        end
+  module AttributeTypes
 
+    class EmbedsOneAttribute < Base
+      def build
+        assn_name = attribute.to_sym
+        class_name = options[:class_name] || attribute.to_s.classify
+        model.store_accessor :data, assn_name
+        model.store_attribute_from_class class_name, assn_name
+        create_embed_one_attributes_method(assn_name)
+        create_embeds_one_accessors assn_name, class_name
+        create_embeds_one_validation(assn_name)
       end
-    
-      module ClassMethods
-
-        def embeds_one(assn_name, *args)
-          store_accessor :data, assn_name
-          options = args.extract_options!
-          class_name = options[:class_name] || assn_name.to_s.classify
-          store_attribute_from_class class_name, assn_name
-          create_embed_one_attributes_method(assn_name)
-          create_embeds_one_accessors assn_name, class_name
-          create_embeds_one_validation(assn_name)
-        end
-
-        private
 
-        def create_embeds_one_accessors(assn_name, class_name)
+      def create_embeds_one_accessors(assn_name, class_name)
+        model.class_eval do
           define_method "build_#{assn_name}", -> (attributes=nil) {
             class_name = class_name.constantize if class_name.respond_to?(:constantize)
             public_send "#{assn_name}=", class_name.new(attributes)
@@ -40,10 +23,11 @@ module ArDocStore
             public_send "build_#{assn_name}" if public_send(assn_name).blank?
           }
         end
+      end
 
-        def create_embed_one_attributes_method(assn_name)
+      def create_embed_one_attributes_method(assn_name)
+        model.class_eval do
           define_method "#{assn_name}_attributes=", -> (values) {
-            # data_will_change!
             values ||= {}
             values.symbolize_keys! if values.respond_to?(:symbolize_keys!)
             if values[:_destroy] && (values[:_destroy] == '1')
@@ -53,15 +37,18 @@ module ArDocStore
             end              
           }
         end
+      end
 
-        def create_embeds_one_validation(assn_name)
+      def create_embeds_one_validation(assn_name)
+        model.class_eval do
           validate_method = "validate_embedded_record_for_#{assn_name}"
           define_method validate_method, -> { validate_embeds_one assn_name }
           validate validate_method
-        end
-
+        end        
       end
-    
+      
+
     end
+
   end
 end

data/lib/ar_doc_store/attribute_types/uuid.rb

@@ -0,0 +1,37 @@
+require 'securerandom'
+
+module ArDocStore
+  module AttributeTypes
+
+    class UuidAttribute < Base
+      def build
+        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
+              value = SecureRandom.uuid
+              write_store_attribute :data, key, value
+            end
+            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)
+          }
+          add_ransacker(key, 'text')
+        end
+      end
+
+      def type
+        :boolean
+      end
+
+    end
+
+  end
+end

data/lib/ar_doc_store/embeddable_model.rb

@@ -4,17 +4,6 @@ module ArDocStore
 
     def self.included(mod)
 
-      mod.class_eval do
-        attr_accessor :_destroy
-        attr_accessor :attributes
-
-        class_attribute :virtual_attributes
-        self.virtual_attributes ||= HashWithIndifferentAccess.new
-
-        delegate :as_json, to: :attributes
-
-      end
-
       mod.send :include, ArDocStore::Storage
       mod.send :include, ArDocStore::Embedding
       mod.send :include, InstanceMethods
@@ -26,13 +15,29 @@ module ArDocStore
       mod.send :include, ActiveModel::Dirty
       mod.send :include, ActiveModel::Serialization
 
+      mod.class_eval do
+        attr_accessor :_destroy
+        attr_accessor :attributes
+
+        class_attribute :virtual_attributes
+        self.virtual_attributes ||= HashWithIndifferentAccess.new
+        
+        delegate :as_json, to: :attributes
+        
+        attribute :id, :uuid
+      end
+
     end
     
     module InstanceMethods
       
-      def initialize(attrs={})
-        attrs ||= {}
+      def initialize(attrs=HashWithIndifferentAccess.new)
         @attributes = HashWithIndifferentAccess.new
+        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)
@@ -40,6 +45,7 @@ module ArDocStore
         virtual_attributes.keys.each do |attr|
           @attributes[attr] ||= nil
         end
+        self
       end
 
       def persisted?
@@ -69,7 +75,7 @@ module ArDocStore
       
       def store_accessor(store, key)
         self.virtual_attributes ||= HashWithIndifferentAccess.new
-        virtual_attributes[key] = true
+        virtual_attributes[key] ||= true
         key = key.to_sym
         define_method key, -> { read_store_attribute(:data, key) }
         define_method "#{key}=".to_sym, -> (value) { write_store_attribute :data, key, value }

data/lib/ar_doc_store/embedding.rb

@@ -1,7 +1,50 @@
 module ArDocStore
   module Embedding
-    def self.included(base)
-      base.send :include, Core
+    def self.included(mod)
+      mod.send :extend, ClassMethods        
+      mod.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+
+      def embeds_many(assn_name, *args)
+        attribute assn_name, :embeds_many, *args
+      end
+
+      def embeds_one(assn_name, *args)
+        attribute assn_name, :embeds_one, *args
+      end
+
+    end
+    
+  
+    module InstanceMethods
+    
+      # Returns whether or not the association is valid and applies any errors to
+      # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
+      # enabled records if they're marked_for_destruction? or destroyed.
+      def embed_valid?(assn_name, record)
+        unless valid = record.valid?
+          record.errors.each do |attribute, message|
+            attribute = "#{assn_name}.#{attribute}"
+            errors[attribute] << message
+            errors[attribute].uniq!
+          end
+        end
+        valid
+      end
+
+      def validate_embeds_many(assn_name)
+        if records = public_send(assn_name)
+          records.each { |record| embed_valid?(assn_name, record) }
+        end
+      end
+
+      def validate_embeds_one(assn_name)
+        record = public_send(assn_name)
+        embed_valid?(assn_name, record) if record
+      end
+
     end
   end
 end

data/lib/ar_doc_store/storage.rb

@@ -2,6 +2,10 @@ module ArDocStore
   module Storage
     
     def self.included(mod)
+      
+      mod.class_attribute :virtual_attributes
+      mod.virtual_attributes ||= HashWithIndifferentAccess.new
+      
       mod.send :include, InstanceMethods
       mod.send :extend, ClassMethods
     end
@@ -105,11 +109,12 @@ module ArDocStore
         }
         define_method "#{key}=".to_sym, -> (value) {
           ivar = "@#{key}"
+          existing = public_send(key)
           class_name = class_name.constantize if class_name.respond_to?(:constantize)
-          if value == ''
+          if value == '' || !value
             value = nil
-          else
-            value = class_name.new(value) unless value.is_a?(class_name)
+          elsif !value.is_a?(class_name)
+            value = existing.apply_attributes(value)
           end
           instance_variable_set ivar, value
           write_store_attribute :data, key, value

data/lib/ar_doc_store/version.rb

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

data/test/embedding_test.rb

@@ -23,6 +23,31 @@ class EmbeddingTest < MiniTest::Test
     assert_nil restroom.door.clear_distance
   end
   
+  def test_attributes_equals_sets_partial_attributes
+    restroom = Restroom.new door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 }
+    restroom.door_attributes = { clear_distance: 7 }
+    assert_equal 7, restroom.door.clear_distance
+    assert_equal 13, restroom.door.opening_force
+  end
+  
+  def test_embeds_many_attributes_equals_sets_partial_attributes
+    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 } },
+      a2: { id: building.restrooms[1].id, _destroy: true },
+      a3: { id: building.restrooms[2].id, door_attributes: { clear_distance: 1 } }
+    }
+    building.restrooms_attributes = restrooms_attributes
+    assert_equal 2, building.restrooms.size
+    assert_equal 10, building.restrooms.first.door.clear_distance
+    assert_equal 15, building.restrooms.last.door.opening_force
+    assert_equal 1, building.restrooms.last.door.clear_distance
+    assert_nil building.restrooms.detect {|restroom| restroom.id == restrooms_attributes[:a2][:id] }
+  end
+  
   def test_attribute_validity_of_embedded_model_from_model
     b = Building.new
     r = Restroom.new
@@ -37,7 +62,7 @@ class EmbeddingTest < MiniTest::Test
   end
 
   def test_model_subclassing
-    assert_equal EmbeddableB.virtual_attributes.size, 2
+    assert_equal EmbeddableB.virtual_attributes.size, 3
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_doc_store
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - David Furber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-23 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -72,15 +72,15 @@ files:
 - lib/ar_doc_store/attribute_types/array.rb
 - lib/ar_doc_store/attribute_types/base.rb
 - lib/ar_doc_store/attribute_types/boolean.rb
+- lib/ar_doc_store/attribute_types/embeds_many.rb
+- lib/ar_doc_store/attribute_types/embeds_one.rb
 - lib/ar_doc_store/attribute_types/enumeration.rb
 - lib/ar_doc_store/attribute_types/float.rb
 - lib/ar_doc_store/attribute_types/integer.rb
 - lib/ar_doc_store/attribute_types/string.rb
+- lib/ar_doc_store/attribute_types/uuid.rb
 - lib/ar_doc_store/embeddable_model.rb
 - lib/ar_doc_store/embedding.rb
-- lib/ar_doc_store/embedding/core.rb
-- lib/ar_doc_store/embedding/embeds_many.rb
-- lib/ar_doc_store/embedding/embeds_one.rb
 - lib/ar_doc_store/model.rb
 - lib/ar_doc_store/storage.rb
 - lib/ar_doc_store/version.rb

data/lib/ar_doc_store/embedding/core.rb

@@ -1,30 +0,0 @@
-module ArDocStore
-  module Embedding
-      module Core
-
-      def self.included(mod)
-        mod.send :include, EmbedsOne
-        mod.send :include, EmbedsMany
-        mod.send :include, InstanceMethods
-      end
-    
-      module InstanceMethods
-      
-        # Returns whether or not the association is valid and applies any errors to
-        # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
-        # enabled records if they're marked_for_destruction? or destroyed.
-        def embed_valid?(assn_name, record)
-          unless valid = record.valid?
-            record.errors.each do |attribute, message|
-              attribute = "#{assn_name}.#{attribute}"
-              errors[attribute] << message
-              errors[attribute].uniq!
-            end
-          end
-          valid
-        end
-
-      end
-    end
-  end
-end

data/lib/ar_doc_store/embedding/embeds_many.rb

@@ -1,95 +0,0 @@
-module ArDocStore
-  module Embedding
-      module EmbedsMany
-
-        def self.included(base)
-          base.send :extend, ClassMethods
-          base.send :include, InstanceMethods
-        end
-        
-        module InstanceMethods
-          # Validate the embedded records
-          def validate_embeds_many(assn_name)
-            if records = public_send(assn_name)
-              records.each { |record| embed_valid?(assn_name, record) }
-            end
-          end
-
-        end
-    
-        module ClassMethods
-
-          def embeds_many(assn_name, *args)
-            store_accessor :data, assn_name
-            options = args.extract_options!
-            class_name = options[:class_name] || assn_name.to_s.classify
-            create_embeds_many_accessors(assn_name, class_name)
-            create_embed_many_attributes_method(assn_name)
-            create_embeds_many_validation(assn_name)
-          end
-
-          private
-
-          def create_embeds_many_accessors(assn_name, class_name)
-            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?
-            }
-          end
-
-          def create_embed_many_attributes_method(assn_name)
-            define_method "#{assn_name}_attributes=", -> (values) {
-              data_will_change!
-              values = values.andand.values || []
-              values = values.reject { |item| item['_destroy'] == '1' }
-              public_send "#{assn_name}=", values
-            }
-          end
-
-          def create_embeds_many_validation(assn_name)
-            validate_method = "validate_embedded_record_for_#{assn_name}"
-            define_method validate_method, -> { validate_embeds_many assn_name }
-            validate validate_method
-          end
-
-        end
-    
-    end
-  end
-end