ledger_sync 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bf08ab386468485d8e81f3e40d43ca41664d69e4a09d1e70f658e047f82295d
-  data.tar.gz: 69a554102281aae008333eeea328691bcc242417152e3fe6e2ddfca726a7cb7c
+  metadata.gz: 53419559e8cc29609542a442a100a9ecf8fe4dff040f4233631f4e13c688c893
+  data.tar.gz: 707b1bc26a777fb442cce8052a8facff59ce715ddaf5a09c8c626b5e7867d0c7
 SHA512:
-  metadata.gz: ac04c1f2fc9fc9fb06443ad61a3f28e3ca102f1bd70d0c8c693549f2a9e75d83b4ad4fc10e5ed476b31038cd0190b6a077f9b3fefa02d629a15746a23e4e6647
-  data.tar.gz: 7b282b14b77360effae62f6b3f4c36c3f067a0d29f5bd721686c80460784943304a42c01cae1336aaf0dd6fc7803f39e63868ea38fce900150385f3b43ff969c
+  metadata.gz: edf14189d54667014a36ab9959ae0ba60a980c80131ea1cf36507358da50151a7e0428cc785d72aba91d6dd7a4b81836f40d743fedf93efbb0c90b3b2f3eecc8
+  data.tar.gz: a8eb0c9a2d75b5a2177f480f3fe2dbe4410201fa59cab4d5abca51586612012271081242e5190f894caa9b218f5ee3e899c1fb42e171512bae949fd40c01a978

data/.gitignore

@@ -11,5 +11,6 @@
 .rspec_status
 
 .byebug_history
+.qa_config.yml
 
 .DS_Store

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ledger_sync (1.1.1)
+    ledger_sync (1.1.2)
       activemodel
       colorize
       coveralls

data/README.md

@@ -189,7 +189,7 @@ puts LedgerSync::Payment.new(
         },
         external_id: "",
         ledger_id: nil,
-        sync_token: nil
+
       }
     },
     "LedgerSync::Customer/b3eab7ec00431a4ae0468fee72e5ba8f": {
@@ -201,8 +201,7 @@ puts LedgerSync::Payment.new(
         email: nil,
         phone_number: nil,
         external_id: "",
-        ledger_id: nil,
-        sync_token: nil
+        ledger_id: nil
       }
     }
   }

data/lib/ledger_sync.rb

@@ -85,9 +85,20 @@ module LedgerSync
   end
 
   def self.register_adaptor(adaptor_key)
+    adaptor_root_path = "ledger_sync/adaptors/#{adaptor_key}"
+    require "#{adaptor_root_path}/adaptor"
     self.adaptors ||= LedgerSync::AdaptorConfigurationStore.new
     self.adaptors.register_adaptor(adaptor_key)
+
     yield(adaptors.send(adaptor_key))
+
+    adaptor_files = Gem.find_files("#{adaptor_root_path}/**/*.rb")
+    # Sort the files to include BFS-style as most dependencies are in parent folders
+    adaptor_files.sort { |a, b| a.count('/') <=> b.count('/') }.each do |path|
+      next if path.include?('config.rb')
+
+      require path
+    end
   end
 
   def self.register_resource(resource:)
@@ -105,12 +116,7 @@ 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
-
+require 'ledger_sync/adaptors/ledger_serializer'
 Gem.find_files('ledger_sync/adaptors/**/config.rb').each { |path| require path }
 
 # Register Resources

data/lib/ledger_sync/adaptors/ledger_serializer.rb

@@ -0,0 +1,124 @@
+# 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
+      attr_reader :resource
+
+      def initialize(resource:)
+        @resource = resource
+        ensure_inferred_resource_class!
+      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.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.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(ledger_attribute:, resource_attribute: nil, type: LedgerSerializerType::ValueType, &block)
+        _attribute(
+          block: (block if block_given?),
+          ledger_attribute: ledger_attribute,
+          resource_attribute: resource_attribute,
+          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.id(ledger_attribute:, resource_attribute:, &block)
+        @id ||= _attribute(
+          block: (block if block_given?),
+          id: true,
+          ledger_attribute: ledger_attribute,
+          resource_attribute: resource_attribute
+        )
+      end
+
+      def self._inferred_resource_class
+        parts = name.split('::')
+        LedgerSync.const_get(parts[parts.index('Adaptors') + 2])
+      end
+
+      private_class_method def self._attribute(**keywords)
+        attributes.add(
+          _build_attribute(**keywords)
+        )
+      end
+
+      private_class_method def self._build_attribute(block: nil, id: false, ledger_attribute:, resource_attribute: nil, resource_class: nil, serializer: nil, type: LedgerSerializerType::ValueType)
+        LedgerSerializerAttribute.new(
+          id: id,
+          block: block,
+          ledger_attribute: ledger_attribute,
+          resource_attribute: resource_attribute,
+          resource_class: resource_class,
+          serializer: serializer,
+          type: type
+        )
+      end
+
+      private
+
+      def ensure_inferred_resource_class!
+        inferred_resource_class = self.class._inferred_resource_class
+        raise "Resource must be a #{inferred_resource_class.name}.  Given #{resource.class}" unless resource.is_a?(inferred_resource_class)
+      end
+    end
+  end
+end

data/lib/ledger_sync/adaptors/ledger_serializer_attribute.rb

@@ -0,0 +1,148 @@
+# 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,
+                  :id,
+                  :ledger_attribute,
+                  :resource_attribute,
+                  :resource_class,
+                  :serializer,
+                  :type
+
+      def initialize(block: nil, id: false, ledger_attribute:, resource_attribute: nil, resource_class: nil, serializer: nil, type: LedgerSerializerType::ValueType)
+        raise 'block and resource_attribute cannot both be present' unless block.nil? || resource_attribute.nil?
+
+        @block = block
+        @id = id
+        @ledger_attribute = ledger_attribute.to_s
+        @resource_attribute = resource_attribute.to_s
+        @resource_class = resource_class
+        @serializer = serializer
+        @type = type.new
+      end
+
+      def block_value_for(resource:)
+        block.call(resource)
+      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 references_many?
+        type.is_a?(LedgerSerializerType::ReferencesManyType)
+      end
+
+      def resource_attribute?
+        resource_attribute.present?
+      end
+
+      def resource_attribute_dot_parts
+        @resource_attribute_dot_parts ||= resource_attribute.split('.')
+      end
+
+      def value_from_local(resource:)
+        value = if block.nil?
+                  dot_value_for(resource: resource)
+                else
+                  block_value_for(resource: resource)
+                end
+
+        if references_many?
+          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 references_many?
+                  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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Adaptors
+    class LedgerSerializerAttributeSet
+      attr_reader :attributes,
+                  :id_attribute,
+                  :ledger_attribute_keyed_hash,
+                  :resource_attribute_keyed_hash,
+                  :serializer_class
+
+      delegate  :[],
+                :each,
+                :include?,
+                :map,
+                to: :attributes
+
+      def initialize(serializer_class:)
+        @attributes = []
+        @ledger_attribute_keyed_hash = {}
+        @resource_attribute_keyed_hash = {}
+        @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
+
+        # 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

@@ -0,0 +1,41 @@
+# 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