redisrank 0.1.0

data/lib/redisrank/finder.rb

@@ -0,0 +1,245 @@
+require 'redisrank/finder/date_set'
+
+module Redisrank
+  class Finder
+    include Database
+
+    class << self
+      def find(*args)
+        new.find(*args)
+      end
+
+      def scope(scope)
+        new.scope(scope)
+      end
+
+      def label(label)
+        new.label(label)
+      end
+
+      def dates(from, till)
+        new.dates(from, till)
+      end
+      alias :date :dates
+
+      def from(date)
+        new.from(date)
+      end
+
+      def till(date)
+        new.till(date)
+      end
+      alias :untill :till
+
+      def depth(unit)
+        new.depth(unit)
+      end
+
+      def interval(unit)
+        new.interval(unit)
+      end
+    end
+
+    attr_reader :options
+
+    def initialize(opts = {})
+      set_options(opts)
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def all(reload = false)
+      @result = nil if reload
+      @result ||= find
+    end
+
+    def rank
+      all.rank
+    end
+
+    def each(&block)
+      all.each(&block)
+    end
+
+    def map(&block)
+      all.map(&block)
+    end
+
+    def each_with_index(&block)
+      all.each_with_index(&block)
+    end
+
+    def parent
+      @parent ||= self.class.new(options.merge(:label => options[:label].parent)) unless options[:label].nil?
+    end
+
+    def children
+      build_key.children.map { |key|
+        self.class.new(options.merge(:label => key.label.to_s))
+      }
+    end
+
+    def connection_ref(ref = nil)
+      return options[:connection_ref] if ref.nil?
+      reset! if options[:connection_ref] != ref
+      options[:connection_ref] = ref
+      self
+    end
+
+    def scope(input = nil)
+      return options[:scope] if input.nil?
+      reset! if !options[:scope].nil? && options[:scope].to_s != input.to_s
+      options[:scope] = Scope.new(input)
+      self
+    end
+
+    def label(input = nil)
+      return options[:label] if input.nil?
+      reset! if options.has_key?(:label) && options[:label].to_s != input.to_s
+      options[:label] = (!input.nil?) ? Label.new(input) : nil
+      self
+    end
+
+    def dates(start, finish)
+      from(start).till(finish)
+    end
+    alias :date :dates
+
+    def from(date = nil)
+      return options[:from] if date.nil?
+      reset! if options[:from] != date
+      options[:from] = date
+      self
+    end
+
+    def till(date = nil)
+      return options[:till] if date.nil?
+      reset! if options[:till] != date
+      options[:till] = date
+      self
+    end
+    alias :until :till
+
+    def depth(unit = nil)
+      return options[:depth] if unit.nil?
+      reset! if options[:depth] != unit
+      options[:depth] = unit
+      self
+    end
+
+    def interval(unit = nil)
+      return options[:interval] if unit.nil?
+      reset! if options[:interval] != unit
+      options[:interval] = unit
+      self
+    end
+
+    def find(opts = {})
+      set_options(opts)
+      raise InvalidOptions.new if !valid_options?
+      if options[:interval].nil? || !options[:interval]
+        find_by_magic
+      else
+        find_by_interval
+      end
+    end
+
+    private
+
+    def set_options(opts = {})
+      opts = opts.clone
+      opts.each do |key, value|
+        self.send(key, opts.delete(key)) if self.respond_to?(key)
+      end
+      self.options.merge!(opts)
+    end
+
+    def find_by_interval
+      raise InvalidOptions.new if !valid_options?
+      key = build_key
+      col = Collection.new(options)
+      col.rank = Result.new(options)
+      build_date_sets.each do |set|
+        set[:add].each do |date|
+          result = Result.new
+          result.date = Date.new(date).to_time
+          db.zrevrange("#{key.prefix}#{date}", 0, -1, :with_scores => true).each do |array|
+            result[array.first] = array.last unless (result[array.first] || 0) > array.last
+            col.rank.merge_to_max!({array.first => array.last})
+          end
+          col << result
+        end
+      end
+      col
+    end
+
+    def find_by_magic
+      raise InvalidOptions.new if !valid_options?
+      key = build_key
+      col = Collection.new(options)
+      col.rank = Result.new(options)
+      sum = []
+      build_date_sets.each do |set|
+        _sum = summarize_add_ranks(set[:add], key, [])
+        _sum = summarize_rem_ranks(set[:rem], key, _sum)
+        _sum = summarize_ranks(_sum)
+        sum += _sum
+      end
+      sum.map{|s| {s.first => s.last}}.each{|i| col.rank.merge_to_max! i}
+      col
+    end
+
+    def reset!
+      @result = nil
+      @parent = nil
+    end
+
+    def valid_options?
+      return true if !options[:scope].blank? && !options[:label].blank? && !options[:from].blank? && !options[:till].blank?
+      false
+    end
+
+    def build_date_sets
+      Finder::DateSet.new(options[:from], options[:till], options[:depth], options[:interval])
+    end
+
+    def build_key
+      Key.new(options[:scope], options[:label])
+    end
+
+    def summarize_add_ranks(sets, key, sum)
+      sets.each do |date|
+        db.zrevrange("#{key.prefix}#{date}", 0, -1, :with_scores => true).each do |r|
+          sum << r
+        end
+      end
+      sum
+    end
+
+    def summarize_rem_ranks(sets, key, sum)
+      sets.each do |date|
+        db.zrevrange("#{key.prefix}#{date}").each do |r|
+          sum.select!{|s| !(s == r)}
+        end
+      end
+      sum
+    end
+
+    def summarize_ranks(sum)
+      result = []
+      keys = sum.map{|r| r.first}.uniq
+      keys.each do |r|
+        r_max = sum.select{|r_keys| r_keys.first == r}.map{|r_keys| r_keys.last}.max
+        result << [r, r_max]
+      end
+      result
+    end
+
+    def db
+      super(options[:connection_ref])
+    end
+
+  end
+end

data/lib/redisrank/finder/date_set.rb

@@ -0,0 +1,99 @@
+module Redisrank
+  class Finder
+    class DateSet < Array
+
+      def initialize(start_date = nil, end_date = nil, depth = nil, interval = false)
+        if !start_date.nil? && !end_date.nil?
+          find_date_sets(start_date, end_date, depth, interval)
+        end
+      end
+
+      def find_date_sets(start_date, end_date, depth = nil, interval = false)
+        if depth.nil? && interval.is_a?(Symbol)
+          depth = interval
+          interval = true
+        end
+        start_date = start_date.to_time if start_date.is_a?(::Date)
+        end_date = end_date.to_time if end_date.is_a?(::Date)
+        if !interval
+          find_date_sets_by_magic(start_date, end_date, depth)
+        else
+          find_date_sets_by_interval(start_date, end_date, depth)
+        end
+      end
+
+      private
+
+      def find_date_sets_by_magic(start_date, end_date, depth = nil)
+        depth ||= :hour
+        depths = Date::DEPTHS[Date::DEPTHS.index(:year), Date::DEPTHS.index(depth)+1].reverse
+        depths.each_with_index do |d, i|
+          sets = [find_start_keys_for(d, start_date, end_date, (i == 0))]
+          sets << find_end_keys_for(d, start_date, end_date, (i == 0))
+          sets.each do |set|
+            self << set if set != { :add => [], :rem => [] }
+          end
+        end
+        self
+      end
+
+      def find_date_sets_by_interval(start_date, end_date, depth, inclusive = true)
+        depth ||= :hour
+        self << { :add => start_date.map_beginning_of_each(depth, :include_start => inclusive, :include_end => inclusive).until(end_date) { |t| t.to_rs.to_s(depth) }, :rem => [] }
+      end
+
+      def find_start_keys_for(unit, start_date, end_date, lowest_depth = false)
+        return find_start_year_for(start_date, end_date, lowest_depth) if unit == :year
+        index = Date::DEPTHS.index(unit)
+        nunit = Date::DEPTHS[(index > 0) ? index-1 : index]
+        if start_date < start_date.beginning_of_closest(nunit) || start_date.next(nunit).beginning_of(nunit) > end_date.beginning_of(nunit)
+          add = []
+          start_date.beginning_of_each(unit, :include_start => lowest_depth).until(start_date.end_of(nunit)) do |t|
+            add << t.to_rs.to_s(unit) if t < end_date.beginning_of(unit)
+          end
+          { :add => add, :rem => [] }
+        else
+          { :add => [start_date.beginning_of(nunit).to_rs.to_s(nunit)],
+            :rem => start_date.beginning_of(nunit).map_beginning_of_each(unit, :include_start => true, :include_end => !lowest_depth).until(start_date) { |t| t.to_rs.to_s(unit) } }
+        end
+      end
+
+      def find_end_keys_for(unit, start_date, end_date, lowest_depth = false)
+        return find_end_year_for(start_date, end_date, lowest_depth) if unit == :year
+        index = Date::DEPTHS.index(unit)
+        nunit = Date::DEPTHS[(index > 0) ? index-1 : index]
+        has_nunit = end_date.prev(nunit).beginning_of(nunit) >= start_date.beginning_of(nunit)
+        nearest_nunit = end_date.beginning_of_closest(nunit)
+        if end_date >= nearest_nunit && has_nunit
+          add = []
+          end_date.beginning_of(nunit).beginning_of_each(unit, :include_start => true, :include_end => lowest_depth).until(end_date) do |t|
+            add << t.to_rs.to_s(unit) if t > start_date.beginning_of(unit)
+          end
+          { :add => add, :rem => [] }
+        elsif has_nunit
+          { :add => [end_date.beginning_of(nunit).to_rs.to_s(nunit)],
+            :rem => end_date.map_beginning_of_each(unit, :include_start => !lowest_depth).until(end_date.end_of(nunit)) { |t| t.to_rs.to_s(unit) } }
+        else
+          { :add => [], :rem => [] }
+        end
+      end
+
+      def find_start_year_for(start_date, end_date, lowest_depth = false)
+        if start_date.years_since(1).beginning_of_year < end_date.beginning_of_year
+          { :add => start_date.map_beginning_of_each_year(:include_end => lowest_depth).until(end_date) { |t| t.to_rs.to_s(:year) }, :rem => [] }
+        else
+          { :add => [], :rem => [] }
+        end
+      end
+
+      def find_end_year_for(start_date, end_date, lowest_depth = false)
+        if lowest_depth
+          { :add => [end_date.beginning_of_year.to_rs.to_s(:year)], :rem => [] }
+        else
+          { :add => [], :rem => [] }
+        end
+      end
+
+    end
+  end
+end

data/lib/redisrank/key.rb

@@ -0,0 +1,84 @@
+module Redisrank
+  class Key
+    include Database
+    include Options
+
+    def default_options
+      { :depth => :hour }
+    end
+
+    def initialize(scope, label_name = nil, time_stamp = nil, opts = {})
+      parse_options(opts)
+      self.scope = scope
+      self.label = label_name if !label_name.nil?
+      self.date = time_stamp ||= Time.now
+    end
+
+    def prefix
+      key = "#{@scope}"
+      key << "/#{label.name}" if !label.nil?
+      key << ":"
+      key
+    end
+
+    def date=(input)
+      @date = (input.instance_of?(Redisrank::Date)) ? input : Date.new(input) # Redisrank::Date, not ::Date
+    end
+    attr_reader :date
+
+    def depth
+      options[:depth]
+    end
+
+    # def scope
+    #   @scope.to_s
+    # end
+
+    def scope=(input)
+      @scope = (input.instance_of?(Redisrank::Scope)) ? input : Scope.new(input)
+    end
+    attr_reader :scope
+
+    def label=(input)
+      @label = (input.instance_of?(Redisrank::Label)) ? input : Label.create(input, @options)
+    end
+    attr_reader :label
+
+    def label_hash
+      @label.hash
+    end
+
+    def parent
+      @parent ||= self.class.new(self.scope, @label.parent, self.date, @options) unless @label.parent.nil?
+    end
+
+    def children
+      members = db.smembers("#{scope}#{LABEL_INDEX}#{@label}") || [] # older versions of Redis returns nil
+      members.map { |member|
+        child_label = [@label, member].reject { |i| i.nil? }
+        self.class.new(self.scope, child_label.join(Redisrank.group_separator), self.date, @options)
+      }
+    end
+
+    def update_index
+      @label.groups.each do |label|
+        parent = (label.parent || "")
+        db.sadd("#{scope}#{LABEL_INDEX}#{parent}", label.me)
+      end
+    end
+
+    def groups
+      @groups ||= @label.groups.map do |label|
+        self.class.new(@scope, label, self.date, @options)
+      end
+    end
+
+    def to_s(depth = nil)
+      depth ||= @options[:depth]
+      key = self.prefix
+      key << @date.to_s(depth)
+      key
+    end
+
+  end
+end

data/lib/redisrank/label.rb

@@ -0,0 +1,69 @@
+module Redisrank
+  class Label
+    include Database
+    include Options
+
+    def default_options
+      { :hashed_label => false }
+    end
+
+    def self.create(name, opts = {})
+      self.new(name, opts).save
+    end
+
+    def self.join(*args)
+      args = args.map {|i| i.to_s}
+      self.new(args.reject {|i| i.blank? }.join(Redisrank.group_separator))
+    end
+
+    def initialize(str, opts = {})
+      parse_options(opts)
+      @raw = str.to_s
+    end
+
+    def to_s
+      @raw
+    end
+
+    def name
+      @options[:hashed_label] ? hash : self.to_s
+    end
+
+    def hash
+      @hash ||= Digest::SHA1.hexdigest(self.to_s)
+    end
+
+    def save
+      @saved = db.hset(KEY_LABELS, hash, self.to_s) if @options[:hashed_label]
+      self
+    end
+
+    def saved?
+      return true unless @options[:hashed_label]
+      @saved ||= false
+    end
+
+    def parent
+      @parent ||= groups[1] if groups.size > 1
+    end
+
+    def me
+      self.to_s.split(Redisrank.group_separator).last
+    end
+
+    def groups
+      return @groups unless @groups.nil?
+      @groups = []
+      parent = ""
+      self.to_s.split(Redisrank.group_separator).each do |part|
+        if !part.blank?
+          group = ((parent.blank?) ? "" : "#{parent}#{Redisrank.group_separator}") + part
+          @groups << Label.new(group)
+          parent = group
+        end
+      end
+      @groups.reverse!
+    end
+
+  end
+end