zermelo 1.1.0 → 1.2.0

data/lib/zermelo/filters/redis_filter.rb

@@ -1,111 +0,0 @@
-require 'zermelo/filters/base'
-
-# TODO check escaping of ids and index_keys -- shouldn't allow bare :
-
-module Zermelo
-
-  module Filters
-
-    class RedisFilter
-
-      include Zermelo::Filters::Base
-
-      # TODO polite error when first/last applied to set
-
-      # more step users
-      def first
-        lock {
-          first_id = resolve_steps(:first)
-          first_id.nil? ? nil : _load(first_id)
-        }
-      end
-
-      def last
-        lock {
-          last_id = resolve_steps(:last)
-          last_id.nil? ? nil : _load(last_id)
-        }
-      end
-      # end step users
-
-      private
-
-      def _count
-        resolve_steps(:count)
-      end
-
-      def _ids
-        resolve_steps(:ids)
-      end
-
-      def _exists?(id)
-        return if id.nil?
-        resolve_steps(:exists?, id)
-      end
-
-      # If called with a block --  takes a block and passes the name of a set to
-      # it; deletes all temporary sets once done
-
-      # If called with any arguments -- treats them as a hash of shortcuts
-
-      # If not called with any arguments -- returns two values, the first is
-      # the name of a set containing the filtered ids, the second is a boolean
-      # for whether or not to clear up that set once it's been used
-
-      def resolve_steps(shortcut, *args)
-        if @steps.empty?
-          sc_klass = {
-            :list       => Zermelo::Filters::Steps::ListStep,
-            :set        => Zermelo::Filters::Steps::SetStep,
-            :sorted_set => Zermelo::Filters::Steps::SortedSetStep
-          }[@initial_key.type]
-          sc = sc_klass.const_get(:REDIS_SHORTCUTS)[shortcut]
-          ret = if sc.nil?
-            yield(@initial_key)
-          else
-            sc.call(*([backend.key_to_redis_key(@initial_key)] + args))
-          end
-          return(ret)
-        end
-
-        idx_attrs = @associated_class.send(:with_index_data) do |d|
-          d.each_with_object({}) do |(name, data), memo|
-            memo[name.to_s] = data.index_klass
-          end
-        end
-
-        attr_types = @associated_class.send(:attribute_types)
-
-        backend.temp_key_wrap do |temp_keys|
-          result     = nil
-          last_step  = @steps.last
-
-          step_opts = {
-            :index_attrs => idx_attrs,
-            :attr_types  => attr_types,
-            :temp_keys   => temp_keys,
-            :source      => @initial_key
-          }
-
-          @steps.each do |step|
-            unless step.class.accepted_types.include?(step_opts[:source].type)
-              raise "'#{step.class.name}' does not accept input type #{step_opts[:source].type}"
-            end
-
-            if step == last_step
-              step_opts.update(:shortcut => shortcut, :shortcut_args => args)
-            end
-
-            result = step.resolve(backend, @associated_class, step_opts)
-
-            step_opts[:source] = result unless step == last_step
-          end
-
-          result
-        end
-      end
-    end
-
-  end
-
-end

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

@@ -1,156 +0,0 @@
-require 'zermelo/filters/steps/base_step'
-
-module Zermelo
-  module Filters
-    class Steps
-      class SortedSetStep < Zermelo::Filters::Steps::BaseStep
-        def self.accepted_types
-          [:sorted_set]
-        end
-
-        def self.returns_type
-          :sorted_set
-        end
-
-        REDIS_SHORTCUTS = {
-          :ids     => proc {|key|     Zermelo.redis.zrange(key, 0, -1) },
-          :count   => proc {|key|     Zermelo.redis.zcard(key) },
-          :exists? => proc {|key, id| !Zermelo.redis.zscore(key, id).nil? },
-          :first   => proc {|key|     Zermelo.redis.zrange(key, 0, 0).first },
-          :last    => proc {|key|     Zermelo.redis.zrevrange(key, 0, 0).first }
-        }
-
-        def resolve(backend, associated_class, opts = {})
-          op     = @options[:op]
-          start  = @options[:start]
-          finish = @options[:finish]
-
-          case backend
-          when Zermelo::Backends::RedisBackend
-            source = opts[:source]
-            idx_attrs = opts[:index_attrs]
-            attr_types = opts[:attr_types]
-            temp_keys = opts[:temp_keys]
-
-            range_temp_key = associated_class.send(:temp_key, :sorted_set)
-            temp_keys << range_temp_key
-            range_ids_set = backend.key_to_redis_key(range_temp_key)
-
-            if @options[:by_score]
-              start = '-inf' if start.nil? || (start <= 0)
-              finish = '+inf' if finish.nil? || (finish <= 0)
-            else
-              start = 0 if start.nil?
-              finish = -1 if finish.nil?
-            end
-
-            args = [start, finish]
-
-            if @options[:by_score]
-              query = :zrangebyscore
-              args = args.map(&:to_s)
-            else
-              query = :zrange
-            end
-
-            args << {:with_scores => :true}
-
-            if @options[:limit]
-              args.last.update(:limit => [0, @options[:limit].to_i])
-            end
-
-            r_source   = backend.key_to_redis_key(source)
-            args.unshift(r_source)
-
-            range_ids_scores = Zermelo.redis.send(query, *args)
-
-            unless range_ids_scores.empty?
-              Zermelo.redis.zadd(range_ids_set, range_ids_scores.map(&:reverse))
-            end
-
-            self.class.evaluate(backend, @options[:op], associated_class,
-              source, [range_temp_key], temp_keys, opts)
-
-          when Zermelo::Backends::InfluxDBBackend
-
-            query = ''
-
-            unless opts[:first].is_a?(TrueClass)
-              case @options[:op]
-              when :intersect_range, :diff_range
-                query += ' AND '
-              when :union_range
-                query += ' OR '
-              end
-            end
-
-            start  = nil if !start.nil?  && (start <= 0)
-            finish = nil if !finish.nil? && (finish <= 0)
-
-            unless start.nil? && finish.nil?
-              time_q = []
-
-              case @options[:op]
-              when :intersect_range, :union_range
-                unless start.nil?
-                  time_q << "(time > #{start - 1}s)"
-                end
-                unless finish.nil?
-                  time_q << "(time < #{finish}s)"
-                end
-              when :diff_range
-                unless start.nil?
-                  time_q << "(time < #{start}s)"
-                end
-                unless finish.nil?
-                  time_q << "(time > #{finish - 1}s)"
-                end
-              end
-
-              query += time_q.join(' AND ')
-            end
-
-            query += ")"
-            query
-          end
-        end
-
-        def self.evaluate(backend, op, associated_class, source, source_keys, temp_keys, opts = {})
-          shortcut = opts[:shortcut]
-
-          weights = case op
-          when :union, :union_range
-            [0.0] * source_keys.length
-          when :diff, :diff_range
-            [-1.0] * source_keys.length
-          end
-
-          r_source   = backend.key_to_redis_key(source)
-          r_source_keys = source_keys.collect {|sk| backend.key_to_redis_key(sk) }
-
-          dest_sorted_set = associated_class.send(:temp_key, :sorted_set)
-          temp_keys << dest_sorted_set
-          r_dest_sorted_set = backend.key_to_redis_key(dest_sorted_set)
-
-          case op
-          when :union, :union_range
-            Zermelo.redis.zinterstore(r_dest_sorted_set, r_source_keys, :weights => weights, :aggregate => 'max')
-            Zermelo.redis.zunionstore(r_dest_sorted_set, [r_source, r_dest_sorted_set])
-          when :intersect, :intersect_range
-            Zermelo.redis.zinterstore(r_dest_sorted_set, [r_source] + r_source_keys, :weights => weights, :aggregate => 'max')
-          when :diff, :diff_range
-            # 'zdiffstore' via weights, relies on non-zero scores being used
-            # see https://code.google.com/p/redis/issues/detail?id=579
-            Zermelo.redis.zinterstore(r_dest_sorted_set, r_source_keys, :weights => weights, :aggregate => 'max')
-            Zermelo.redis.zunionstore(r_dest_sorted_set, [r_source, r_dest_sorted_set])
-            Zermelo.redis.zremrangebyscore(r_dest_sorted_set, "0", "0")
-          end
-
-          return dest_sorted_set if shortcut.nil?
-          REDIS_SHORTCUTS[shortcut].call(*([r_dest_sorted_set] + opts[:shortcut_args]))
-        end
-
-      end
-    end
-  end
-end

data/lib/zermelo/records/base.rb

@@ -1,62 +0,0 @@
-require 'monitor'
-
-require 'active_support/concern'
-require 'active_support/core_ext/object/blank'
-require 'active_support/inflector'
-require 'active_model'
-
-require 'zermelo/associations/class_methods'
-
-require 'zermelo/records/instance_methods'
-require 'zermelo/records/class_methods'
-require 'zermelo/records/type_validator'
-
-# TODO escape ids and index_keys -- shouldn't allow bare :
-
-# TODO callbacks on before/after add/delete on association?
-
-# TODO optional sort via Redis SORT, first/last for has_many via those
-
-# TODO get DIFF working for exclusion case against ZSETs
-
-module Zermelo
-
-  module Records
-
-    module Base
-
-      extend ActiveSupport::Concern
-
-      include Zermelo::Records::InstMethods
-
-      included do
-        include ActiveModel::AttributeMethods
-        extend ActiveModel::Callbacks
-        include ActiveModel::Dirty
-        include ActiveModel::Validations
-        include ActiveModel::Validations::Callbacks
-
-        # include ActiveModel::MassAssignmentSecurity
-
-        @lock = Monitor.new
-
-        extend Zermelo::Records::ClassMethods
-        extend Zermelo::Associations::ClassMethods
-
-        attr_accessor :attributes
-
-        define_model_callbacks :create, :update, :destroy
-
-        attribute_method_suffix  "="  # attr_writers
-        # attribute_method_suffix  ""   # attr_readers # DEPRECATED
-
-        validates_with Zermelo::Records::TypeValidator
-
-        define_attributes :id => :string
-      end
-
-    end
-
-  end
-
-end

data/lib/zermelo/records/redis_record.rb

@@ -1,27 +0,0 @@
-require 'active_support/concern'
-
-require 'zermelo/records/base'
-
-# TODO check escaping of ids and index_keys -- shouldn't allow bare :, ' '
-
-# TODO callbacks on before/after add/delete on association?
-
-module Zermelo
-
-  module Records
-
-    module RedisRecord
-
-      extend ActiveSupport::Concern
-
-      include Zermelo::Records::Base
-
-      included do
-        set_backend :redis
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'zermelo/associations/belongs_to'
-
-describe Zermelo::Associations::BelongsTo, :redis => true do
-
-end

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

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'zermelo/associations/has_many'
-
-describe Zermelo::Associations::HasMany, :redis => true do
-
-end

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

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'zermelo/associations/has_one'
-
-describe Zermelo::Associations::HasOne, :redis => true do
-
-end

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

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'zermelo/associations/has_sorted_set'
-
-describe Zermelo::Associations::HasSortedSet, :redis => true do
-
-end