ar_doc_store 1.0.5 → 2.0.0

data/lib/ar_doc_store/{attribute_types/embeds_one_attribute.rb → attributes/embeds_one.rb}

@@ -1,51 +1,45 @@
 module ArDocStore
-  module AttributeTypes
+  module Attributes
+    class EmbedsOne < EmbedsBase
+      private
 
-    class EmbedsOneAttribute < BaseAttribute
-      attr_reader :class_name
-      def build
-        @class_name = options[:class_name] || attribute.to_s.classify
-        create_accessors
-        create_embed_one_attributes_method
-        create_embeds_one_accessors
-        create_embeds_one_validation
-      end
-
-      def create_accessors
+      def store_attribute
         model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        attribute :#{attribute}, ArDocStore::Types::EmbedsOne.new("#{@class_name}")
         def #{attribute}
-          @#{attribute} || begin
-            item = read_store_attribute json_column, :#{attribute}
-            item = #{class_name}.build(item) unless item.is_a?(#{class_name})
-            @#{attribute} = item
-          end
+          value = send :attribute, :#{attribute}
+          value && value.parent = self 
+          value && value.embedded_as = :#{attribute}
+          value
         end
-
         def #{attribute}=(value)
-          if value == '' || !value
-            value = nil
-          elsif value.is_a?(#{class_name})
-            value = value.attributes
-          end
-          value = #{class_name}.build value
-          @#{attribute} = value
-          write_store_attribute json_column, :#{attribute}, value
+          value = nil if value == '' || value == ['']
+          write_attribute :#{attribute}, value
+          #{attribute}.parent = self
+          #{attribute}.embedded_as = :#{attribute}
+          write_store_attribute json_column, :#{attribute}, #{attribute}
+          #{attribute}          
         end
         CODE
       end
 
-      def create_embeds_one_accessors
+      def create_build_method
         model.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def build_#{attribute}(attributes=nil)
-          self.#{attribute} = #{class_name}.build(attributes)
+          self.#{attribute} = #{class_name}.build(attributes, self)
         end
+        CODE
+      end
+
+      def create_ensure_method
+        model.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def ensure_#{attribute}
           #{attribute} || build_#{attribute}
         end
         CODE
       end
 
-      def create_embed_one_attributes_method
+      def create_attributes_method
         model.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{attribute}_attributes=(values={})
           values.symbolize_keys! if values.respond_to?(:symbolize_keys!)
@@ -54,12 +48,13 @@ module ArDocStore
           else
             item = ensure_#{attribute}
             item.attributes = values
+            item
           end
         end
         CODE
       end
 
-      def create_embeds_one_validation
+      def create_validation
         model.class_eval <<-CODE, __FILE__, __LINE__ + 1
           def validate_embedded_record_for_#{attribute}
             validate_embeds_one :#{attribute}

data/lib/ar_doc_store/{attribute_types/enumeration_attribute.rb → attributes/enumeration.rb}

@@ -1,8 +1,6 @@
 module ArDocStore
-  module AttributeTypes
-
-    class EnumerationAttribute < BaseAttribute
-
+  module Attributes
+    class Enumeration < Base
       def build
         key = attribute.to_sym
         dictionary = options[:values]
@@ -10,7 +8,6 @@ module ArDocStore
         strict = options[:strict]
         default_value = default
         model.class_eval do
-
           if multiple
             json_attribute key, as: :array, default: default_value
             if strict
@@ -35,7 +32,6 @@ module ArDocStore
       def type
         :string
       end
-
     end
   end
 end

data/lib/ar_doc_store/{attribute_types/float_attribute.rb → attributes/float.rb}

@@ -1,11 +1,6 @@
 module ArDocStore
-  module AttributeTypes
-
-    class FloatAttribute < BaseAttribute
-      def conversion
-        :to_f
-      end
-
+  module Attributes
+    class Float < Base
       def predicate
         'float'
       end
@@ -14,7 +9,9 @@ module ArDocStore
         :number
       end
 
+      def attribute_type
+        ActiveModel::Type::Float
+      end
     end
-
   end
 end

data/lib/ar_doc_store/{attribute_types/integer_attribute.rb → attributes/integer.rb}

@@ -1,11 +1,6 @@
 module ArDocStore
-  module AttributeTypes
-
-    class IntegerAttribute < BaseAttribute
-      def conversion
-        :to_i
-      end
-
+  module Attributes
+    class Integer < Base
       def predicate
         'int'
       end
@@ -14,7 +9,9 @@ module ArDocStore
         :number
       end
 
+      def attribute_type
+        ActiveModel::Type::Integer
+      end
     end
-
   end
 end

data/lib/ar_doc_store/attributes/string.rb

@@ -0,0 +1,13 @@
+module ArDocStore
+  module Attributes
+    class String < Base
+      def predicate
+        'text'
+      end
+
+      def attribute_type
+        ActiveModel::Type::String
+      end
+    end
+  end
+end

data/lib/ar_doc_store/embeddable_model.rb

@@ -3,71 +3,67 @@ require 'securerandom'
 module ArDocStore
   module EmbeddableModel
     def self.included(mod)
+      mod.send :include, ActiveModel::Model
+      mod.send :include, ActiveModel::Attributes
       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, ActiveSupport::Callbacks
       mod.send :include, InstanceMethods
       mod.send :extend,  ClassMethods
 
       mod.class_eval do
+        define_callbacks :persist
         attr_accessor :_destroy
         attr_accessor :parent
-        attr_reader :attributes
+        attr_accessor :embedded_as
 
-        class_attribute :virtual_attributes
-        self.virtual_attributes ||= HashWithIndifferentAccess.new
+        class_attribute :json_attributes
+        self.json_attributes = HashWithIndifferentAccess.new
 
-        delegate :as_json, to: :attributes
-
-        json_attribute :id, :uuid
-
-        def self.attribute(name, *args)
-          json_attribute name, *args
-        end
+        json_attribute :id, :string #, default: -> { SecureRandom.uuid }
 
+        set_callback :persist, :before, :ensure_id
+        set_callback :persist, :after, :mark_embeds_as_persisted
       end
-
     end
 
     module InstanceMethods
+      def initialize(values={})
+        super(values)
+        values && persisted? && values.keys.each do |key|
+          mutations_from_database.forget_change(key)
+        end
+      end
 
-      def initialize(attrs=HashWithIndifferentAccess.new)
-        @_initialized = true
-        initialize_attributes attrs
+      def embedded?
+        true
       end
 
-      def instantiate(attrs=HashWithIndifferentAccess.new)
-        initialize_attributes attrs
-        @_initialized = true
-        self
+      def persist
+        run_callbacks :persist
       end
 
-      def initialize_attributes(attrs)
-        @attributes ||= HashWithIndifferentAccess.new
-        self.parent = attributes.delete(:parent) if attributes
-        self.attributes = attrs
+      def ensure_id
+        self.id ||= SecureRandom.uuid
       end
 
-      def attributes=(attrs=HashWithIndifferentAccess.new)
-        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)
-          }
+      def mark_embeds_as_persisted
+        json_attributes.values.each do |value|
+          if value.respond_to?(:embedded?) && value.embedded? && respond_to?(value.attribute) && !public_send(value.attribute).nil?
+            public_send(value.attribute).persist
+          end
         end
-        self
+      end
+
+      def new_record?
+        id.blank?
       end
 
       def persisted?
-        !!read_store_attribute(nil, :id)
+        id.present?
       end
 
       def inspect
@@ -79,58 +75,38 @@ module ArDocStore
       end
 
       def write_store_attribute(store, attribute, value)
-        if @_initialized
-          old_value = attributes[attribute]
-          if attribute.to_s != 'id' && value != old_value
-            if Rails.version >= '5.2.0'
-              set_attribute_was(attribute, old_value)
-              mutations_from_database.force_change(attribute)
-            else
-              public_send :"#{attribute}_will_change!"
-            end
-            if parent
-              parent.public_send("#{parent.json_column}_will_change!")
-            end
+        if parent
+          if parent.is_a?(EmbeddedCollection)
+            parent.save
+          else
+            parent.send :write_store_attribute, store, embedded_as, as_json
           end
         end
-        attributes[attribute] = value
-      end
-
-      def write_default_store_attribute(attr, value)
-        attributes[attr] = value
+        value
       end
 
       def to_param
         id
       end
 
-      def id_will_change!
+      def as_json(_=nil)
+        attributes.inject({}) do |attrs, attr|
+          attrs[attr[0]] = attr[1] unless attr[1].nil?
+          attrs
+        end
       end
-
     end
 
     module ClassMethods
-
-      #:nodoc:
-      def store_accessor(store, key)
-        self.virtual_attributes ||= HashWithIndifferentAccess.new
-        self.virtual_attributes = virtual_attributes.merge key =>  true
-        key = key.to_sym
-        define_method key, -> { read_store_attribute(json_column, key) }
-        define_method "#{key}=".to_sym, -> (value) { write_store_attribute json_column, key, value }
+      def build(attrs=HashWithIndifferentAccess.new, parent = nil)
+        model = if attrs.is_a?(self.class)
+                  attrs
+                else
+                  new(attrs)
+                end
+        model.parent = parent
+        model
       end
-
-      def build(attrs=HashWithIndifferentAccess.new)
-        if attrs.is_a?(self.class)
-          attrs
-        else
-          instance = allocate
-          instance.instantiate attrs
-        end
-      end
-
-
     end
-
   end
 end

data/lib/ar_doc_store/embedded_collection.rb

@@ -0,0 +1,14 @@
+module ArDocStore
+  class EmbeddedCollection < Array
+    attr_accessor :parent, :embedded_as
+    def save
+      parent.send :write_store_attribute, parent.json_column, embedded_as, as_json
+    end
+    def persist
+      each &:persist
+    end
+    def inspect
+      "ArDocStore::EmbeddedCollection - #{as_json.inspect}"
+    end
+  end
+end

data/lib/ar_doc_store/embedding.rb

@@ -6,7 +6,6 @@ module ArDocStore
     end
 
     module ClassMethods
-
       def embeds_many(assn_name, *args)
         json_attribute assn_name, :embeds_many, *args
       end
@@ -14,7 +13,6 @@ module ArDocStore
       def embeds_one(assn_name, *args)
         json_attribute assn_name, :embeds_one, *args
       end
-
     end
 
 

data/lib/ar_doc_store/model.rb

@@ -4,19 +4,29 @@ module ArDocStore
       mod.send :include, ArDocStore::Storage
       mod.send :include, ArDocStore::Embedding
       mod.send :include, InstanceMethods
+      mod.after_initialize :assign_json_data
+      mod.before_save :mark_embeds_as_persisted
     end
 
     module InstanceMethods
-
-      def write_store_attribute(store_attribute, key, value)
-        public_send "#{key}_will_change!"
-        super(store_attribute, key, value)
+      def assign_json_data
+        json_data = self[json_column]
+        return if json_data.blank?
+        json_attributes.keys.each do |key|
+          next unless json_data.key?(key)
+          send :attribute=, key, json_data[key]
+          self[key].parent = self if self[key].respond_to?(:parent)
+          self[key].embedded_as = key if self[key].respond_to?(:embedded_as)
+          mutations_from_database.forget_change(key) unless new_record?
+        end
       end
-
-      def write_default_store_attribute(key, default_value)
-        data[key] = default_value
+      def mark_embeds_as_persisted
+        json_attributes.values.each do |value|
+          if value.respond_to?(:embedded?) && value.embedded? && respond_to?(value.attribute) && !public_send(value.attribute).nil?
+            public_send(value.attribute).persist
+          end
+        end
       end
-
     end
   end
 end

data/lib/ar_doc_store/storage.rb

@@ -5,77 +5,19 @@ module ArDocStore
 
       mod.class_attribute :json_column
       mod.json_column ||= :data
-      mod.class_attribute :virtual_attributes
-      mod.virtual_attributes ||= HashWithIndifferentAccess.new
-
-      mod.send :include, InstanceMethods
+      mod.class_attribute :json_attributes
+      mod.json_attributes ||= HashWithIndifferentAccess.new
       mod.send :extend, ClassMethods
     end
 
-    module InstanceMethods
-
-      def json_column
-        self.class.json_column
-      end
-
-      def write_attribute(name, value)
-        if is_stored_attribute?(name)
-          write_store_attribute json_column, attribute_name_from_foreign_key(name), value
-        else
-          super
-        end
-      end
-
-      def read_attribute(name)
-        if is_stored_attribute?(name)
-          read_store_attribute json_column, attribute_name_from_foreign_key(name)
-        else
-          super
-        end
-      end
-
-      private
-
-      def is_stored_attribute?(name)
-        name = name.to_sym
-        is_store_accessor_method?(name) || name =~ /data\-\>\>/
-      end
-
-      def is_store_accessor_method?(name)
-        name = name.to_sym
-        self.class.stored_attributes[json_column] && self.class.stored_attributes[json_column].include?(name)
-      end
-
-      def attribute_name_from_foreign_key(name)
-        is_store_accessor_method?(name) ? name : name.match(/\'(\w+)\'/)[0].gsub("'", '')
-      end
-
-      def clean_attribute_names_for_arel(attribute_names)
-        attribute_names.reject{|attribute_name| is_stored_attribute?(attribute_name)}
-      end
-
-      # Overridden otherwise insert and update queries get fooled into thinking that stored attributes are real columns.
-      def arel_attributes_with_values_for_create(attribute_names) #:nodoc:
-        super clean_attribute_names_for_arel(attribute_names)
-      end
-
-      # Overridden otherwise insert and update queries get fooled into thinking that stored attributes are real columns.
-      def arel_attributes_with_values_for_update(attribute_names) #:nodoc:
-        super clean_attribute_names_for_arel(attribute_names)
-      end
-    end
-
     module ClassMethods
-
       def json_attribute(name, *args)
         type = args.shift if args.first.is_a?(Symbol)
         options = args.extract_options!
         type ||= options.delete(:as) || :string
-        class_name = ArDocStore.mappings[type] || "ArDocStore::AttributeTypes::#{type.to_s.classify}Attribute"
+        class_name = ArDocStore.mappings[type] || "ArDocStore::Attributes::#{type.to_s.classify}"
         raise "Invalid attribute type: #{class_name}" unless const_defined?(class_name)
-        class_name.constantize.build self, name, options
-        define_virtual_attribute_method name
-        define_method "#{name}?", -> { public_send(name).present? }
+        json_attributes[name] = class_name.constantize.build self, name, options
       end
 
       #:nodoc:
@@ -89,71 +31,6 @@ module ArDocStore
           Arel.sql(sql)
         end
       end
-
-      # Pretty much the same as define_attribute_method but skipping the matches that create read and write methods
-      def define_virtual_attribute_method(attr_name)
-        attr_name = attr_name.to_s
-        attribute_method_matchers.each do |matcher|
-          method_name = matcher.method_name(attr_name)
-          next if instance_method_already_implemented?(method_name)
-          next if %w{attribute attribute= attribute_before_type_cast}.include? matcher.method_missing_target
-          generate_method = "define_method_#{matcher.method_missing_target}"
-          if respond_to?(generate_method, true)
-            send(generate_method, attr_name)
-          else
-            define_proxy_call true, generated_attribute_methods, method_name, matcher.method_missing_target, attr_name.to_s
-          end
-        end
-        attribute_method_matchers_cache.clear
-      end
-
-
-      # TODO: Remove the following deprecated methods once projects that use them have been refactored.
-      #:nodoc:
-      def store_attributes(typecast_method, predicate=nil, attributes=[], default_value=nil)
-        attributes = [attributes] unless attributes.respond_to?(:each)
-        attributes.each do |key|
-          store_attribute key, typecast_method, predicate, default_value
-        end
-      end
-
-      # Allows you to define several string attributes at once. Deprecated.
-      def string_attributes(*args)
-        args.each do |arg|
-          json_attribute arg, as: :string
-        end
-      end
-
-      # Allows you to define several float attributes at once. Deprecated.
-      def float_attributes(*args)
-        args.each do |arg|
-          json_attribute arg, as: :float
-        end
-      end
-
-      # Allows you to define several integer attributes at once. Deprecated.
-      def integer_attributes(*args)
-        args.each do |arg|
-          json_attribute arg, as: :integer
-        end
-      end
-
-      # Allows you to define several boolean attributes at once. Deprecated.
-      def boolean_attributes(*args)
-        args.each do |arg|
-          json_attribute arg, as: :boolean
-        end
-      end
-
-      # Shorthand for attribute :name, as: :enumeration, values: %w{a b c}
-      # Deprecated.
-      def enumerates(field, *args)
-        options = args.extract_options!
-        options[:as] = :enumeration
-        json_attribute field, options
-      end
-
-
     end
 
   end