ledger_sync 1.3.3 → 1.4.2

data/lib/ledger_sync/type/boolean.rb

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

data/lib/ledger_sync/type/date.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value_mixin'
+
 module LedgerSync
   module Type
     class Date < ActiveModel::Type::Date # :nodoc:
@@ -10,7 +12,7 @@ module LedgerSync
       end
 
       def valid_classes
-        [::Date]
+        [::Date, ::String]
       end
     end
   end

data/lib/ledger_sync/type/float.rb

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

data/lib/ledger_sync/type/hash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+
+module LedgerSync
+  module Type
+    class Hash < Value # :nodoc:
+      include ValueMixin
+
+      def cast?
+        true
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        raw_old_value != new_value if new_value.is_a?(::Hash)
+      end
+
+      def type
+        :id
+      end
+
+      def valid_classes
+        [::Hash]
+      end
+
+      private
+
+      def cast_value(args = {})
+        value = args.fetch(:value)
+
+        case value
+        when ::Hash then value.clone
+        else { value: value }
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/type/id.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value'
+
 module LedgerSync
   module Type
     class ID < Value # :nodoc:
@@ -18,12 +20,16 @@ module LedgerSync
       end
 
       def valid_classes
-        [::String, ::Symbol, ::Integer]
+        [::String, ::Symbol, ::Integer, ::NilClass]
       end
 
       private
 
-      def cast_value(value)
+      def cast_value(args = {})
+        value = args.fetch(:value)
+
+        return if value.nil?
+
         case value
         when ::String then ::String.new(value)
         else value.to_s

data/lib/ledger_sync/type/integer.rb

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

data/lib/ledger_sync/type/reference_many.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'value'
+
 module LedgerSync
   module Type
     class ReferenceMany < Value # :nodoc:
@@ -12,24 +14,32 @@ module LedgerSync
         super()
       end
 
-      def error_message(attribute:, resource:, value:)
-        return super unless value.is_a?(Array)
+      def cast(args = {})
+        value = args.fetch(:value)
+        return if value.nil?
+
+        many_array_class = LedgerSync::ResourceAttribute::Reference::Many::ManyArray
 
-        invalid_classes = value.reject { |e| e.is_a?(resource_class) }.map(&:class)
-        "Attribute #{attribute.name} for #{resource.class.name} should be an array of #{resource_class.name}.  Given array containing: #{invalid_classes.join(', ')}"
+        return value if value.is_a?(many_array_class)
+        unless value.is_a?(Array)
+          raise "Cannot convert #{value.class} to LedgerSync::ResourceAttribute::Reference::Many::ManyArray"
+        end
+
+        many_array_class.new(value)
       end
 
       def type
         :reference_many
       end
 
-      def valid_without_casting?(value:)
+      def valid?(value:)
         return false unless value.is_a?(Array)
         return true if (resource_classes & value.map(&:class)).any?
         return true if value.is_a?(Array) && value.empty?
 
         false
       end
+
       private
 
       def resource_classes

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