modis 1.3.0 → 1.4.0

data/lib/modis.rb

@@ -3,6 +3,7 @@ require 'connection_pool'
 require 'active_model'
 require 'active_support/all'
 require 'yaml'
+require 'msgpack'
 
 require 'modis/version'
 require 'modis/configuration'
@@ -22,7 +23,7 @@ module Modis
                   :connection_pool_timeout
   end
 
-  self.redis_options = {}
+  self.redis_options = { driver: :hiredis }
   self.connection_pool_size = 5
   self.connection_pool_timeout = 5
 

data/lib/modis/attribute.rb

@@ -1,6 +1,12 @@
 module Modis
   module Attribute
-    TYPES = [:string, :integer, :float, :timestamp, :boolean, :array, :hash]
+    TYPES = { string: [String],
+              integer: [Fixnum],
+              float: [Float],
+              timestamp: [Time],
+              hash: [Hash],
+              array: [Array],
+              boolean: [TrueClass, FalseClass] }.freeze
 
     def self.included(base)
       base.extend ClassMethods
@@ -10,46 +16,64 @@ module Modis
     end
 
     module ClassMethods
-      def bootstrap_attributes
+      def bootstrap_attributes(parent = nil)
+        attr_reader :attributes
+
         class << self
-          attr_accessor :attributes
+          attr_accessor :attributes, :attributes_with_defaults
         end
 
-        self.attributes = {}
+        self.attributes = parent ? parent.attributes.dup : {}
+        self.attributes_with_defaults = parent ? parent.attributes_with_defaults.dup : {}
 
-        attribute :id, :integer
+        attribute :id, :integer unless parent
       end
 
-      def attribute(name, types, options = {})
+      def attribute(name, type, options = {})
         name = name.to_s
-        types = Array[*types]
         raise AttributeError, "Attribute with name '#{name}' has already been specified." if attributes.key?(name)
-        types.each { |type| raise UnsupportedAttributeType, type unless TYPES.include?(type) }
 
-        attributes[name] = options.update(types: types)
-        define_attribute_methods [name]
-        class_eval <<-EOS, __FILE__, __LINE__
+        type_classes = Array(type).map do |t|
+          raise UnsupportedAttributeType, t unless TYPES.key?(t)
+          TYPES[t]
+        end.flatten
+
+        attributes[name] = options.update(type: type)
+        attributes_with_defaults[name] = options[:default] if options[:default]
+        define_attribute_methods([name])
+
+        value_coercion = type == :timestamp ? 'value = Time.new(*value) if value && value.is_a?(Array) && value.count == 7' : nil
+        predicate = type_classes.map { |cls| "value.is_a?(#{cls.name})" }.join(' || ')
+
+        type_check = <<-RUBY
+        if value && !(#{predicate})
+          raise Modis::AttributeCoercionError, "Received value of type '\#{value.class}', expected '#{type_classes.join("', '")}' for attribute '#{name}'."
+        end
+        RUBY
+
+        class_eval <<-RUBY, __FILE__, __LINE__
           def #{name}
             attributes['#{name}']
           end
 
           def #{name}=(value)
-            ensure_type('#{name}', value)
-            #{name}_will_change! unless value == attributes['#{name}']
-            attributes['#{name}'] = value
+            #{value_coercion}
+
+            # ActiveSupport's Time#<=> does not perform well when comparing with NilClass.
+            if (value.nil? ^ attributes['#{name}'].nil?) || (value != attributes['#{name}'])
+              #{type_check}
+              #{name}_will_change!
+              attributes['#{name}'] = value
+            end
           end
-        EOS
+        RUBY
       end
     end
 
-    def attributes
-      @attributes ||= Hash[self.class.attributes.keys.zip]
-    end
-
     def assign_attributes(hash)
       hash.each do |k, v|
         setter = "#{k}="
-        send(setter, v) if respond_to?(setter)
+        send(setter, v) if self.class.attributes.key?(k.to_s)
       end
     end
 
@@ -65,19 +89,15 @@ module Modis
 
     def set_sti_type
       return unless self.class.sti_child?
-      assign_attributes(type: self.class.name)
+      write_attribute(:type, self.class.name)
     end
 
     def reset_changes
-      @changed_attributes.clear if @changed_attributes
+      @changed_attributes = nil
     end
 
     def apply_defaults
-      defaults = {}
-      self.class.attributes.each do |attribute, options|
-        defaults[attribute] = options[:default] if options[:default]
-      end
-      assign_attributes(defaults)
+      @attributes = Hash[self.class.attributes_with_defaults]
     end
   end
 end

data/lib/modis/configuration.rb

@@ -3,10 +3,12 @@ module Modis
     yield config
   end
 
-  def self.config
-    @config ||= Configuration.new
+  class Configuration < Struct.new(:namespace)
   end
 
-  class Configuration < Struct.new(:namespace)
+  class << self
+    attr_reader :config
   end
+
+  @config = Configuration.new
 end

data/lib/modis/finder.rb

@@ -5,33 +5,26 @@ module Modis
     end
 
     module ClassMethods
-      def find(id)
-        Modis.with_connection do |redis|
-          attributes = attributes_for(redis, id)
-          model_for(attributes)
-        end
+      def find(*ids)
+        models = find_all(ids)
+        ids.count == 1 ? models.first : models
       end
 
       def all
-        records = []
-
-        Modis.with_connection do |redis|
+        records = Modis.with_connection do |redis|
           ids = redis.smembers(key_for(:all))
-          records = redis.pipelined do
+          redis.pipelined do
             ids.map { |id| record_for(redis, id) }
           end
         end
 
-        records.map do |record|
-          attributes = record_to_attributes(record)
-          model_for(attributes)
-        end
+        records_to_models(records)
       end
 
       def attributes_for(redis, id)
         raise RecordNotFound, "Couldn't find #{name} without an ID" if id.nil?
 
-        attributes = record_to_attributes(record_for(redis, id))
+        attributes = deserialize(record_for(redis, id))
 
         unless attributes['id'].present?
           raise RecordNotFound, "Couldn't find #{name} with id=#{id}"
@@ -40,15 +33,34 @@ module Modis
         attributes
       end
 
+      def find_all(ids)
+        raise RecordNotFound, "Couldn't find #{name} without an ID" if ids.empty?
+
+        records = Modis.with_connection do |redis|
+          blk = proc { |id| record_for(redis, id) }
+          ids.count == 1 ? ids.map(&blk) : redis.pipelined { ids.map(&blk) }
+        end
+
+        models = records_to_models(records)
+
+        if models.count < ids.count
+          missing = ids - models.map(&:id)
+          raise RecordNotFound, "Couldn't find #{name} with id=#{missing.first}"
+        end
+
+        models
+      end
+
       private
 
-      def model_for(attributes)
-        model_class(attributes).new(attributes, new_record: false)
+      def records_to_models(records)
+        records.map do |record|
+          model_for(deserialize(record)) unless record.blank?
+        end.compact
       end
 
-      def record_to_attributes(record)
-        record.each { |k, v| record[k] = coerce_from_persistence(v) }
-        record
+      def model_for(attributes)
+        model_class(attributes).new(attributes, new_record: false)
       end
 
       def record_for(redis, id)

data/lib/modis/index.rb

@@ -4,19 +4,16 @@ module Modis
       base.extend ClassMethods
       base.instance_eval do
         bootstrap_indexes
-        after__internal_create :add_to_index
-        after__internal_update :update_index
-        before__internal_destroy :remove_from_index
       end
     end
 
     module ClassMethods
-      def bootstrap_indexes
+      def bootstrap_indexes(parent = nil)
         class << self
           attr_accessor :indexed_attributes
         end
 
-        self.indexed_attributes = []
+        self.indexed_attributes = parent ? parent.indexed_attributes.dup : []
       end
 
       def index(attribute)
@@ -28,8 +25,9 @@ module Modis
       def where(query)
         raise IndexError, 'Queries using multiple indexes is not currently supported.' if query.keys.size > 1
         attribute, value = query.first
-        index = index_for(attribute, value)
-        index.map { |id| find(id) }
+        ids = index_for(attribute, value)
+        return [] if ids.empty?
+        find_all(ids)
       end
 
       def index_for(attribute, value)
@@ -54,38 +52,32 @@ module Modis
       self.class.index_key(attribute, value)
     end
 
-    def add_to_index
+    def add_to_indexes(redis)
       return if indexed_attributes.empty?
 
-      Modis.with_connection do |redis|
-        indexed_attributes.each do |attribute|
-          key = index_key(attribute, read_attribute(attribute))
-          redis.sadd(key, id)
-        end
+      indexed_attributes.each do |attribute|
+        key = index_key(attribute, read_attribute(attribute))
+        redis.sadd(key, id)
       end
     end
 
-    def remove_from_index
+    def remove_from_indexes(redis)
       return if indexed_attributes.empty?
 
-      Modis.with_connection do |redis|
-        indexed_attributes.each do |attribute|
-          key = index_key(attribute, read_attribute(attribute))
-          redis.srem(key, id)
-        end
+      indexed_attributes.each do |attribute|
+        key = index_key(attribute, read_attribute(attribute))
+        redis.srem(key, id)
       end
     end
 
-    def update_index
+    def update_indexes(redis)
       return if indexed_attributes.empty?
 
-      Modis.with_connection do |redis|
-        (changes.keys & indexed_attributes).each do |attribute|
-          old_value, new_value = changes[attribute]
-          old_key = index_key(attribute, old_value)
-          new_key = index_key(attribute, new_value)
-          redis.smove(old_key, new_key, id)
-        end
+      (changes.keys & indexed_attributes).each do |attribute|
+        old_value, new_value = changes[attribute]
+        old_key = index_key(attribute, old_value)
+        new_key = index_key(attribute, new_value)
+        redis.smove(old_key, new_key, id)
       end
     end
   end

data/lib/modis/model.rb

@@ -10,7 +10,6 @@ module Modis
         extend ActiveModel::Callbacks
 
         define_model_callbacks :save, :create, :update, :destroy
-        define_model_callbacks :_internal_create, :_internal_update, :_internal_destroy
 
         include Modis::Errors
         include Modis::Transaction
@@ -31,9 +30,9 @@ module Modis
     end
 
     def initialize(record = nil, options = {})
-      set_sti_type
       apply_defaults
-      assign_attributes(record.symbolize_keys) if record
+      set_sti_type
+      assign_attributes(record) if record
       reset_changes
 
       return unless options.key?(:new_record)

data/lib/modis/persistence.rb

@@ -3,8 +3,10 @@ module Modis
     def self.included(base)
       base.extend ClassMethods
       base.instance_eval do
-        after__internal_create :track
-        before__internal_destroy :untrack
+        class << self
+          attr_reader :sti_child
+          alias_method :sti_child?, :sti_child
+        end
       end
     end
 
@@ -19,31 +21,26 @@ module Modis
             attribute :type, :string unless attributes.key?('type')
           end
 
-          class << self
-            delegate :attributes, :indexed_attributes, to: :sti_parent
-          end
-
           @sti_child = true
           @sti_parent = parent
-        end
-      end
 
-      # :nodoc:
-      def sti_child?
-        @sti_child == true
+          bootstrap_attributes(parent)
+          bootstrap_indexes(parent)
+        end
       end
 
       def namespace
         return sti_parent.namespace if sti_child?
-        return @namespace if @namespace
-        @namespace = name.split('::').map(&:underscore).join(':')
+        @namespace ||= name.split('::').map(&:underscore).join(':')
       end
 
-      attr_writer :namespace
+      def namespace=(value)
+        @namespace = value
+        @absolute_namespace = nil
+      end
 
       def absolute_namespace
-        parts = [Modis.config.namespace, namespace]
-        @absolute_namespace = parts.compact.join(':')
+        @absolute_namespace ||= [Modis.config.namespace, namespace].compact.join(':')
       end
 
       def key_for(id)
@@ -62,8 +59,43 @@ module Modis
         model
       end
 
-      def coerce_from_persistence(value)
-        YAML.load(value)
+      YAML_MARKER = '---'.freeze
+      def deserialize(record)
+        values = record.values
+        values = MessagePack.unpack(msgpack_array_header(values.size) + values.join)
+        keys = record.keys
+        values.each_with_index { |v, i| record[keys[i]] = v }
+        record
+      rescue MessagePack::MalformedFormatError
+        found_yaml = false
+
+        record.each do |k, v|
+          if v.start_with?(YAML_MARKER)
+            found_yaml = true
+            record[k] = YAML.load(v)
+          else
+            record[k] = MessagePack.unpack(v)
+          end
+        end
+
+        if found_yaml
+          id = record['id']
+          STDERR.puts "#{self}(id: #{id}) contains attributes serialized as YAML. As of Modis 1.4.0, YAML is no longer used as the serialization format. To improve performance loading this record, you can force the record to new serialization format (MessagePack) with: #{self}.find(#{id}).save!(yaml_sucks: true)"
+        end
+
+        record
+      end
+
+      private
+
+      def msgpack_array_header(n)
+        if n < 16
+          [0x90 | n].pack("C")
+        elsif n < 65536
+          [0xDC, n].pack("Cn")
+        else
+          [0xDD, n].pack("CN")
+        end.force_encoding(Encoding::UTF_8)
       end
     end
 
@@ -92,7 +124,9 @@ module Modis
     def destroy
       self.class.transaction do |redis|
         run_callbacks :destroy do
-          run_callbacks :_internal_destroy do
+          redis.pipelined do
+            remove_from_indexes(redis)
+            redis.srem(self.class.key_for(:all), id)
             redis.del(key)
           end
         end
@@ -122,37 +156,18 @@ module Modis
 
     private
 
-    def coerce_for_persistence(attribute, value)
-      ensure_type(attribute, value)
-      YAML.dump(value)
-    end
-
-    def ensure_type(attribute, value)
-      types = self.class.attributes[attribute.to_s][:types]
-      type_classes = types.map { |type| classes_for_type(type) }.flatten
-
-      return unless value && !type_classes.include?(value.class)
-      raise Modis::AttributeCoercionError, "Received value of type '#{value.class}', expected '#{type_classes.join('\', \'')}' for attribute '#{attribute}'."
-    end
-
-    def classes_for_type(type)
-      { string: [String],
-        integer: [Fixnum],
-        float: [Float],
-        timestamp: [Time],
-        hash: [Hash],
-        array: [Array],
-        boolean: [TrueClass, FalseClass] }[type]
+    def coerce_for_persistence(value)
+      value = [value.year, value.month, value.day, value.hour, value.min, value.sec, value.strftime("%:z")] if value.is_a?(Time)
+      MessagePack.pack(value)
     end
 
     def create_or_update(args = {})
       validate(args)
-      future = persist
+      future = persist(args[:yaml_sucks])
 
-      if future && future.value == 'OK'
+      if future && (future == :unchanged || future.value == 'OK')
         reset_changes
         @new_record = false
-        new_record? ? add_to_index : update_index
         true
       else
         false
@@ -165,7 +180,7 @@ module Modis
       raise Modis::RecordInvalid, errors.full_messages.join(', ')
     end
 
-    def persist
+    def persist(persist_all)
       future = nil
       set_id if new_record?
       callback = new_record? ? :create : :update
@@ -173,10 +188,16 @@ module Modis
       self.class.transaction do |redis|
         run_callbacks :save do
           run_callbacks callback do
-            run_callbacks "_internal_#{callback}" do
-              attrs = []
-              attributes.each { |k, v| attrs << k << coerce_for_persistence(k, v) }
-              future = redis.hmset(self.class.key_for(id), attrs)
+            redis.pipelined do
+              attrs = coerced_attributes(persist_all)
+              future = attrs.any? ? redis.hmset(self.class.key_for(id), attrs) : :unchanged
+
+              if new_record?
+                redis.sadd(self.class.key_for(:all), id)
+                add_to_indexes(redis)
+              else
+                update_indexes(redis)
+              end
             end
           end
         end
@@ -185,18 +206,28 @@ module Modis
       future
     end
 
-    def set_id
-      Modis.with_connection do |redis|
-        self.id = redis.incr("#{self.class.absolute_namespace}_id_seq")
+    def coerced_attributes(persist_all) # rubocop:disable Metrics/AbcSize
+      attrs = []
+
+      if new_record? || persist_all
+        attributes.each do |k, v|
+          if (self.class.attributes[k][:default] || nil) != v
+            attrs << k << coerce_for_persistence(v)
+          end
+        end
+      else
+        changed_attributes.each do |k, _|
+          attrs << k << coerce_for_persistence(attributes[k])
+        end
       end
-    end
 
-    def track
-      Modis.with_connection { |redis| redis.sadd(self.class.key_for(:all), id) }
+      attrs
     end
 
-    def untrack
-      Modis.with_connection { |redis| redis.srem(self.class.key_for(:all), id) }
+    def set_id
+      Modis.with_connection do |redis|
+        self.id = redis.incr("#{self.class.absolute_namespace}_id_seq")
+      end
     end
   end
 end