ledger_sync 1.3.4 → 1.4.4

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/{adaptor_errors.rb → ledger_errors.rb}

@@ -2,12 +2,12 @@
 
 module LedgerSync
   class Error
-    class AdaptorError < Error
-      attr_reader :adaptor
+    class LedgerError < Error
+      attr_reader :client
       attr_reader :response
 
-      def initialize(adaptor:, message:, response: nil)
-        @adaptor = adaptor
+      def initialize(client:, message:, response: nil)
+        @client = client
         @response = response
         super(message: message)
       end
@@ -16,24 +16,24 @@ module LedgerSync
       class AuthorizationError < self; end
       class ConfigurationError < self; end
 
-      class MissingAdaptorError < self
+      class MissingLedgerError < self
         def initialize(message:)
           super(
             message: message,
-            adaptor: nil,
+            client: nil,
           )
         end
       end
 
-      class AdaptorValidationError < self
+      class LedgerValidationError < self
         attr_reader :attribute, :validation
 
-        def initialize(message:, adaptor:, attribute:, validation:)
+        def initialize(message:, client:, attribute:, validation:)
           @attribute = attribute
           @validation = validation
           super(
             message: message,
-            adaptor: adaptor,
+            client: client,
           )
         end
       end
@@ -41,14 +41,14 @@ module LedgerSync
       class ThrottleError < self
         attr_reader :rate_limiting_wait_in_seconds
 
-        def initialize(adaptor:, message: nil, response: nil)
+        def initialize(client:, 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.ledgers.config_from_class(
+            client_class: client.class
           ).rate_limiting_wait_in_seconds
 
           super(
-            adaptor: adaptor,
+            client: client,
             message: message,
             response: response
           )

data/lib/ledger_sync/error/operation_errors.rb

@@ -31,7 +31,7 @@ module LedgerSync
         attr_reader :attribute,
                     :validation
 
-        def initialize(message:, attribute:, operation:, validation:, response:nil)
+        def initialize(message:, attribute:, operation:, validation:, response: nil)
           @attribute = attribute
           @validation = validation
 

data/lib/ledger_sync/error/resource_errors.rb

@@ -1,29 +1,59 @@
+# 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

data/lib/ledger_sync/{adaptor_configuration.rb → ledger_configuration.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  class AdaptorConfiguration
+  class LedgerConfiguration
     include Fingerprintable::Mixin
     include SimplySerializable::Mixin
 
@@ -13,7 +13,7 @@ module LedgerSync
     attr_reader :aliases,
                 :root_key
 
-    serialize only: %i[
+    simply_serialize only: %i[
       aliases
       module_string
       root_key
@@ -27,31 +27,31 @@ module LedgerSync
       @module_string = module_string || LedgerSync::Util::StringHelpers.camelcase(root_key)
     end
 
-    def adaptor_klass
-      @adaptor_klass ||= base_module::Adaptor
+    def client_class
+      @client_class ||= base_module::Client
     end
 
     def add_alias(new_alias)
       @aliases << new_alias
-      LedgerSync.adaptors.add_alias(new_alias, self)
+      LedgerSync.ledgers.add_alias(new_alias, self)
     end
 
     def base_module
       @base_module ||= begin
-        LedgerSync::Adaptors.const_get(@module_string)
+        LedgerSync::Ledgers.const_get(@module_string)
       end
     end
 
-    # Delegate #new to the adaptor class enabling faster adaptor initialization
-    # e.g. LedgerSync.adaptors.test.new(...)
+    # Delegate #new to the client class enabling faster client initialization
+    # e.g. LedgerSync.ledgers.test.new(...)
     def new(*args)
-      adaptor_klass.new(*args)
+      client_class.new(*args)
     end
 
-    # Delegate #new_from_env to the adaptor class enabling faster adaptor initialization
-    # e.g. LedgerSync.adaptors.test.new_from_env(...)
+    # 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)
-      adaptor_klass.new_from_env(*args)
+      client_class.new_from_env(*args)
     end
 
     def test?

data/lib/ledger_sync/ledger_configuration_store.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class LedgerConfigurationStore
+    include Enumerable
+
+    attr_reader :configs, :inflections
+
+    def initialize
+      @keys = []
+      @configs = {}
+      @inflections = []
+      @class_configs = {}
+    end
+
+    def add_alias(client_key, existing_config)
+      if respond_to?(client_key)
+        if send(client_key) != existing_config
+          raise LedgerSync::ConfigurationError, "Alias already taken: #{client_key}"
+        end
+
+        return
+      end
+
+      _instance_methods_for(client_key: client_key, ledger_config: existing_config)
+    end
+
+    def config_from_class(client_class:)
+      @class_configs.fetch(client_class)
+    end
+
+    def each
+      configs.each { |k, v| yield(k, v) }
+    end
+
+    def register_ledger(ledger_config:)
+      _instance_methods_for(
+        client_key: ledger_config.root_key,
+        ledger_config: ledger_config
+      )
+    end
+
+    private
+
+    def _instance_methods_for(client_key:, ledger_config:)
+      @keys << client_key.to_sym
+
+      @configs[client_key] = ledger_config
+      @class_configs[ledger_config.client_class] = ledger_config
+
+      instance_variable_set(
+        "@#{client_key}",
+        ledger_config
+      )
+
+      @inflections |= [ledger_config.module_string]
+      self.class.class_eval { attr_reader client_key }
+    end
+  end
+end

data/lib/ledger_sync/{adaptors/adaptor.rb → ledgers/client.rb}

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  module Adaptors
-    class Adaptor
+  module Ledgers
+    class Client
       include Fingerprintable::Mixin
       include SimplySerializable::Mixin
       include Validatable
+      include Util::Mixins::ResourceRegisterableMixin
 
-      serialize only: %i[
-        adaptor_configuration
+      simply_serialize only: %i[
+        ledger_configuration
       ]
 
       def initialize(*)
         raise NotImplementedError
       end
 
-      def adaptor_configuration
+      def ledger_configuration
         self.class.config
       end
 
@@ -31,24 +32,25 @@ module LedgerSync
         end]
       end
 
-      def operation_for(method:, resource:)
+      def operation_for(args = {})
+        method = args.fetch(:method)
+        resource = args.fetch(:resource)
+
         self.class.operation_class_for(
           method: method,
           resource_class: resource.class
         ).new(
-          adaptor: self,
+          client: self,
           resource: resource
         )
       end
 
-      def searcher_for?(resource_type:)
-        searcher_klass_for(resource_type: resource_type)
-      rescue NameError
-        false
+      def searcher_for(*args)
+        self.class.searcher_for(*args)
       end
 
-      def searcher_klass_for(resource_type:)
-        base_module.const_get(LedgerSync::Util::StringHelpers.camelcase(resource_type.to_s))::Searcher
+      def searcher_class_for(*args)
+        self.class.searcher_class_for(*args)
       end
 
       def url_for(*_args)
@@ -68,10 +70,10 @@ module LedgerSync
       end
 
       def self.config
-        @config ||= LedgerSync.adaptors.config_from_klass(klass: self)
+        @config ||= LedgerSync.ledgers.config_from_class(client_class: self)
       end
 
-      # These are attributes that must always be saved after the adaptor is called.
+      # These are attributes that must always be saved after the client is called.
       # For example, the library will handle refreshing tokens that will need
       # to be saved back to the application layer for future use.
       def self.ledger_attributes_to_save
@@ -92,8 +94,24 @@ module LedgerSync
       end
 
       def self.resource_from_ledger_type(type:, converter: nil)
-        converter ||= Proc.new { |n| n.underscore }
-        ledger_resource_type_overrides.invert[converter.call(type).to_sym] || LedgerSync.resources[converter.call(type).to_sym]
+        converter ||= proc { |n| n.underscore }
+        ledger_resource_type_overrides.invert[converter.call(type).to_sym] || resources[converter.call(type).to_sym]
+      end
+
+      def self.resources
+        @resources ||= {}
+      end
+
+      def self.root_key
+        @root_key ||= config.root_key
+      end
+
+      def self.searcher_for(resource_type:, query: '')
+        searcher_class_for(resource_type: resource_type).new(client: self, query: query)
+      end
+
+      def self.searcher_class_for(resource_type:)
+        base_module.const_get(LedgerSync::Util::StringHelpers.camelcase(resource_type.to_s))::Searcher
       end
 
       def self.url_for(resource: nil); end

data/lib/ledger_sync/{adaptors → ledgers}/contract.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  module Adaptors
+  module Ledgers
     class Contract < Dry::Validation::Contract
       module Types
         include Dry::Types()

data/lib/ledger_sync/ledgers/dashboard_url_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    class DashboardURLHelper
+      attr_reader :resource,
+                  :base_url
+
+      def initialize(args = {})
+        @resource = args.fetch(:resource)
+        @base_url = args.fetch(:base_url)
+      end
+
+      def url
+        File.join(base_url, resource_path)
+      end
+
+      def resource_path
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/infer_client_mixin.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module InferClientMixin
+        module ClassMethods
+          def inferred_client_class
+            @inferred_client_class ||= begin
+              return if name.nil?
+
+              parts = name.split('::')
+              return unless parts.include?('Ledgers')
+
+              LedgerSync::Ledgers.const_get(
+                parts[parts.index('Ledgers') + 1]
+              )::Client
+            end
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end