ledger_sync 1.3.4 → 1.3.5

data/lib/ledger_sync/adaptors/stripe/dashboard_url_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    module Stripe
+      class DashboardURLHelper < LedgerSync::Adaptors::DashboardURLHelper
+        def resource_path
+          @resource_path = case resource
+          when LedgerSync::Customer
+            "/customers/#{resource.ledger_id}"
+          else
+            raise Error::AdaptorError::UnknownURLFormat.new(
+              adaptor: self,
+              resource: resource
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/deserializer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'serialization/mixin'
+require_relative 'serialization/deserializer_attribute_set'
+require_relative 'serialization/deserializer_attribute'
+
+module LedgerSync
+  class Deserializer
+    include Serialization::Mixin
+
+    def attribute_value_from_ledger(hash:, ledger_serializer_attribute:, resource:)
+      ledger_serializer_attribute.value_from_hash(
+        hash: hash,
+        resource: resource
+      )
+    end
+
+    def deserialize(args = {})
+      hash     = args.fetch(:hash)
+      resource = args.fetch(:resource)
+
+      deserialize_into = resource.dup # Do not overwrite values in the resource
+      hash = Util::HashHelpers.deep_stringify_keys(hash)
+
+      self.class.attributes.each_value do |ledger_serializer_attribute|
+        value = attribute_value_from_ledger(
+          hash: hash,
+          ledger_serializer_attribute: ledger_serializer_attribute,
+          resource: deserialize_into
+        )
+
+        deserialize_into.assign_attribute(
+          ledger_serializer_attribute.resource_attribute_dot_parts.first,
+          value
+        )
+      end
+
+      deserialize_into
+    end
+
+    def self.attribute(resource_attribute, args = {}, &block)
+      _attribute(
+        args.merge(
+          block: (block if block_given?),
+          resource_attribute: resource_attribute
+        )
+      )
+    end
+
+    def self.attribute_class
+      Serialization::DeserializerAttribute
+    end
+
+    def self.attributes
+      @attributes ||= Serialization::DeserializerAttributeSet.new(serializer_class: self)
+    end
+  end
+end
+

data/lib/ledger_sync/error/adaptor_errors.rb

@@ -43,8 +43,8 @@ module LedgerSync
 
         def initialize(adaptor:, message: nil, response: nil)
           message ||= 'Your request has been throttled.'
-          @rate_limiting_wait_in_seconds = LedgerSync.adaptors.config_from_klass(
-            klass: adaptor.class
+          @rate_limiting_wait_in_seconds = LedgerSync.adaptors.config_from_class(
+            adaptor_class: adaptor.class
           ).rate_limiting_wait_in_seconds
 
           super(

data/lib/ledger_sync/error/resource_errors.rb

@@ -1,4 +1,22 @@
+# frozen_string_literal: true
+
 module LedgerSync
+  class ResourceAttributeError < Error
+    class TypeError < self
+      attr_reader :attribute, :resource_class, :value
+
+      def initialize(args = {})
+        @attribute = args.fetch(:attribute)
+        @resource_class = args.fetch(:resource_class)
+        @value = args.fetch(:value)
+
+        message = attribute.type.error_message(args)
+
+        super(message: message)
+      end
+    end
+  end
+
   class ResourceError < Error
     attr_reader :resource
 
@@ -6,25 +24,6 @@ module LedgerSync
       @resource = resource
       super(message: message)
     end
-    class AttributeTypeError < self
-      attr_reader :attribute, :resource, :value
-
-      def initialize(attribute:, resource:, value:)
-        @attribute = attribute
-        @resource = resource
-        @value = value
-
-        resource_class = resource.class
-
-        message = attribute.type.error_message(
-          attribute: attribute,
-          resource: resource,
-          value: value
-        )
-
-        super(message: message, resource: nil)
-      end
-    end
 
     class ReferenceAssignmentError < self
       def initialize(attribute:, resource:, value:)

data/lib/ledger_sync/resource.rb

@@ -12,6 +12,7 @@ module LedgerSync
     include ResourceAttribute::Mixin
     include ResourceAttribute::Reference::One::Mixin
     include ResourceAttribute::Reference::Many::Mixin
+    include Util::Mixins::DupableMixin
 
     PRIMITIVES = [
       ActiveModel::Type,
@@ -28,6 +29,9 @@ module LedgerSync
 
     serialize except: %i[resource_attributes references]
 
+    attribute :external_id, type: Type::ID
+    attribute :ledger_id, type: Type::ID
+
     def assign_attribute(name, value)
       public_send("#{name}=", value)
       self
@@ -46,11 +50,7 @@ module LedgerSync
       super.merge(Hash[resource_attributes.references_many.map { |ref| [ref.name, ref.changes['value']] if ref.changed? }.compact])
     end
 
-    def dup
-      Marshal.load(Marshal.dump(self))
-    end
-
-    def klass_from_resource_type(obj)
+    def class_from_resource_type(obj)
       LedgerSync.const_get(LedgerSync::Util::StringHelpers.camelcase(obj))
     end
 
@@ -59,8 +59,9 @@ module LedgerSync
     end
 
     def self.inherited(subclass)
-      subclass.attribute :external_id, type: Type::ID
-      subclass.attribute :ledger_id, type: Type::ID
+      resource_attributes.each do |_name, resource_attribute|
+        subclass._add_resource_attribute(resource_attribute)
+      end
     end
 
     def self.resource_module_str
@@ -79,7 +80,7 @@ module LedgerSync
     end
 
     def ==(other)
-      other.fingerprint == fingerprint
+      other&.fingerprint == fingerprint
     end
   end
 end

data/lib/ledger_sync/resource_attribute.rb

@@ -14,22 +14,35 @@ 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
+
+    def assert_valid(args = {})
+      value = args.fetch(:value)
 
-      @type = type
+      return if valid_with?(value: value)
 
-      @value = value
+      raise ResourceAttributeError::TypeError.new(
+        attribute: self,
+        resource_class: resource_class,
+        value: value
+      )
     end
 
     def cast(value)
@@ -50,5 +63,15 @@ module LedgerSync
     def valid_with?(value:)
       type.valid_without_casting?(value: value)
     end
+
+    def value=(val)
+      assert_valid(value: val)
+      @value = type.cast(val)
+    end
+
+    def will_change?(val)
+      assert_valid(value: val)
+      value != type.cast(val)
+    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,22 +30,10 @@ 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]
@@ -44,14 +41,7 @@ module LedgerSync
         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

@@ -56,18 +56,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

@@ -14,17 +14,23 @@ module LedgerSync
 
           module ClassMethods
             def references_one(name, to:)
-              resource_attribute = ResourceAttribute::Reference::One.new(name: name, to: to)
+              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/resources/location.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class Location < LedgerSync::Resource
+    attribute :name, type: Type::String
+  end
+end

data/lib/ledger_sync/serialization/attribute.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+Gem.find_files('ledger_sync/serialization/type/**/*.rb').each { |path| require path }
+
+module LedgerSync
+  class Serialization
+    class Attribute
+      attr_reader :block,
+                  :hash_attribute,
+                  :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) || Type::ValueType.new
+      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 references_many?
+        type.is_a?(Type::ReferencesManyType)
+      end
+
+      def references_one?
+        type.is_a?(Type::ReferencesOneType)
+      end
+
+      def resource_attribute_dot_parts
+        @resource_attribute_dot_parts ||= resource_attribute.split('.')
+      end
+    end
+  end
+end