Merge branch 'release/v0.2.4'

Example:

    finder = Redistat::Finder.new
    finder.scope("Foo") #=> Finder object
    finder.scope        #=> Scope object
    finder.scope.to_s   #=> "Foo"

.gitignore

@@ -19,6 +19,7 @@ rdoc
 pkg/*
 *.gem
 .bundle
+Gemfile.lock
 
 ## PROJECT::SPECIFIC
 .yardoc/*

.rvmrc

@@ -0,0 +1 @@
+rvm gemset use redistat

Gemfile.lock

@@ -1,41 +0,0 @@
-PATH
-  remote: .
-  specs:
-    redistat (0.0.6)
-      activesupport (>= 2.3.0)
-      json (>= 1.4.0)
-      redis (>= 2.1.0)
-      time_ext (>= 0.2.8)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (3.0.3)
-    diff-lcs (1.1.2)
-    i18n (0.4.2)
-    json (1.4.6)
-    redis (2.1.1)
-    rspec (2.1.0)
-      rspec-core (~> 2.1.0)
-      rspec-expectations (~> 2.1.0)
-      rspec-mocks (~> 2.1.0)
-    rspec-core (2.1.0)
-    rspec-expectations (2.1.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.1.0)
-    time_ext (0.2.8)
-      activesupport (>= 2.3.0)
-      i18n (>= 0.4.2)
-    yard (0.6.3)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (>= 2.3.0)
-  json (>= 1.4.0)
-  redis (>= 2.1.0)
-  redistat!
-  rspec (>= 2.1.0)
-  time_ext (>= 0.2.8)
-  yard (>= 0.6.3)

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Jim Myhrberg.
+Copyright (c) 2011 Jim Myhrberg.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -14,7 +14,7 @@ Redis fits perfectly with all of these requirements. It has atomic operations li
 
     gem install redistat
 
-If you are using Ruby 1.8.x, it's recommended you also install the `system_timer` gem, as the Redis gem will otherwise complain.
+If you are using Ruby 1.8.x, it's recommended you also install the `SystemTimer` gem, as the Redis gem will otherwise complain.
 
 ## Usage
 
@@ -66,6 +66,11 @@ When retrieving statistics for a given date range, Redistat figures out how to d
 * Anything else that becomes apparent after real-world use.
 
 
+## Credits
+
+[Global Personals](http://globalpersonals.co.uk/) deserves a thank you. Currently the primary user of Redistat, they've allowed me to spend some company time to further develop the project.
+
+
 ## Note on Patches/Pull Requests
  
 * Fork the project.
@@ -79,7 +84,7 @@ When retrieving statistics for a given date range, Redistat figures out how to d
 
 ## License and Copyright
 
-Copyright (c) 2010 Jim Myhrberg.
+Copyright (c) 2011 Jim Myhrberg.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

Rakefile

@@ -14,6 +14,7 @@ end
 RSpec::Core::RakeTask.new(:rcov) do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
   spec.rcov = true
+  spec.rcov_opts = ['--exclude', 'spec']
 end
 
 task :default => [:start, :spec, :stop]

lib/redistat.rb

@@ -1,39 +1,46 @@
 
 require 'rubygems'
-require 'active_support'
-require 'active_support/hash_with_indifferent_access' if !Hash.respond_to?(:with_indifferent_access) # Active Support 2.x and 3.x
-require 'redis'
 require 'date'
 require 'time'
-require 'time_ext'
-require 'json'
 require 'digest/sha1'
 
-require 'redistat/collection'
+# Active Support 2.x or 3.x
+require 'active_support'
+if !{}.respond_to?(:with_indifferent_access)
+  require 'active_support/core_ext/hash/indifferent_access'
+  require 'active_support/core_ext/hash/reverse_merge'
+end
+
+require 'time_ext'
+require 'redis'
+require 'json'
+
+require 'redistat/options'
 require 'redistat/connection'
 require 'redistat/database'
+require 'redistat/collection'
 require 'redistat/date'
+require 'redistat/date_helper'
 require 'redistat/event'
 require 'redistat/finder'
-require 'redistat/finder/date_set'
 require 'redistat/key'
 require 'redistat/label'
 require 'redistat/model'
 require 'redistat/result'
 require 'redistat/scope'
 require 'redistat/summary'
+require 'redistat/version'
 
-require 'redistat/core_ext/date'
-require 'redistat/core_ext/time'
-require 'redistat/core_ext/fixnum'
-require 'redistat/core_ext/bignum'
+require 'redistat/core_ext'
 
 module Redistat
   
   KEY_NEXT_ID = ".next_id"
   KEY_EVENT = ".event:"
-  KEY_LEBELS = "Redistat.lables:"
+  KEY_LABELS = "Redistat.labels:" # used for reverse label hash lookup
   KEY_EVENT_IDS = ".event_ids"
+  LABEL_INDEX = ".label_index:"
+  GROUP_SEPARATOR = "/"
   
   class InvalidOptions < ArgumentError; end
   class RedisServerIsTooOld < Exception; end

lib/redistat/connection.rb

@@ -18,6 +18,7 @@ module Redistat
       end
       
       def create(options = {})
+        #TODO clean/remove all ref-less connections
         ref = options.delete(:ref) || :default
         options.reverse_merge!(default_options)
         conn = (connections[connection_id(options)] ||= connection(options))
@@ -26,15 +27,11 @@ module Redistat
       end
       
       def connections
-        threaded[:connections] ||= {}
+        @connections ||= {}
       end
       
       def references
-        threaded[:references] ||= {}
-      end
-      
-      def threaded
-        Thread.current[:redistat] ||= {}
+        @references ||= {}
       end
       
       private

lib/redistat/core_ext.rb

@@ -0,0 +1,5 @@
+require 'redistat/core_ext/bignum'
+require 'redistat/core_ext/date'
+require 'redistat/core_ext/fixnum'
+require 'redistat/core_ext/hash'
+require 'redistat/core_ext/time'

lib/redistat/core_ext/hash.rb

@@ -0,0 +1,23 @@
+class Hash
+  
+  def merge_and_incr(hash)
+    self.clone.merge_and_incr!(hash)
+  end
+  
+  def merge_and_incr!(hash)
+    raise ArgumentError unless hash.is_a?(Hash)
+    hash.each do |key, value|
+      self[key] = value unless self.set_or_incr(key, value)
+    end
+    self
+  end
+  
+  def set_or_incr(key, value)
+    return false unless value.is_a?(Numeric)
+    self[key] = 0 unless self.has_key?(key)
+    return false unless self[key].is_a?(Numeric)
+    self[key] += value
+    true
+  end
+  
+end

lib/redistat/database.rb

@@ -4,6 +4,7 @@ module Redistat
       base.extend(Database)
     end
     def db(ref = nil)
+      ref ||= @options[:connection_ref] if !@options.nil?
       Redistat.connection(ref)
     end
   end

lib/redistat/date.rb

@@ -85,11 +85,4 @@ module Redistat
     end
     
   end
-  
-  module DateHelper
-    def to_redistat(depth = nil)
-      Redistat::Date.new(self, depth)
-    end
-    alias :to_rs :to_redistat
-  end
 end

lib/redistat/date_helper.rb

@@ -0,0 +1,8 @@
+module Redistat
+  module DateHelper
+    def to_redistat(depth = nil)
+      Redistat::Date.new(self, depth)
+    end
+    alias :to_rs :to_redistat
+  end
+end

lib/redistat/event.rb

@@ -1,39 +1,30 @@
 module Redistat
   class Event
     include Database
+    include Options
     
     attr_reader :id
     attr_reader :key
-    attr_reader :connection_ref
     
     attr_accessor :stats
     attr_accessor :meta
-    attr_accessor :options
     
-    def initialize(scope, label = nil, date = nil, stats = {}, options = {}, meta = {}, is_new = true)
-      @options = parse_options(options)
-      @connection_ref = @options[:connection_ref]
+    def default_options
+      { :depth => :hour,
+        :store_event => false,
+        :connection_ref => nil,
+        :enable_grouping => true,
+        :label_indexing => true }
+    end
+    
+    def initialize(scope, label = nil, date = nil, stats = {}, opts = {}, meta = {}, is_new = true)
+      parse_options(opts)
       @key = Key.new(scope, label, date, @options)
       @stats = stats ||= {}
       @meta = meta ||= {}
       @new = is_new
     end
     
-    def db
-      super(@connection_ref)
-    end
-    
-    def parse_options(options)
-      default_options.each do |opt, val|
-        options[opt] = val if options[opt].nil?
-      end
-      options
-    end
-
-    def default_options
-      { :depth => :hour, :store_event => false, :connection_ref => nil }
-    end
-    
     def new?
       @new
     end
@@ -72,7 +63,7 @@ module Redistat
     
     def save
       return false if !self.new?
-      Summary.update_all(@key, @stats, depth_limit, @connection_ref)
+      Summary.update_all(@key, @stats, depth_limit, @options)
       if @options[:store_event]
         @id = self.next_id
         db.hmset("#{self.scope}#{KEY_EVENT}#{@id}",
@@ -100,7 +91,7 @@ module Redistat
       event = db.hgetall "#{scope}#{KEY_EVENT}#{id}"
       return nil if event.size == 0
       self.new( event["scope"], event["label"], event["date"], JSON.parse(event["stats"]),
-                JSON.parse(event["meta"]), JSON.parse(event["options"]), false )
+                JSON.parse(event["options"]), JSON.parse(event["meta"]), false )
     end
     
   end

lib/redistat/finder.rb

@@ -1,98 +1,10 @@
+require 'redistat/finder/date_set'
+
 module Redistat
   class Finder
     include Database
     
-    attr_reader :options
-    
-    def initialize(options = {})
-      @options = options
-    end
-    
-    def db
-      super(@options[:connection_ref])
-    end
-    
-    def valid_options?
-      return true if !@options[:scope].blank? && !@options[:label].blank? && !@options[:from].blank? && !@options[:till].blank?
-      false
-    end
-    
-    def find(options = {})
-      @options.merge!(options)
-      raise InvalidOptions.new if !valid_options?
-      if @options[:interval].nil? || !@options[:interval]
-        find_by_magic
-      else
-        find_by_interval
-      end
-    end
-    
-    def find_by_interval(options = {})
-      @options.merge!(options)
-      raise InvalidOptions.new if !valid_options?
-      key = build_key
-      col = Collection.new(@options)
-      col.total = 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.hgetall("#{key.prefix}#{date}").each do |k, v|
-            result[k] = v
-            col.total.set_or_incr(k, v.to_i)
-          end
-          col << result
-        end
-      end
-      col
-    end
-    
-    def find_by_magic(options = {})
-      @options.merge!(options)
-      raise InvalidOptions.new if !valid_options?
-      key = Key.new(@options[:scope], @options[:label])
-      col = Collection.new(@options)
-      col.total = Result.new(@options)
-      col << col.total
-      build_date_sets.each do |set|
-        sum = Result.new
-        sum = summarize_add_keys(set[:add], key, sum)
-        sum = summarize_rem_keys(set[:rem], key, sum)
-        sum.each do |k, v|
-          col.total.set_or_incr(k, v.to_i)
-        end
-      end
-      col
-    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_keys(sets, key, sum)
-      sets.each do |date|
-        db.hgetall("#{key.prefix}#{date}").each do |k, v|
-          sum.set_or_incr(k, v.to_i)
-        end
-      end
-      sum
-    end
-    
-    def summarize_rem_keys(sets, key, sum)
-      sets.each do |date|
-        db.hgetall("#{key.prefix}#{date}").each do |k, v|
-          sum.set_or_incr(k, -v.to_i)
-        end
-      end
-      sum
-    end
-    
     class << self
-    
       def find(*args)
         new.find(*args)
       end
@@ -126,44 +38,199 @@ module Redistat
       def interval(unit)
         new.interval(unit)
       end
-      
     end
     
-    def scope(scope)
-      @options[:scope] = scope
+    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 total
+      all.total
+    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 label(label)
-      @options[:label] = label
+    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 dates(from, till)
-      from(from).till(till)
+    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)
-      @options[:from] = date
+    def from(date = nil)
+      return options[:from] if date.nil?
+      reset! if options[:from] != date
+      options[:from] = date
       self
     end
     
-    def till(date)
-      @options[:till] = date
+    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)
-      @options[:depth] = unit
+    def depth(unit = nil)
+      return options[:depth] if unit.nil?
+      reset! if options[:depth] != unit
+      options[:depth] = unit
       self
     end
     
-    def interval(unit)
-      @options[:interval] = unit
+    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.total = 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.hgetall("#{key.prefix}#{date}").each do |k, v|
+            result[k] = v
+            col.total.set_or_incr(k, v.to_i)
+          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.total = Result.new(options)
+      col << col.total
+      build_date_sets.each do |set|
+        sum = Result.new
+        sum = summarize_add_keys(set[:add], key, sum)
+        sum = summarize_rem_keys(set[:rem], key, sum)
+        sum.each do |k, v|
+          col.total.set_or_incr(k, v.to_i)
+        end
+      end
+      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_keys(sets, key, sum)
+      sets.each do |date|
+        db.hgetall("#{key.prefix}#{date}").each do |k, v|
+          sum.set_or_incr(k, v.to_i)
+        end
+      end
+      sum
+    end
+    
+    def summarize_rem_keys(sets, key, sum)
+      sets.each do |date|
+        db.hgetall("#{key.prefix}#{date}").each do |k, v|
+          sum.set_or_incr(k, -v.to_i)
+        end
+      end
+      sum
+    end
+    
+    def db
+      super(options[:connection_ref])
+    end
+    
   end
 end

lib/redistat/finder/date_set.rb

@@ -9,6 +9,10 @@ module Redistat
       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

lib/redistat/key.rb

@@ -1,24 +1,22 @@
 module Redistat
   class Key
+    include Database
+    include Options
     
-    attr_accessor :scope
-    attr_accessor :date
-    attr_accessor :options
+    def default_options
+      { :depth => :hour }
+    end
     
-    def initialize(scope, label_name = nil, time_stamp = nil, options = {})
-      @options = default_options.merge(options || {})
-      @scope = scope
+    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 default_options
-      { :depth => :hour, :hashed_label => false }
-    end
-    
     def prefix
       key = "#{@scope}"
-      key << "/#{label}" if !label.nil?
+      key << "/#{label.name}" if !label.nil?
       key << ":"
       key
     end
@@ -26,21 +24,52 @@ module Redistat
     def date=(input)
       @date = (input.instance_of?(Redistat::Date)) ? input : Date.new(input) # Redistat::Date, not ::Date
     end
+    attr_reader :date
     
     def depth
-      @options[:depth]
+      options[:depth]
     end
     
-    def label
-      @label.name
+    # def scope
+    #   @scope.to_s
+    # end
+    
+    def scope=(input)
+      @scope = (input.instance_of?(Redistat::Scope)) ? input : Scope.new(input)
     end
+    attr_reader :scope
+    
+    def label=(input)
+      @label = (input.instance_of?(Redistat::Label)) ? input : Label.create(input, @options)
+    end
+    attr_reader :label
     
     def label_hash
       @label.hash
     end
     
-    def label=(input)
-      @label = (input.instance_of?(Redistat::Label)) ? input : Label.create(input, @options)
+    def parent
+      @parent ||= self.class.new(self.scope, @label.parent, self.date, @options) unless @label.parent.nil?
+    end
+    
+    def children
+      db.smembers("#{scope}#{LABEL_INDEX}#{@label}").map { |member|
+        child_label = [@label, member].reject { |i| i.nil? }
+        self.class.new(self.scope, child_label.join(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)

lib/redistat/label.rb

@@ -1,38 +1,68 @@
 module Redistat
   class Label
     include Database
+    include Options
     
-    attr_reader :raw
-    attr_reader :connection_ref
+    def default_options
+      { :hashed_label => false }
+    end
     
-    def initialize(str, options = {})
-      @options = options
+    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(GROUP_SEPARATOR))
+    end
+    
+    def initialize(str, opts = {})
+      parse_options(opts)
       @raw = str.to_s
     end
-
-    def db
-      super(@options[:connection_ref])
+    
+    def to_s
+      @raw
     end
     
     def name
-      @options[:hashed_label] ? hash : @raw
+      @options[:hashed_label] ? hash : self.to_s
     end
     
     def hash
-      @hash ||= Digest::SHA1.hexdigest(@raw)
+      @hash ||= Digest::SHA1.hexdigest(self.to_s)
     end
     
     def save
-      @saved = (db.set("#{KEY_LEBELS}#{hash}", @raw) == "OK") if @options[:hashed_label]
+      @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 self.create(name, options = {})
-      self.new(name, options).save
+    def parent
+      @parent ||= groups[1] if groups.size > 1
+    end
+    
+    def me
+      self.to_s.split(GROUP_SEPARATOR).last
+    end
+    
+    def groups
+      return @groups unless @groups.nil?
+      @groups = []
+      parent = ""
+      self.to_s.split(GROUP_SEPARATOR).each do |part|
+        if !part.blank?
+          group = ((parent.blank?) ? "" : "#{parent}#{GROUP_SEPARATOR}") + part
+          @groups << Label.new(group)
+          parent = group
+        end
+      end
+      @groups.reverse!
     end
     
   end

lib/redistat/model.rb

@@ -1,78 +1,69 @@
 module Redistat
   module Model
-    include Redistat::Database
+    include Database
+    include Options
     
     def self.included(base)
       base.extend(self)
     end
     
-    def store(label, stats = {}, date = nil, meta = {}, opts = {})
-      Event.new(name, label, date, stats, options.merge(opts), meta).save
+    
+    #
+    # statistics store/fetch methods
+    # 
+    
+    def store(label, stats = {}, date = nil, opts = {}, meta = {})
+      Event.new(self.name, label, date, stats, options.merge(opts), meta).save
     end
     alias :event :store
+
+    def fetch(label, from, till, opts = {})
+      find(label, from, till, opts).all
+    end
+    alias :lookup :fetch
+
+    def find(label, from, till, opts = {})
+      Finder.new( { :scope => self.name,
+                    :label => label,
+                    :from  => from,
+                    :till  => till }.merge(options.merge(opts)) )
+    end
+    
+    def find_event(event_id)
+      Event.find(self.name, event_id)
+    end
+    
+    
+    #
+    # options methods
+    #
+    
+    option_accessor :depth
+    option_accessor :class_name
+    option_accessor :store_event
+    option_accessor :hashed_label
+    option_accessor :label_indexing
+    
+    alias :scope :class_name
     
     def connect_to(opts = {})
       Connection.create(opts.merge(:ref => name))
       options[:connection_ref] = name
     end
     
+    
+    #
+    # resource access methods
+    #
+    
     def connection
       db(options[:connection_ref])
     end
     alias :redis :connection
     
-    def fetch(label, from, till, opts = {})
-      Finder.find({
-        :scope => name,
-        :label => label,
-        :from  => from,
-        :till  => till
-      }.merge(options.merge(opts)))
-    end
-    alias :lookup :fetch
-    
-    def hashed_label(boolean = nil)
-      if !boolean.nil?
-        options[:hashed_label] = boolean
-      else
-        options[:hashed_label] || nil
-      end
-    end
-    
-    def class_name(class_name = nil)
-      if !class_name.nil?
-        options[:class_name] = class_name
-      else
-        options[:class_name] || nil
-      end
-    end
-    alias :scope :class_name
-    
-    def depth(depth = nil)
-      if !depth.nil?
-        options[:depth] = depth
-      else
-        options[:depth] || nil
-      end
-    end
-    
-    def store_event(boolean = nil)
-      if !boolean.nil?
-        options[:store_event] = boolean
-      else
-        options[:store_event] || nil
-      end
-    end
-    
-    def options
-      @options ||= {}
-    end
-    
-    private
-    
     def name
       options[:class_name] || (@name ||= self.to_s)
     end
-    
+      
   end
 end

lib/redistat/options.rb

@@ -0,0 +1,41 @@
+module Redistat
+  module Options
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def option_accessor(*opts)
+        opts.each do |option|
+          define_method(option) do |*args|
+            if !args.first.nil?
+              options[option.to_sym] = args.first
+            else
+              options[option.to_sym] || nil
+            end
+          end
+        end
+      end
+    end
+    
+    def parse_options(opts)
+      opts ||= {}
+      @raw_options = opts
+      @options = default_options.merge(opts.reject { |k,v| v.nil? })
+    end
+    
+    def default_options
+      {}
+    end
+    
+    def options
+      @options ||= {}
+    end
+    
+    def raw_options
+      @raw_options ||= {}
+    end
+    
+  end
+end

lib/redistat/result.rb

@@ -1,5 +1,5 @@
 module Redistat
-  class Result < ::ActiveSupport::HashWithIndifferentAccess
+  class Result < HashWithIndifferentAccess
     
     attr_accessor :from
     attr_accessor :till
@@ -12,12 +12,5 @@ module Redistat
       @till = options[:till] ||= nil
     end
     
-    
-    def set_or_incr(key, value)
-      self[key] = 0 if !self.has_key?(key)
-      self[key] += value
-      self
-    end
-    
   end
-end
+end

lib/redistat/summary.rb

@@ -2,23 +2,66 @@ module Redistat
   class Summary
     include Database
     
-    def self.update_all(key, stats = {}, depth_limit = nil, connection_ref = nil)
+    def self.default_options
+      { :enable_grouping => true,
+        :label_indexing => true,
+        :connection_ref => nil }
+    end
+    
+    def self.update_all(key, stats = {}, depth_limit = nil, opts = {})
       stats ||= {}
-      depth_limit ||= key.depth
       return nil if stats.size == 0
+      
+      options = default_options.merge((opts || {}).reject { |k,v| v.nil? })
+      
+      depth_limit ||= key.depth
+      
+      if options[:enable_grouping]
+        stats = inject_group_summaries(stats)
+        key.groups.each do |k|
+          update_key(k, stats, depth_limit, options[:connection_ref])
+          k.update_index if options[:label_indexing]
+        end
+      else
+        update_key(key, stats, depth_limit, options[:connection_ref])
+      end
+    end
+    
+    private
+    
+    def self.update_key(key, stats, depth_limit, connection_ref)
       Date::DEPTHS.each do |depth|
         update(key, stats, depth, connection_ref)
         break if depth == depth_limit
       end
     end
     
-    private
-    
     def self.update(key, stats, depth, connection_ref = nil)
       stats.each do |field, value|
         db(connection_ref).hincrby key.to_s(depth), field, value
       end
     end
     
+    def self.inject_group_summaries!(stats)
+      summaries = {}
+      stats.each do |key, value|
+        parts = key.to_s.split(GROUP_SEPARATOR)
+        parts.pop
+        if parts.size > 0
+          sum_parts = []
+          parts.each do |part|
+            sum_parts << part
+            sum_key = sum_parts.join(GROUP_SEPARATOR)
+            (summaries.has_key?(sum_key)) ? summaries[sum_key] += value : summaries[sum_key] = value
+          end
+        end
+      end
+      stats.merge_and_incr!(summaries)
+    end
+    
+    def self.inject_group_summaries(stats)
+      inject_group_summaries!(stats.clone)
+    end
+    
   end
 end

lib/redistat/version.rb

@@ -1,3 +1,3 @@
 module Redistat
-  VERSION = "0.0.7"
-end
+  VERSION = "0.2.4"
+end

redistat.gemspec

@@ -19,11 +19,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_runtime_dependency 'activesupport', '>= 2.3.0'
+  s.add_runtime_dependency 'activesupport', '>= 2.3.6'
   s.add_runtime_dependency 'json', '>= 1.4.0'
   s.add_runtime_dependency 'redis', '>= 2.1.0'
-  s.add_runtime_dependency 'time_ext', '>= 0.2.8'
+  s.add_runtime_dependency 'time_ext', '>= 0.2.9'
   
   s.add_development_dependency 'rspec', '>= 2.1.0'
+  s.add_development_dependency 'rcov', '>= 0.9.9'
   s.add_development_dependency 'yard', '>= 0.6.3'
 end

spec/core_ext/hash_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Hash do
+  
+  it "should #set_or_incr values" do
+    hash = {:count => 1}
+    hash.set_or_incr(:sum, 3).should be_true
+    hash.should == {:count => 1, :sum => 3}
+    hash.set_or_incr(:count, 4).should be_true
+    hash.should == {:count => 5, :sum => 3}
+    hash.set_or_incr(:count, 'test').should be_false
+    hash.set_or_incr(:view, 'test').should be_false
+    hash.should == {:count => 5, :sum => 3}
+    hash[:view] = 'test'
+    hash.set_or_incr(:view, 3).should be_false
+  end
+  
+  it "should #merge_and_incr hashes" do
+    hash = { :count => 1, :city => 'hell', :sum => 3, :name => 'john' }
+    
+    new_hash = { :count => 3, :city => 'slum', :views => 2 }
+    hash.clone.merge_and_incr(new_hash).should == { :count => 4, :city => 'slum', :views => 2,
+                                                    :sum   => 3, :name => 'john' }
+    
+    new_hash = { :count => 'six', :city => 'slum', :views => 2, :time => 'late' }
+    hash.clone.merge_and_incr(new_hash).should == { :count => 'six', :city => 'slum', :views => 2,
+                                                    :sum   => 3, :name => 'john', :time => 'late' }
+  end
+  
+end

spec/event_spec.rb

@@ -8,8 +8,8 @@ describe Redistat::Event do
     @scope = "PageViews"
     @label = "about_us"
     @label_hash = Digest::SHA1.hexdigest(@label)
-    @stats = {:views => 1}
-    @meta = {:user_id => 239}
+    @stats = {'views' => 1}
+    @meta = {'user_id' => 239}
     @options = {:depth => :hour}
     @date = Time.now
     @event = Redistat::Event.new(@scope, @label, @date, @stats, @options, @meta)
@@ -17,8 +17,8 @@ describe Redistat::Event do
   
   it "should initialize properly" do
     @event.id.should be_nil
-    @event.scope.should == @scope
-    @event.label.should == @label
+    @event.scope.to_s.should == @scope
+    @event.label.to_s.should == @label
     @event.label_hash.should == @label_hash
     @event.date.to_time.to_s.should == @date.to_s
     @event.stats.should == @stats
@@ -33,12 +33,12 @@ describe Redistat::Event do
     @event.date = @date
     @event.date.to_time.to_s.should == @date.to_s
     # label
-    @event.label.should == @label
+    @event.label.to_s.should == @label
     @event.label_hash.should == @label_hash
     @label = "contact_us"
     @label_hash = Digest::SHA1.hexdigest(@label)
     @event.label = @label
-    @event.label.should == @label
+    @event.label.to_s.should == @label
     @event.label_hash.should == @label_hash
   end
   
@@ -63,9 +63,11 @@ describe Redistat::Event do
   it "should find event by id" do
     @event = Redistat::Event.new(@scope, @label, @date, @stats, @options.merge({:store_event => true}), @meta).save
     fetched = Redistat::Event.find(@scope, @event.id)
-    @event.scope.should == fetched.scope
-    @event.label.should == fetched.label
+    @event.scope.to_s.should == fetched.scope.to_s
+    @event.label.to_s.should == fetched.label.to_s
     @event.date.to_s.should == fetched.date.to_s
+    @event.stats.should == fetched.stats
+    @event.meta.should == fetched.meta
   end
   
   it "should store summarized statistics" do

spec/finder/date_set_spec.rb

@@ -28,11 +28,13 @@ describe Redistat::Finder::DateSet do
     result = Redistat::Finder::DateSet.new.find_date_sets(t_start, t_end, :hour, true)
     result[0][:add].should == ["2010082818", "2010082819", "2010082820", "2010082821", "2010082822"]
     result[0][:rem].should == []
+    result.should == Redistat::Finder::DateSet.new(t_start, t_end, nil, :hour)
     
     t_end = t_start + 4.days
     result = Redistat::Finder::DateSet.new.find_date_sets(t_start, t_end, :day, true)
     result[0][:add].should == ["20100828", "20100829", "20100830", "20100831", "20100901"]
     result[0][:rem].should == []
+    result.should == Redistat::Finder::DateSet.new(t_start, t_end, nil, :day)
   end
   
   it "should find start keys properly" do

spec/finder_spec.rb

@@ -9,38 +9,52 @@ describe Redistat::Finder do
     @label = "about_us"
     @date = Time.now
     @key = Redistat::Key.new(@scope, @label, @date, {:depth => :day})
-    @stats = {"views" => 3, "visitors" => 2}
+    @stats = {"views" => 3, "visitors" => 2}    
+    @two_hours_ago = 2.hours.ago
+    @one_hour_ago = 1.hour.ago
   end
   
   it "should initialize properly" do
-    two_hours_ago = 2.hours.ago
-    one_hour_ago = 1.hour.ago
-    options = {:scope => "PageViews", :label => "Label", :from => two_hours_ago, :till => one_hour_ago, :depth => :hour, :interval => :hour}
+    options = {:scope => "PageViews", :label => "Label", :from => @two_hours_ago, :till => @one_hour_ago, :depth => :hour, :interval => :hour}
     
-    finder = Redistat::Finder.new(options)
-    finder.options.should == options
-
-    finder = Redistat::Finder.dates(two_hours_ago, one_hour_ago).scope("PageViews").label("Label").depth(:hour).interval(:hour)
-    finder.options.should == options
-                                    
-    finder = Redistat::Finder.scope("PageViews").label("Label").from(two_hours_ago).till(one_hour_ago).depth(:hour).interval(:hour)
-    finder.options.should == options
+    finder = Redistat::Finder.new
+    finder.send(:set_options, options)
+    finder.options[:scope].should be_a(Redistat::Scope)
+    finder.options[:scope].to_s.should == options[:scope]
+    finder.options[:label].should be_a(Redistat::Label)
+    finder.options[:label].to_s.should == options[:label]
+    finder.options.should == options.merge(:scope => finder.options[:scope], :label => finder.options[:label])
     
-    finder = Redistat::Finder.label("Label").from(two_hours_ago).till(one_hour_ago).depth(:hour).interval(:hour).scope("PageViews")
-    finder.options.should == options
+    finder = Redistat::Finder.scope("hello")
+    finder.options[:scope].to_s.should == "hello"
+    finder.scope.to_s.should == "hello"
     
-    finder = Redistat::Finder.from(two_hours_ago).till(one_hour_ago).depth(:hour).interval(:hour).scope("PageViews").label("Label")
-    finder.options.should == options
+    finder = Redistat::Finder.label("hello")
+    finder.options[:label].to_s.should == "hello"
+    finder.label.to_s.should == "hello"
     
-    finder = Redistat::Finder.till(one_hour_ago).depth(:hour).interval(:hour).scope("PageViews").label("Label").from(two_hours_ago)
-    finder.options.should == options
+    finder = Redistat::Finder.dates(@two_hours_ago, @one_hour_ago)
+    finder.options[:from].should == @two_hours_ago
+    finder.options[:till].should == @one_hour_ago
     
-    finder = Redistat::Finder.depth(:hour).interval(:hour).scope("PageViews").label("Label").from(two_hours_ago).till(one_hour_ago)
-    finder.options.should == options
+    finder = Redistat::Finder.from(@two_hours_ago)
+    finder.options[:from].should == @two_hours_ago
+    finder.from.should == @two_hours_ago
     
-    finder = Redistat::Finder.interval(:hour).scope("PageViews").label("Label").from(two_hours_ago).till(one_hour_ago).depth(:hour)
-    finder.options.should == options
+    finder = Redistat::Finder.till(@one_hour_ago)
+    finder.options[:till].should == @one_hour_ago
+    finder.till.should == @one_hour_ago
     
+    finder = Redistat::Finder.depth(:hour)
+    finder.options[:depth].should == :hour
+    finder.depth.should == :hour
+    
+    finder = Redistat::Finder.interval(true)
+    finder.options[:interval].should be_true
+    finder.interval.should be_true
+    finder = Redistat::Finder.interval(false)
+    finder.options[:interval].should be_false
+    finder.interval.should be_false
   end
   
   it "should fetch stats properly" do
@@ -85,6 +99,96 @@ describe Redistat::Finder do
     lambda { Redistat::Finder.find(:from => 3.hours.ago) }.should raise_error(Redistat::InvalidOptions)
   end
   
+  describe "Grouping" do
+    before(:each) do
+      @options = {:scope => "PageViews", :label => "message/public", :from => @two_hours_ago, :till => @one_hour_ago, :depth => :hour, :interval => :hour}
+      @finder = Redistat::Finder.new(@options)
+    end
+    
+    it "should return parent finder" do
+      @finder.instance_variable_get("@parent").should be_nil
+      @finder.parent.should be_a(Redistat::Finder)
+      @finder.instance_variable_get("@parent").should_not be_nil
+      @finder.parent.options[:label].to_s.should == 'message'
+      @finder.label('message')
+      @finder.instance_variable_get("@parent").should be_nil
+      @finder.parent.should_not be_nil
+      @finder.parent.options[:label].should be_nil
+      @finder.parent.parent.should be_nil
+    end
+    
+    it "should find children" do
+      Redistat::Key.new("PageViews", "message/public/die").update_index
+      Redistat::Key.new("PageViews", "message/public/live").update_index
+      Redistat::Key.new("PageViews", "message/public/fester").update_index
+      members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}message/public") # checking 'message/public'
+      @finder.children.first.should be_a(Redistat::Finder)
+      subs = @finder.children.map { |f| f.options[:label].me }
+      subs.should have(3).items
+      subs.should include('die')
+      subs.should include('live')
+      subs.should include('fester')
+    end
+  end
+  
+  describe "Lazy-Loading" do
+    
+    before(:each) do
+      @first_stat, @last_stat = create_example_stats
+
+      @finder = Redistat::Finder.new
+      @finder.from(@first_stat).till(@last_stat).scope(@scope).label(@label).depth(:hour)
+      
+      @match = [{}, {"visitors"=>"4", "views"=>"6"},
+                    {"visitors"=>"2", "views"=>"3"},
+                    {"visitors"=>"2", "views"=>"3"}, {}]
+    end
+    
+    it "should lazy-load" do
+      @finder.instance_variable_get("@result").should be_nil
+      stats = @finder.all
+      @finder.instance_variable_get("@result").should_not be_nil
+      
+      stats.should == @finder.find # find method directly fetches results
+      stats.total.should == @finder.total
+      stats.total.should == { "views" => 12, "visitors" => 8 }
+      stats.total.from.should == @first_stat
+      stats.total.till.should == @last_stat
+      stats.first.should == stats.total
+
+      @finder.all.object_id.should == stats.object_id
+      @finder.from(@first_stat + 2.hours)
+      @finder.instance_variable_get("@result").should be_nil
+      @finder.all.object_id.should_not == stats.object_id
+      stats = @finder.all
+      stats.total.should == { "views" => 6, "visitors" => 4 }
+    end
+    
+    it "should handle #map" do
+      @finder.interval(:hour)
+      @finder.map { |r| r }.should == @match
+    end
+    
+    it "should handle #each" do
+      @finder.interval(:hour)
+      
+      res = []
+      @finder.each { |r| res << r }
+      res.should == @match
+    end
+    
+    it "should handle #each_with_index" do
+      @finder.interval(:hour)
+      
+      res = {}
+      match = {}
+      @finder.each_with_index { |r, i| res[i] = r }
+      @match.each_with_index { |r, i| match[i] = r }
+      res.should == match
+    end
+    
+  end # "Lazy-Loading"
+  
   
   # helper methods
   
@@ -93,7 +197,7 @@ describe Redistat::Finder do
     Redistat::Summary.update(key, @stats, :hour)
     key = Redistat::Key.new(@scope, @label, Time.parse("2010-05-14 13:53"))
     Redistat::Summary.update(key, @stats, :hour)
-    key = Redistat::Key.new(@scope, @label, Time.parse("2010-05-14 14:32"))
+    key = Redistat::Key.new(@scope, @label, Time.parse("2010-05-14 14:52"))
     Redistat::Summary.update(key, @stats, :hour)
     key = Redistat::Key.new(@scope, @label, (last = Time.parse("2010-05-14 15:02")))
     Redistat::Summary.update(key, @stats, :hour)

spec/key_spec.rb

@@ -1,8 +1,10 @@
 require "spec_helper"
 
 describe Redistat::Key do
+  include Redistat::Database
   
   before(:each) do
+    db.flushdb
     @scope = "PageViews"
     @label = "about_us"
     @label_hash = Digest::SHA1.hexdigest(@label)
@@ -11,9 +13,10 @@ describe Redistat::Key do
   end
   
   it "should initialize properly" do
-    @key.scope.should == @scope
-    @key.label.should == @label
+    @key.scope.to_s.should == @scope
+    @key.label.to_s.should == @label
     @key.label_hash.should == @label_hash
+    @key.groups.map { |k| k.instance_variable_get("@label") }.should == @key.instance_variable_get("@label").groups
     @key.date.should be_instance_of(Redistat::Date)
     @key.date.to_time.to_s.should == @date.to_s
   end
@@ -25,6 +28,8 @@ describe Redistat::Key do
       @key.to_s(props.last).should == "#{@scope}/#{@label}:#{@key.date.to_s(props.last)}"
       props.pop
     end
+    key = Redistat::Key.new(@scope, nil, @date, {:depth => :hour})
+    key.to_s.should == "#{@scope}:#{key.date.to_s(:hour)}"
   end
   
   it "should abide to hashed_label option" do
@@ -41,23 +46,84 @@ describe Redistat::Key do
   
   it "should allow changing attributes" do
     # scope
-    @key.scope.should == @scope
+    @key.scope.to_s.should == @scope
     @scope = "VisitorCount"
     @key.scope = @scope
-    @key.scope.should == @scope
+    @key.scope.to_s.should == @scope
     # date
     @key.date.to_time.to_s.should == @date.to_s
     @date = Time.now
     @key.date = @date
     @key.date.to_time.to_s.should == @date.to_s
     # label
-    @key.label.should == @label
+    @key.label.to_s.should == @label
     @key.label_hash == @label_hash
     @label = "contact_us"
     @label_hash = Digest::SHA1.hexdigest(@label)
     @key.label = @label
-    @key.label.should == @label
+    @key.label.to_s.should == @label
     @key.label_hash == @label_hash
   end
   
+  describe "Grouping" do
+    before(:each) do
+      @label = "message/public/offensive"
+      @key = Redistat::Key.new(@scope, @label, @date, {:depth => :hour})
+    end
+    
+    it "should create a group of keys from label group" do
+      label = 'message/public/offensive'
+      result = [ "message/public/offensive",
+                 "message/public",
+                 "message" ]
+
+      key = Redistat::Key.new(@scope, label, @date, {:depth => :hour})
+
+      key.groups.map { |k| k.label.to_s }.should == result
+    end
+    
+    it "should know it's parent" do
+      @key.parent.should be_a(Redistat::Key)
+      @key.parent.label.to_s.should == 'message/public'
+      Redistat::Key.new(@scope, 'hello', @date).parent.should be_nil
+    end
+    
+    it "should update label index and return children" do
+      db.smembers("#{@scope}#{Redistat::LABEL_INDEX}#{@key.label.parent}").should == []
+      @key.children.should have(0).items
+      
+      @key.update_index                                                  # indexing 'message/publish/offensive'
+      Redistat::Key.new("PageViews", "message/public/die").update_index  # indexing 'message/publish/die'
+      Redistat::Key.new("PageViews", "message/public/live").update_index # indexing 'message/publish/live'
+      
+      members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}#{@key.label.parent}") # checking 'message/public'
+      members.should have(3).item
+      members.should include('offensive')
+      members.should include('live')
+      members.should include('die')
+      
+      key = @key.parent
+      key.children.first.should be_a(Redistat::Key)
+      key.children.should have(3).item
+      key.children.map { |k| k.label.me }.should == members
+      
+      members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}#{key.label.parent}") # checking 'message'
+      members.should have(1).item
+      members.should include('public')
+      
+      key = key.parent
+      key.children.should have(1).item
+      key.children.map { |k| k.label.me }.should == members
+      
+      members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}") # checking ''
+      members.should have(1).item
+      members.should include('message')
+      
+      key.parent.should be_nil
+      key = Redistat::Key.new("PageViews")
+      key.children.should have(1).item
+      key.children.map { |k| k.label.me }.should include('message')
+    end
+  end
+  
 end

spec/label_spec.rb

@@ -17,12 +17,55 @@ describe Redistat::Label do
   it "should store a label hash lookup key" do
     label = Redistat::Label.new(@name, {:hashed_label => true}).save
     label.saved?.should be_true
-    db.get("#{Redistat::KEY_LEBELS}#{label.hash}").should == @name
+    db.hget(Redistat::KEY_LABELS, label.hash).should == @name
     
     name = "contact_us"
     label = Redistat::Label.create(name, {:hashed_label => true})
     label.saved?.should be_true
-    db.get("#{Redistat::KEY_LEBELS}#{label.hash}").should == name
+    db.hget(Redistat::KEY_LABELS, label.hash).should == name
+  end
+  
+  it "should join labels" do
+    include Redistat
+    label = Label.join('email', 'message', 'public')
+    label.should be_a(Label)
+    label.to_s.should == 'email/message/public'
+    label = Label.join(Label.new('email'), Label.new('message'), Label.new('public'))
+    label.should be_a(Label)
+    label.to_s.should == 'email/message/public'
+    label = Label.join('email', '', 'message', nil, 'public')
+    label.should be_a(Label)
+    label.to_s.should == 'email/message/public'
+  end
+  
+  describe "Grouping" do
+    before(:each) do
+      @name = "message/public/offensive"
+      @label = Redistat::Label.new(@name)
+    end
+    
+    it "should know it's parent label group" do
+      @label.parent.to_s.should == 'message/public'
+      Redistat::Label.new('hello').parent.should be_nil
+    end
+    
+    it "should separate label names into groups" do
+      @label.name.should == @name
+      @label.groups.map { |l| l.to_s }.should == [ "message/public/offensive",
+                                                   "message/public",
+                                                   "message" ]
+
+      @name = "/message/public/"
+      @label = Redistat::Label.new(@name)
+      @label.name.should == @name
+      @label.groups.map { |l| l.to_s }.should == [ "message/public",
+                                                   "message" ]
+
+      @name = "message"
+      @label = Redistat::Label.new(@name)
+      @label.name.should == @name
+      @label.groups.map { |l| l.to_s }.should == [ "message" ]
+    end
   end
   
 end

spec/model_spec.rb

@@ -5,6 +5,7 @@ describe Redistat::Model do
   include Redistat::Database
   
   before(:each) do
+    @time = Time.utc(2010, 8, 28, 12, 0, 0)
     ModelHelper1.redis.flushdb
     ModelHelper2.redis.flushdb
     ModelHelper3.redis.flushdb
@@ -16,6 +17,22 @@ describe Redistat::Model do
     ModelHelper2.send(:name).should == "ModelHelper2"
   end
   
+  it "should return a Finder" do
+    two_hours_ago = 2.hours.ago
+    one_hour_ago  = 1.hour.ago
+    finder = ModelHelper1.find('label', two_hours_ago, one_hour_ago)
+    finder.should be_a(Redistat::Finder)
+    finder.options[:scope].to_s.should == 'ModelHelper1'
+    finder.options[:label].to_s.should == 'label'
+    finder.options[:from].should  == two_hours_ago
+    finder.options[:till].should  == one_hour_ago
+  end
+  
+  it "should #find_event" do
+    Redistat::Event.should_receive(:find).with('ModelHelper1', 1)
+    ModelHelper1.find_event(1)
+  end
+  
   it "should listen to model-defined options" do
     ModelHelper2.depth.should == :day
     ModelHelper2.store_event.should == true
@@ -43,61 +60,98 @@ describe Redistat::Model do
   end
   
   it "should store and fetch stats" do
-    ModelHelper1.store("sheep.black", {:count => 6, :weight => 461}, 4.hours.ago)
-    ModelHelper1.store("sheep.black", {:count => 2, :weight => 156})
+    ModelHelper1.store("sheep.black", {:count => 6, :weight => 461}, @time.hours_ago(4))
+    ModelHelper1.store("sheep.black", {:count => 2, :weight => 156}, @time)
     
-    stats = ModelHelper1.fetch("sheep.black", 2.hours.ago, 1.hour.from_now)
+    stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(2), @time.hours_since(1))
     stats.total["count"].should == 2
     stats.total["weight"].should == 156
     stats.first.should == stats.total
     
-    stats = ModelHelper1.fetch("sheep.black", 5.hours.ago, 1.hour.from_now)
+    stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
     stats.first.should == stats.total
     
-    ModelHelper1.store("sheep.white", {:count => 5, :weight => 393}, 4.hours.ago)
-    ModelHelper1.store("sheep.white", {:count => 4, :weight => 316})
+    ModelHelper1.store("sheep.white", {:count => 5, :weight => 393}, @time.hours_ago(4))
+    ModelHelper1.store("sheep.white", {:count => 4, :weight => 316}, @time)
     
-    stats = ModelHelper1.fetch("sheep.white", 2.hours.ago, 1.hour.from_now)
+    stats = ModelHelper1.fetch("sheep.white", @time.hours_ago(2), @time.hours_since(1))
     stats.total[:count].should == 4
     stats.total[:weight].should == 316
     stats.first.should == stats.total
     
-    stats = ModelHelper1.fetch("sheep.white", 5.hours.ago, 1.hour.from_now)
+    stats = ModelHelper1.fetch("sheep.white", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 9
     stats.total[:weight].should == 709
     stats.first.should == stats.total
   end
   
+  it "should store and fetch grouping enabled stats" do
+    ModelHelper1.store("sheep/black", {:count => 6, :weight => 461}, @time.hours_ago(4))
+    ModelHelper1.store("sheep/black", {:count => 2, :weight => 156}, @time)
+    ModelHelper1.store("sheep/white", {:count => 5, :weight => 393}, @time.hours_ago(4))
+    ModelHelper1.store("sheep/white", {:count => 4, :weight => 316}, @time)
+    
+    stats = ModelHelper1.fetch("sheep/black", @time.hours_ago(2), @time.hours_since(1))
+    stats.total["count"].should == 2
+    stats.total["weight"].should == 156
+    stats.first.should == stats.total
+    
+    stats = ModelHelper1.fetch("sheep/black", @time.hours_ago(5), @time.hours_since(1))
+    stats.total[:count].should == 8
+    stats.total[:weight].should == 617
+    stats.first.should == stats.total
+    
+    stats = ModelHelper1.fetch("sheep/white", @time.hours_ago(2), @time.hours_since(1))
+    stats.total[:count].should == 4
+    stats.total[:weight].should == 316
+    stats.first.should == stats.total
+    
+    stats = ModelHelper1.fetch("sheep/white", @time.hours_ago(5), @time.hours_since(1))
+    stats.total[:count].should == 9
+    stats.total[:weight].should == 709
+    stats.first.should == stats.total
+    
+    stats = ModelHelper1.fetch("sheep", @time.hours_ago(2), @time.hours_since(1))
+    stats.total[:count].should == 6
+    stats.total[:weight].should == 472
+    stats.first.should == stats.total
+    
+    stats = ModelHelper1.fetch("sheep", @time.hours_ago(5), @time.hours_since(1))
+    stats.total[:count].should == 17
+    stats.total[:weight].should == 1326
+    stats.first.should == stats.total
+  end
+  
   it "should connect to different Redis servers on a per-model basis" do
     ModelHelper3.redis.client.db.should == 14
     
-    ModelHelper3.store("sheep.black", {:count => 6, :weight => 461}, 4.hours.ago)
-    ModelHelper3.store("sheep.black", {:count => 2, :weight => 156})
+    ModelHelper3.store("sheep.black", {:count => 6, :weight => 461}, @time.hours_ago(4), :label_indexing => false)
+    ModelHelper3.store("sheep.black", {:count => 2, :weight => 156}, @time, :label_indexing => false)
     
     db.keys("*").should be_empty
     ModelHelper1.redis.keys("*").should be_empty
     db("ModelHelper3").keys("*").should have(5).items
     ModelHelper3.redis.keys("*").should have(5).items
     
-    stats = ModelHelper3.fetch("sheep.black", 2.hours.ago, 1.hour.from_now)
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(2), @time.hours_since(1), :label_indexing => false)
     stats.total["count"].should == 2
     stats.total["weight"].should == 156
-    stats = ModelHelper3.fetch("sheep.black", 5.hours.ago, 1.hour.from_now)
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
     
     ModelHelper3.connect_to(:port => 8379, :db => 13)
     ModelHelper3.redis.client.db.should == 13
     
-    stats = ModelHelper3.fetch("sheep.black", 5.hours.ago, 1.hour.from_now)
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
     stats.total.should == {}
     
     ModelHelper3.connect_to(:port => 8379, :db => 14)
     ModelHelper3.redis.client.db.should == 14
     
-    stats = ModelHelper3.fetch("sheep.black", 5.hours.ago, 1.hour.from_now)
+    stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
   end

spec/options_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Redistat::Options do
+  
+  before(:each) do
+    @helper = OptionsHelper.new
+    @helper.parse_options(:wtf => 'dude', :foo => 'booze')
+  end
+  
+  it "should #parse_options" do
+    @helper.options[:hello].should == 'world'
+    @helper.options[:foo].should == 'booze'
+    @helper.options[:wtf].should == 'dude'
+    @helper.raw_options.should_not have_key(:hello)
+  end
+  
+  it "should create option_accessors" do
+    @helper.hello.should == 'world'
+    @helper.hello('woooo')
+    @helper.hello.should == 'woooo'
+  end
+  
+end
+
+class OptionsHelper
+  include Redistat::Options
+  
+  option_accessor :hello
+  
+  def default_options
+    { :hello => 'world',
+      :foo => 'bar' }
+  end
+  
+  
+end

spec/spec_helper.rb

@@ -8,5 +8,5 @@ require 'rspec'
 require 'rspec/autorun'
 
 # use the test Redistat instance
-Redistat.connect(:port => 8379, :db => 15)
+Redistat.connect(:port => 8379, :db => 15, :thread_safe => true)
 Redistat.redis.flushdb

spec/summary_spec.rb

@@ -46,4 +46,87 @@ describe Redistat::Summary do
     end
   end
   
+  it "should update summaries even if no label is set" do
+    key = Redistat::Key.new(@scope, nil, @date, {:depth => :day})
+    Redistat::Summary.update(key, @stats, :hour)
+    summary = db.hgetall(key.to_s(:hour))
+    summary.should have(2).items
+    summary["views"].should == "3"
+    summary["visitors"].should == "2"
+  end
+  
+  it "should inject stats key grouping summaries" do
+    hash = { "count/hello" => 3, "count/world"   => 7,
+             "death/bomb"  => 4, "death/unicorn" => 3,
+             :"od/sugar"   => 7, :"od/meth"      => 8 }
+    res = Redistat::Summary.send(:inject_group_summaries, hash)
+    res.should == { "count" => 10, "count/hello" => 3, "count/world"   => 7,
+                    "death" => 7,  "death/bomb"  => 4, "death/unicorn" => 3,
+                    "od"    => 15, :"od/sugar"   => 7, :"od/meth"      => 8 }
+  end
+  
+  it "should properly store key group summaries" do
+    stats = {"views" => 3, "visitors/eu" => 2, "visitors/us" => 4}
+    Redistat::Summary.update_all(@key, stats, :hour)
+    summary = db.hgetall(@key.to_s(:hour))
+    summary.should have(4).items
+    summary["views"].should == "3"
+    summary["visitors"].should == "6"
+    summary["visitors/eu"].should == "2"
+    summary["visitors/us"].should == "4"
+  end
+  
+  it "should not store key group summaries when option is disabled" do
+    stats = {"views" => 3, "visitors/eu" => 2, "visitors/us" => 4}
+    Redistat::Summary.update_all(@key, stats, :hour, {:enable_grouping => false})
+    summary = db.hgetall(@key.to_s(:hour))
+    summary.should have(3).items
+    summary["views"].should == "3"
+    summary["visitors/eu"].should == "2"
+    summary["visitors/us"].should == "4"
+  end
+  
+  it "should store label-based grouping enabled stats" do
+    stats = {"views" => 3, "visitors/eu" => 2, "visitors/us" => 4}
+    label = "views/about_us"
+    key = Redistat::Key.new(@scope, label, @date)
+    Redistat::Summary.update_all(key, stats, :hour)
+
+    key.groups[0].label.to_s.should == "views/about_us"
+    key.groups[1].label.to_s.should == "views"
+    child1 = key.groups[0]
+    parent = key.groups[1]
+    
+    label = "views/contact"
+    key = Redistat::Key.new(@scope, label, @date)
+    Redistat::Summary.update_all(key, stats, :hour)
+    
+    key.groups[0].label.to_s.should == "views/contact"
+    key.groups[1].label.to_s.should == "views"
+    child2 = key.groups[0]
+    
+    summary = db.hgetall(child1.to_s(:hour))
+    summary["views"].should == "3"
+    summary["visitors/eu"].should == "2"
+    summary["visitors/us"].should == "4"
+    
+    summary = db.hgetall(child2.to_s(:hour))
+    summary["views"].should == "3"
+    summary["visitors/eu"].should == "2"
+    summary["visitors/us"].should == "4"
+    
+    summary = db.hgetall(parent.to_s(:hour))
+    summary["views"].should == "6"
+    summary["visitors/eu"].should == "4"
+    summary["visitors/us"].should == "8"
+  end
+  
 end
+
+
+
+
+
+
+
+

spec/thread_safety_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe "Thread-Safety" do
+  include Redistat::Database
+  
+  before(:each) do
+    db.flushdb
+  end
+  
+  #TODO should have more comprehensive thread-safe tests
+  
+  it "should incr in multiple threads" do
+    threads = []
+    50.times do
+      threads << Thread.new {
+        db.incr("spec:incr")
+      }
+    end
+    threads.each { |t| t.join }
+    db.get("spec:incr").should == "50"
+  end
+  
+  it "should store event in multiple threads" do
+    class ThreadSafetySpec
+      include Redistat::Model
+    end
+    threads = []
+    50.times do
+      threads << Thread.new {
+        ThreadSafetySpec.store("spec:threadsafe", {:count => 1, :rand => rand(5)})
+      }
+    end
+    threads.each { |t| t.join }
+    result = ThreadSafetySpec.fetch("spec:threadsafe", 5.hours.ago, 5.hours.from_now)
+    result.total[:count].should == 50
+    result.total[:rand].should <= 250
+  end
+  
+end