ledger_sync 1.3.3 → 1.4.2

data/lib/ledger_sync/resource_attribute.rb

@@ -14,26 +14,39 @@ module LedgerSync
   class ResourceAttribute
     include Fingerprintable::Mixin
     include SimplySerializable::Mixin
+    include Util::Mixins::DupableMixin
 
-    attr_accessor :value
     attr_reader :name,
                 :reference,
-                :type
+                :resource_class,
+                :type,
+                :value
 
-    def initialize(name:, type:, value: nil)
-      @name = name.to_sym
+    def initialize(args = {})
+      @name           = args.fetch(:name).to_sym
+      @resource_class = args.fetch(:resource_class)
+      @type           = args.fetch(:type)
+      @value          = args.fetch(:value, nil)
 
-      type = type.new if type.respond_to?(:new) && !type.is_a?(Type::Value)
+      @type = type.new if type.respond_to?(:new) && !type.is_a?(Type::Value)
 
       raise "Invalid Type: #{type}" unless type.is_a?(ActiveModel::Type::Value)
+    end
 
-      @type = type
+    def assert_valid(args = {})
+      value = args.fetch(:value)
 
-      @value = value
+      type.assert_valid(value: value)
+    rescue Error::TypeError::ValueClassError
+      raise ResourceAttributeError::TypeError.new(
+        attribute: self,
+        resource_class: resource_class,
+        value: value
+      )
     end
 
     def cast(value)
-      type.cast(value)
+      type.cast(value: value)
     end
 
     # This is for ActiveModel::Dirty, since we define @attributes
@@ -48,7 +61,16 @@ module LedgerSync
     end
 
     def valid_with?(value:)
-      type.valid_without_casting?(value: value)
+      type.valid?(value: value)
+    end
+
+    def value=(val)
+      @value = type.cast(value: val)
+    end
+
+    def will_change?(val)
+      assert_valid(value: val)
+      value != type.cast(value: val)
     end
   end
 end

data/lib/ledger_sync/resource_attribute/dirty_mixin.rb

@@ -61,6 +61,10 @@ module LedgerSync
         @mutations_from_database = ActiveModel::ForcedMutationTracker.new(self) # Manually set to expected value
         resource_attributes.references_many.map(&:save)
       end
+
+      def save!
+        save
+      end
     end
   end
 end

data/lib/ledger_sync/resource_attribute/mixin.rb

@@ -13,6 +13,15 @@ module LedgerSync
       end
 
       module ClassMethods
+        def _add_resource_attribute(resource_attribute)
+          _define_attribute_methods(resource_attribute.name)
+
+          resource_attributes.add(resource_attribute)
+          references_many_resource_attributes << resource_attribute if resource_attribute.type.is_a?(Reference::Many)
+
+          resource_attribute
+        end
+
         def _define_attribute_methods(name)
           class_eval do
             define_attribute_methods name
@@ -21,37 +30,18 @@ module LedgerSync
               resource_attributes[name].value
             end
 
-            define_method "_#{name}_valid_with_value?" do |val|
-              unless resource_attributes[name].valid_with?(value: val)
-                raise ResourceError::AttributeTypeError.new(
-                  attribute: resource_attributes[name],
-                  resource: self,
-                  value: val
-                )
-              end
-            end
-
             define_method "#{name}=" do |val|
-              attribute = resource_attributes[name]
-              public_send("_#{name}_valid_with_value?", val)
-              val = attribute.type.cast(val) if attribute.type.cast?
-              public_send("#{name}_will_change!") unless val == resource_attributes[name] # For Dirty
-              attribute.value = val
+              resource_attribute = resource_attributes[name]
+              public_send("#{name}_will_change!") if resource_attribute.will_change?(val) # For Dirty
+              resource_attribute.value = val
             end
 
-            serialize attributes: [name]
+            simply_serialize attributes: [name]
           end
         end
 
         def attribute(name, type:)
-          resource_attribute = ResourceAttribute.new(name: name, type: type)
-
-          _define_attribute_methods(name)
-
-          resource_attributes.add(resource_attribute)
-          references_many_resource_attributes << resource_attribute if resource_attribute.type.is_a?(Reference::Many)
-
-          resource_attribute
+          _add_resource_attribute(ResourceAttribute.new(name: name, resource_class: self, type: type))
         end
 
         def references_many_resource_attributes

data/lib/ledger_sync/resource_attribute/reference/many.rb

@@ -7,35 +7,23 @@ module LedgerSync
   class ResourceAttribute
     class Reference
       class Many < Reference
-        class ManyArray
+        class ManyArray < Array
           include ActiveModel::Dirty
 
           ARRAY_METHODS_TO_OVERRIDE_WITH_DIRTY = %w[<< | []= + -].freeze
 
-          delegate  :count,
-                    :each,
-                    :include?,
-                    :map,
-                    to: :value
-
-          attr_accessor :value
-
           define_attribute_methods :value
 
-          def initialize
-            @value = []
-          end
-
           ARRAY_METHODS_TO_OVERRIDE_WITH_DIRTY.each do |array_method|
             define_method(array_method) do |val|
               value_will_change!
-              @value = @value.send(array_method, val)
+              super(val)
             end
           end
 
           def ==(other)
-            return false unless other.is_a?(ManyArray)
-            return false unless other.sorted_fingerprints == sorted_fingerprints
+            return false unless other.is_a?(ManyArray) || other.is_a?(Array)
+            return false unless sorted_fingerprints(other) == sorted_fingerprints
 
             true
           end
@@ -44,8 +32,12 @@ module LedgerSync
             changes_applied
           end
 
-          def sorted_fingerprints
-            value.map(&:fingerprint).sort
+          def sorted_fingerprints(other = nil)
+            (other || self).map(&:fingerprint).sort
+          end
+
+          def value
+            self
           end
         end
 
@@ -56,18 +48,24 @@ module LedgerSync
 
           module ClassMethods
             def references_many(name, to:)
-              resource_attribute = ResourceAttribute::Reference::Many.new(name: name, to: to)
+              resource_attribute = ResourceAttribute::Reference::Many.new(
+                name: name,
+                resource_class: self,
+                to: to
+              )
               resource_attributes.add resource_attribute
               _define_attribute_methods(name)
             end
           end
         end
 
-        def initialize(name:, to:)
+        def initialize(args = {})
+          to = args.fetch(:to)
           super(
-            name: name,
-            type: Type::ReferenceMany.new(resource_class: to),
-            value: ManyArray.new
+            args.except(:to).merge(
+              type: Type::ReferenceMany.new(resource_class: to),
+              value: ManyArray.new
+            )
           )
         end
 

data/lib/ledger_sync/resource_attribute/reference/one.rb

@@ -13,18 +13,29 @@ module LedgerSync
           end
 
           module ClassMethods
-            def references_one(name, to:)
-              resource_attribute = ResourceAttribute::Reference::One.new(name: name, to: to)
+            def references_one(name, to: nil)
+              to ||= begin
+                require "ledger_sync/ledgers/#{inferred_client_class.root_key}/resources/#{name}"
+                inferred_client_class.resources[name]
+              end
+
+              resource_attribute = ResourceAttribute::Reference::One.new(
+                name: name,
+                resource_class: self,
+                to: to
+              )
               resource_attributes.add resource_attribute
               _define_attribute_methods(name)
             end
           end
         end
 
-        def initialize(name:, to:)
+        def initialize(args = {})
+          to = args.fetch(:to)
           super(
-            name: name,
-            type: Type::ReferenceOne.new(resource_class: to)
+            args.except(:to).merge(
+              type: Type::ReferenceOne.new(resource_class: to)
+            )
           )
         end
       end

data/lib/ledger_sync/resource_attribute_set.rb

@@ -2,19 +2,15 @@
 
 module LedgerSync
   class ResourceAttributeSet
+    include Util::Mixins::DelegateIterableMethodsMixin
+
     attr_reader :attributes,
                 :references,
                 :references_one,
                 :references_many,
                 :resource
 
-    delegate  :[],
-              :each,
-              :include?,
-              :key?,
-              :keys,
-              :map,
-              to: :attributes
+    delegate_hash_methods_to :attributes
 
     alias names keys
 

data/lib/ledger_sync/result.rb

@@ -31,7 +31,7 @@ module LedgerSync
 
       def self.included(base)
         base.class_eval do
-          serialize only: %i[operation resource response]
+          simply_serialize only: %i[operation resource response]
         end
       end
 
@@ -64,7 +64,7 @@ module LedgerSync
       def self.included(base)
         base.class_eval do
           # TODO: removed next and previous searcher, because it causes a string of them.  We should add next_searcher_params which would be easier to serialize.
-          serialize only: %i[resources searcher]
+          simply_serialize only: %i[resources searcher]
         end
       end
 
@@ -100,7 +100,7 @@ module LedgerSync
 
       def self.included(base)
         base.class_eval do
-          serialize only: %i[validator]
+          simply_serialize only: %i[validator]
         end
       end
 

data/lib/ledger_sync/serialization/attribute.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+Gem.find_files('ledger_sync/serialization/type/**/*.rb').each { |path| require path }
+
+module LedgerSync
+  module Serialization
+    class Attribute
+      attr_reader :block,
+                  :hash_attribute,
+                  :if_method,
+                  :resource_attribute,
+                  :resource_class,
+                  :type
+
+      def initialize(args = {})
+        @block              = args.fetch(:block, nil)
+        @hash_attribute     = args.fetch(:hash_attribute, nil).try(:to_s)
+        @resource_attribute = args.fetch(:resource_attribute, nil).try(:to_s)
+        @resource_class     = args.fetch(:resource_class, nil)
+        @type               = args.fetch(:type, nil) || LedgerSync::Type::Value.new
+        @if_method          = args.fetch(:if, nil)
+      end
+
+      def block_value_for(args = {})
+        block.call(args.merge(attribute: self))
+      end
+
+      def hash_attribute_dot_parts
+        @hash_attribute_dot_parts ||= hash_attribute.split('.')
+      end
+
+      def reference?
+        references_many? || references_one?
+      end
+
+      def resource_attribute_dot_parts
+        @resource_attribute_dot_parts ||= resource_attribute.split('.')
+      end
+    end
+  end
+end

data/lib/ledger_sync/serialization/attribute_set_mixin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Serialization
+    module AttributeSetMixin
+      include Util::Mixins::DelegateIterableMethodsMixin
+
+      attr_reader :attributes,
+                  :serializer_class
+
+      delegate_hash_methods_to :attributes
+
+      def initialize(args = {})
+        @attributes       = {}
+        @serializer_class = args.fetch(:serializer_class)
+      end
+
+      def add(_attribute)
+        raise NotImplementedError
+      end
+
+      def hash_attribute?(key)
+        hash_attribute_keyed_hash.include?(key.to_s)
+      end
+    end
+  end
+end

data/lib/ledger_sync/serialization/deserializer_attribute.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'attribute'
+
+module LedgerSync
+  module Serialization
+    class DeserializerAttribute < Attribute
+      def initialize(args = {})
+        super
+
+        raise 'Missing resource_attribute' if resource_attribute.blank?
+
+        if block.present?
+          raise 'block and hash_attribute cannot both be present' if hash_attribute.present?
+        else
+          @hash_attribute ||= resource_attribute
+        end
+      end
+
+      def references_many?
+        type.is_a?(Type::DeserializerReferencesManyType)
+      end
+
+      def references_one?
+        type.is_a?(Type::DeserializerReferencesOneType)
+      end
+
+      def value_from_hash(hash:, resource:)
+        return block_value_for(hash: hash) if block.present?
+
+        value = hash.dig(*hash_attribute.split('.'))
+
+        if type.is_a?(Type::DeserializerType)
+          type.cast(deserializer_attribute: self, resource: resource, value: value)
+        else
+          value = type.cast(value: value)
+          return value if resource_attribute_dot_parts.count <= 1
+
+          nested_resource = resource.send(resource_attribute_dot_parts.first)
+          nested_resource ||= resource_attribute_class(resource: resource).new
+
+          build_resource_value_from_nested_attributes(
+            nested_resource,
+            value,
+            resource_attribute_dot_parts[1..-1]
+          )
+        end
+      end
+
+      private
+
+      def build_resource_value_from_nested_attributes(resource, value, attribute_parts)
+        resource = resource.dup
+        first_attribute, *remaining_attributes = attribute_parts
+
+        if remaining_attributes.count.zero?
+          resource.public_send("#{first_attribute}=", value)
+        else
+          resource.public_send(
+            "#{first_attribute}=",
+            build_resource_value_from_nested_attributes(
+              resource.public_send(first_attribute) || resource.class.resource_attributes[first_attribute.to_sym].type.resource_class.new,
+              value,
+              remaining_attributes
+            )
+          )
+        end
+
+        resource
+      end
+
+      def resource_attribute_class(resource:)
+        @resource_attribute_type ||= {}
+        @resource_attribute_type[resource] ||= resource.class.resource_attributes[resource_attribute_dot_parts.first.to_sym].type.resource_class
+      end
+    end
+  end
+end