sequent 0.1.10 → 1.0.0

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

@@ -22,6 +22,13 @@ class Float
   end
 end
 
+class BigDecimal
+  def self.deserialize_from_json(value)
+    return nil if value.nil?
+    BigDecimal.new(value)
+  end
+end
+
 class Boolean
   def self.deserialize_from_json(value)
     value.nil? ? nil : (value.present? ? value : false)
@@ -29,12 +36,25 @@ class Boolean
 end
 
 class Date
+  def self.from_params(value)
+    return value if value.is_a?(Date)
+    value.blank? ? nil : Date.iso8601(value.dup)
+  rescue ArgumentError
+    value
+  end
+
   def self.deserialize_from_json(value)
     value.blank? ? nil : Date.iso8601(value.dup)
   end
 end
 
 class DateTime
+  def self.from_params(value)
+    value.blank? ? nil : DateTime.iso8601(value.dup)
+  rescue ArgumentError
+    value
+  end
+
   def self.deserialize_from_json(value)
     value.blank? ? nil : DateTime.iso8601(value.dup)
   end

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

@@ -16,6 +16,10 @@ module Sequent
         def to_s
           "Sequent::Core::Helpers::ArrayWithType.new(#{item_type})"
         end
+
+        def candidate?(value)
+          value.is_a?(Array)
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
-require 'active_model'
+require 'active_model/validator'
+
 module Sequent
   module Core
     module Helpers
@@ -32,12 +33,12 @@ module Sequent
           associations.each do |association|
             value = record.instance_variable_get("@#{association.to_s}")
             if value && incorrect_type?(value, record, association)
-              record.errors[association] = "is not of type #{record.class.types[association]}"
-            elsif value && value.kind_of?(Array)
-              item_type = record.class.type_for(association).item_type
-              record.errors[association] = "is invalid" unless validate_all(value, item_type).all?
+              record.errors.add(association, "is not of type #{describe_type(record.class.types[association])}")
+            elsif value && value.is_a?(Array)
+              item_type = record.class.types.fetch(association).item_type
+              record.errors.add(association, "is invalid") unless validate_all(value, item_type).all?
             else
-              record.errors[association] = "is invalid" if value && value.invalid?
+              record.errors.add(association, "is invalid") if value && value.invalid?
             end
           end
         end
@@ -45,7 +46,13 @@ module Sequent
         private
 
         def incorrect_type?(value, record, association)
-          !value.kind_of?(Array) && record.class.respond_to?(:types) && !value.kind_of?(record.class.types[association])
+          return unless record.class.respond_to?(:types)
+          type = record.class.types[association]
+          if type.respond_to?(:candidate?)
+            !type.candidate?(value)
+          else
+            !value.is_a?(type)
+          end
         end
 
         def validate_all(values, item_type)
@@ -59,6 +66,14 @@ module Sequent
             end
           end
         end
+
+        def describe_type(type)
+          if type.is_a?(ArrayWithType)
+            'array'
+          else
+            type.to_s
+          end
+        end
       end
     end
   end

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

@@ -33,10 +33,6 @@ module Sequent
             end
           end
 
-          def type_for(name)
-            @types.find { |k, _| k == name }.last
-          end
-
           def attrs(args)
             @types ||= {}
             @types.merge!(args)
@@ -122,6 +118,19 @@ EOS
           hash
         end
 
+        def as_json(opts = {})
+          hash = HashWithIndifferentAccess.new
+          self.class.types.each do |name, _|
+            value = self.instance_variable_get("@#{name}")
+            hash[name] = if value.respond_to?(:as_json)
+                           value.as_json(opts)
+                         else
+                           value
+                         end
+          end
+          hash
+        end
+
         def update(changes)
           self.class.new(attributes.merge(changes))
         end
@@ -134,8 +143,8 @@ EOS
               value.validation_errors.each { |k, v| result["#{field[0].to_s}_#{k.to_s}".to_sym] = v }
             elsif field[1].class == ArrayWithType and value.present?
               value
-              .select { |val| val.respond_to?(:validation_errors) }
-              .each_with_index do |val, index|
+                .select { |val| val.respond_to?(:validation_errors) }
+                .each_with_index do |val, index|
                 val.validation_errors.each do |k, v|
                   result["#{field[0].to_s}_#{index}_#{k.to_s}".to_sym] = v
                 end

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

@@ -11,9 +11,17 @@ module Sequent
       #
       module ParamSupport
         module ClassMethods
-          def from_params(params = {})
-            allocate.tap { |x| x.from_params(params) }
+          def from_params(params = {}, strict_nil_check = true)
+            allocate.tap { |x| x.from_params(params, strict_nil_check) }
           end
+
+          # Create an object based on HTTP form data
+          # This differs from form_params that an empty string
+          # is the same as nil since HTTP form post will send empty text fields
+          def from_form_data(params = {})
+            from_params(params, false)
+          end
+
         end
 
         # extend host class with class methods when we're included
@@ -21,18 +29,19 @@ module Sequent
           host_class.extend(ClassMethods)
         end
 
-        def from_params(params)
+        def from_params(params, strict_nil_check = true)
           params = HashWithIndifferentAccess.new(params)
           self.class.types.each do |attribute, type|
             value = params[attribute]
 
-            next if value.blank?
+            next if strict_nil_check && value.nil?
+            next if (!strict_nil_check && value.blank?)
             if type.respond_to? :from_params
               value = type.from_params(value)
-            elsif type.is_a? Sequent::Core::Helpers::ArrayWithType
+            elsif value.is_a?(Array)
               value = value.map do |v|
                 if type.item_type.respond_to?(:from_params)
-                  type.item_type.from_params(v)
+                  type.item_type.from_params(v, strict_nil_check)
                 else
                   v
                 end
@@ -53,7 +62,7 @@ module Sequent
             next if field[0] == "errors"
             hash[field[0]] = if value.kind_of?(Array)
                                next if value.blank?
-                               value.map{|v|value_to_string(v)}
+                               value.map { |v| value_to_string(v) }
                              else
                                value_to_string(value)
                              end
@@ -69,34 +78,24 @@ module Sequent
           elsif val.is_a? DateTime
             val.iso8601
           elsif val.is_a? Date
-            val.strftime("%d-%m-%Y")
+            val.iso8601
           else
             val
           end
         end
 
-        def make_params(root, hash, memo = {})
-          hash.each do |k, v|
-            key = "#{root}[#{k}]"
-            if v.is_a? Hash
-              make_params(key, v, memo)
-            elsif v.is_a?(Array) && v.first.is_a?(Hash)
-              key = "#{key}[]"
-              v.each { |value| make_params(key, value, memo) }
-            elsif v.is_a?(Array)
-              memo["#{key}[]"] = v
-            else
-              string_value = v.nil? ? "" : v.to_s
-              if memo.has_key?(key)
-                if memo[:key].is_a? Array
-                  memo[key] << string_value
-                else
-                  memo[key] = [memo[key], string_value]
-                end
-              else
-                memo[key] = string_value
+        def make_params(key, enumerable, memo = {})
+          case enumerable
+            when Array
+              enumerable.each_with_index do |object, index|
+                make_params("#{key}[#{index}]", object, memo)
               end
-            end
+            when Hash
+              enumerable.each do |hash_key, object|
+                make_params("#{key}[#{hash_key}]", object, memo)
+              end
+            else
+              memo[key] = enumerable
           end
           memo
         end

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

@@ -17,7 +17,6 @@ module Sequent
       module SelfApplier
 
         module ClassMethods
-
           def on(*message_classes, &block)
             message_classes.each { |message_class| message_mapping[message_class] = block }
           end
@@ -25,6 +24,10 @@ module Sequent
           def message_mapping
             @message_mapping ||= {}
           end
+
+          def handles_message?(message)
+            message_mapping.keys.include? message.class
+          end
         end
 
         def self.included(host_class)
@@ -35,9 +38,7 @@ module Sequent
           handler = self.class.message_mapping[message.class]
           self.instance_exec(message, &handler) if handler
         end
-
       end
-
     end
   end
 end

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

@@ -9,6 +9,7 @@ module Sequent
           ::Symbol => ->(value) { Symbol.deserialize_from_json(value) },
           ::String => ->(value) { value },
           ::Integer => ->(value) { parse_to_integer(value) },
+          ::BigDecimal => ->(value) { parse_to_bigdecimal(value) },
           ::Float => ->(value) { parse_to_float(value) },
           ::Boolean => ->(value) { parse_to_bool(value) },
           ::Date => ->(value) { parse_to_date(value) },
@@ -17,7 +18,12 @@ module Sequent
         }
 
         def self.parse_to_integer(value)
-          Integer(value) unless value.blank?
+          return value if value.is_a?(Integer)
+          Integer(value, 10) unless value.blank?
+        end
+
+        def self.parse_to_bigdecimal(value)
+          BigDecimal.new(value) unless value.blank?
         end
 
         def self.parse_to_float(value)
@@ -34,7 +40,7 @@ module Sequent
 
         def self.parse_to_date(value)
           return if value.blank?
-          value.is_a?(Date) ? value : Date.strptime(value, "%d-%m-%Y")
+          value.is_a?(Date) ? value : Date.iso8601(value.dup)
         end
 
         def self.parse_to_date_time(value)
@@ -42,6 +48,7 @@ module Sequent
         end
 
         def self.parse_array(values, type_in_array)
+          fail "invalid value for array(): \"#{values}\"" unless values.is_a?(Array)
           values.map do |item|
             if item.respond_to?(:parse_attrs_to_correct_types)
               item.parse_attrs_to_correct_types
@@ -65,7 +72,7 @@ module Sequent
         end
 
         def parse_from_string(value)
-          parser = PARSERS[@klass]
+          parser = PARSERS.fetch(@klass) { |key| fail "Unsupported value type: #{key}" }
           if @array_with_type
             parser.call(value, @array_with_type.item_type)
           else

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

@@ -2,7 +2,10 @@ require 'active_model'
 
 module Sequent
   module Core
+    TypeConversionError = Class.new(RuntimeError)
+
     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.
@@ -21,6 +24,8 @@ module Sequent
             end
           end
           the_copy
+        rescue => e
+          raise TypeConversionError, e.message
         end
       end
     end

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

@@ -6,11 +6,11 @@ module Sequent
       module UuidHelper
 
         def new_uuid
-          SecureRandom.uuid
+          warn "DEPRECATION WARNING: Sequent::Core::Helpers::UuidHelper.new_uuid is deprecated. Use Sequent.new_uuid instead"
+          Sequent.new_uuid
         end
 
         module_function :new_uuid
-
       end
     end
   end

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

@@ -27,8 +27,8 @@ module Sequent
         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
+          return false unless value =~ /\d{4}-\d{2}-\d{2}/
+          !!Date.iso8601(value) rescue false
         end
 
         def self.valid_date_time?(value)

data/lib/sequent/core/random_uuid_generator.rb

@@ -0,0 +1,9 @@
+module Sequent
+  module Core
+    module RandomUuidGenerator
+      def self.uuid
+        SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/sequent/core/record_sessions/active_record_session.rb

@@ -11,16 +11,21 @@ module Sequent
       class ActiveRecordSession
 
         def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {}, &block)
-          defaults = {update_sequence_number: true}
-          args = defaults.merge(options)
           record = record_class.unscoped.where(where_clause).first
           raise("Record of class #{record_class} with where clause #{where_clause} not found while handling event #{event}") unless record
-          yield record if block_given?
-          record.sequence_number = event.sequence_number if args[:update_sequence_number]
           record.updated_at = event.created_at if record.respond_to?(:updated_at)
+          yield record if block_given?
+          update_sequence_number = options.key?(:update_sequence_number) ?
+                                     options[:update_sequence_number] :
+                                     record.respond_to?(:sequence_number=)
+          record.sequence_number = event.sequence_number if update_sequence_number
           record.save!
         end
 
+        def execute(statement)
+          ActiveRecord::Base.connection.execute(statement)
+        end
+
         def create_record(record_class, values)
           record = new_record(record_class, values)
           yield record if block_given?
@@ -31,7 +36,8 @@ module Sequent
         def create_or_update_record(record_class, values, created_at = Time.now)
           record = get_record(record_class, values)
           unless record
-            record = new_record(record_class, values.merge(created_at: created_at))
+            record = new_record(record_class, values)
+            record.created_at = created_at if record.respond_to?(:created_at)
           end
           yield record
           record.save!

data/lib/sequent/core/record_sessions/replay_events_session.rb

@@ -52,6 +52,92 @@ module Sequent
           end
         end
 
+        class Index
+          def initialize(indexed_columns)
+            @indexed_columns = Hash.new do |hash, record_class|
+              if record_class.column_names.include? 'aggregate_id'
+                hash[record_class] = [:aggregate_id]
+              else
+                hash[record_class] = []
+              end
+            end
+
+            @indexed_columns.merge!(indexed_columns)
+
+            @index = {}
+            @reverse_index = {}
+          end
+
+          def add(record_class, record)
+            return unless indexed?(record_class)
+
+            get_keys(record_class, record).each do |key|
+              @index[key.hash] = [] unless @index.has_key? key.hash
+              @index[key.hash] << record
+
+              @reverse_index[record.object_id.hash] = [] unless @reverse_index.has_key? record.object_id.hash
+              @reverse_index[record.object_id.hash] << key.hash
+            end
+          end
+
+          def remove(record_class, record)
+            return unless indexed?(record_class)
+
+            keys = @reverse_index.delete(record.object_id.hash) { [] }
+
+            return unless keys.any?
+
+            keys.each do |key|
+              @index[key].delete(record)
+              @index.delete(key) if @index[key].count == 0
+            end
+          end
+
+          def update(record_class, record)
+            remove(record_class, record)
+            add(record_class, record)
+          end
+
+          def find(record_class, where_clause)
+            key = [record_class.name]
+            get_index(record_class, where_clause).each do |field|
+              key << field
+              key << where_clause[field]
+            end
+            @index[key.hash] || []
+          end
+
+          def clear
+            @index = {}
+            @reverse_index = {}
+          end
+
+          def use_index?(record_class, where_clause)
+            @indexed_columns.has_key?(record_class) && @indexed_columns[record_class].any? { |indexed_where| where_clause.keys.size == indexed_where.size && (where_clause.keys - indexed_where).empty? }
+          end
+
+          private
+
+          def indexed?(record_class)
+            @indexed_columns.has_key?(record_class)
+          end
+
+          def get_keys(record_class, record)
+            @indexed_columns[record_class].map do |index|
+              arr = [record_class.name]
+              index.each do |key|
+                arr << key
+                arr << record[key]
+              end
+              arr
+            end
+          end
+
+          def get_index(record_class, where_clause)
+            @indexed_columns[record_class].find { |indexed_where| where_clause.keys.size == indexed_where.size && (where_clause.keys - indexed_where).empty? }
+          end
+        end
+
         # +insert_with_csv_size+ number of records to insert in a single batch
         #
         # +indices+ Hash of indices to create in memory. Greatly speeds up the replaying.
@@ -60,17 +146,18 @@ module Sequent
         def initialize(insert_with_csv_size = 50, indices = {})
           @insert_with_csv_size = insert_with_csv_size
           @record_store = Hash.new { |h, k| h[k] = Set.new }
-          @record_index = {}
-          @indices = indices
+          @record_index = Index.new(indices)
         end
 
         def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {}, &block)
-          defaults = {update_sequence_number: true}
-          args = defaults.merge(options)
           record = get_record!(record_class, where_clause)
           record.updated_at = event.created_at if record.respond_to?(:updated_at)
           yield record if block_given?
-          record.sequence_number = event.sequence_number if args[:update_sequence_number]
+          @record_index.update(record_class, record)
+          update_sequence_number = options.key?(:update_sequence_number) ?
+                                     options[:update_sequence_number] :
+                                     record.respond_to?(:sequence_number=)
+          record.sequence_number = event.sequence_number if update_sequence_number
         end
 
         def create_record(record_class, values)
@@ -81,11 +168,6 @@ module Sequent
           if self.class.struct_cache.has_key?(struct_class_name)
             struct_class = self.class.struct_cache[struct_class_name]
           else
-            if column_names.include? :aggregate_id
-              @indices[record_class] ||= []
-              @indices[record_class] << [:aggregate_id]
-            end
-
             # We create a struct on the fly.
             # Since the replay happens in memory we implement the ==, eql? and hash methods
             # to point to the same object. A record is the same if and only if they point to
@@ -95,11 +177,7 @@ module Sequent
               class #{struct_class_name}
                 include InitStruct
                 def ==(other)
-                  return true if self.equal?(other)
-                  super
-                end
-                def eql?(other)
-                  self == other
+                  self.equal?(other)
                 end
                 def hash
                   self.object_id.hash
@@ -115,12 +193,8 @@ module Sequent
           yield record if block_given?
           @record_store[record_class] << record
 
-          if indexed?(record_class)
-            do_with_cache_keys(record_class, record) do |key|
-              @record_index[key] = [] unless @record_index.has_key?(key)
-              @record_index[key] << record
-            end
-          end
+          @record_index.add(record_class, record)
+
           record
         end
 
@@ -130,6 +204,7 @@ module Sequent
             record = create_record(record_class, values.merge(created_at: created_at))
           end
           yield record if block_given?
+          @record_index.update(record_class, record)
           record
         end
 
@@ -152,11 +227,7 @@ module Sequent
 
         def delete_record(record_class, record)
           @record_store[record_class].delete(record)
-          if indexed?(record_class)
-            do_with_cache_keys(record_class, record) do |key|
-              @record_index[key].delete(record) if @record_index.has_key?(key)
-            end
-          end
+          @record_index.remove(record_class, record)
         end
 
         def update_all_records(record_class, where_clause, updates)
@@ -164,6 +235,7 @@ module Sequent
             updates.each_pair do |k, v|
               record[k.to_sym] = v
             end
+            @record_index.update(record_class, record)
           end
         end
 
@@ -171,18 +243,19 @@ module Sequent
           records = find_records(record_class, where_clause)
           records.each do |record|
             yield record
+            @record_index.update(record_class, record)
           end
         end
 
         def do_with_record(record_class, where_clause)
           record = get_record!(record_class, where_clause)
           yield record
+          @record_index.update(record_class, record)
         end
 
         def find_records(record_class, where_clause)
-          if use_index?(record_class, where_clause)
-            values = get_index(record_class, where_clause).map { |field| where_clause[field] }
-            @record_index[[record_class, *values]] || []
+          if @record_index.use_index?(record_class, where_clause)
+            @record_index.find(record_class, where_clause)
           else
             @record_store[record_class].select do |record|
               where_clause.all? do |k, v|
@@ -195,7 +268,6 @@ module Sequent
                   actual_value == expected_value
                 end
               end
-
             end
           end.dup
         end
@@ -206,101 +278,59 @@ module Sequent
         end
 
         def commit
-          begin
-            @record_store.each do |clazz, records|
-              if records.size > @insert_with_csv_size
-                csv = CSV.new("")
-                column_names = clazz.column_names.reject { |name| name == "id" }
-                records.each do |obj|
-                  begin
-                    csv << column_names.map do |column_name|
-                      obj[column_name]
-                    end
+          @record_store.each do |clazz, records|
+            @column_cache ||= {}
+            @column_cache[clazz.name] ||= clazz.columns.reduce({}) do |hash, column|
+              hash.merge({ column.name => column })
+            end
+            if records.size > @insert_with_csv_size
+              csv = CSV.new("")
+              column_names = clazz.column_names.reject { |name| name == "id" }
+              records.each do |obj|
+                begin
+                  csv << column_names.map do |column_name|
+                    @column_cache[clazz.name][column_name].type_cast_for_database(obj[column_name])
                   end
                 end
+              end
 
-                buf = ''
-                conn = ActiveRecord::Base.connection.raw_connection
-                copy_data = StringIO.new csv.string
-                conn.transaction do
-                  conn.exec("COPY #{clazz.table_name} (#{column_names.join(",")}) FROM STDIN WITH csv")
-                  begin
-                    while copy_data.read(1024, buf)
-                      ### Uncomment this to test error-handling for exceptions from the reader side:
-                      # raise Errno::ECONNRESET, "socket closed while reading"
-                      until conn.put_copy_data(buf)
-                        sleep 0.1
-                      end
-                    end
-                  rescue Errno => err
-                    errmsg = "%s while reading copy data: %s" % [err.class.name, err.message]
-                    conn.put_copy_end(errmsg)
-                  ensure
-                    conn.put_copy_end
-                    copy_data.close
-                    while res = conn.get_result
-                      status = res.res_status(res.result_status)
-                      if status != "PGRES_COMMAND_OK"
-                        raise "Postgres copy command failed: #{status}, #{res.error_message}"
-                      end
-                    end
+              buf = ''
+              conn = ActiveRecord::Base.connection.raw_connection
+              copy_data = StringIO.new csv.string
+              conn.transaction do
+                conn.copy_data("COPY #{clazz.table_name} (#{column_names.join(",")}) FROM STDIN WITH csv") do
+                  while copy_data.read(1024, buf)
+                    conn.put_copy_data(buf)
                   end
                 end
-
-              else
-
-                clazz.unscoped do
-                  inserts = []
-                  column_names = clazz.column_names.reject { |name| name == "id" }
-                  prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(",")
-                  records.each do |r|
-                    values = column_names.map { |name| r[name.to_sym] }
-                    inserts << values
-                  end
-                  sql = %Q{insert into #{clazz.table_name} (#{column_names.join(",")}) values (#{prepared_values})}
-                  inserts.each do |insert|
-                    clazz.connection.raw_connection.async_exec(sql, insert)
+              end
+            else
+              clazz.unscoped do
+                inserts = []
+                column_names = clazz.column_names.reject { |name| name == "id" }
+                prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(",")
+                records.each do |r|
+                  values = column_names.map do |column_name|
+                    @column_cache[clazz.name][column_name].type_cast_for_database(r[column_name.to_sym])
                   end
+                  inserts << values
+                end
+                sql = %Q{insert into #{clazz.table_name} (#{column_names.join(",")}) values (#{prepared_values})}
+                inserts.each do |insert|
+                  clazz.connection.raw_connection.async_exec(sql, insert)
                 end
               end
             end
-
-
-          ensure
-            clear
           end
+        ensure
+          clear
         end
 
         def clear
           @record_store.clear
           @record_index.clear
         end
-
-        private
-        def indexed?(record_class)
-          @indices.has_key?(record_class)
-        end
-
-        def do_with_cache_keys(record_class, record)
-          @indices[record_class].each do |index|
-            cache_key = [record_class]
-            index.each do |key|
-              cache_key << record[key]
-            end
-            yield cache_key
-          end
-        end
-
-        def use_index?(record_class, where_clause)
-          @indices.has_key?(record_class) and @indices[record_class].any? { |indexed_where| where_clause.keys.size == indexed_where.size and (where_clause.keys - indexed_where).empty? }
-        end
-
-        def get_index(record_class, where_clause)
-          @indices[record_class].find { |indexed_where| where_clause.keys.size == indexed_where.size and (where_clause.keys - indexed_where).empty? }
-        end
-
       end
-
     end
   end
 end