sequent 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ffdbe1d8e772c148815f98b0d7baa96f32dd5870
-  data.tar.gz: 3b7ed01b18a23c5d7b8522a4b5d0c1af311be02f
+  metadata.gz: 2a1582cc8d34049b1e10ed9c90391e3e7167c1ff
+  data.tar.gz: 5960fdac4834a4bb4f96b1643e6885da90f79587
 SHA512:
-  metadata.gz: 5ec2840094aa3f915222047623d3f570563efa800736883c9d07b724773b0948b74602d26560337bb20455fde183a066181cbe594959ca52ebd1d73fea6a0f9e
-  data.tar.gz: 60ac65d32eda16ce7db21cb51ba0a61b6b741b86636185569b1683c76a983c35d6ca806a744befdd195df997ecb3b8df481fd17a15e312d648a7fa816d3127a7
+  metadata.gz: 6f8ac133e7cbf158f48fe175527b4093c961b3637ea4a5b04d8373caeb2915dbc0ffede971c4f2a6a5d34bbc470e8cd3d9991ebaac784afd73ec610212f94be6
+  data.tar.gz: 1fdbf2610073c2731dfda81416a39c6d40eed6cdf4eed05ab0ac5c5813078d68c82a8a28bd8338c0ed06ef98ef0f2bc9f098c185ce6af4967e6f9ce9a900b6e1

data/lib/sequent/core/command.rb

@@ -17,6 +17,7 @@ module Sequent
               Sequent::Core::Helpers::EqualSupport,
               Sequent::Core::Helpers::ParamSupport,
               Sequent::Core::Helpers::Mergable
+      include Sequent::Core::Helpers::TypeConversionSupport
 
       attrs created_at: DateTime
 

data/lib/sequent/core/command_service.rb

@@ -71,14 +71,10 @@ module Sequent
             commands.each do |command|
               @filters.each { |filter| filter.execute(command) }
 
-              if command.valid?
-                @command_handlers.each do |command_handler|
-                  command_handler.handle_message command if command_handler.handles_message? command
-                end
-              end
-
-              @repository.commit(command)
-              raise CommandNotValid.new(command) unless command.validation_errors.empty?
+              raise CommandNotValid.new(command) unless command.valid?
+              parsed_command = command.parse_attrs_to_correct_types
+              @command_handlers.select { |h| h.handles_message?(parsed_command) }.each { |h| h.handle_message parsed_command }
+              @repository.commit(parsed_command)
             end
           end
         ensure

data/lib/sequent/core/ext/ext.rb

@@ -0,0 +1,54 @@
+class Symbol
+
+  def self.deserialize_from_json(value)
+    value.blank? ? nil : value.try(:to_sym)
+  end
+
+end
+
+class String
+
+  def self.deserialize_from_json(value)
+    value
+  end
+
+end
+
+class Integer
+
+  def self.deserialize_from_json(value)
+    value.blank? ? nil : value.to_i
+  end
+
+end
+
+class Boolean
+
+  def self.deserialize_from_json(value)
+    value.nil? ? nil : (value.present? ? value : false)
+  end
+
+end
+
+class Date
+
+  def self.deserialize_from_json(value)
+    value.blank? ? nil : Date.iso8601(value.dup)
+  end
+
+end
+
+class DateTime
+
+  def self.deserialize_from_json(value)
+    value.blank? ? nil : DateTime.iso8601(value.dup)
+  end
+
+end
+
+class Array
+
+  def self.deserialize_from_json(value)
+    value
+  end
+end

data/lib/sequent/core/helpers/array_with_type.rb

@@ -0,0 +1,22 @@
+module Sequent
+  module Core
+    module Helpers
+      class ArrayWithType
+        attr_accessor :item_type
+
+        def initialize(item_type)
+          raise "needs a item_type" unless item_type
+          @item_type = item_type
+        end
+
+        def deserialize_from_json(value)
+          value.nil? ? nil : value.map { |item| item_type.deserialize_from_json(item) }
+        end
+
+        def to_s
+          "Sequent::Core::Helpers::ArrayWithType.new(#{item_type})"
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/association_validator.rb

@@ -23,13 +23,31 @@ module Sequent
           associations.each do |association|
             next unless association # since ruby 2.0...?
             value = record.instance_variable_get("@#{association.to_s}")
-            if value && !value.kind_of?(Array) && record.respond_to?(:attributes) && !value.kind_of?(record.attributes[association])
+            if value && incorrect_type?(value, record, association)
               record.errors[association] = "is not of type #{record.attributes[association]}"
             elsif value && value.kind_of?(Array)
-              record.errors[association] = "is invalid" if value.any? { |v| not v.valid? }
+              item_type = record.class.type_for(association).item_type
+              record.errors[association] = "is invalid" if all_valid?(value, item_type)
             else
               record.errors[association] = "is invalid" if value && value.invalid?
+            end
+          end
+        end
+
+        private
 
+        def incorrect_type?(value, record, association)
+          !value.kind_of?(Array) && record.respond_to?(:attributes) && !value.kind_of?(record.attributes[association])
+        end
+
+        def all_valid?(value, item_type)
+          value.any? do |v|
+            if v.nil?
+              true
+            elsif v.respond_to? :valid?
+              not v.valid?
+            else
+              not Sequent::Core::Helpers::ValueValidators.for(item_type).valid_value?(v)
             end
           end
         end

data/lib/sequent/core/helpers/attribute_support.rb

@@ -1,47 +1,7 @@
 require 'active_support'
-# TODO: Move this into a separate core_ext folder like for instance Rails does.
-# WARNING: Monkey patches below...
-class Symbol
-  def self.deserialize_from_json(value)
-    value.try(:to_sym)
-  end
-end
-
-class String
-  def self.deserialize_from_json(value)
-    value
-  end
-end
-
-class Integer
-  def self.deserialize_from_json(value)
-    value.blank? ? nil : value.to_i
-  end
-end
-
-class Boolean
-  def self.deserialize_from_json(value)
-    value.nil? ? nil : (value.present? ? value : false)
-  end
-end
-
-class Date
-  def self.deserialize_from_json(value)
-    value.nil? ? nil : Date.iso8601(value.dup)
-  end
-end
-
-class DateTime
-  def self.deserialize_from_json(value)
-    value.nil? ? nil : DateTime.iso8601(value.dup)
-  end
-end
-
-class Array
-  def self.deserialize_from_json(value)
-    value
-  end
-end
+require_relative '../ext/ext'
+require_relative 'array_with_type'
+require_relative 'default_validators'
 
 module Sequent
   module Core
@@ -73,13 +33,30 @@ module Sequent
             end
           end
 
+          def type_for(name)
+            @types.find { |k, _| k == name }.last
+          end
+
           def attrs(args)
             @types ||= {}
             @types.merge!(args)
-            args.each do |attribute, _|
+            associations = []
+            args.each do |attribute, type|
               attr_accessor attribute
-            end
+              if included_modules.include?(Sequent::Core::Helpers::TypeConversionSupport)
+                Sequent::Core::Helpers::DefaultValidators.for(type).add_validations_for(self, attribute)
+              end
 
+              if type.class == Sequent::Core::Helpers::ArrayWithType
+                associations << attribute
+              elsif included_modules.include?(ActiveModel::Validations) &&
+                type.included_modules.include?(Sequent::Core::Helpers::AttributeSupport)
+                associations << attribute
+              end
+            end
+            if included_modules.include?(ActiveModel::Validations) && associations.present?
+              validates_with Sequent::Core::Helpers::AssociationValidator, associations: associations
+            end
             # Generate method that sets all defined attributes based on the attrs hash.
             class_eval <<EOS
               def update_all_attributes(attrs)
@@ -148,57 +125,8 @@ EOS
           prefix ? HashWithIndifferentAccess[result.map { |k, v| ["#{prefix}_#{k}", v] }] : result
         end
 
-        # If you have a Date object validate it with this method when the unparsed input is a String
-        # This scenario is typically when a date is posted from the web.
-        #
-        # Example
-        #
-        #   class Person < Sequent::Core::ValueObject
-        #     attrs date_of_birth: Date
-        #
-        #     validate :valid_date
-        #   end
-        #
-        # If the date_of_birth is a valid date it will be parsed into a proper Date object.
-        # This implementation currently only support dd-mm-yyyy format.
-        def valid_date
-          self.class.types.each do |name, clazz|
-            if clazz == Date
-              return if self.instance_variable_get("@#{name}").kind_of? Date
-              unless self.instance_variable_get("@#{name}").blank?
-                if (/\d{2}-\d{2}-\d{4}/ =~ self.instance_variable_get("@#{name}")).nil?
-                  @errors.add(name.to_s, :invalid_date) if (/\d{2}-\d{2}-\d{4}/ =~ self.instance_variable_get("@#{name}")).nil?
-                else
-                  begin
-                    self.instance_variable_set "@#{name}", Date.strptime(self.instance_variable_get("@#{name}"), "%d-%m-%Y")
-                  rescue
-                    @errors.add(name.to_s, :invalid_date)
-                  end
-                end
-              end
-
-            end
-          end
-        end
-
       end
 
-      class ArrayWithType
-        attr_accessor :item_type
-
-        def initialize(item_type)
-          raise "needs a item_type" unless item_type
-          @item_type = item_type
-        end
-
-        def deserialize_from_json(value)
-          value.nil? ? nil : value.map { |item| item_type.deserialize_from_json(item) }
-        end
-
-        def to_s
-          "Sequent::Core::Helpers::ArrayWithType.new(#{item_type})"
-        end
-      end
 
     end
   end

data/lib/sequent/core/helpers/date_time_validator.rb

@@ -0,0 +1,20 @@
+require 'active_model'
+
+module Sequent
+  module Core
+    module Helpers
+      # Validates DateTimes
+      # Automatically included when using a
+      #
+      #   attrs value: DateTime
+      class DateTimeValidator < ActiveModel::EachValidator
+        def validate_each(subject, attribute, value)
+          return if value.is_a?(DateTime)
+          DateTime.deserialize_from_json(value)
+        rescue
+          subject.errors.add attribute, :invalid_date_time
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/date_validator.rb

@@ -0,0 +1,18 @@
+require 'active_model'
+require_relative 'value_validators'
+
+module Sequent
+  module Core
+    module Helpers
+      # Validates Dates
+      # Automatically included when using a
+      #
+      #   attrs value: Date
+      class DateValidator < ActiveModel::EachValidator
+        def validate_each(subject, attribute, value)
+          subject.errors.add attribute, :invalid_date unless Sequent::Core::Helpers::ValueValidators.for(Date).valid_value?(value)
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/default_validators.rb

@@ -0,0 +1,26 @@
+module Sequent
+  module Core
+    module Helpers
+      class DefaultValidators
+        VALIDATORS = {
+          Integer => ->(klass, field) { klass.validates_numericality_of field, only_integer: true, allow_nil: true, allow_blank: true },
+          Date => ->(klass, field) { klass.validates field, "sequent::Core::Helpers::Date" => true },
+          DateTime => ->(klass, field) { klass.validates field, "sequent::Core::Helpers::DateTime" => true }
+        }
+
+        def self.for(type)
+          new(type)
+        end
+
+        def initialize(type)
+          @type = type
+        end
+
+        def add_validations_for(klass, field)
+          validator = VALIDATORS[@type]
+          validator.call(klass, field) if validator
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/helpers.rb

@@ -1,9 +1,13 @@
 require_relative 'uuid_helper'
 require_relative 'copyable'
+require_relative 'value_validators'
+require_relative 'string_to_value_parsers'
 require_relative 'attribute_support'
 require_relative 'equal_support'
 require_relative 'param_support'
 require_relative 'mergable'
 require_relative 'association_validator'
 require_relative 'string_support'
-require_relative 'boolean_support'
+require_relative 'type_conversion_support'
+require_relative 'date_validator'
+require_relative 'date_time_validator'

data/lib/sequent/core/helpers/param_support.rb

@@ -22,8 +22,6 @@ module Sequent
                 value = type.from_params(value)
               elsif type.is_a? Sequent::Core::Helpers::ArrayWithType
                 value = value.map { |v| type.item_type.from_params(v) }
-              elsif type <= Date
-                value = Date.strptime(value, "%d-%m-%Y") if value
               end
               result.instance_variable_set(:"@#{attribute}", value)
             end
@@ -49,8 +47,10 @@ module Sequent
               value = value.as_params
             elsif value.kind_of?(Array)
               value = value.map { |val| val.kind_of?(ValueObject) ? val.as_params : val }
-            elsif value.kind_of? Date
-              value = value.strftime("%d-%m-%Y") if value
+            elsif value.is_a? DateTime
+              value = value.iso8601
+            elsif value.is_a? Date
+              value = value.strftime("%d-%m-%Y") # TODO Remove to TypeConverter
             end
             hash[field[0]] = value
           end

data/lib/sequent/core/helpers/string_to_value_parsers.rb

@@ -0,0 +1,73 @@
+require_relative '../ext/ext'
+require_relative 'array_with_type'
+
+module Sequent
+  module Core
+    module Helpers
+      class StringToValueParsers
+        PARSERS = {
+          ::Symbol => ->(value) { Symbol.deserialize_from_json(value) },
+          ::String => ->(value) { value },
+          ::Integer => ->(value) { parse_to_integer(value) },
+          ::Boolean => ->(value) { parse_to_bool(value) },
+          ::Date => ->(value) { parse_to_date(value) },
+          ::DateTime => ->(value) { parse_to_date_time(value) },
+          ::Sequent::Core::Helpers::ArrayWithType => ->(values, type_in_array) { parse_array(values, type_in_array) }
+        }
+
+        def self.parse_to_integer(value)
+          Integer(value) unless value.blank?
+        end
+
+        def self.parse_to_bool(value)
+          if value.blank? && !(value.is_a?(TrueClass) || value.is_a?(FalseClass))
+            nil
+          else
+            (value.is_a?(TrueClass) || value == "true")
+          end
+        end
+
+        def self.parse_to_date(value)
+          return if value.blank?
+          value.is_a?(Date) ? value : Date.strptime(value, "%d-%m-%Y")
+        end
+
+        def self.parse_to_date_time(value)
+          value.is_a?(DateTime) ? value : DateTime.deserialize_from_json(value)
+        end
+
+        def self.parse_array(values, type_in_array)
+          values.map do |item|
+            if item.respond_to?(:parse_attrs_to_correct_types)
+              item.parse_attrs_to_correct_types
+            else
+              Sequent::Core::Helpers::StringToValueParsers.for(type_in_array).parse_from_string(item)
+            end
+          end
+        end
+
+        def self.for(klass)
+          new(klass)
+        end
+
+        def initialize(klass)
+          if klass.is_a? Sequent::Core::Helpers::ArrayWithType
+            @array_with_type = klass
+            @klass = klass.class
+          else
+            @klass = klass
+          end
+        end
+
+        def parse_from_string(value)
+          parser = PARSERS[@klass]
+          if @array_with_type
+            parser.call(value, @array_with_type.item_type)
+          else
+            parser.call(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/type_conversion_support.rb

@@ -0,0 +1,28 @@
+require 'active_model'
+
+module Sequent
+  module Core
+    module Helpers
+      # Will parse all values to the correct types.
+      # The raw values are typically posted from the web and are therefor mostly strings.
+      # To parse a raw value your class must have a parse_from_string method that returns the parsed values.
+      # See sequent/core/ext for currently supported classes.
+      module TypeConversionSupport
+        def parse_attrs_to_correct_types
+          the_copy = dup
+          the_copy.attributes.each do |name, type|
+            raw_value = the_copy.send("#{name}")
+            next if raw_value.nil?
+            if raw_value.respond_to?(:parse_attrs_to_correct_types)
+              the_copy.send("#{name}=", raw_value.parse_attrs_to_correct_types)
+            else
+              parsed_value = Sequent::Core::Helpers::StringToValueParsers.for(type).parse_from_string(raw_value)
+              the_copy.send("#{name}=", parsed_value)
+            end
+          end
+          the_copy
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/value_validators.rb

@@ -0,0 +1,53 @@
+require_relative '../ext/ext'
+
+module Sequent
+  module Core
+    module Helpers
+      class ValueValidators
+        VALIDATORS = {
+          ::Symbol => ->(_) { true },
+          ::String => ->(value) { value.nil? || value.is_a?(String) },
+          ::Integer => ->(value) { valid_integer?(value) },
+          ::Boolean => ->(value) { valid_bool?(value) },
+          ::Date => ->(value) { valid_date?(value) },
+          ::DateTime => ->(value) { valid_date_time?(value) }
+        }
+
+        def self.valid_integer?(value)
+          value.blank? || Integer(value)
+        rescue
+          false
+        end
+
+        def self.valid_bool?(value)
+          return true if value.blank?
+          value.is_a?(TrueClass) || value.is_a?(FalseClass) || value == "true" || value == "false"
+        end
+
+        def self.valid_date?(value)
+          return true if value.blank?
+          return true if value.is_a?(Date)
+          return false unless value =~ /\d{2}-\d{2}-\d{4}/
+          !!Date.strptime(value, "%d-%m-%Y") rescue false
+        end
+
+        def self.valid_date_time?(value)
+          return true if value.blank?
+          value.is_a?(DateTime) || !!DateTime.iso8601(value.dup) rescue false
+        end
+
+        def self.for(klass)
+          new(klass)
+        end
+
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def valid_value?(value)
+          VALIDATORS[@klass].call(value)
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/value_object.rb

@@ -33,6 +33,7 @@ module Sequent
               Sequent::Core::Helpers::ParamSupport,
               ActiveModel::Serializers::JSON,
               ActiveModel::Validations
+      include Sequent::Core::Helpers::TypeConversionSupport
 
       self.include_root_in_json=false
 

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sequent
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Lars Vonk
@@ -131,17 +131,24 @@ files:
 - lib/sequent/core/event.rb
 - lib/sequent/core/event_record.rb
 - lib/sequent/core/event_store.rb
+- lib/sequent/core/ext/ext.rb
+- lib/sequent/core/helpers/array_with_type.rb
 - lib/sequent/core/helpers/association_validator.rb
 - lib/sequent/core/helpers/attribute_support.rb
-- lib/sequent/core/helpers/boolean_support.rb
 - lib/sequent/core/helpers/copyable.rb
+- lib/sequent/core/helpers/date_time_validator.rb
+- lib/sequent/core/helpers/date_validator.rb
+- lib/sequent/core/helpers/default_validators.rb
 - lib/sequent/core/helpers/equal_support.rb
 - lib/sequent/core/helpers/helpers.rb
 - lib/sequent/core/helpers/mergable.rb
 - lib/sequent/core/helpers/param_support.rb
 - lib/sequent/core/helpers/self_applier.rb
 - lib/sequent/core/helpers/string_support.rb
+- lib/sequent/core/helpers/string_to_value_parsers.rb
+- lib/sequent/core/helpers/type_conversion_support.rb
 - lib/sequent/core/helpers/uuid_helper.rb
+- lib/sequent/core/helpers/value_validators.rb
 - lib/sequent/core/record_sessions/active_record_session.rb
 - lib/sequent/core/record_sessions/record_sessions.rb
 - lib/sequent/core/record_sessions/replay_events_session.rb
@@ -181,3 +188,4 @@ signing_key:
 specification_version: 4
 summary: Event sourcing framework for Ruby
 test_files: []
+has_rdoc: 

data/lib/sequent/core/helpers/boolean_support.rb

@@ -1,36 +0,0 @@
-module Sequent
-  module Core
-    module Helpers
-      #
-      # Parses the strings "true", "false" and nil to true, false, false
-      #
-      # You need to include this module explicitly when working with booleans.
-      #
-      # Example:
-      #
-      #   class Registration < Sequent::Core::ValueObject
-      #     include Sequent::Core::Helpers::BooleanSupport
-      #     attrs accepted_terms: Boolean
-      #   end
-      module BooleanSupport
-
-        def self.included(base)
-          base.before_validation :parse_booleans
-        end
-
-        def parse_booleans
-          attributes.each do |name, type|
-            if type == Boolean
-              raw_value = self.instance_variable_get("@#{name}")
-              return if raw_value.kind_of? Boolean
-              return unless [nil, "true", "false"].include?(raw_value)
-              bool_value = raw_value == "true" ? true : false
-              self.instance_variable_set "@#{name}", bool_value
-            end
-          end
-        end
-      end
-
-    end
-  end
-end