ledger_sync 1.3.3 → 1.4.2

data/lib/ledger_sync/util/resource_converter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'resource_converter/attribute_set'
+require_relative 'resource_converter/attribute'
+Gem.find_files('ledger_sync/util/resource_converter/type/**/*.rb').each { |path| require path }
+
+module LedgerSync
+  module Util
+    class ResourceConverter
+      def convert(args = {})
+        destination  = args.fetch(:destination).dup
+        destination  = Util::HashHelpers.deep_stringify_keys(destination) if destination.is_a?(Hash)
+        only_changes = args.fetch(:only_changes, false)
+        source       = args.fetch(:source).dup
+        source       = Util::HashHelpers.deep_stringify_keys(source) if source.is_a?(Hash)
+
+        if source.is_a?(Hash) && args.key?(:only_changes)
+          raise 'only_changes can only be passed when the source is a resource'
+        end
+
+        self.class.attributes.each do |converter_attribute|
+          next if only_changes && !source.attribute_changed?(converter_attribute.source_attribute)
+
+          args_to_pass = {
+            destination: destination,
+            source: source
+          }
+          next if converter_attribute.if_method.present? && !send(converter_attribute.if_method, args_to_pass)
+
+
+          # This is for in place changes
+          destination = converter_attribute.build_destination!(args_to_pass)
+        end
+
+        destination
+      end
+
+      def self._attribute(destination_attribute = nil, args = {}, &block)
+        if args.key?(:destination_attribute)
+          raise 'You cannot provide destination_attribute in args.  Pass the value as the first argument.'
+        end
+
+        attributes.add(
+          ResourceConverter::Attribute.new(
+            args.merge(
+              block: (block if block_given?),
+              destination_attribute: destination_attribute
+            )
+          )
+        )
+      end
+
+      def self.attribute(*args, &block)
+        _attribute(*args, &block)
+      end
+
+      def self.attributes
+        @attributes ||= ResourceConverter::AttributeSet.new(resource_converter_class: self)
+      end
+
+      def self._references(destination_attribute = nil, args = {}, &block)
+        reference_type     = args.fetch(:reference_type)
+        resource_converter = args.fetch(:resource_converter)
+
+        reference_type_class = case reference_type
+                               when :many
+                                 ResourceConverter::Type::ReferencesManyType
+                               when :one
+                                 ResourceConverter::Type::ReferencesOneType
+                               else
+                                 raise "Unkown reference type: #{references_type}"
+                               end
+
+        _attribute(
+          destination_attribute,
+          {
+            type: reference_type_class.new(
+              resource_converter: resource_converter
+            )
+          }.merge(
+            args.except(
+              %i[
+                reference_type
+                resource_converter
+              ]
+            )
+          ),
+          &block
+        )
+      end
+
+      def self.references_one(destination_attribute = nil, args = {}, &block)
+        _references(
+          destination_attribute,
+          {
+            reference_type: :one
+          }.merge(args),
+          &block
+        )
+      end
+
+      def self.references_many(destination_attribute = nil, args = {}, &block)
+        _references(
+          destination_attribute,
+          {
+            reference_type: :many
+          }.merge(args),
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/resource_converter/attribute.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+Gem.find_files('ledger_sync/serialization/type/**/*.rb').each { |path| require path }
+
+module LedgerSync
+  module Util
+    class ResourceConverter
+      class Attribute
+        attr_reader :block,
+                    :destination_attribute,
+                    :if_method,
+                    :source_attribute,
+                    :type
+
+        def initialize(args = {})
+          @block                 = args.fetch(:block, nil)
+          @destination_attribute = args.fetch(:destination_attribute, nil).to_s
+          @source_attribute      = args.fetch(:source_attribute, destination_attribute).to_s
+          @type                  = args.fetch(:type, nil) || LedgerSync::Type::Value.new
+          @if_method             = args.fetch(:if, nil)
+
+          return if block.blank?
+
+          raise 'block cannot be provided on references' if reference?
+          raise 'block and destination_attribute cannot both be present' if destination_attribute.present?
+          raise 'block and source_attribute cannot both be present' if source_attribute.present?
+        end
+
+        def block?
+          block.present?
+        end
+
+        def block_value_for(args = {})
+          destination = args.fetch(:destination).dup
+          source      = args.fetch(:source).dup
+
+          new_destination = block.call(
+            {
+              attribute: self,
+              destination: destination,
+              source: source
+            }
+          )
+
+          return new_destination if destination.class == new_destination.class
+
+          raise "Block value must be the same class as the destination: #{destination.class}"
+        end
+
+        def build_destination!(args = {})
+          destination = args.fetch(:destination)
+          destination = Util::HashHelpers.deep_stringify_keys(destination) if destination.is_a?(Hash)
+          source      = args.fetch(:source).dup
+          source      = Util::HashHelpers.deep_stringify_keys(source) if source.is_a?(Hash)
+
+          if block?
+            return block_value_for(
+              destination: destination,
+              source: source
+            )
+          end
+
+          value = value(destination: destination, source: source)
+
+          if destination.is_a?(Hash)
+            destination = Util::HashHelpers.deep_merge(
+              hash_to_merge_into: destination,
+              other_hash: destination_attribute_dot_parts.reverse.inject(value) { |a, n| { n => a } }
+            )
+          else
+            destination.assign_attribute(
+              destination_attribute_dot_parts.first,
+              value
+            )
+          end
+
+          destination
+        end
+
+        def destination_attribute_class(destination:)
+          @destination_attribute_type ||= {}
+          @destination_attribute_type[destination] ||= destination.class.destination_attributes[destination_attribute_dot_parts.first.to_sym].type.resource_class
+        end
+
+        def destination_attribute_dot_parts
+          @destination_attribute_dot_parts ||= destination_attribute.split('.')
+        end
+
+        def reference?
+          references_many? || references_one?
+        end
+
+        def references_one?
+          type.is_a?(Type::ReferencesOneType)
+        end
+
+        def references_many?
+          type.is_a?(Type::ReferencesManyType)
+        end
+
+        def reference_resource_converter
+          @reference_resource_converter ||= type.resource_converter
+        end
+
+        def source_attribute_dot_parts
+          @source_attribute_dot_parts ||= source_attribute.split('.')
+        end
+
+        def value(destination:, source:)
+          value = if source.is_a?(Hash)
+                    source.dig(*source_attribute_dot_parts)
+                  else
+                    source_attribute_dot_parts.inject(source) { |r, dot_method| r&.send(dot_method) }
+                  end
+
+          return type.cast(value: value) unless reference?
+
+          destination_attribute_first_dot_part = destination_attribute_dot_parts.first
+          new_destination = if destination.is_a?(Hash)
+                              {}
+                            else
+                              destination.class.resource_attributes.fetch(
+                                destination_attribute_first_dot_part.to_sym
+                              ).type.resource_class.new
+                            end
+          type.cast(destination: new_destination, source: source, value: value)
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/resource_converter/attribute_set.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../mixins/delegate_iterable_methods_mixin'
+
+module LedgerSync
+  module Util
+    class ResourceConverter
+      class AttributeSet
+        include Mixins::DelegateIterableMethodsMixin
+
+        attr_reader :attributes,
+                    :resource_converter_class
+
+        delegate_array_methods_to :attributes
+
+        def initialize(args = {})
+          @attributes               = []
+          @attribute_keys           = {}
+          @resource_converter_class = args.fetch(:resource_converter_class)
+        end
+
+        def add(attribute)
+          unless attribute.destination_attribute.nil?
+            if @attribute_keys.key?(attribute.destination_attribute.to_s)
+              raise "destination_attribute already defined for #{resource_converter_class.name}: #{attribute.destination_attribute}"
+            end
+
+            @attribute_keys[attribute.destination_attribute] = attribute
+          end
+
+          attributes << attribute
+
+          attribute
+        end
+
+        def hash_attribute?(key)
+          hash_attribute_keyed_hash.include?(key.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/resource_converter/type/references_many_type.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'resource_converter_type'
+
+module LedgerSync
+  module Util
+    class ResourceConverter
+      module Type
+        class ReferencesManyType < ResourceConverterType
+          def cast_value(args = {})
+            destination = args.fetch(:destination)
+            values = args.fetch(:value)
+
+            return if values.nil?
+
+            values.map do |value|
+              super(
+                destination: destination,
+                value: value
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/resource_converter/type/references_one_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'resource_converter_type'
+
+module LedgerSync
+  module Util
+    class ResourceConverter
+      module Type
+        class ReferencesOneType < ResourceConverterType
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/resource_converter/type/resource_converter_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Util
+    class ResourceConverter
+      module Type
+        class ResourceConverterType < LedgerSync::Type::Value
+          attr_reader :resource_converter
+
+          def initialize(args = {})
+            @resource_converter = args.fetch(:resource_converter)
+          end
+
+          def cast_value(args = {})
+            destination = args.fetch(:destination)
+            source      = args.fetch(:value)
+
+            return if source.nil?
+
+            resource_converter.new.convert(destination: destination, source: source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/resources_builder.rb

@@ -6,16 +6,18 @@ module LedgerSync
       attr_reader :cast,
                   :data,
                   :ignore_unrecognized_attributes,
+                  :ledger,
                   :root_resource_external_id,
                   :root_resource_type
 
-      def initialize(cast: true, data:, ignore_unrecognized_attributes: false, root_resource_external_id:, root_resource_type:)
-        @all_resources = {}
-        @cast = cast
-        @data = Util::HashHelpers.deep_symbolize_keys(data)
-        @ignore_unrecognized_attributes = ignore_unrecognized_attributes
-        @root_resource_external_id = root_resource_external_id
-        @root_resource_type = root_resource_type
+      def initialize(args = {})
+        @all_resources                  = {}
+        @ledger                         = args.fetch(:ledger)
+        @cast                           = args.fetch(:cast, true)
+        @data                           = Util::HashHelpers.deep_symbolize_keys(args.fetch(:data))
+        @ignore_unrecognized_attributes = args.fetch(:ignore_unrecognized_attributes, false)
+        @root_resource_external_id      = args.fetch(:root_resource_external_id)
+        @root_resource_type             = args.fetch(:root_resource_type)
       end
 
       def resource
@@ -42,7 +44,11 @@ module LedgerSync
         current_data = @data.dig(type, external_id, :data)
         raise "No data provided for #{type} (ID: #{external_id})" if current_data.nil?
 
-        resource_class = LedgerSync.resources[type]
+        resource_class = if ledger == :root
+                           LedgerSync.resources.find { |e| e.resource_type == type }
+                         else
+                           LedgerSync.ledgers.send(ledger).client_class.resources[type]
+                         end
         raise "#{type} is an invalid resource type" if resource_class.nil?
 
         current_data = Hash[
@@ -50,7 +56,9 @@ module LedgerSync
             k = k.to_sym
 
             attribute = resource_class.resource_attributes[k]
-            raise "Unrecognized attribute for #{resource_class.name}: #{k}" if attribute.nil? && !ignore_unrecognized_attributes
+            if attribute.nil? && !ignore_unrecognized_attributes
+              raise "Unrecognized attribute for #{resource_class.name}: #{k}"
+            end
 
             v = if attribute.is_a?(ResourceAttribute::Reference::One)
                   resource_type = resource_type_by(external_id: current_data[k])
@@ -66,7 +74,7 @@ module LedgerSync
                     )
                   end
                 elsif cast
-                  attribute.type.cast(v)
+                  attribute.type.cast(value: v)
                 else
                   v
                 end
@@ -87,7 +95,7 @@ module LedgerSync
         @external_id_to_type_hash ||= begin
           ret = {}
           data.each do |type, type_resources|
-            type_resources.keys.each do |external_id|
+            type_resources.each_key do |external_id|
               ret[external_id] = type
             end
           end

data/lib/ledger_sync/util/string_helpers.rb

@@ -6,7 +6,7 @@ module LedgerSync
       module_function
 
       def camelcase(str)
-        str.to_s.split('/').map { |e| inflect(e.split('_').collect(&:capitalize).join) }.join('::')
+        str.to_s.split('/').map { |e| inflect(e.split('_').collect(&:camelcase).join) }.join('::')
       end
 
       def underscore!(str)
@@ -22,9 +22,9 @@ module LedgerSync
       end
 
       def inflect(str)
-        return str unless LedgerSync.respond_to?(:adaptors)
+        return str unless LedgerSync.respond_to?(:ledgers)
 
-        LedgerSync.adaptors.inflections.each do |inflection|
+        LedgerSync.ledgers.inflections.each do |inflection|
           next unless inflection.downcase == str.downcase
 
           return inflection

data/lib/ledger_sync/util/url_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Util
+    class URLHelpers
+      def self.merge_params_in_url(args = {})
+        params = args.fetch(:params)
+        uri    = args.fetch(:url)
+
+        uri = URI.parse(uri) unless uri.is_a?(URI::HTTPS) || uri.is_a?(URI::HTTP)
+        uri.query = URI.encode_www_form(
+          params.inject(URI.decode_www_form(String(uri.query))) { |prev, param| prev << param }
+        )
+
+        uri.to_s
+      end
+
+      def self.merge_params_in_path(args = {})
+        params = args.fetch(:params)
+        path   = args.fetch(:path)
+
+        root, str_params = path.split('?')
+        str_params = Rack::Utils.parse_nested_query(str_params)
+
+        [
+          root,
+          Rack::Utils.build_query(str_params.merge(HashHelpers.deep_stringify_keys(params)))
+        ].compact.join('?')
+      end
+
+      def self.id_from_url(args = {})
+        uri = args.fetch(:url)
+
+        URI.parse(uri).path.split('/').last
+      end
+    end
+  end
+end