ledger_sync 1.4.4 → 1.5.0

data/documentation/site/guides/contribute/index.md

@@ -15,4 +15,8 @@ Everyone interacting in the LedgerSync project’s codebases, issue trackers, ch
 
 After checking out the repo, run `bin/setup` to install dependencies.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org)
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org)
+
+## Development
+
+The LedgerSync repo follow [the git flow pattern](https://nvie.com/posts/a-successful-git-branching-model/).  You can find [a great cheat sheet here](http://danielkummer.github.io/git-flow-cheatsheet/).  Please be sure to follow the naming convention and read our guide to deployment if you are pushing new versions of the gem.

data/ledger_sync.gemspec

@@ -6,7 +6,9 @@ require 'ledger_sync/version'
 
 Gem::Specification.new do |spec|
   spec.name = 'ledger_sync'
-  spec.version = LedgerSync::VERSION
+  spec.version = LedgerSync.version
+
+  spec.required_ruby_version = '>= 2.5.8'
 
   # spec.required_rubygems_version = Gem::Requirement.new('>= 0') if spec.respond_to? :required_rubygems_version=
   spec.authors = ['Ryan Jackson']
@@ -29,15 +31,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency('awesome_print', '>= 0')
-  spec.add_development_dependency('bump')
-  spec.add_development_dependency('bundler', '~> 1.16')
+  spec.add_development_dependency('bump', '~> 0.9.0')
+  spec.add_development_dependency('bundler', '~> 2.1')
   spec.add_development_dependency('byebug', '>= 0')
-  spec.add_development_dependency('factory_bot')
+  spec.add_development_dependency('factory_bot', '~> 6.1.0')
   spec.add_development_dependency('jekyll', '~> 3.8.4')
   spec.add_development_dependency('jekyll-menus', '~> 0.6.0')
   spec.add_development_dependency('jekyll-paginate', '~> 1.1')
   spec.add_development_dependency('jekyll-paginate-v2', '~> 1.9')
-  spec.add_development_dependency('overcommit')
+  spec.add_development_dependency('overcommit', '~> 0.57.0')
   spec.add_development_dependency('rake', '~> 13.0')
   spec.add_development_dependency('rspec', '~> 3.2')
   spec.add_development_dependency('rubocop', '>= 0')
@@ -45,19 +47,19 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('webmock', '>= 0')
   spec.add_runtime_dependency('activemodel', '>= 0')
   spec.add_runtime_dependency('colorize', '>= 0')
-  spec.add_runtime_dependency('coveralls')
-  spec.add_runtime_dependency('dotenv')
-  spec.add_runtime_dependency('dry-schema')
-  spec.add_runtime_dependency('dry-validation')
+  spec.add_runtime_dependency('coveralls', '~> 0.8.23')
+  spec.add_runtime_dependency('dotenv', '~> 2.7.6')
+  spec.add_runtime_dependency('dry-schema', '~> 1.5.4')
+  spec.add_runtime_dependency('dry-validation', '~> 1.5.6')
   spec.add_runtime_dependency('faraday', '>= 0')
   spec.add_runtime_dependency('faraday-detailed_logger', '>= 0')
   spec.add_runtime_dependency('faraday_middleware', '>= 0')
   spec.add_runtime_dependency('fingerprintable', '>= 1.2.1')
-  spec.add_runtime_dependency('netsuite')
+  spec.add_runtime_dependency('netsuite', '~> 0.8.6')
   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.5.1')
-  spec.add_runtime_dependency('stripe')
+  spec.add_runtime_dependency('stripe', '~> 5.26.0')
 end

data/lib/ledger_sync.rb

@@ -81,8 +81,14 @@ module LedgerSync
   LEVEL_ERROR = Logger::ERROR
   LEVEL_INFO = Logger::INFO
 
-  class << self
-    attr_accessor :ledgers
+  module Test
+    def require_spec_helper
+      require File.join(LedgerSync.root, 'lib/test/support/spec_helper')
+    end
+  end
+
+  def self.ledgers
+    @ledgers ||= LedgerSync::LedgerConfigurationStore.new
   end
 
   def self.log_level
@@ -105,19 +111,18 @@ module LedgerSync
     @logger = val
   end
 
-  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)
+  def self.register_ledger(*args)
+    ledger_config = LedgerSync::LedgerConfiguration.new(*args)
+
     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")
+    ledgers.register_ledger(ledger_config: ledger_config)
+
+    client_files = Gem.find_files("#{ledger_config.root_path}/resource.rb")
+    client_files |= Gem.find_files("#{ledger_config.root_path}/resources/**/*.rb")
+    client_files |= Gem.find_files("#{ledger_config.root_path}/serialization/**/*.rb")
     # Sort the files to include BFS-style as most dependencies are in parent folders
-    client_files |= Gem.find_files("#{ledger_root_path}/**/*.rb").sort { |a, b| a.count('/') <=> b.count('/') }
+    client_files |= Gem.find_files("#{ledger_config.root_path}/**/*.rb").sort { |a, b| a.count('/') <=> b.count('/') }
 
     client_files.each do |path|
       next if path.include?('config.rb')

data/lib/ledger_sync/deserializer.rb

@@ -100,8 +100,8 @@ module LedgerSync
         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
+        require "#{inferred_config.root_path}/#{resource_key}/deserializer"
+        inferred_config.client_class.resources[resource_key]::Deserializer
       end
     end
   end

data/lib/ledger_sync/error.rb

@@ -5,7 +5,7 @@ module LedgerSync
     module HelpersMixin
       module ClassMethods
         def raise_if_unexpected_class(expected:, given:)
-          expected = [expected] unless expected.is_a?(Array)
+          expected = Array(expected)
           expected = expected.map { |e| (e.is_a?(Class) ? e : e.class) }
           given = given.class unless given.is_a?(Class)
 
@@ -32,7 +32,7 @@ module LedgerSync
 
     class UnexpectedClassError < self
       def initialize(expected:, given:)
-        expected = [expected] unless expected.is_a?(Array)
+        expected = Array(expected)
 
         super(
           message: "Unexpected class.  Given #{given.name}.  Expected: #{expected.map(&:name).join(', ')}"

data/lib/ledger_sync/error/ledger_errors.rb

@@ -3,8 +3,7 @@
 module LedgerSync
   class Error
     class LedgerError < Error
-      attr_reader :client
-      attr_reader :response
+      attr_reader :client, :response
 
       def initialize(client:, message:, response: nil)
         @client = client

data/lib/ledger_sync/error/operation_errors.rb

@@ -5,7 +5,7 @@ module LedgerSync
     class OperationError < Error
       attr_reader :operation, :response
 
-      def initialize(message: nil, operation:, response: nil)
+      def initialize(operation:, message: nil, response: nil)
         message ||= 'Operation failed.'
         @operation = operation
         @response = response
@@ -16,7 +16,7 @@ module LedgerSync
       class NotFoundError < self; end
       class LedgerValidationError < self; end
       class PerformedOperationError < self
-        def initialize(message: nil, operation:, response: nil)
+        def initialize(operation:, message: nil, response: nil)
           message ||= 'Operation has already been performed. Please check the result.'
 
           super(

data/lib/ledger_sync/error/resource_errors.rb

@@ -15,7 +15,7 @@ module LedgerSync
 
       private
 
-      def generate_message
+      def generate_message # rubocop:disable Metrics/PerceivedComplexity
         ret = "Attribute #{attribute.name} for #{resource_class.name} should be "
 
         ret += case attribute

data/lib/ledger_sync/ledger_configuration.rb

@@ -5,43 +5,47 @@ module LedgerSync
     include Fingerprintable::Mixin
     include SimplySerializable::Mixin
 
-    attr_accessor :module_string,
-                  :name,
+    attr_accessor :name,
                   :rate_limiting_wait_in_seconds,
                   :test
 
     attr_reader :aliases,
-                :root_key
+                :base_module,
+                :root_key,
+                :root_path
 
     simply_serialize only: %i[
       aliases
-      module_string
+      base_module
       root_key
       rate_limiting_wait_in_seconds
       test
     ]
 
-    def initialize(root_key, module_string: nil)
+    def initialize(root_key, args = {})
       @root_key = root_key
       @aliases = []
-      @module_string = module_string || LedgerSync::Util::StringHelpers.camelcase(root_key)
+      @root_path = args.fetch(:root_path, "ledger_sync/ledgers/#{root_key}")
+
+      require client_path
+
+      @base_module = args.fetch(:base_module, nil)
+      @base_module ||= LedgerSync::Ledgers.const_get(LedgerSync::Util::StringHelpers.camelcase(root_key))
     end
 
     def client_class
       @client_class ||= base_module::Client
     end
 
+    def client_path
+      @client_path ||= File.join(root_path, '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)

data/lib/ledger_sync/ledger_configuration_store.rb

@@ -4,10 +4,11 @@ module LedgerSync
   class LedgerConfigurationStore
     include Enumerable
 
-    attr_reader :configs, :inflections
+    attr_reader :configs, :inflections, :base_module_to_config_mapping
 
     def initialize
       @keys = []
+      @base_module_to_config_mapping = {}
       @configs = {}
       @inflections = []
       @class_configs = {}
@@ -15,9 +16,7 @@ module LedgerSync
 
     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
+        raise "Alias already taken: #{client_key}" if send(client_key) != existing_config
 
         return
       end
@@ -29,11 +28,21 @@ module LedgerSync
       @class_configs.fetch(client_class)
     end
 
-    def each
-      configs.each { |k, v| yield(k, v) }
+    def config_from_base_module(base_module:)
+      @base_module_to_config_mapping.fetch(base_module, nil)
+    end
+
+    def each(&block)
+      configs.each(&block)
+    end
+
+    def find(&block)
+      configs.values.find(&block)
     end
 
     def register_ledger(ledger_config:)
+      @base_module_to_config_mapping[ledger_config.base_module] = ledger_config
+
       _instance_methods_for(
         client_key: ledger_config.root_key,
         ledger_config: ledger_config
@@ -53,7 +62,7 @@ module LedgerSync
         ledger_config
       )
 
-      @inflections |= [ledger_config.module_string]
+      @inflections |= ledger_config.base_module.name.split('::')
       self.class.class_eval { attr_reader client_key }
     end
   end

data/lib/ledger_sync/ledgers/client.rb

@@ -2,119 +2,134 @@
 
 module LedgerSync
   module Ledgers
-    class Client
-      include Fingerprintable::Mixin
-      include SimplySerializable::Mixin
-      include Validatable
-      include Util::Mixins::ResourceRegisterableMixin
-
-      simply_serialize only: %i[
-        ledger_configuration
-      ]
-
-      def initialize(*)
-        raise NotImplementedError
-      end
-
-      def ledger_configuration
-        self.class.config
-      end
-
-      def base_module
-        self.class.base_module
-      end
-
-      def ledger_attributes_to_save
-        return {} if self.class.ledger_attributes_to_save.nil?
-
-        Hash[self.class.ledger_attributes_to_save.map do |attribute|
-          [attribute, send(attribute)]
-        end]
-      end
-
-      def operation_for(args = {})
-        method = args.fetch(:method)
-        resource = args.fetch(:resource)
-
-        self.class.operation_class_for(
-          method: method,
-          resource_class: resource.class
-        ).new(
-          client: self,
-          resource: resource
-        )
-      end
-
-      def searcher_for(*args)
-        self.class.searcher_for(*args)
-      end
-
-      def searcher_class_for(*args)
-        self.class.searcher_class_for(*args)
-      end
-
-      def url_for(*_args)
-        raise NotImplementedError
-      end
-
-      def parse_operation_error(*)
-        nil
-      end
-
-      def self.base_module
-        config.base_module
-      end
-
-      def self.base_operation_module_for(resource_class:)
-        base_module.const_get("#{resource_class.resource_module_str}::Operations")
-      end
-
-      def self.config
-        @config ||= LedgerSync.ledgers.config_from_class(client_class: self)
-      end
-
-      # 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
-        raise NotImplementedError
-      end
-
-      def self.ledger_resource_type_for(resource_class:)
-        ledger_resource_type_overrides[resource_class] || resource_class.resource_type.to_s
-      end
-
-      def self.ledger_resource_type_overrides
-        {}
+    module Client
+      module SharedClassMethods
+        def base_operations_module_for(resource_class:)
+          resource_class::Operations
+        end
+      end
+
+      extend SharedClassMethods
+
+      module Mixin
+        module InstanceMethods
+          def ledger_configuration
+            self.class.config
+          end
+
+          def base_module
+            self.class.base_module
+          end
+
+          def ledger_attributes_to_save
+            return {} if self.class.ledger_attributes_to_save.nil?
+
+            Hash[self.class.ledger_attributes_to_save.map do |attribute|
+              [attribute, send(attribute)]
+            end]
+          end
+
+          def operation_for(args = {})
+            method = args.fetch(:method)
+            resource = args.fetch(:resource)
+
+            self.class.operation_class_for(
+              method: method,
+              resource_class: resource.class
+            ).new(
+              client: self,
+              resource: resource
+            )
+          end
+
+          def searcher_for(*args)
+            self.class.searcher_for(*args)
+          end
+
+          def searcher_class_for(*args)
+            self.class.searcher_class_for(*args)
+          end
+
+          def url_for(*_args)
+            raise NotImplementedError
+          end
+
+          def parse_operation_error(*)
+            nil
+          end
+        end
+
+        module ClassMethods
+          def base_module
+            config.base_module
+          end
+
+          def config
+            @config ||= LedgerSync.ledgers.config_from_class(client_class: self)
+          end
+
+          # 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 ledger_attributes_to_save
+            raise NotImplementedError
+          end
+
+          def ledger_resource_type_for(resource_class:)
+            ledger_resource_type_overrides[resource_class] || resource_class.resource_type.to_s
+          end
+
+          def ledger_resource_type_overrides
+            {}
+          end
+
+          def operation_class_for(*args)
+            Client.operation_class_for(*args)
+          end
+
+          def resource_from_ledger_type(type:, converter: nil)
+            converter ||= proc { |n| n.underscore }
+            ledger_resource_type_overrides.invert[converter.call(type).to_sym] || resources[converter.call(type).to_sym]
+          end
+
+          def resources
+            @resources ||= {}
+          end
+
+          def root_key
+            @root_key ||= config.root_key
+          end
+
+          def searcher_for(resource_type:, query: '')
+            searcher_class_for(resource_type: resource_type).new(client: self, query: query)
+          end
+
+          def searcher_class_for(resource_type:)
+            base_module.const_get(LedgerSync::Util::StringHelpers.camelcase(resource_type.to_s))::Searcher
+          end
+
+          def url_for(resource: nil); end
+        end
+
+        def self.included(base)
+          base.include Fingerprintable::Mixin
+          base.include SimplySerializable::Mixin
+          base.include Validatable
+          base.include Util::Mixins::ResourceRegisterableMixin
+          base.extend SharedClassMethods
+          base.extend ClassMethods
+          base.include InstanceMethods
+
+          base.simply_serialize only: %i[
+            ledger_configuration
+          ]
+        end
       end
 
       def self.operation_class_for(method:, resource_class:)
-        base_operation_module_for(resource_class: resource_class)
+        base_operations_module_for(resource_class: resource_class)
           .const_get(LedgerSync::Util::StringHelpers.camelcase(method.to_s))
       end
-
-      def self.resource_from_ledger_type(type:, converter: nil)
-        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
     end
   end
 end