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"

lib/redistat/event.rb

@@ -91,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

@@ -81,49 +81,56 @@ module Redistat
       }
     end
     
-    def connection_ref(ref)
+    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(scope)
-      reset! if !options[:scope].nil? && options[:scope].to_s != scope
-      options[:scope] = Scope.new(scope)
+    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(label)
-      reset! if options.has_key?(:label) && options[:label].to_s != label.to_s
-      options[:label] = (!label.nil?) ? Label.new(label) : nil
+    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(from, till)
-      from(from).till(till)
+    def dates(start, finish)
+      from(start).till(finish)
     end
     alias :date :dates
     
-    def 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)
+    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)
+    def depth(unit = nil)
+      return options[:depth] if unit.nil?
       reset! if options[:depth] != unit
       options[:depth] = unit
       self
     end
     
-    def interval(unit)
+    def interval(unit = nil)
+      return options[:interval] if unit.nil?
       reset! if options[:interval] != unit
       options[:interval] = unit
       self

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

@@ -30,13 +30,14 @@ module Redistat
       options[:depth]
     end
     
-    def scope
-      @scope.to_s
-    end
+    # 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)
@@ -60,7 +61,6 @@ module Redistat
     
     def update_index
       @label.groups.each do |label|
-        # break if label.parent.nil?
         parent = (label.parent || "")
         db.sadd("#{scope}#{LABEL_INDEX}#{parent}", label.me)
       end

lib/redistat/label.rb

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

lib/redistat/model.rb

@@ -13,7 +13,7 @@ module Redistat
     # 
     
     def store(label, stats = {}, date = nil, opts = {}, meta = {})
-      Event.new(name, label, date, stats, options.merge(opts), meta).save
+      Event.new(self.name, label, date, stats, options.merge(opts), meta).save
     end
     alias :event :store
 
@@ -29,6 +29,10 @@ module Redistat
                     :till  => till }.merge(options.merge(opts)) )
     end
     
+    def find_event(event_id)
+      Event.find(self.name, event_id)
+    end
+    
     
     #
     # options methods

lib/redistat/version.rb

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

redistat.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   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'

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,7 +17,7 @@ describe Redistat::Event do
   
   it "should initialize properly" do
     @event.id.should be_nil
-    @event.scope.should == @scope
+    @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
@@ -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.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

@@ -25,31 +25,36 @@ describe Redistat::Finder do
     finder.options[:label].to_s.should == options[:label]
     finder.options.should == options.merge(:scope => finder.options[:scope], :label => finder.options[:label])
     
+    finder = Redistat::Finder.scope("hello")
+    finder.options[:scope].to_s.should == "hello"
+    finder.scope.to_s.should == "hello"
+    
+    finder = Redistat::Finder.label("hello")
+    finder.options[:label].to_s.should == "hello"
+    finder.label.to_s.should == "hello"
+    
     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.scope("hello")
-    finder.options[:scope].to_s.should == "hello"
-    
-    finder = Redistat::Finder.label("hello")
-    finder.options[:label].to_s.should == "hello"
-    
     finder = Redistat::Finder.from(@two_hours_ago)
     finder.options[:from].should == @two_hours_ago
+    finder.from.should == @two_hours_ago
     
     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

spec/key_spec.rb

@@ -13,7 +13,7 @@ describe Redistat::Key do
   end
   
   it "should initialize properly" do
-    @key.scope.should == @scope
+    @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
@@ -28,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
@@ -44,10 +46,10 @@ 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

spec/label_spec.rb

@@ -25,6 +25,19 @@ describe Redistat::Label do
     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"

spec/model_spec.rb

@@ -28,6 +28,11 @@ describe Redistat::Model do
     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

spec/summary_spec.rb

@@ -46,6 +46,15 @@ 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,