ledger_sync 1.3.2 → 1.4.1

data/ledger_sync.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('bundler', '~> 1.16')
   spec.add_development_dependency('byebug', '>= 0')
   spec.add_development_dependency('factory_bot')
-  spec.add_development_dependency('rake', '~> 10.0')
+  spec.add_development_dependency('rake', '~> 13.0')
   spec.add_development_dependency('rspec', '~> 3.2')
   spec.add_development_dependency('rubocop', '>= 0')
   spec.add_development_dependency('vcr', '>= 0')
@@ -50,7 +50,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency('netsuite')
   spec.add_runtime_dependency('nokogiri', '>= 0')
   spec.add_runtime_dependency('oauth2', '>= 0')
+  spec.add_runtime_dependency('pd_ruby', '>= 0')
   spec.add_runtime_dependency('resonad', '>= 0')
-  spec.add_runtime_dependency('simply_serializable', '>= 1.3.0')
+  spec.add_runtime_dependency('simply_serializable', '>= 1.5.1')
   spec.add_runtime_dependency('stripe')
 end

data/lib/ledger_sync.rb

@@ -14,6 +14,7 @@ require 'stripe'
 require 'netsuite'
 require 'oauth2'
 require 'tempfile'
+require 'pd_ruby'
 
 # Dotenv
 require 'dotenv'
@@ -34,32 +35,44 @@ Gem.find_files('ledger_sync/error/**/*.rb').each { |path| require path }
 
 # Support Classes
 require 'ledger_sync/util/resonad'
-require 'ledger_sync/util/debug'
+require 'ledger_sync/util/url_helpers'
 require 'ledger_sync/util/signer'
 require 'ledger_sync/util/hash_helpers'
+require 'ledger_sync/util/read_only_object'
 require 'ledger_sync/util/resources_builder'
-require 'ledger_sync/adaptor_configuration'
-require 'ledger_sync/adaptor_configuration_store'
+require 'ledger_sync/ledger_configuration'
+require 'ledger_sync/ledger_configuration_store'
 require 'ledger_sync/util/performer'
 require 'ledger_sync/util/validator'
 require 'ledger_sync/util/string_helpers'
+require 'ledger_sync/util/mixins/delegate_iterable_methods_mixin'
+require 'ledger_sync/util/mixins/resource_registerable_mixin'
+require 'ledger_sync/util/mixins/dupable_mixin'
 require 'ledger_sync/result'
-
-# Adaptors
-Gem.find_files('ledger_sync/adaptors/mixins/**/*.rb').each { |path| require path }
-require 'ledger_sync/adaptors/adaptor'
-require 'ledger_sync/adaptors/searcher'
-require 'ledger_sync/adaptors/ledger_serializer'
-require 'ledger_sync/adaptors/operation'
-require 'ledger_sync/adaptors/contract'
-require 'ledger_sync/adaptors/response'
-require 'ledger_sync/adaptors/request'
-
-# Resources (resources are registerd below)
+require 'ledger_sync/operation'
+require 'ledger_sync/resource_adaptor'
+
+Gem.find_files('ledger_sync/type/**/*.rb').each { |path| require path }
+Gem.find_files('ledger_sync/serialization/type/**/*.rb').each { |path| require path }
+require 'ledger_sync/serializer'
+require 'ledger_sync/deserializer'
+
+# Ledgers
+Gem.find_files('ledger_sync/ledgers/mixins/**/*.rb').each { |path| require path }
+require 'ledger_sync/ledgers/client'
+require 'ledger_sync/ledgers/dashboard_url_helper'
+require 'ledger_sync/ledgers/searcher'
+require 'ledger_sync/ledgers/operation'
+require 'ledger_sync/ledgers/contract'
+require 'ledger_sync/ledgers/response'
+require 'ledger_sync/ledgers/request'
+
+# Resources (resources are registered below)
 require 'ledger_sync/resource' # Template class
-Gem.find_files('ledger_sync/resources/**/*.rb').each { |path| require path }
 
 module LedgerSync
+  include Util::Mixins::ResourceRegisterableMixin
+
   @log_level = nil
   @logger = nil
 
@@ -69,7 +82,7 @@ module LedgerSync
   LEVEL_INFO = Logger::INFO
 
   class << self
-    attr_accessor :adaptors, :resources
+    attr_accessor :ledgers
   end
 
   def self.log_level
@@ -90,56 +103,31 @@ module LedgerSync
     @logger = val
   end
 
-  def self.register_adaptor(adaptor_key, module_string: nil)
-    adaptor_root_path = "ledger_sync/adaptors/#{adaptor_key}"
-    require "#{adaptor_root_path}/adaptor"
-    self.adaptors ||= LedgerSync::AdaptorConfigurationStore.new
-    adaptor_config = LedgerSync::AdaptorConfiguration.new(adaptor_key, module_string: module_string)
-    yield(adaptor_config)
-    self.adaptors.register_adaptor(adaptor_config: adaptor_config)
-
-    adaptor_files = Gem.find_files("#{adaptor_root_path}/**/*.rb")
+  def self.register_ledger(ledger_key, module_string: nil)
+    ledger_root_path = "ledger_sync/ledgers/#{ledger_key}"
+    require "#{ledger_root_path}/client"
+    self.ledgers ||= LedgerSync::LedgerConfigurationStore.new
+    ledger_config = LedgerSync::LedgerConfiguration.new(ledger_key, module_string: module_string)
+    yield(ledger_config)
+    self.ledgers.register_ledger(ledger_config: ledger_config)
+
+    client_files = Gem.find_files("#{ledger_root_path}/resource.rb")
+    client_files |= Gem.find_files("#{ledger_root_path}/resources/**/*.rb")
+    client_files |= Gem.find_files("#{ledger_root_path}/serialization/**/*.rb")
     # Sort the files to include BFS-style as most dependencies are in parent folders
-    adaptor_files.sort { |a, b| a.count('/') <=> b.count('/') }.each do |path|
+    client_files |= Gem.find_files("#{ledger_root_path}/**/*.rb").sort { |a, b| a.count('/') <=> b.count('/') }
+
+    client_files.each do |path|
       next if path.include?('config.rb')
 
       require path
     end
   end
 
-  def self.register_resource(resource:)
-    self.resources ||= {}
-    raise "Resource key #{resource.resource_type} already exists." if resources.key?(resource.resource_type)
-
-    self.resources[resource.resource_type] = resource
-  end
-
   def self.root
     File.dirname __dir__
   end
 end
 
-# Load Adaptors
-Gem.find_files('ledger_sync/adaptors/**/config.rb').each { |path| require path }
-
-# Register Resources
-LedgerSync.register_resource(resource: LedgerSync::Account)
-LedgerSync.register_resource(resource: LedgerSync::Bill)
-LedgerSync.register_resource(resource: LedgerSync::BillLineItem)
-LedgerSync.register_resource(resource: LedgerSync::Currency)
-LedgerSync.register_resource(resource: LedgerSync::Customer)
-LedgerSync.register_resource(resource: LedgerSync::Department)
-LedgerSync.register_resource(resource: LedgerSync::Deposit)
-LedgerSync.register_resource(resource: LedgerSync::DepositLineItem)
-LedgerSync.register_resource(resource: LedgerSync::Expense)
-LedgerSync.register_resource(resource: LedgerSync::ExpenseLineItem)
-LedgerSync.register_resource(resource: LedgerSync::Invoice)
-LedgerSync.register_resource(resource: LedgerSync::InvoiceSalesLineItem)
-LedgerSync.register_resource(resource: LedgerSync::Item)
-LedgerSync.register_resource(resource: LedgerSync::JournalEntry)
-LedgerSync.register_resource(resource: LedgerSync::JournalEntryLineItem)
-LedgerSync.register_resource(resource: LedgerSync::LedgerClass)
-LedgerSync.register_resource(resource: LedgerSync::Payment)
-LedgerSync.register_resource(resource: LedgerSync::PaymentLineItem)
-LedgerSync.register_resource(resource: LedgerSync::Transfer)
-LedgerSync.register_resource(resource: LedgerSync::Vendor)
+# Load Ledgers
+Gem.find_files('ledger_sync/ledgers/**/config.rb').each { |path| require path }

data/lib/ledger_sync/core_ext/resonad.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-require 'ledger_sync/util/debug'
 require 'simply_serializable'
 
 class Resonad
   include SimplySerializable::Mixin
 
   class Success < Resonad
-    serialize only: %i[value]
+    simply_serialize only: %i[value]
   end
 
   class Failure < Resonad
-    serialize only: %i[error]
+    simply_serialize only: %i[error]
   end
 end

data/lib/ledger_sync/deserializer.rb

@@ -0,0 +1,108 @@
+# 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
+
+    class Delegator
+      def deserialize(args = {})
+        deserializer_for(args).new.deserialize(args)
+      end
+
+      private
+
+      def deserializer_for(_args = {})
+        raise NotImplementedError
+      end
+    end
+
+    def attribute_value_from_ledger(hash:, deserializer_attribute:, resource:)
+      deserializer_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 |deserializer_attribute|
+        value = attribute_value_from_ledger(
+          hash: hash,
+          deserializer_attribute: deserializer_attribute,
+          resource: deserialize_into
+        )
+
+        deserialize_into.assign_attribute(
+          deserializer_attribute.resource_attribute_dot_parts.first,
+          value
+        )
+      end
+
+      deserialize_into
+    end
+
+    def self.attribute(resource_attribute, args = {}, &block)
+      if args.key?(:resource_attribute)
+        raise 'You cannot provide resource_attribute in args.  Pass the value as the first argument.'
+      end
+
+      _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
+
+    def self.references_one(resource_attribute, args = {}, &block)
+      attribute(
+        resource_attribute,
+        {
+          type: Serialization::Type::DeserializerReferencesOneType.new(
+            deserializer: deserializer_from(resource_attribute, args)
+          )
+        }.merge(args),
+        &block
+      )
+    end
+
+    def self.references_many(resource_attribute, args = {}, &block)
+      attribute(
+        resource_attribute,
+        {
+          type: Serialization::Type::DeserializerReferencesManyType.new(
+            deserializer: deserializer_from(resource_attribute, args)
+          )
+        }.merge(args),
+        &block
+      )
+    end
+
+    def self.deserializer_from(resource_attribute, args = {})
+      if args.key?(:deserializer)
+        args.fetch(:deserializer)
+      else
+        resource_key = inferred_resource_class.resource_attributes[resource_attribute].type.resource_class.resource_type
+        require "ledger_sync/ledgers/#{inferred_client_class.root_key}/#{resource_key}/deserializer"
+        inferred_client_class.resources[resource_key]::Deserializer
+      end
+    end
+  end
+end

data/lib/ledger_sync/error.rb

@@ -1,10 +1,58 @@
+# frozen_string_literal: true
+
 module LedgerSync
   class Error < StandardError
+    module HelpersMixin
+      module ClassMethods
+        def raise_if_unexpected_class(expected:, given:)
+          expected = [expected] unless expected.is_a?(Array)
+          expected = expected.map { |e| (e.is_a?(Class) ? e : e.class) }
+          given = given.class unless given.is_a?(Class)
+
+          return if expected.any? { |c| given <= c }
+
+          raise UnexpectedClassError.new(
+            expected: expected,
+            given: given
+          )
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+    end
+
     attr_reader :message
 
     def initialize(message:)
       @message = message
       super(message)
     end
+
+    class UnexpectedClassError < self
+      def initialize(expected:, given:)
+        expected = [expected] unless expected.is_a?(Array)
+
+        super(
+          message: "Unexpected class.  Given #{given.name}.  Expected: #{expected.map(&:name).join(', ')}"
+        )
+      end
+    end
+
+    module TypeError
+      class ValueClassError < UnexpectedClassError
+      end
+
+      class StringFromSetError < Error
+        def initialize(expected:, given:)
+          to_show = expected.first(10).join(', ')
+          to_show += ", ... (#{expected.count - 10} more possible values)" if expected.count > 10
+          super(
+            message: "Unexpected value. Given #{given}. Expected: #{to_show}"
+          )
+        end
+      end
+    end
   end
 end

data/lib/ledger_sync/error/ledger_errors.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class Error
+    class LedgerError < Error
+      attr_reader :client
+      attr_reader :response
+
+      def initialize(client:, message:, response: nil)
+        @client = client
+        @response = response
+        super(message: message)
+      end
+
+      class AuthenticationError < self; end
+      class AuthorizationError < self; end
+      class ConfigurationError < self; end
+
+      class MissingLedgerError < self
+        def initialize(message:)
+          super(
+            message: message,
+            client: nil,
+          )
+        end
+      end
+
+      class LedgerValidationError < self
+        attr_reader :attribute, :validation
+
+        def initialize(message:, client:, attribute:, validation:)
+          @attribute = attribute
+          @validation = validation
+          super(
+            message: message,
+            client: client,
+          )
+        end
+      end
+
+      class ThrottleError < self
+        attr_reader :rate_limiting_wait_in_seconds
+
+        def initialize(client:, message: nil, response: nil)
+          message ||= 'Your request has been throttled.'
+          @rate_limiting_wait_in_seconds = LedgerSync.ledgers.config_from_class(
+            client_class: client.class
+          ).rate_limiting_wait_in_seconds
+
+          super(
+            client: client,
+            message: message,
+            response: response
+          )
+        end
+      end
+
+      class UnknownURLFormat < self
+        attr_reader :resource
+
+        def initialize(*args, resource:, **keywords)
+          super(
+            *args,
+            {
+              message: "Unknown URL format for #{resource.class}"
+            }.merge(keywords)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/error/operation_errors.rb

@@ -15,16 +15,6 @@ module LedgerSync
       class DuplicateLedgerResourceError < self; end
       class NotFoundError < self; end
       class LedgerValidationError < self; end
-      class LedgerIDRequired < self
-        def initialize(**keywords)
-          super(
-            {
-              message: 'Resource ledger_id is required.'
-            }.merge(keywords)
-          )
-        end
-      end
-
       class PerformedOperationError < self
         def initialize(message: nil, operation:, response: nil)
           message ||= 'Operation has already been performed. Please check the result.'

data/lib/ledger_sync/error/resource_errors.rb

@@ -1,29 +1,58 @@
+# frozen_string_literal: true
+
 module LedgerSync
-  class ResourceError < Error
-    attr_reader :resource
+  class ResourceAttributeError < Error
+    class TypeError < self
+      attr_reader :attribute, :resource_class, :value
 
-    def initialize(message:, resource:)
-      @resource = resource
-      super(message: message)
-    end
-    class AttributeTypeError < self
-      attr_reader :attribute, :resource, :value
+      def initialize(args = {})
+        @attribute      = args.fetch(:attribute)
+        @resource_class = args.fetch(:resource_class)
+        @value          = args.fetch(:value)
 
-      def initialize(attribute:, resource:, value:)
-        @attribute = attribute
-        @resource = resource
-        @value = value
+        super(message: generate_message)
+      end
 
-        resource_class = resource.class
+      private
 
-        message = attribute.type.error_message(
-          attribute: attribute,
-          resource: resource,
-          value: value
-        )
+      def generate_message
+        ret = "Attribute #{attribute.name} for #{resource_class.name} should be "
 
-        super(message: message, resource: nil)
+        ret += case attribute
+               when LedgerSync::ResourceAttribute::Reference::Many
+                 invalid_classes = value.reject { |e| e.is_a?(type_resource_class) }.map(&:class)
+                 if type_resource_class.is_a?(Array)
+                   "an array of one or more of the following: #{type_resource_class.name}.  Given array containing: #{invalid_classes.join(', ')}"
+                 else
+                   "an array of #{type_resource_class.name}.  Given array containing: #{invalid_classes.join(', ')}"
+                 end
+               else
+                 if type_resource_class.is_a?(Array)
+                   "one of the following: #{type_resource_class.map(&:name).join(', ')}.  Given #{value.class.name}"
+                 else
+                   "a #{type_resource_class.name}.  Given #{value.class.name}"
+                 end
+               end
+
+        ret
       end
+
+      def type_resource_class
+        @type_resource_class ||= if attribute.is_a?(LedgerSync::ResourceAttribute::Reference)
+                                   attribute.type.resource_class
+                                 else
+                                   attribute.type.valid_classes
+                                 end
+    end
+    end
+  end
+
+  class ResourceError < Error
+    attr_reader :resource
+
+    def initialize(message:, resource:)
+      @resource = resource
+      super(message: message)
     end
 
     class ReferenceAssignmentError < self