ledger_sync 1.3.5 → 1.4.0

data/ledger_sync.gemspec

@@ -52,6 +52,6 @@ Gem::Specification.new do |spec|
   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

@@ -35,41 +35,44 @@ Gem.find_files('ledger_sync/error/**/*.rb').each { |path| require path }
 
 # Support Classes
 require 'ledger_sync/util/resonad'
+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'
+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'
-require 'ledger_sync/serialization/deserializer_delegator'
-require 'ledger_sync/serialization/serializer_delegator'
-
-# Adaptors
-Gem.find_files('ledger_sync/adaptors/mixins/**/*.rb').each { |path| require path }
-require 'ledger_sync/adaptors/adaptor'
-require 'ledger_sync/adaptors/dashboard_url_helper'
-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/resource' # Template class
-Gem.find_files('ledger_sync/resources/**/*.rb').each { |path| require path }
 
-Gem.find_files('ledger_sync/adaptors/quickbooks_online/resources/**/*.rb').each { |path| require path }
+# 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
 
 module LedgerSync
+  include Util::Mixins::ResourceRegisterableMixin
+
   @log_level = nil
   @logger = nil
 
@@ -79,7 +82,7 @@ module LedgerSync
   LEVEL_INFO = Logger::INFO
 
   class << self
-    attr_accessor :adaptors, :resources
+    attr_accessor :ledgers
   end
 
   def self.log_level
@@ -100,59 +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)
-LedgerSync.register_resource(resource: LedgerSync::Location)
-
-LedgerSync.register_resource(resource: LedgerSync::Adaptors::QuickBooksOnline::Preferences)
+# Load Ledgers
+Gem.find_files('ledger_sync/ledgers/**/config.rb').each { |path| require path }

data/lib/ledger_sync/core_ext/resonad.rb

@@ -6,10 +6,10 @@ 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

@@ -8,8 +8,20 @@ module LedgerSync
   class Deserializer
     include Serialization::Mixin
 
-    def attribute_value_from_ledger(hash:, ledger_serializer_attribute:, resource:)
-      ledger_serializer_attribute.value_from_hash(
+    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
       )
@@ -22,15 +34,15 @@ module LedgerSync
       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|
+      self.class.attributes.each_value do |deserializer_attribute|
         value = attribute_value_from_ledger(
           hash: hash,
-          ledger_serializer_attribute: ledger_serializer_attribute,
+          deserializer_attribute: deserializer_attribute,
           resource: deserialize_into
         )
 
         deserialize_into.assign_attribute(
-          ledger_serializer_attribute.resource_attribute_dot_parts.first,
+          deserializer_attribute.resource_attribute_dot_parts.first,
           value
         )
       end
@@ -39,6 +51,10 @@ module LedgerSync
     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?),
@@ -54,6 +70,39 @@ module LedgerSync
     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

@@ -39,5 +39,20 @@ module LedgerSync
         )
       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/resource_errors.rb

@@ -6,14 +6,44 @@ module LedgerSync
       attr_reader :attribute, :resource_class, :value
 
       def initialize(args = {})
-        @attribute = args.fetch(:attribute)
+        @attribute      = args.fetch(:attribute)
         @resource_class = args.fetch(:resource_class)
-        @value = args.fetch(:value)
+        @value          = args.fetch(:value)
 
-        message = attribute.type.error_message(args)
+        super(message: generate_message)
+      end
+
+      private
+
+      def generate_message
+        ret = "Attribute #{attribute.name} for #{resource_class.name} should be "
 
-        super(message: message)
+        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
 

data/lib/ledger_sync/ledger_configuration.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class LedgerConfiguration
+    include Fingerprintable::Mixin
+    include SimplySerializable::Mixin
+
+    attr_accessor :module_string,
+                  :name,
+                  :rate_limiting_wait_in_seconds,
+                  :test
+
+    attr_reader :aliases,
+                :root_key
+
+    simply_serialize only: %i[
+      aliases
+      module_string
+      root_key
+      rate_limiting_wait_in_seconds
+      test
+    ]
+
+    def initialize(root_key, module_string: nil)
+      @root_key = root_key
+      @aliases = []
+      @module_string = module_string || LedgerSync::Util::StringHelpers.camelcase(root_key)
+    end
+
+    def client_class
+      @client_class ||= base_module::Client
+    end
+
+    def add_alias(new_alias)
+      @aliases << new_alias
+      LedgerSync.ledgers.add_alias(new_alias, self)
+    end
+
+    def base_module
+      @base_module ||= begin
+        LedgerSync::Ledgers.const_get(@module_string)
+      end
+    end
+
+    # Delegate #new to the client class enabling faster client initialization
+    # e.g. LedgerSync.ledgers.test.new(...)
+    def new(*args)
+      client_class.new(*args)
+    end
+
+    # Delegate #new_from_env to the client class enabling faster client initialization
+    # e.g. LedgerSync.ledgers.test.new_from_env(...)
+    def new_from_env(*args)
+      client_class.new_from_env(*args)
+    end
+
+    def test?
+      test == true
+    end
+  end
+end