ledger_sync 1.3.5 → 1.4.0

data/.ruby-version

@@ -1 +0,0 @@
-2.6.6

data/_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-cayman

data/lib/ledger_sync/adaptor_configuration.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  class AdaptorConfiguration
-    include Fingerprintable::Mixin
-    include SimplySerializable::Mixin
-
-    attr_accessor :module_string,
-                  :name,
-                  :rate_limiting_wait_in_seconds,
-                  :test
-
-    attr_reader :aliases,
-                :root_key
-
-    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 adaptor_class
-      @adaptor_class ||= base_module::Adaptor
-    end
-
-    def add_alias(new_alias)
-      @aliases << new_alias
-      LedgerSync.adaptors.add_alias(new_alias, self)
-    end
-
-    def base_module
-      @base_module ||= begin
-        LedgerSync::Adaptors.const_get(@module_string)
-      end
-    end
-
-    # Delegate #new to the adaptor class enabling faster adaptor initialization
-    # e.g. LedgerSync.adaptors.test.new(...)
-    def new(*args)
-      adaptor_class.new(*args)
-    end
-
-    # Delegate #new_from_env to the adaptor class enabling faster adaptor initialization
-    # e.g. LedgerSync.adaptors.test.new_from_env(...)
-    def new_from_env(*args)
-      adaptor_class.new_from_env(*args)
-    end
-
-    def test?
-      test == true
-    end
-  end
-end

data/lib/ledger_sync/adaptor_configuration_store.rb

@@ -1,56 +0,0 @@
-module LedgerSync
-  class AdaptorConfigurationStore
-    include Enumerable
-
-    attr_reader :configs, :inflections
-
-    def initialize
-      @keys = []
-      @configs = {}
-      @inflections = []
-      @class_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: adaptor_key, adaptor_config: existing_config)
-    end
-
-    def config_from_class(adaptor_class:)
-      @class_configs.fetch(adaptor_class)
-    end
-
-    def each
-      configs.each { |k, v| yield(k, v) }
-    end
-
-    def register_adaptor(adaptor_config:)
-      _instance_methods_for(
-        adaptor_key: adaptor_config.root_key,
-        adaptor_config: adaptor_config
-      )
-    end
-
-    private
-
-    def _instance_methods_for(adaptor_key:, adaptor_config:)
-      @keys << adaptor_key.to_sym
-
-      @configs[adaptor_key] = adaptor_config
-      @class_configs[adaptor_config.adaptor_class] = adaptor_config
-
-      instance_variable_set(
-        "@#{adaptor_key}",
-        adaptor_config
-      )
-
-      @inflections |= [adaptor_config.module_string]
-      self.class.class_eval { attr_reader adaptor_key }
-    end
-  end
-end

data/lib/ledger_sync/adaptors/adaptor.rb

@@ -1,100 +0,0 @@
-# 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
-        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(method:, resource:)
-        self.class.operation_class_for(
-          method: method,
-          resource_class: resource.class
-        ).new(
-          adaptor: self,
-          resource: resource
-        )
-      end
-
-      def searcher_for(resource_type:, query: '')
-        searcher_class_for(resource_type: resource_type).new(adaptor: 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(*_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.adaptors.config_from_class(adaptor_class: 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.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
-        {}
-      end
-
-      def self.operation_class_for(method:, resource_class:)
-        base_operation_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.new { |n| n.underscore }
-        ledger_resource_type_overrides.invert[converter.call(type).to_sym] || LedgerSync.resources[converter.call(type).to_sym]
-      end
-
-      def self.url_for(resource: nil); end
-    end
-  end
-end

data/lib/ledger_sync/adaptors/contract.rb

@@ -1,16 +0,0 @@
-# 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/dashboard_url_helper.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Adaptors
-    class DashboardURLHelper
-      attr_reader :resource,
-                  :base_url
-
-      def initialize(resource:, base_url:)
-        @resource = resource
-        @base_url = base_url
-      end
-
-      def url
-        @base_url + resource_path
-      end
-
-      def resource_path
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/ledger_sync/adaptors/ledger_serializer.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'ledger_serializer_type/value_type'
-require_relative 'ledger_serializer_attribute'
-require_relative 'ledger_serializer_attribute_set'
-Gem.find_files('ledger_sync/adaptors/ledger_serializer_type/**/*.rb').each { |path| require path }
-
-module LedgerSync
-  module Adaptors
-    class LedgerSerializer
-      include Mixins::InferResourceClassMixin
-
-      attr_reader :resource
-
-      def initialize(**keywords)
-        @resource = keywords.fetch(:resource)
-      end
-
-      def attribute_value_from_ledger(hash:, ledger_serializer_attribute:, resource:)
-        ledger_serializer_attribute.value_from_ledger(
-          hash: hash,
-          resource: resource
-        )
-      end
-
-      def deserialize(hash:)
-        deserialize_into = resource.dup # Do not overwrite values in the resource
-        hash = Util::HashHelpers.deep_stringify_keys(hash)
-
-        self.class.attributes.deserializable_attributes.each do |ledger_serializer_attribute|
-          next unless ledger_serializer_attribute.resource_attribute?
-
-          value = attribute_value_from_ledger(
-            hash: hash,
-            ledger_serializer_attribute: ledger_serializer_attribute,
-            resource: deserialize_into
-          )
-
-          deserialize_into.assign_attribute(
-            ledger_serializer_attribute.resource_attribute_dot_parts.first,
-            value
-          )
-        end
-
-        deserialize_into
-      end
-
-      def to_ledger_hash(only_changes: false)
-        ret = {}
-
-        self.class.attributes.serializable_attributes.each do |ledger_serializer_attribute|
-          next if only_changes && !resource.attribute_changed?(ledger_serializer_attribute.resource_attribute)
-
-          ret = Util::HashHelpers.deep_merge(
-            hash_to_merge_into: ret,
-            other_hash: ledger_serializer_attribute.ledger_attribute_hash_for(resource: resource)
-          )
-        end
-
-        ret
-      end
-
-      def self.attribute(
-        deserialize: true,
-        ledger_attribute:,
-        resource_attribute: nil,
-        serialize: true,
-        type: LedgerSerializerType::ValueType,
-        &block
-      )
-        _attribute(
-          block: (block if block_given?),
-          deserialize: deserialize,
-          ledger_attribute: ledger_attribute,
-          resource_attribute: resource_attribute,
-          serialize: serialize,
-          type: type
-        )
-      end
-
-      def self.attributes
-        @attributes ||= LedgerSerializerAttributeSet.new(serializer_class: self)
-      end
-
-      def self.references_many(ledger_attribute:, resource_attribute:, serializer:)
-        _attribute(
-          ledger_attribute: ledger_attribute,
-          resource_attribute: resource_attribute,
-          serializer: serializer,
-          type: LedgerSerializerType::ReferencesManyType
-        )
-      end
-
-      def self.references_one(ledger_attribute:, resource_attribute:, serializer:)
-        _attribute(
-          ledger_attribute: ledger_attribute,
-          resource_attribute: resource_attribute,
-          serializer: serializer,
-          type: LedgerSerializerType::ReferencesOneType
-        )
-      end
-
-      def self.id(ledger_attribute:, resource_attribute:, &block)
-        @id ||= _attribute(
-          block: (block if block_given?),
-          id: true,
-          ledger_attribute: ledger_attribute,
-          resource_attribute: resource_attribute
-        )
-      end
-
-      private_class_method def self._attribute(**keywords)
-        attributes.add(
-          _build_attribute(**keywords)
-        )
-      end
-
-      private_class_method def self._build_attribute(
-        block: nil,
-        deserialize: true,
-        id: false,
-        ledger_attribute:,
-        resource_attribute: nil,
-        resource_class: nil,
-        serialize: true,
-        serializer: nil,
-        type: LedgerSerializerType::ValueType
-      )
-        LedgerSerializerAttribute.new(
-          id: id,
-          block: block,
-          deserialize: deserialize,
-          ledger_attribute: ledger_attribute,
-          resource_attribute: resource_attribute,
-          resource_class: resource_class,
-          serialize: serialize,
-          serializer: serializer,
-          type: type
-        )
-      end
-    end
-  end
-end

data/lib/ledger_sync/adaptors/ledger_serializer_attribute.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'ledger_serializer_type/value_type'
-Gem.find_files('ledger_sync/adaptors/ledger_serializer_type/**/*.rb').each { |path| require path }
-
-module LedgerSync
-  module Adaptors
-    class LedgerSerializerAttribute
-      attr_reader :block,
-                  :deserialize,
-                  :id,
-                  :ledger_attribute,
-                  :resource_attribute,
-                  :resource_class,
-                  :serialize,
-                  :serializer,
-                  :type
-
-      def initialize(
-        block: nil,
-        deserialize: true,
-        id: false,
-        ledger_attribute:,
-        resource_attribute: nil,
-        resource_class: nil,
-        serialize: true,
-        serializer: nil,
-        type: LedgerSerializerType::ValueType
-      )
-        raise 'block and resource_attribute cannot both be present' unless block.nil? || resource_attribute.nil?
-
-        @block = block
-        @deserialize = deserialize
-        @id = id
-        @ledger_attribute = ledger_attribute.to_s
-        @resource_attribute = resource_attribute.to_s
-        @resource_class = resource_class
-        @serialize = serialize
-        @serializer = serializer
-        @type = type.new
-      end
-
-      def block_value_for(resource:)
-        block.call(resource)
-      end
-
-      def deserialize?
-        deserialize
-      end
-
-      # Make nested/dot calls (e.g. `vendor.ledger_id`)
-      def dot_value_for(resource:)
-        resource_attribute_dot_parts.inject(resource) { |r, dot_method| r&.send(dot_method) }
-      end
-
-      def ledger_attribute_dot_parts
-        @ledger_attribute_dot_parts ||= ledger_attribute.split('.')
-      end
-
-      def ledger_attribute_hash_for(resource:)
-        ledger_attribute_hash_with(value: value_from_local(resource: resource))
-      end
-
-      # Create nested hash for ledger
-      #
-      # when ledger_attribute = 'Foo.Bar.Baz',
-      # ledger_attribute_hash_with(value: 123)
-      # Result:
-      # {
-      #   'Foo' => {
-      #     'Bar' => {
-      #       'Baz' => 123
-      #     }
-      #   }
-      # }
-      def ledger_attribute_hash_with(value:)
-        ledger_attribute_dot_parts.reverse.inject(value) { |a, n| { n => a } }
-      end
-
-      def reference?
-        references_many? || references_one?
-      end
-
-      def references_many?
-        type.is_a?(LedgerSerializerType::ReferencesManyType)
-      end
-
-      def references_one?
-        type.is_a?(LedgerSerializerType::ReferencesOneType)
-      end
-
-      def resource_attribute?
-        resource_attribute.present?
-      end
-
-      def resource_attribute_dot_parts
-        @resource_attribute_dot_parts ||= resource_attribute.split('.')
-      end
-
-      def serialize?
-        serialize
-      end
-
-      def value_from_local(resource:)
-        value = if block.nil?
-                  dot_value_for(resource: resource)
-                else
-                  block_value_for(resource: resource)
-                end
-
-        if reference?
-          type.convert_from_local(
-            serializer: serializer,
-            value: value
-          )
-        else
-          type.convert_from_local(
-            value: value
-          )
-        end
-      end
-
-      def value_from_ledger(hash:, resource:)
-        value = hash.dig(*ledger_attribute_dot_parts)
-
-        value = if reference?
-                  type.convert_from_ledger(
-                    resource_class: resource_class,
-                    serializer: serializer,
-                    value: value
-                  )
-                else
-                  type.convert_from_ledger(
-                    value: value
-                  )
-                end
-
-        return value if resource_attribute_dot_parts.count <= 1
-
-        nested_resource = resource.send(resource_attribute_dot_parts.first)
-        nested_resource ||= resource_attribute_class(resource: resource).new
-
-        build_resource_value_from_nested_attributes(
-          nested_resource,
-          value,
-          resource_attribute_dot_parts[1..-1]
-        )
-      end
-
-      private
-
-      def build_resource_value_from_nested_attributes(resource, value, attribute_parts)
-        resource = resource.dup
-        first_attribute, *remaining_attributes = attribute_parts
-
-        if remaining_attributes.count.zero?
-          resource.public_send("#{first_attribute}=", value)
-        else
-          resource.public_send(
-            "#{first_attribute}=",
-            build_resource_value_from_nested_attributes(
-              resource.public_send(first_attribute) || resource.class.resource_attributes[first_attribute.to_sym].type.resource_class.new,
-              value,
-              remaining_attributes
-            )
-          )
-        end
-
-        resource
-      end
-
-      def resource_attribute_class(resource:)
-        @resource_attribute_type ||= {}
-        @resource_attribute_type[resource] ||= resource.class.resource_attributes[resource_attribute_dot_parts.first.to_sym].type.resource_class
-      end
-    end
-  end
-end