ledger_sync 1.3.2 → 1.4.1

data/lib/ledger_sync/type/reference_one.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value'
+
 module LedgerSync
   module Type
     class ReferenceOne < Value # :nodoc:
@@ -12,33 +14,22 @@ module LedgerSync
         super()
       end
 
-      def error_message(attribute:, resource:, value:)
-        if resource_class.is_a?(Array)
-          "Attribute #{attribute.name} for #{resource.class.name} should be one of the following: #{resource_class.map(&:name).join(', ')}.  Given #{value.class.name}"
-        else
-          "Attribute #{attribute.name} for #{resource.class.name} should be a #{resource_class.name}.  Given #{value.class.name}"
-        end
-      end
-
       def type
         :reference_one
       end
 
-      def valid_without_casting?(value:)
-        return true if value.nil?
-        return true if resource_classes.select { |e| value.is_a?(e) }.any?
-
-        false
-      end
-
-      private
-
       def resource_classes
         @resource_classes ||= if resource_class.is_a?(Array)
                                 resource_class
                               else
                                 [resource_class]
-                              end
+        end
+      end
+
+      private
+
+      def valid_classes
+        resource_classes
       end
     end
   end

data/lib/ledger_sync/type/string.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value_mixin'
+
 module LedgerSync
   module Type
     class String < ActiveModel::Type::String # :nodoc:

data/lib/ledger_sync/type/string_from_set.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'string'
+
+module LedgerSync
+  module Type
+    class StringFromSet < String # :nodoc:
+      attr_reader :values
+
+      def initialize(args = {})
+        @values = args.fetch(:values)
+
+        super(args.except(:values))
+      end
+
+      def assert_valid(args = {})
+        return if valid_value?(args)
+
+        raise Error::TypeError::StringFromSetError.new(
+          expected: @values,
+          given: args.fetch(:value)
+        )
+      end
+
+      def valid?(args = {})
+        super && valid_value?(args)
+      end
+
+      def type
+        :StringFromSet
+      end
+
+      private
+
+      def valid_value?(args = {})
+        value = args.fetch(:value).try(:to_s)
+        return true if value.blank?
+
+        @values.include?(value)
+      end
+    end
+  end
+end

data/lib/ledger_sync/type/value_mixin.rb

@@ -8,24 +8,54 @@ module LedgerSync
         base.include SimplySerializable::Mixin
       end
 
-      def cast?
-        false
+      def assert_valid(args = {})
+        return if valid_class?(args)
+
+        value = args.fetch(:value)
+
+        raise Error::TypeError::ValueClassError.new(
+          expected: valid_classes,
+          given: value.class
+        )
       end
 
-      def error_message(attribute:, resource:, value:)
-        "Attribute #{attribute.name} for #{resource.class.name} should be a class supported by #{self.class.name}.  Given: #{value.class}"
+      # Do not override this method.  Override private method cast_value
+      def cast(args = {})
+        assert_valid(args)
+        cast_value(args)
       end
 
-      def valid_classes
-        raise NotImplementedError
+      def valid?(args = {})
+        valid_class?(args)
       end
 
-      def valid_without_casting?(value:)
+      private
+
+      # Override this method to handle different types of casting.
+      def cast_value(args = {})
+        value = args.fetch(:value)
+
+        super(value)
+      end
+
+      def valid_class?(args = {})
+        value = args.fetch(:value)
+
         return true if value.nil?
         return true if valid_classes.select { |e| value.is_a?(e) }.any?
 
         false
       end
+
+      def valid_classes
+        [
+          Object
+        ]
+      end
+
+      # def cast?
+      #   false
+      # end
     end
   end
 end

data/lib/ledger_sync/util/mixins/delegate_iterable_methods_mixin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Util
+    module Mixins
+      module DelegateIterableMethodsMixin
+        module ClassMethods
+          SHARED_METHODS = %i[
+            []
+            any?
+            count
+            each
+            empty?
+            include?
+            map
+          ].freeze
+
+          ARRAY_METHODS = (SHARED_METHODS | %i[]).freeze
+
+          HASH_METHODS = (SHARED_METHODS | %i[
+            each_value
+            fetch
+            key?
+            keys
+            values
+          ]).freeze
+
+          def delegate_array_methods_to(delegate_to)
+            delegate(*ARRAY_METHODS, to: delegate_to)
+          end
+
+          def delegate_hash_methods_to(delegate_to)
+            delegate(*HASH_METHODS, to: delegate_to)
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/mixins/dupable_mixin.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Util
+    module Mixins
+      module DupableMixin
+        def dup
+          Marshal.load(Marshal.dump(self))
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/mixins/resource_registerable_mixin.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Util
+    module Mixins
+      module ResourceRegisterableMixin
+        module ClassMethods
+          def register_resource(resource:)
+            if resources.is_a?(Hash)
+              raise "Resource key #{resource.resource_type} already exists." if resources.key?(resource.resource_type)
+
+              resources[resource.resource_type] = resource
+            else
+              resources << resource
+            end
+          end
+
+          def resources
+            @resources ||= []
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/util/read_only_object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Util
+    class ReadOnlyObject
+      attr_reader :raw
+
+      def initialize(args = {})
+        @raw = args.with_indifferent_access
+
+        self.class.attributes.except { |k, _| e.to_sym == :raw }.each do |name, attr_settings|
+          if attr_settings.key?(:default)
+            instance_variable_set(
+              "@#{name}",
+              raw.fetch(name, attr_settings[:default])
+            )
+          else
+            instance_variable_set(
+              "@#{name}",
+              raw.fetch(attr_settings.fetch(:source, name))
+            )
+          end
+        end
+      end
+
+      def ==(other)
+        self.class.attributes.keys.all? { |name| send(name) == other.send(name) }
+      end
+
+      def self.attributes
+        @attributes ||= {}
+      end
+
+      def self.attribute(name, **keywords)
+        attributes[name.to_sym] = keywords
+        attr_reader name
+      end
+
+      def self.new_from_array(data)
+        data.map { |e| new_from_hash(e) }
+      end
+
+      def self.new_from_hash(data)
+        new(
+          data.symbolize_keys
+        )
+      end
+
+      def self.source_keys
+        @source_keys ||= attributes.map { |k, v| v.fetch(:source, k).to_sym }
+      end
+    end
+  end
+end

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