ledger_sync 1.3.4 → 1.4.4

data/_config.yml

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

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 = []
-      @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: adaptor_key, adaptor_config: 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_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
-      @klass_configs[adaptor_config.adaptor_klass] = 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/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

data/lib/ledger_sync/adaptors/ledger_serializer_attribute_set.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Adaptors
-    class LedgerSerializerAttributeSet
-      attr_reader :attributes,
-                  :deserializable_attributes,
-                  :id_attribute,
-                  :ledger_attribute_keyed_hash,
-                  :resource_attribute_keyed_hash,
-                  :serializable_attributes,
-                  :serializer_class
-
-      delegate  :[],
-                :each,
-                :include?,
-                :map,
-                to: :attributes
-
-      def initialize(serializer_class:)
-        @attributes = []
-        @deserializable_attributes = []
-        @ledger_attribute_keyed_hash = {}
-        @resource_attribute_keyed_hash = {}
-        @serializable_attributes = []
-        @serializer_class = serializer_class
-      end
-
-      def add(attribute)
-        @attributes << attribute
-        @id_attribute = attribute if attribute.id
-        if attribute.ledger_attribute.present?
-          raise "ledger_attribute already defined for #{serializer_class.name}: #{attribute.ledger_attribute}" if ledger_attribute_keyed_hash.key?(attribute.ledger_attribute.to_s)
-
-          ledger_attribute_keyed_hash[attribute.ledger_attribute.to_s] = attribute
-        end
-
-        if attribute.resource_attribute.present?
-          # raise "resource_attribute already defined for #{serializer_class.name}: #{attribute.resource_attribute}" if resource_attribute_keyed_hash.key?(attribute.resource_attribute.to_s)
-
-          resource_attribute_keyed_hash[attribute.resource_attribute.to_s] = attribute
-        end
-
-        serializable_attributes << attribute if attribute.serialize?
-        deserializable_attributes << attribute if attribute.deserialize?
-
-        # TODO: Can make this validate something like `expense.vendor.id`
-        # raise "#{resource_attribute} is not an attribute of the resource #{_inferred_resource_class}" if !resource_attribute.nil? && !_inferred_resource_class.serialize_attribute?(resource_attribute)
-
-        attribute
-      end
-
-      def ledger_attribute?(key)
-        ledger_attribute_keyed_hash.include?(key.to_s)
-      end
-    end
-  end
-end

data/lib/ledger_sync/adaptors/ledger_serializer_type/mapping_type.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module LedgerSync
-  module Adaptors
-    module LedgerSerializerType
-      class MappingType < ValueType
-        attr_reader :source, :value
-
-        def self.mapping
-          @mapping ||= begin
-            raise NotImplementedError
-          end
-        end
-
-        def convert_from_ledger(value:)
-          return if value.nil?
-          raise "Ledger to local mapping not found: #{value}" unless reverse_mapping_hash.key?(value)
-
-          reverse_mapping_hash[value]
-        end
-
-        def convert_from_local(value:)
-          return if value.nil?
-          raise "Local to ledger mapping not found: #{value}" unless mapping_hash.key?(value)
-
-          mapping_hash[value]
-        end
-
-        private
-
-        def mapping_hash
-          @mapping_hash ||= self.class.mapping
-        end
-
-        def reverse_mapping_hash
-          @reverse_mapping_hash ||= mapping_hash.to_a.map(&:reverse).to_h
-        end
-      end
-    end
-  end
-end