ledger_sync 0.1.0 → 1.0.0

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "ledger_sync"
+require 'bundler/setup'
+require 'ledger_sync'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "ledger_sync"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/docker-compose.yml

@@ -0,0 +1,4 @@
+version: '2'
+services:
+  lib:
+    build: .

data/ledger_sync.gemspec

@@ -5,15 +5,18 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'ledger_sync/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'ledger_sync'
-  spec.version       = LedgerSync::VERSION
-  spec.authors       = ['Ryan Jackson']
-  spec.email         = ['ryanwjackson@gmail.com']
+  spec.name = 'ledger_sync'
+  spec.version = LedgerSync::VERSION
 
-  spec.summary        = 'Sync resources to accounting software.'
-  spec.description    = 'Ledger Sync is a simple library that allows you to sync resources to popular accounting software like QuickBooks Online, Xero, NetSuite, etc.'
-  spec.homepage       = 'https://github.com/Modern-Treasury/ledger_sync'
-  spec.license        = 'MIT'
+  # spec.required_rubygems_version = Gem::Requirement.new('>= 0') if spec.respond_to? :required_rubygems_version=
+  spec.authors = ['Ryan Jackson']
+  spec.date = '2019-05-21'
+  spec.description = 'LedgerSync is a simple library that allows you to sync common objects to popular accounting software like QuickBooks Online, Xero, NetSuite, etc.'
+  spec.email = ['ryanwjackson@gmail.com']
+  spec.homepage = 'https://github.com/LedgerSync/ledger_sync'
+  spec.licenses = ['MIT']
+  spec.rubygems_version = '3.0.3'
+  spec.summary = 'Sync common objects to accounting software.'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -24,7 +27,25 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency('awesome_print', '>= 0')
+  spec.add_development_dependency('bump')
+  spec.add_development_dependency('bundler', '~> 1.16')
+  spec.add_development_dependency('byebug', '>= 0')
+  spec.add_development_dependency('rake', '~> 10.0')
+  spec.add_development_dependency('rspec', '~> 3.2')
+  spec.add_development_dependency('rubocop', '>= 0')
+  spec.add_development_dependency('vcr', '>= 0')
+  spec.add_development_dependency('webmock', '>= 0')
+  spec.add_runtime_dependency('colorize', '>= 0')
+  spec.add_runtime_dependency('coveralls')
+  spec.add_runtime_dependency('dry-schema')
+  spec.add_runtime_dependency('dry-validation')
+  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('nokogiri', '>= 0')
+  spec.add_runtime_dependency('oauth2', '>= 0')
+  spec.add_runtime_dependency('resonad', '>= 0')
+  spec.add_runtime_dependency('simply_serializable', '>= 1.3.0')
 end

data/lib/ledger_sync.rb

@@ -1,6 +1,118 @@
-require "ledger_sync/version"
+# frozen_string_literal: true
+
+require 'json'
+require 'dry-schema'
+require 'dry-validation'
+require 'logger'
+require 'resonad'
+require 'uri'
+require 'colorize'
+require 'fingerprintable'
+require 'simply_serializable'
+
+# Version
+require 'ledger_sync/version'
+
+# Concerns
+require 'ledger_sync/concerns/validatable'
+
+# Extensions
+require 'ledger_sync/core_ext/resonad'
+
+# Errors
+require 'ledger_sync/error'
+require 'ledger_sync/error/adaptor_errors'
+require 'ledger_sync/error/operation_errors'
+require 'ledger_sync/error/resource_errors'
+
+# Support Classes
+require 'ledger_sync/util/debug'
+require 'ledger_sync/util/hash_helpers'
+require 'ledger_sync/util/resources_builder'
+require 'ledger_sync/adaptor_configuration'
+require 'ledger_sync/adaptor_configuration_store'
+require 'ledger_sync/util/coordinator'
+require 'ledger_sync/util/performer'
+require 'ledger_sync/util/validator'
+require 'ledger_sync/util/string_helpers'
+require 'ledger_sync/result'
+require 'ledger_sync/adaptors/operation'
+require 'ledger_sync/adaptors/contract'
+
+# Resources (resources are registerd below)
+require 'ledger_sync/resource' # Template class
+require 'ledger_sync/resources/customer'
+require 'ledger_sync/resources/vendor'
+require 'ledger_sync/resources/invoice'
+require 'ledger_sync/resources/payment'
+require 'ledger_sync/resources/product'
+
+# Synchronizer
+require 'ledger_sync/sync'
 
 module LedgerSync
-  class Error < StandardError; end
-  # Your code goes here...
+  @log_level = nil
+  @logger = nil
+
+  # map to the same values as the standard library's logger
+  LEVEL_DEBUG = Logger::DEBUG
+  LEVEL_ERROR = Logger::ERROR
+  LEVEL_INFO = Logger::INFO
+
+  class << self
+    attr_accessor :adaptors, :resources
+  end
+
+  def self.log_level
+    @log_level
+  end
+
+  def self.log_level=(val)
+    raise ArgumentError, 'log_level should only be set to `nil`, `debug` or `info`' if !val.nil? && ![LEVEL_DEBUG, LEVEL_ERROR, LEVEL_INFO].include?(val)
+
+    @log_level = val
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
+
+  def self.register_adaptor(adaptor_key)
+    self.adaptors ||= LedgerSync::AdaptorConfigurationStore.new
+    self.adaptors.register_adaptor(adaptor_key)
+    yield(adaptors.send(adaptor_key))
+  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
+
+# Adaptors
+require 'ledger_sync/adaptors/adaptor'
+require 'ledger_sync/adaptors/searcher'
+Gem.find_files('ledger_sync/adaptors/**/*.rb').each do |path|
+  next if path.include?('config.rb')
+
+  require path
 end
+
+Gem.find_files('ledger_sync/adaptors/**/config.rb').each { |path| require path }
+
+# Register Resources
+LedgerSync.register_resource(resource: LedgerSync::Customer)
+LedgerSync.register_resource(resource: LedgerSync::Vendor)
+LedgerSync.register_resource(resource: LedgerSync::Invoice)
+LedgerSync.register_resource(resource: LedgerSync::Payment)
+LedgerSync.register_resource(resource: LedgerSync::Product)

data/lib/ledger_sync/adaptor_configuration.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class AdaptorConfiguration
+    include Fingerprintable::Mixin
+    include SimplySerializable::Mixin
+
+    attr_accessor :module,
+                  :name,
+                  :rate_limiting_wait_in_seconds,
+                  :test
+
+    attr_reader :aliases,
+                :root_key
+
+    serialize only: %i[
+      aliases
+      module
+      root_key
+      rate_limiting_wait_in_seconds
+      test
+    ]
+
+    def initialize(root_key)
+      @root_key = root_key
+      @aliases = []
+      @module = LedgerSync::Util::StringHelpers.camelcase(root_key)
+    end
+
+    def adaptor_klass
+      @adaptor_klass ||= base_module::Adaptor
+    end
+
+    def base_module
+      @base_module ||= begin
+        LedgerSync::Adaptors.const_get(@module)
+      end
+    end
+
+    def add_alias(new_alias)
+      @aliases << new_alias
+      LedgerSync.adaptors.add_alias(new_alias, self)
+    end
+
+    # Delegate new to the adaptor class enabling faster adaptor initialization
+    # e.g. LedgerSync.adaptors.test.new(...)
+    def new(*args)
+      adaptor_klass.new(*args)
+    end
+
+    def test?
+      test == true
+    end
+  end
+end

data/lib/ledger_sync/adaptor_configuration_store.rb

@@ -0,0 +1,52 @@
+module LedgerSync
+  class AdaptorConfigurationStore
+    include Enumerable
+
+    attr_reader :configs
+
+    def initialize
+      @keys = []
+      @configs = {}
+      @klass_configs = {}
+    end
+
+    def add_alias(adaptor_key, existing_config)
+      if respond_to?(adaptor_key)
+        raise LedgerSync::ConfigurationError, "Alias already taken: #{adaptor_key}" if send(adaptor_key) != existing_config
+
+        return
+      end
+
+      instance_methods_for(adaptor_key, existing_config)
+    end
+
+    def config_from_klass(klass:)
+      @klass_configs.fetch(klass)
+    end
+
+    def each
+      configs.each { |k, v| yield(k, v) }
+    end
+
+    def register_adaptor(adaptor_key)
+      instance_methods_for(adaptor_key)
+    end
+
+    private
+
+    def instance_methods_for(adaptor_key, existing_config = nil)
+      @keys << adaptor_key.to_sym
+
+      config = existing_config || LedgerSync::AdaptorConfiguration.new(adaptor_key)
+      @configs[adaptor_key] = config
+      @klass_configs[config.adaptor_klass] = config
+
+      instance_variable_set(
+        "@#{adaptor_key}",
+        config
+      )
+
+      self.class.class_eval { attr_reader adaptor_key }
+    end
+  end
+end

data/lib/ledger_sync/adaptors/adaptor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    class Adaptor
+      include Fingerprintable::Mixin
+      include SimplySerializable::Mixin
+      include Validatable
+
+      serialize only: %i[
+        adaptor_configuration
+      ]
+
+      def initialize(*)
+        raise NotImplementedError
+      end
+
+      def adaptor_configuration
+        self.class.config
+      end
+
+      def base_module
+        adaptor_configuration.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 searcher_for?(resource_type:)
+        searcher_klass_for(resource_type: resource_type)
+      rescue NameError
+        false
+      end
+
+      def searcher_klass_for(resource_type:)
+        base_module.const_get(LedgerSync::Util::StringHelpers.camelcase(resource_type.to_s))::Searcher
+      end
+
+      def url_for(*_args)
+        raise NotImplementedError
+      end
+
+      def parse_operation_error(*)
+        nil
+      end
+
+      def self.config
+        @config ||= LedgerSync.adaptors.config_from_klass(klass: self)
+      end
+
+      # These are attributes that must always be saved after the adaptor 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.url_for(resource: nil); end
+    end
+  end
+end

data/lib/ledger_sync/adaptors/contract.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    class Contract < Dry::Validation::Contract
+      module Types
+        include Dry::Types()
+
+        Reference = Dry::Schema.Params do
+          required(:object).filled(eql?: :reference)
+          required(:id).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/adaptors/operation.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    module Operation
+      TYPES = %i[create find update upsert].freeze
+
+      module Mixin
+        module ClassMethods
+          def adaptor_klass
+            @adaptor_klass ||= Class.const_get("#{name.split('::')[0..2].join('::')}::Adaptor")
+          end
+
+          def resource_klass
+            @resource_klass ||= LedgerSync.const_get(
+              name
+                .split("#{adaptor_klass.config.base_module.name}::")
+                .last
+                .split('::Operations')
+                .first
+            )
+          end
+        end
+
+        def self.included(base)
+          base.include SimplySerializable::Mixin
+          base.include Fingerprintable::Mixin
+          # base.include Validatable
+          base.extend ClassMethods
+
+          base.class_eval do
+            serialize only: %i[
+              adaptor
+              after_operations
+              before_operations
+              operations
+              resource
+              root_operation
+              result
+              response
+              original
+            ]
+          end
+        end
+
+        attr_reader :adaptor,
+                    :after_operations,
+                    :before_operations,
+                    :operations,
+                    :resource,
+                    :root_operation,
+                    :result,
+                    :response,
+                    :original
+
+        def initialize(adaptor:, resource:)
+          raise 'Missing adaptor' if adaptor.nil?
+          raise 'Missing resource' if resource.nil?
+
+          raise "#{resource.class.name} is not a valid resource type.  Expected #{self.class.resource_klass.name}" unless resource.is_a?(self.class.resource_klass)
+
+          @adaptor = adaptor
+          @after_operations = []
+          @before_operations = []
+          @operations = []
+          @resource = resource
+          @result = nil
+          @root_operation = nil
+        end
+
+        def add_after_operation(operation)
+          @operations << operation
+          @after_operations << operation
+        end
+
+        def add_before_operation(operation)
+          @operations << operation
+          @before_operations << operation
+        end
+
+        def add_root_operation(operation)
+          @operations << operation
+          @root_operation = operation
+        end
+
+        def perform
+          failure(LedgerSync::Error::OperationError::PerformedOperationError.new(operation: self)) if @performed
+
+          begin
+            operate
+          rescue LedgerSync::Error => e
+            failure(e)
+          rescue => e
+            parsed_error = adaptor.parse_operation_error(error: e, operation: self)
+            raise e unless parsed_error
+
+            failure(parsed_error)
+          ensure
+            @performed = true
+          end
+        end
+
+        def performed?
+          @performed == true
+        end
+
+        def prepare
+          build
+        end
+
+        # Results
+
+        def failure(error)
+          @result = LedgerSync::OperationResult.Failure(
+            error,
+            operation: self,
+            response: error
+          )
+        end
+
+        def failure?
+          result.failure?
+        end
+
+        def success(response:)
+          @result = LedgerSync::OperationResult.Success(
+            self,
+            operation: self,
+            response: response
+          )
+        end
+
+        def success?
+          result.success?
+        end
+
+        def validate
+          raise "#{self.class.name}::Contract must be defined to validate." unless self.class.const_defined?('Contract')
+
+          serializer = resource.serializer
+          serialized_resource = serializer.serialize[:objects][serializer.id][:data]
+
+          Util::Validator.new(
+            contract: self.class::Contract,
+            data: serialized_resource
+          ).validate
+        end
+
+        def valid?
+          validate.success?
+        end
+
+        # Comparison
+
+        def ==(other)
+          return false unless self.class == other.class
+          return false unless resource == other.resource
+
+          true
+        end
+
+        # Type Methods
+
+        TYPES.each do |type|
+          define_method "#{type.to_s.downcase}?" do
+            false
+          end
+
+          define_method "convert_to_#{type.to_s.downcase}" do
+            update_klass_name = self.class.name.split('::')[0..-2].append(LedgerSync::Util::StringHelpers.camelcase(type.to_s)).join('::')
+            Object.const_get(update_klass_name).new(adaptor: adaptor, resource: resource)
+          end
+        end
+
+        def merge_into(from:, to:)
+          case to
+          when String, Integer, Array then from
+          else to.merge!(from) { |_key, old_value, new_value| merge_into(from: old_value, to: new_value) } if to && from
+          end
+        end
+
+        private
+
+        def build
+          add_root_operation self
+        end
+
+        def operate
+          raise NotImplementedError, self.class.name
+        end
+      end
+
+      TYPES.each do |type|
+        klass = Class.new do
+          include Operation::Mixin
+
+          define_method("#{type.to_s.downcase}?") do
+            true
+          end
+        end
+        Operation.const_set(LedgerSync::Util::StringHelpers.camelcase(type.to_s), klass)
+      end
+
+      def self.klass_from(adaptor:, method:, object:)
+        adaptor.base_module.const_get(
+          LedgerSync::Util::StringHelpers.camelcase(object)
+        )::Operations.const_get(
+          LedgerSync::Util::StringHelpers.camelcase(method)
+        )
+      end
+    end
+  end
+end