zermelo 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69911858d3394494076bade1249037f111eb5e7b
-  data.tar.gz: 5b2c9e463d7fb0b71a7135bad76b481e4e18629a
+  metadata.gz: 41344d467203608ea5d05ba4e7e50ba3d0ba08c5
+  data.tar.gz: 62498b43b9556a7de290d83fc118ca0aa8ed6c48
 SHA512:
-  metadata.gz: b2b62aabc2f4421d99e53bc298e260550d2124cb957786c6ef1bce894cb0fd43c0cd704a6378e6a6acfbc2cfebffda52412984756fc314f98322a2ea63cb7a23
-  data.tar.gz: 69d7a165a1da92e759c6923828d12340d793eead6ee20681a0e22c9f7dde901b0421323ce0fd4c960bc708f5d84e9ebfab79bf166f638a3768032c8b75214074
+  metadata.gz: 475b586c7cca398659befa76233ff27eda95ead07db02b7ac56c3fdd8fbb4ef6ea724708da35ca9d3e471fa4f54023ea18129f145ec141053d6ea7bf601ee010
+  data.tar.gz: d3b7c8da76210b3d6f0c350bbc3601ec4d3f78c336864a1d885e5a9ac1682db0bd8575a16d68641869eb791a3799ee5e5ed92fdaeca7d0c936ccdc8df23c057c

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Zermelo Changelog
 
+# 1.4.0 - 2015-10-07
+
+ * store sorted_set ids in zset, makes some queries combine properly that
+   previously resulted in errors
+ * bugfix transactions, weren't applied properly
+
 # 1.3.0 - 2015-08-15
 
  * handle some Zermelo objects as query values, less data back-and-forth

data/lib/zermelo/associations/class_methods.rb

@@ -114,7 +114,7 @@ module Zermelo
           idx_data = name.nil? ? @index_data : @index_data[name]
           yield idx_data unless idx_data.nil?
         end
-       end
+      end
       # end used internally within Zermelo
 
       def add_index_data(klass, name, args = {})

data/lib/zermelo/associations/multiple.rb

@@ -82,7 +82,7 @@ module Zermelo
       def add_ids(*record_ids)
         raise 'No record ids to add' if record_ids.empty?
         @parent_klass.lock(*@lock_klasses) do
-          records = @associated_class.find_by_ids!(*record_ids)
+          @associated_class.find_by_ids!(*record_ids) # ensure they exist
           _add_ids({:callbacks => true}, *record_ids)
         end
       end
@@ -155,20 +155,23 @@ module Zermelo
           when :has_many
             # inverse is belongs_to
             record_ids.each do |record_id|
-              _inverse.id = record_id
-              @backend.add(_inverse, "#{@inverse}_id" => @parent_id)
+              _inverse_copy = _inverse.clone
+              _inverse_copy.id = record_id
+              @backend.add(_inverse_copy, "#{@inverse}_id" => @parent_id)
             end
           when :has_sorted_set
             # inverse is belongs_to
-            record_ids.each do |(score, record_id)|
-              _inverse.id = record_id
-              @backend.add(_inverse, "#{@inverse}_id" => @parent_id)
+            record_ids.each do |score_and_record_id|
+              _inverse_copy = _inverse.clone
+              _inverse_copy.id = score_and_record_id.last
+              @backend.add(_inverse_copy, "#{@inverse}_id" => @parent_id)
             end
           when :has_and_belongs_to_many
             # inverse is has_and_belongs_to_many
             record_ids.each do |record_id|
-              _inverse.id = record_id
-              @backend.add(_inverse, @parent_id)
+              _inverse_copy = _inverse.clone
+              _inverse_copy.id = record_id
+              @backend.add(_inverse_copy, @parent_id)
             end
           end
 
@@ -194,14 +197,16 @@ module Zermelo
           when :has_many, :has_sorted_set
             # inverse is belongs_to
             record_ids.each do |record_id|
-              _inverse.id = record_id
-              @backend.delete(_inverse, "#{@inverse}_id")
+              _inverse_copy = _inverse.clone
+              _inverse_copy.id = record_id
+              @backend.delete(_inverse_copy, "#{@inverse}_id")
             end
           when :has_and_belongs_to_many
             # inverse is has_and_belongs_to_many
             record_ids.each do |record_id|
-              _inverse.id = record_id
-              @backend.delete(_inverse, @parent_id)
+              _inverse_copy = _inverse.clone
+              _inverse_copy.id = record_id
+              @backend.delete(_inverse_copy, @parent_id)
             end
           end
 

data/lib/zermelo/backends/redis.rb

@@ -12,6 +12,11 @@ module Zermelo
 
       include Zermelo::Backend
 
+      def initialize
+        @transaction_redis = nil
+        @changes = nil
+      end
+
       # def default_sorted_set_key
       #   :timestamp
       # end
@@ -153,9 +158,9 @@ module Zermelo
         end
       end
 
-      # TODO converge usage of idx_class and _index lookup invocation
+      def index_lookup(att, associated_class, type, idx_class, value,
+        attr_type, temp_keys)
 
-      def index_lookup(att, associated_class, idx_class, value, attr_type, temp_keys)
         if (idx_class == Zermelo::Associations::RangeIndex) && !value.is_a?(Zermelo::Filters::IndexRange)
           raise "Range index must be passed a range"
         end
@@ -164,7 +169,7 @@ module Zermelo
         when Regexp
           raise "Can't query non-string values via regexp" unless :string.eql?(attr_type)
 
-          idx_key = associated_class.send(:temp_key, :set)
+          idx_key = associated_class.send(:temp_key, type)
           temp_keys << idx_key
           idx_result = key_to_redis_key(idx_key)
 
@@ -182,7 +187,15 @@ module Zermelo
               (starts_with_string_re === k) &&
                 (value === unescape_key_name(k.sub(starts_with_string_re, '')))
             })
-            Zermelo.redis.sadd(idx_result, matching_ids) unless matching_ids.empty?
+
+            unless matching_ids.empty?
+              case type
+              when :set
+                Zermelo.redis.sadd(idx_result, matching_ids)
+              when :sorted_set
+                Zermelo.redis.zadd(idx_result, matching_ids.map {|m| [1, m]})
+              end
+            end
           when 'Zermelo::Associations::Index'
             key_root = key_to_redis_key(Zermelo::Records::Key.new(
               :klass  => associated_class,
@@ -209,7 +222,14 @@ module Zermelo
               value === $1
             end
 
-            Zermelo.redis.sunionstore(idx_result, matching_sets) unless matching_sets.empty?
+            unless matching_sets.empty?
+              case type
+              when :set
+                Zermelo.redis.sunionstore(idx_result, matching_sets)
+              when :sorted_set
+                Zermelo.redis.zunionstore(idx_result, matching_sets)
+              end
+            end
           end
           idx_key
         else
@@ -217,30 +237,20 @@ module Zermelo
 
           case index
           when Zermelo::Associations::RangeIndex
-            r_index_key = key_to_redis_key(index.key)
-            range = if value.by_score
-              range_start  = value.start.nil?  ? '-inf' : safe_value(attr_type, value.start)
-              range_finish = value.finish.nil? ? '+inf' : safe_value(attr_type, value.finish)
-              Zermelo.redis.zrangebyscore(r_index_key, range_start, range_finish)
-            else
-              range_start  = value.start  ||  0
-              range_finish = value.finish || -1
-              Zermelo.redis.zrange(r_index_key, range_start, range_finish)
-            end
-
-            # TODO another way for index_lookup to indicate 'empty result', rather
-            # than creating & returning an empty key
-            idx_key = associated_class.send(:temp_key, :set)
-            temp_keys << idx_key
-            Zermelo.redis.sadd(key_to_redis_key(idx_key), range) unless range.empty?
-            idx_key
+            range_lookup(index.key, value, type, attr_type, associated_class, temp_keys)
           when Zermelo::Associations::UniqueIndex
-            idx_key = associated_class.send(:temp_key, :set)
+            idx_key = associated_class.send(:temp_key, type)
             temp_keys << idx_key
 
-            Zermelo.redis.sadd(key_to_redis_key(idx_key),
-              Zermelo.redis.hget(key_to_redis_key(index.key),
-                                 index_keys(attr_type, value).join(':')))
+            val = Zermelo.redis.hget(key_to_redis_key(index.key),
+                               index_keys(attr_type, value).join(':'))
+
+            case type
+            when :set
+              Zermelo.redis.sadd(key_to_redis_key(idx_key), val)
+            when :sorted_set
+              Zermelo.redis.zadd(key_to_redis_key(idx_key), [1, val])
+            end
             idx_key
           when Zermelo::Associations::Index
             index.key(value)
@@ -248,15 +258,49 @@ module Zermelo
         end
       end
 
+      def range_lookup(key, range, type, attr_type, associated_class, temp_keys)
+        r_key = key_to_redis_key(key)
+        opts = case type
+        when :set
+          {}
+        when :sorted_set
+          {:with_scores => true}
+        end
+        result = if range.by_score
+          range_start  = range.start.nil?  ? '-inf' : safe_value(attr_type, range.start)
+          range_finish = range.finish.nil? ? '+inf' : safe_value(attr_type, range.finish)
+          Zermelo.redis.zrangebyscore(r_key, range_start, range_finish, opts)
+        else
+          range_start  = range.start  ||  0
+          range_finish = range.finish || -1
+          Zermelo.redis.zrange(r_key, range_start, range_finish, opts)
+        end
+
+        # TODO another way for index_lookup to indicate 'empty result', rather
+        # than creating & returning an empty key
+        ret_key = associated_class.send(:temp_key, key.type)
+        temp_keys << ret_key
+        unless result.empty?
+          r_key = key_to_redis_key(ret_key)
+          case type
+          when :set
+            Zermelo.redis.sadd(r_key, result)
+          when :sorted_set
+            Zermelo.redis.zadd(r_key, result.map {|r| [r.last, r.first]})
+          end
+        end
+        ret_key
+      end
+
       private
 
       def change(op, key, value = nil, key_to = nil, value_to = nil)
         ch = [op, key, value, key_to, value_to]
-        if @in_transaction
-          @changes << ch
-        else
+        if @transaction_redis.nil?
           apply_changes([ch])
+          return
         end
+        @changes << ch
       end
 
       def apply_changes(changes)

data/lib/zermelo/filter.rb

@@ -169,8 +169,8 @@ module Zermelo
     end
 
     def associations_for(name)
-      data_type, type_klass = @associated_class.send(:with_association_data, name.to_sym) do |data|
-        [data.data_type, data.type_klass]
+      data_type = @associated_class.send(:with_association_data, name.to_sym) do |data|
+        data.data_type
       end
 
       lock {

data/lib/zermelo/filters/steps/list_step.rb

@@ -25,8 +25,8 @@ module Zermelo
           when Zermelo::Backends::Redis
 
             source = opts[:source]
-            idx_attrs = opts[:index_attrs]
-            attr_types = opts[:attr_types]
+            # idx_attrs = opts[:index_attrs]
+            # attr_types = opts[:attr_types]
             temp_keys = opts[:temp_keys]
 
             # TODO apply these transformations via a subset?
@@ -46,7 +46,7 @@ module Zermelo
                 r_source, o, (o + l), :with_scores => true
               )
 
-              Zermelo.redis.zadd(r_limited, lim.collect {|l| [l[1], l[0]]} )
+              Zermelo.redis.zadd(r_limited, lim.collect {|li| [li[1], li[0]]} )
 
               [limited, r_limited]
             when :list

data/lib/zermelo/filters/steps/set_step.rb

@@ -26,9 +26,14 @@ module Zermelo
 
             source_keys = @attributes.each_with_object([]) do |(att, value), memo|
               idx_class = nil
+              use_sort_attr = false
               unless :id.eql?(att)
                 idx_class = idx_attrs[att.to_s]
-                raise "'#{att}' property is not indexed" if idx_class.nil?
+                if idx_class.nil?
+                  use_sort_attr = :sorted_set.eql?(source.type) &&
+                    att.eql?(associated_class.instance_variable_get('@sort_attribute'))
+                  raise "'#{att}' property is not indexed" unless use_sort_attr
+                end
               end
 
               if [Set, Array].any? {|t| value.is_a?(t) }
@@ -37,7 +42,21 @@ module Zermelo
                 r_conditions_set = backend.key_to_redis_key(conditions_set)
 
                 backend.temp_key_wrap do |conditions_temp_keys|
-                  if idx_class.nil?
+                  if use_sort_attr
+                    range_keys = value.collect {|v|
+                      rl = backend.range_lookup(associated_class.ids_key, v,
+                        source_type, attr_types[att], associated_class, conditions_temp_keys)
+                      backend.key_to_redis_key(rl)
+                    }
+
+                    case source.type
+                    when :set
+                      Zermelo.redis.sunionstore(r_conditions_set, *range_keys)
+                    when :sorted_set
+                      Zermelo.redis.zunionstore(r_conditions_set, range_keys)
+                    end
+                  elsif idx_class.nil?
+                    # query against the :id field
                     cond_objects, cond_ids = value.partition do |v|
                       [Zermelo::Filter, Zermelo::Associations::Multiple].any? {|c| v.is_a?(c)}
                     end
@@ -53,15 +72,33 @@ module Zermelo
                         backend.key_to_redis_key(k)
                       end
 
-                      Zermelo.redis.sunionstore(r_conditions_set, *cond_keys)
+                      case source.type
+                      when :set
+                        Zermelo.redis.sunionstore(r_conditions_set, *cond_keys)
+                      when :sorted_set
+                        Zermelo.redis.zunionstore(r_conditions_set, cond_keys)
+                      end
                     end
                     unless cond_ids.empty?
-                      cond_ids.map! {|ci| ci.is_a?(Zermelo::Associations::Singular) ? ci.id : ci }
-                      Zermelo.redis.sadd(r_conditions_set, cond_ids)
+                      case source.type
+                      when :set
+                        s_ids = cond_ids.map {|ci| ci.is_a?(Zermelo::Associations::Singular) ? ci.id : ci }
+                        Zermelo.redis.sadd(r_conditions_set, s_ids)
+                      when :sorted_set
+                        z_ids = cond_ids.map do |ci|
+                          # is 1 a valid sort value? what's happening with it?
+                          if ci.is_a?(Zermelo::Associations::Singular)
+                            [1, ci.id]
+                          else
+                            [1, ci]
+                          end
+                        end
+                        Zermelo.redis.zadd(r_conditions_set, z_ids)
+                      end
                     end
                   else
-                    index_keys = value.to_a.collect {|v|
-                      il = backend.index_lookup(att, associated_class,
+                    index_keys = value.collect {|v|
+                      il = backend.index_lookup(att, associated_class, source.type,
                         idx_class, v, attr_types[att], conditions_temp_keys)
                       backend.key_to_redis_key(il)
                     }
@@ -75,6 +112,9 @@ module Zermelo
                   end
                 end
                 memo << conditions_set
+              elsif use_sort_attr
+                memo << backend.range_lookup(associated_class.ids_key, value,
+                  source.type, attr_types[att], associated_class, temp_keys)
               elsif idx_class.nil?
                 case value
                 when Zermelo::Filter
@@ -84,15 +124,22 @@ module Zermelo
                 when Zermelo::Associations::Multiple
                   memo << value.instance_variable_get('@record_ids_key')
                 else
-                  ts = associated_class.send(:temp_key, :set)
+                  ts = associated_class.send(:temp_key, source.type)
                   temp_keys << ts
                   r_ts = backend.key_to_redis_key(ts)
-                  Zermelo.redis.sadd(r_ts,
-                    value.is_a?(Zermelo::Associations::Singular) ? value.id : value)
+                  case source.type
+                  when :set
+                    s_id = value.is_a?(Zermelo::Associations::Singular) ? value.id : value
+                    Zermelo.redis.sadd(r_ts, s_id)
+                  when :sorted_set
+                    # is 1 a valid sort value? what's happening with it?
+                    z_id = [1, (value.is_a?(Zermelo::Associations::Singular) ? value.id : value)]
+                    Zermelo.redis.zadd(r_ts, z_id)
+                  end
                   memo << ts
                 end
               else
-                memo << backend.index_lookup(att, associated_class,
+                memo << backend.index_lookup(att, associated_class, source.type,
                           idx_class, value, attr_types[att], temp_keys)
               end
             end

data/lib/zermelo/filters/steps/sort_step.rb

@@ -16,7 +16,7 @@ module Zermelo
           case backend
           when Zermelo::Backends::Redis
             source = opts[:source]
-            idx_attrs = opts[:index_attrs]
+            # idx_attrs = opts[:index_attrs]
             attr_types = opts[:attr_types]
             temp_keys = opts[:temp_keys]
 

data/lib/zermelo/record.rb

@@ -12,9 +12,7 @@ require 'zermelo/records/class_methods'
 require 'zermelo/records/type_validator'
 
 module Zermelo
-
   module Record
-
     extend ActiveSupport::Concern
 
     include Zermelo::Records::InstMethods
@@ -31,11 +29,11 @@ module Zermelo
 
       # include ActiveModel::MassAssignmentSecurity
 
-      @lock = Monitor.new
-
       extend Zermelo::Records::ClassMethods
       extend Zermelo::Associations::ClassMethods
 
+      @lock = Monitor.new
+
       attr_accessor :attributes
 
       define_model_callbacks :create, :update, :destroy
@@ -47,7 +45,5 @@ module Zermelo
 
       define_attributes :id => :string
     end
-
   end
-
 end

data/lib/zermelo/records/class_methods.rb

@@ -11,11 +11,8 @@ require 'zermelo/records/attributes'
 require 'zermelo/records/key'
 
 module Zermelo
-
   module Records
-
     module ClassMethods
-
       include Zermelo::Records::Attributes
 
       extend Forwardable
@@ -37,14 +34,6 @@ module Zermelo
         "%08x-%04x-%04x-%04x-%04x%08x" % ary
       end
 
-      def add_id(id)
-        backend.add(ids_key, id.to_s)
-      end
-
-      def delete_id(id)
-        backend.delete(ids_key, id.to_s)
-      end
-
       def lock(*klasses, &block)
         klasses += [self] unless klasses.include?(self)
         backend.lock(*klasses, &block)
@@ -57,7 +46,7 @@ module Zermelo
 
         begin
           yield
-        rescue Exception => e
+        rescue Exception # => e
           backend.abort_transaction
           # p e.message
           # puts e.backtrace.join("\n")
@@ -94,14 +83,6 @@ module Zermelo
         self.name.demodulize.underscore
       end
 
-      def ids_key
-        @ids_key ||= Zermelo::Records::Key.new(
-                       :klass => self, :name => 'ids',
-                       :type => :set,
-                       :object => :attribute
-                     )
-      end
-
       def temp_key(type)
         Zermelo::Records::Key.new(
           :klass  => self,
@@ -119,9 +100,60 @@ module Zermelo
       def filter
         backend.filter(ids_key, self)
       end
+    end
+
+    module Unordered
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def ids_key
+          @ids_key ||= Zermelo::Records::Key.new(
+                         :klass => self, :name => 'ids',
+                         :type => :set,
+                         :object => :attribute
+                       )
+        end
+
+        def add_id(id)
+          backend.add(ids_key, id)
+        end
 
+        def delete_id(id)
+          backend.delete(ids_key, id)
+        end
+      end
     end
 
-  end
+    module Ordered
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        extend Forwardable
 
+        def_delegators :filter,
+          :first, :last
+
+        def ids_key
+          @ids_key ||= Zermelo::Records::Key.new(
+                         :klass => self, :name => 'ids',
+                         :type => :sorted_set,
+                         :object => :attribute
+                       )
+        end
+
+        def define_sort_attribute(k)
+          @sort_attribute = k
+          @sort_attribute_type = attribute_types[k.to_sym]
+        end
+
+        def add_id(id, val)
+          backend.add(ids_key, [backend.safe_value(@sort_attribute_type, val), id])
+        end
+
+        def delete_id(id)
+          backend.delete(ids_key, id)
+        end
+      end
+    end
+  end
 end

data/lib/zermelo/records/influxdb.rb

@@ -25,6 +25,7 @@ module Zermelo
       extend ActiveSupport::Concern
 
       include Zermelo::Record
+      include Zermelo::Records::Unordered
 
       included do
         set_backend :influxdb

data/lib/zermelo/records/instance_methods.rb

@@ -83,6 +83,15 @@ module Zermelo
         creating = !self.persisted?
         saved = false
 
+        sort_val = nil
+        case self
+        when Zermelo::Records::Ordered
+          sort_attr = self.class.instance_variable_get('@sort_attribute')
+          raise 'Ordered record types must define_sort_attribute' if sort_attr.nil?
+          sort_val = @attributes[sort_attr.to_s]
+          raise "Value required for sort_attribute #{sort_attr}" if sort_val.nil?
+        end
+
         run_callbacks( (creating ? :create : :update) ) do
 
           idx_attrs = self.class.send(:with_index_data) do |d|
@@ -119,9 +128,16 @@ module Zermelo
               end
             end
 
-            # ids is a set, so update won't create duplicates
+            # ids is a set/sorted set, so update won't create duplicates
             # NB influxdb backend doesn't need this
-            self.class.add_id(@attributes['id'])
+
+            # FIXME distinguish between this in the class methods?
+            case self
+            when Zermelo::Records::Ordered
+              self.class.add_id(@attributes['id'], sort_val)
+            when Zermelo::Records::Unordered
+              self.class.add_id(@attributes['id'])
+            end
           end
 
           @is_new = false

data/lib/zermelo/records/redis.rb

@@ -4,10 +4,22 @@ require 'zermelo/record'
 
 module Zermelo
   module Records
-    module Redis
+    module RedisSet
       extend ActiveSupport::Concern
 
       include Zermelo::Record
+      include Zermelo::Records::Unordered
+
+      included do
+        set_backend :redis
+      end
+    end
+
+    module RedisSortedSet
+      extend ActiveSupport::Concern
+
+      include Zermelo::Record
+      include Zermelo::Records::Ordered
 
       included do
         set_backend :redis

data/lib/zermelo/records/type_validator.rb

@@ -8,9 +8,9 @@ module Zermelo
           value = record.send(name)
           next if value.nil?
           valid_type = Zermelo::ALL_TYPES[type]
-          unless valid_type.any? {|type| value.is_a?(type) }
+          unless valid_type.any? {|t| value.is_a?(t) }
             count = (valid_type.size > 1) ? 'one of ' : ''
-            type_str = valid_type.collect {|type| type.name }.join(", ")
+            type_str = valid_type.collect {|t| t.name }.join(", ")
             record.errors.add(name, "should be #{count}#{type_str} but is #{value.class.name}")
           end
         end

data/lib/zermelo/version.rb

@@ -1,3 +1,3 @@
 module Zermelo
-  VERSION = '1.3.0'
+  VERSION = '1.4.0'
 end

data/spec/lib/zermelo/associations/index_spec.rb

@@ -12,7 +12,7 @@ describe Zermelo::Associations::Index do
 
     module ZermeloExamples
       class RedisIndex
-        include Zermelo::Records::Redis
+        include Zermelo::Records::RedisSet
         define_attributes :emotion => :string
         validates :emotion, :presence => true, :inclusion => {:in => %w(happy sad indifferent)}
         index_by :emotion

data/spec/lib/zermelo/associations/multiple_spec.rb

@@ -212,13 +212,13 @@ describe Zermelo::Associations::Multiple do
 
       module ZermeloExamples
         class AssociationsHasManyParentRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           has_many :children, :class_name => 'ZermeloExamples::AssociationsHasManyChildRedis',
             :inverse_of => :parent
         end
 
         class AssociationsHasManyChildRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           define_attributes :important => :boolean
           index_by :important
           belongs_to :parent, :class_name => 'ZermeloExamples::AssociationsHasManyParentRedis',
@@ -671,7 +671,7 @@ describe Zermelo::Associations::Multiple do
 
       module ZermeloExamples
         class AssociationsHasAndBelongsToManyPrimaryRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           define_attributes :active => :boolean
           index_by :active
           has_and_belongs_to_many :secondaries,
@@ -680,7 +680,7 @@ describe Zermelo::Associations::Multiple do
         end
 
         class AssociationsHasAndBelongsToManySecondaryRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           # define_attributes :important => :boolean
           # index_by :important
           has_and_belongs_to_many :primaries,
@@ -773,7 +773,7 @@ describe Zermelo::Associations::Multiple do
 
       module ZermeloExamples
         class AssociationsHasSortedSetParentRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           has_sorted_set :children, :class_name => 'ZermeloExamples::AssociationsHasSortedSetChildRedis',
             :inverse_of => :parent, :key => :timestamp
           has_sorted_set :reversed_children, :class_name => 'ZermeloExamples::AssociationsHasSortedSetChildRedis',
@@ -781,11 +781,11 @@ describe Zermelo::Associations::Multiple do
         end
 
         class AssociationsHasSortedSetChildRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSortedSet
           define_attributes :emotion => :string,
                             :timestamp => :timestamp
+          define_sort_attribute :timestamp
           index_by :emotion
-          range_index_by :timestamp
           belongs_to :parent, :class_name => 'ZermeloExamples::AssociationsHasSortedSetParentRedis',
             :inverse_of => :children
           belongs_to :reversed_parent, :class_name => 'ZermeloExamples::AssociationsHasSortedSetParentRedis',
@@ -811,10 +811,9 @@ describe Zermelo::Associations::Multiple do
           'timestamp' => attrs[:timestamp].to_f}.to_a.flatten)
 
         redis.sadd("#{ck}::indices:by_emotion:string:#{attrs[:emotion]}", attrs[:id])
-        redis.zadd("#{ck}::indices:by_timestamp", attrs[:timestamp].to_f, attrs[:id])
         redis.hmset("#{ck}:#{attrs[:id]}:assocs:belongs_to",
                     {'parent_id' => parent.id}.to_a.flatten) unless parent.nil?
-        redis.sadd("#{ck}::attrs:ids", attrs[:id])
+        redis.zadd("#{ck}::attrs:ids", attrs[:timestamp].to_f, attrs[:id])
       end
 
       def create_reversed_child(parent, attrs = {})
@@ -824,10 +823,9 @@ describe Zermelo::Associations::Multiple do
           'timestamp' => attrs[:timestamp].to_f}.to_a.flatten)
 
         redis.sadd("#{ck}::indices:by_emotion:string:#{attrs[:emotion]}", attrs[:id])
-        redis.zadd("#{ck}::indices:by_timestamp", attrs[:timestamp].to_f, attrs[:id])
         redis.hmset("#{ck}:#{attrs[:id]}:assocs:belongs_to",
                     {'reversed_parent_id' => parent.id}.to_a.flatten) unless parent.nil?
-        redis.sadd("#{ck}::attrs:ids", attrs[:id])
+        redis.zadd("#{ck}::attrs:ids", attrs[:timestamp].to_f, attrs[:id])
       end
 
       let(:parent) {
@@ -846,11 +844,10 @@ describe Zermelo::Associations::Multiple do
                                    "#{pk}:8:assocs:children_ids",
                                    "#{ck}::attrs:ids",
                                    "#{ck}::indices:by_emotion:string:indifferent",
-                                   "#{ck}::indices:by_timestamp",
                                    "#{ck}:4:attrs",
                                    "#{ck}:4:assocs:belongs_to"])
 
-        expect(redis.smembers("#{ck}::attrs:ids")).to eq(['4'])
+        expect(redis.zrange("#{ck}::attrs:ids", 0, -1)).to eq(['4'])
         expect(redis.hgetall("#{ck}:4:attrs")).to eq(
           {'emotion' => 'indifferent', 'timestamp' => time.to_f.to_s}
         )
@@ -882,12 +879,12 @@ describe Zermelo::Associations::Multiple do
         create_child(parent, :id => '4', :emotion => 'indifferent', :timestamp => time)
         child = child_class.find_by_id('4')
 
-        expect(redis.smembers("#{ck}::attrs:ids")).to eq(['4'])
+        expect(redis.zrange("#{ck}::attrs:ids", 0, -1)).to eq(['4'])
         expect(redis.zrange("#{pk}:8:assocs:children_ids", 0, -1)).to eq(['4'])
 
         parent.children.remove(child)
 
-        expect(redis.smembers("#{ck}::attrs:ids")).to eq(['4'])    # child not deleted
+        expect(redis.zrange("#{ck}::attrs:ids", 0, -1)).to eq(['4'])         # child not deleted
         expect(redis.zrange("#{pk}:8:assocs:children_ids", 0, -1)).to eq([]) # but association is
       end
 
@@ -898,7 +895,6 @@ describe Zermelo::Associations::Multiple do
         expect(redis.keys).to match_array(["#{pk}::attrs:ids",
                               "#{pk}:8:assocs:children_ids",
                               "#{ck}::attrs:ids",
-                              "#{ck}::indices:by_timestamp",
                               "#{ck}::indices:by_emotion:string:upset",
                               "#{ck}:6:attrs",
                               "#{ck}:6:assocs:belongs_to"])
@@ -906,7 +902,6 @@ describe Zermelo::Associations::Multiple do
         parent.destroy
 
         expect(redis.keys).to match_array(["#{ck}::attrs:ids",
-                              "#{ck}::indices:by_timestamp",
                               "#{ck}::indices:by_emotion:string:upset",
                               "#{ck}:6:attrs"])
       end

data/spec/lib/zermelo/associations/range_index_spec.rb

@@ -12,10 +12,10 @@ describe Zermelo::Associations::RangeIndex do
 
     module ZermeloExamples
       class RedisRangeIndex
-        include Zermelo::Records::Redis
+        include Zermelo::Records::RedisSet
         define_attributes :created_at => :timestamp
-        validates :created_at, :presence => true
         range_index_by :created_at
+        validates :created_at, :presence => true
       end
     end
 

data/spec/lib/zermelo/associations/singular_spec.rb

@@ -42,13 +42,13 @@ describe Zermelo::Associations::Singular do
 
       module ZermeloExamples
         class AssociationsHasOneParentRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           has_one :child, :class_name => 'ZermeloExamples::AssociationsHasOneChildRedis',
             :inverse_of => :parent
         end
 
         class AssociationsHasOneChildRedis
-          include Zermelo::Records::Redis
+          include Zermelo::Records::RedisSet
           belongs_to :parent, :class_name => 'ZermeloExamples::AssociationsHasOneParentRedis',
             :inverse_of => :child
         end

data/spec/lib/zermelo/associations/unique_index_spec.rb

@@ -10,7 +10,7 @@ describe Zermelo::Associations::UniqueIndex do
 
     module ZermeloExamples
       class RedisUniqueIndex
-        include Zermelo::Records::Redis
+        include Zermelo::Records::RedisSet
         define_attributes :name => :string
         validates :name, :presence => true
         unique_index_by :name

data/spec/lib/zermelo/filter_spec.rb

@@ -229,7 +229,7 @@ describe Zermelo::Filter do
 
     module ZermeloExamples
       class FilterRedis
-        include Zermelo::Records::Redis
+        include Zermelo::Records::RedisSet
         define_attributes :name       => :string,
                           :active     => :boolean,
                           :created_at => :timestamp

data/spec/lib/zermelo/locks/redis_lock_spec.rb

@@ -8,12 +8,12 @@ describe Zermelo::Locks::RedisLock, :redis => true do
 
   module Zermelo
     class RedisLockExample
-      include Zermelo::Records::Redis
+      include Zermelo::Records::RedisSet
       define_attributes :name => :string
     end
 
     class AnotherExample
-      include Zermelo::Records::Redis
+      include Zermelo::Records::RedisSet
       define_attributes :age => :integer
     end
   end

data/spec/lib/zermelo/records/instance_methods_spec.rb

@@ -89,7 +89,7 @@ describe Zermelo::Records::InstMethods do
 
     module ZermeloExamples
       class InstanceMethodsRedis
-        include Zermelo::Records::Redis
+        include Zermelo::Records::RedisSet
 
         define_attributes :name => :string
         validates :name, :presence => true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zermelo
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Ali Graham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-15 00:00:00.000000000 Z
+date: 2015-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -137,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - Redis and/or InfluxDB, and the related gems
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: ActiveModel-based set-theoretic ORM for Redis/InfluxDB