ledger_sync 1.3.4 → 1.4.4

data/lib/ledger_sync/resource_adaptor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class ResourceAdaptor
+    module Mixin
+      module ClassMethods
+        def attribute(record_attribute, args = {})
+          resource_attribute = args.fetch(:resource_attribute, record_attribute)
+
+          attributes[record_attribute.to_sym] = {
+            record_attribute: record_attribute,
+            resource_attribute: resource_attribute
+          }
+
+          define_method(resource_attribute) do
+            resource.send(record_attribute)
+          end
+
+          define_method("#{resource_attribute}=") do |*setter_args|
+            resource.send("#{record_attribute}=", *setter_args)
+          end
+        end
+
+        def attributes
+          @attributes ||= {}
+        end
+      end
+
+      module InstanceMethods
+        def initialize(args = {})
+          @resource = args.fetch(:resource).dup
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.attr_reader(:resource)
+        base.attribute(:ledger_id)
+        base.attribute(:external_id)
+        base.include(InstanceMethods)
+      end
+    end
+
+    def initialize(*)
+      raise NotImplementedError
+    end
+
+    def self.inherited(base)
+      base.include(Mixin)
+    end
+  end
+end

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

@@ -36,7 +36,7 @@ module LedgerSync
       # Change the dirty change set of {"name" => ["Bill", "Bob"]}
       # to current values of attributes that have changed: {"name" => "Bob"}
       def changes_to_h
-        Hash[changes.map { |k, v| [k, v.last] }]
+        changes.transform_values(&:last)
       end
 
       def dirty_attributes_to_h
@@ -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
@@ -65,7 +55,7 @@ module LedgerSync
 
       def initialize(**data)
         # Initialize empty values
-        resource_attributes.keys.each { |e| instance_variable_set("@#{e}", nil) }
+        resource_attributes.each_key { |e| instance_variable_set("@#{e}", nil) }
 
         assign_attributes(data)
 
@@ -95,8 +85,8 @@ module LedgerSync
       end
 
       def serialize_attributes
-        Hash[resource_attributes.map { |k, v| [k, v.value] }]
+        resource_attributes.transform_values(&:value)
       end
     end
   end
-end
+end

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
 
@@ -51,7 +47,7 @@ module LedgerSync
     end
 
     def to_h
-      Hash[attributes.map { |k, v| [k, v.value] }]
+      attributes.transform_values(&:value)
     end
   end
 end

data/lib/ledger_sync/result.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module LedgerSync
   module ResultBase
     module HelperMethods
-      def Success(value = nil, *args)
+      def Success(value = nil, *args) # rubocop:disable Naming/MethodName
         self::Success.new(value, *args)
       end
 
-      def Failure(error = nil, *args)
+      def Failure(error = nil, *args) # rubocop:disable Naming/MethodName
         self::Failure.new(error, *args)
       end
     end
@@ -31,7 +33,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
 
@@ -52,22 +54,15 @@ module LedgerSync
 
       def self.included(base)
         base.class_eval do
-          serialize only: %i[
-            next_searcher
-            previous_searcher
+          # 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.
+          simply_serialize only: %i[
             resources
             searcher
           ]
         end
       end
 
-      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]
-        end
-      end
-
       def initialize(*args, searcher:, **keywords)
         @resources = searcher.resources
         @searcher = searcher
@@ -100,7 +95,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