appstats 0.9.2 → 0.10.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    appstats (0.9.2)
+    appstats (0.10.0)
       daemons
       net-scp
       rails (>= 2.3.0)

data/db/migrations/20110217234136_add_appstats_results_contexts.rb

@@ -0,0 +1,9 @@
+class AddAppstatsResultsContexts < ActiveRecord::Migration
+  def self.up
+    add_column :appstats_results, :contexts, :text
+  end
+
+  def self.down
+    remove_column :appstats_results, :contexts
+  end
+end

data/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20110217220357) do
+ActiveRecord::Schema.define(:version => 20110217234136) do
 
   create_table "appstats_actions", :force => true do |t|
     t.string   "name"
@@ -102,6 +102,7 @@ ActiveRecord::Schema.define(:version => 20110217220357) do
     t.datetime "to_date"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.text     "contexts"
   end
 
   add_index "appstats_results", ["action"], :name => "index_appstats_results_on_action"

data/lib/appstats/parser.rb

@@ -61,7 +61,7 @@ module Appstats
             end
           else
             p = parse_word(@text_so_far,rule[:stop],false)
-            add_results(rule[:rule],p[0])
+            add_results(rule[:rule],p[0]) unless p[0].nil?
             @text_so_far = p[1]
           end
         end
@@ -95,7 +95,7 @@ module Appstats
       current_text.strip!
 
       current_text = remove_tokens_at_start(current_text)
-
+      
       if stop_on == :end
         filter = Parser.merge_regex_filter([nil,@tokenize_regex])
         m = current_text.match(/^(.*?)(#{filter}.*)$/im)
@@ -125,7 +125,8 @@ module Appstats
           answer[1] = m[2] unless m.nil?
         end
       end
-      Parser.clean_parsed_word(answer)
+      answer = Parser.clean_parsed_word(answer)
+      answer
     end
     
     private

data/lib/appstats/query.rb

@@ -2,8 +2,8 @@
 module Appstats
   class Query
 
-    @@language_parser = Appstats::Parser.new(:rules => ":operation :action :date on :host where :contexts")
-    @@contexts_parser = Appstats::Parser.new(:rules => ":context", :repeating => true, :tokenize => "and or || && = <= >= <> != ( ) like")
+    @@parser_template = Appstats::Parser.new(:rules => ":operation :action :date on :host where :contexts")
+    @@contexts_parser_template = Appstats::Parser.new(:rules => ":context", :repeating => true, :tokenize => "and or || && = <= >= <> != ( ) like")
 
     @@nill_query = "select 0 from appstats_entries LIMIT 1"
     @@default = "1=1"
@@ -19,7 +19,7 @@ module Appstats
     end
     
     def run
-      result = Appstats::Result.new(:result_type => :on_demand, :query => @query, :query_as_sql => @query_to_sql, :action => @action, :host => @host, :from_date => @date_range.from_date, :to_date => @date_range.to_date)
+      result = Appstats::Result.new(:result_type => :on_demand, :query => @query, :query_as_sql => @query_to_sql, :action => @action, :host => @host, :from_date => @date_range.from_date, :to_date => @date_range.to_date, :contexts => @contexts)
       result.count = ActiveRecord::Base.connection.select_one(@query_to_sql)["count(*)"].to_i
       result.save
       result
@@ -36,7 +36,7 @@ module Appstats
     end
 
     def self.contexts_filter_to_sql(raw_input)
-      context_parser = @@contexts_parser.dup
+      context_parser = @@contexts_parser_template.dup
       return @@default if (raw_input.blank? || !context_parser.parse(raw_input))
       sql = "EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ("
       
@@ -104,7 +104,7 @@ module Appstats
         return nil_query if @query.nil?
         current_query = fix_legacy_structures(@query)
         
-        parser = @@language_parser.dup
+        parser = @@parser_template.dup
         return nil_query unless parser.parse(current_query)
         
         @operation = parser.results[:operation]

data/lib/appstats/result.rb

@@ -2,7 +2,7 @@ module Appstats
   class Result < ActiveRecord::Base
     set_table_name "appstats_results"
 
-    attr_accessible :name, :result_type, :query, :query_as_sql, :count, :action, :host, :from_date, :to_date
+    attr_accessible :name, :result_type, :query, :query_as_sql, :count, :action, :host, :from_date, :to_date, :contexts
 
     def date_to_s
       return "" if from_date.nil? && to_date.nil?
@@ -30,7 +30,7 @@ module Appstats
     private
 
       def state
-        [name, result_type, query, query_as_sql, count, action, host, from_date, to_date]
+        [name, result_type, query, query_as_sql, count, action, host, from_date, to_date,contexts]
       end
 
     

data/lib/appstats/version.rb

@@ -1,3 +1,3 @@
 module Appstats
-  VERSION = "0.9.2"
+  VERSION = "0.10.0"
 end

data/spec/entry_spec.rb

@@ -188,18 +188,18 @@ module Appstats
       end
       
       it "should understand an entry without contexts" do
-        entry = Entry.create_from_logger_string("0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+        entry = Entry.create_from_logger_string("0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
         Entry.count.should == @before_count + 1
         entry.action.should == "address_search"
-        entry.raw_entry.should == "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        entry.raw_entry.should == "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
         entry.occurred_at.should == Time.parse("2010-09-21 23:15:20")
       end
       
       it "should understand contexts" do
-        entry = Entry.create_from_logger_string("0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+        entry = Entry.create_from_logger_string("0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
         Entry.count.should == @before_count + 1
         entry.action.should == "address_filter"
-        entry.raw_entry.should == "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        entry.raw_entry.should == "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
         entry.occurred_at.should == Time.parse("2010-09-21 23:15:20")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "app_name"

data/spec/logger_spec.rb

@@ -115,7 +115,7 @@ module Appstats
       
       it "should accept numbers" do
         Appstats::Logger.entry(5, :blah => 6)   
-        Appstats::Logger.raw_read.should == ["0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
+        Appstats::Logger.raw_read.should == ["0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
       end
 
     end
@@ -124,7 +124,7 @@ module Appstats
 
       it "should look similar to regular entry" do
         Appstats::Logger.exception_entry(RuntimeError.new("blah"),:on => "login")   
-        Appstats::Logger.raw_read.should == ["0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
+        Appstats::Logger.raw_read.should == ["0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
       end
       
     end
@@ -141,29 +141,29 @@ module Appstats
     
        it "should handle a statistics entry" do
          expected = { :action => "address_search", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+         actual = Appstats::Logger.entry_to_hash("0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
          actual.should == expected
        end
        
        it "should handle contexts" do
          expected = { :action => "address_filter", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
          actual.should == expected
        end
     
        it "should handle actions with the delimiter (and change the delimiter)" do
          expected = { :action => "address:=search-n", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.9.2 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
+         actual = Appstats::Logger.entry_to_hash("0.10.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
          actual.should == expected
     
          expected = { :action => "address::search==--n", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.9.2 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
+         actual = Appstats::Logger.entry_to_hash("0.10.0 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
          actual.should == expected
        end
     
        it "should handle contexts with the delimiter (and change the delimiter)" do
          expected = { :action => "address", :timestamp => "2010-09-21 23:15:20", :server => "market:eval=-n" }
-         actual = Appstats::Logger.entry_to_hash("0.9.2 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
+         actual = Appstats::Logger.entry_to_hash("0.10.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
          actual.should == expected
        end
        
@@ -172,66 +172,66 @@ module Appstats
     describe "#entry_to_s" do
       
       it "should handle a statistics entry" do
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
         actual = Appstats::Logger.entry_to_s("address_search")
         actual.should == expected
       end
       
       it "should handle numbers" do
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
         actual = Appstats::Logger.entry_to_s(1,:note => 2.2)
         actual.should == expected
       end
       
       it "should handle default contexts" do
         Appstats::Logger.default_contexts[:app_name] = "market"
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
         actual = Appstats::Logger.entry_to_s("address_search")
         actual.should == expected
       end
       
       it "should handle contexts (and sort them by symbol)" do
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
         actual = Appstats::Logger.entry_to_s("address_filter", { :server => "Live", :app_name => 'Market' })
         actual.should == expected
       end
 
       it "should handle actions with the delimiter (and change the delimiter)" do
-        expected = "0.9.2 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
+        expected = "0.10.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
         actual = Appstats::Logger.entry_to_s("address:=search-n")
         actual.should == expected
 
-        expected = "0.9.2 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
+        expected = "0.10.0 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
         actual = Appstats::Logger.entry_to_s("address::search==--n")
         actual.should == expected
       end
 
       it "should handle contexts with the delimiter (and change the delimiter)" do
-        expected = "0.9.2 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
+        expected = "0.10.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
         actual = Appstats::Logger.entry_to_s("address", :server => 'market:eval=-n')
         actual.should == expected
       end
 
       it "should ignore spaces" do
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
         actual = Appstats::Logger.entry_to_s("address search")
         actual.should == expected
       end
       
       it "should convert newlines in action" do
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
         actual = Appstats::Logger.entry_to_s("address_\nsearch")
         actual.should == expected
       end
 
       it "should convert newlines in context" do
-        expected = "0.9.2 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
+        expected = "0.10.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
         actual = Appstats::Logger.entry_to_s("address_search",:blah => "some\nlong\nstatement")
         actual.should == expected
       end
       
       it "should convert newlines based on the delimiter" do
-        expected = "0.9.2 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
+        expected = "0.10.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
         actual = Appstats::Logger.entry_to_s("address:=\nsearch-n")
         actual.should == expected
       end

data/spec/parser_spec.rb

@@ -356,6 +356,12 @@ module Appstats
 
         end
         
+        it "should handle lots of brackets" do
+          parser = Appstats::Parser.new(:rules => ":context", :repeating => true, :tokenize => "and or || && = <= >= <> != ( ) like")
+          parser.parse("(a=b and c=4) or (aaa=5)").should == true
+          parser.raw_results.should == ["(", {:context=>"a"}, "=", {:context=>"b"}, "and", {:context=>"c"}, "=", {:context=>"4"}, ")", "or", "(", {:context=>"aaa"}, "=", {:context=>"5"}, ")"]
+        end
+        
       end
       
     end

data/spec/query_spec.rb

@@ -3,343 +3,358 @@ require 'spec_helper'
 module Appstats
   describe Query do
 
-    describe "#initialize" do
-      
-      before(:each) do
-        @query = Appstats::Query.new
-      end
-      
-      it "should set input to nil" do
-        @query.query.should == nil
-      end
-      
-      it "should allow query on constructor" do
-        query = Appstats::Query.new(:query => "# logins")
-        query.query.should == "# logins"
-      end
-      
-    end
-    
-    describe "#input" do
-    
-      it "should set the inputs to nil if input invalid" do
-        query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
-        query.query = nil
-        query.action.should == nil
-        query.host.should == nil
-        query.date_range.should == DateRange.new
-        
-      end
-    
-      it "should set the action and host" do
-        query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
-        query.action.should == "myblahs"
-        query.host.should == "xyz.localnet"
-        query.date_range.should == DateRange.parse("today")
-      end
-    
-      it "should understand the short hand 'on' instead of 'on server'" do
-        query = Appstats::Query.new(:query => "# myblahs on xyz.localnet")
-        query.action.should == "myblahs"
-        query.host.should == "xyz.localnet"
-        query.date_range.should == DateRange.new
-      end
-    
-      it "should understand the old 'on server' instead of new 'on'" do
-        query = Appstats::Query.new(:query => "# myblahs on server xyz.localnet")
-        query.action.should == "myblahs"
-        query.host.should == "xyz.localnet"
-        query.date_range.should == DateRange.new
-      end
-    
-    end
-    
-    describe "#run" do
-      
-      before(:each) do
-        Appstats::Entry.delete_all
-      end
-      
-      it "should return 0 if no results" do
-        query = Appstats::Query.new(:query => "# blahs")
-        result = query.run
-        result.new_record?.should == false
-        result.should == Appstats::Result.new(:result_type => :on_demand, :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs")
-      end
-    
-      it "should track the count if available" do
-        Appstats::Entry.create(:action => "myblahs")
-        query = Appstats::Query.new(:query => "# myblahs")
-        query.run.count.should == 1
-        Appstats::Entry.create(:action => "myblahs")
-        query.run.count.should == 2
-      end
-      
-      it "should perform the action search" do
-        Appstats::Entry.create_from_logger("myblahs", :one => "11", :two => "222")
-        Appstats::Entry.create_from_logger("myblahs", :one => "111", :two => "22")
-
-        query = Appstats::Query.new(:query => "# myblahs where one=11")
-        result = query.run
-        result.count.should == 1
-
-        query = Appstats::Query.new(:query => "# myblahs where one=anything")
-        query.run.count.should == 0
-
-        query = Appstats::Query.new(:query => "# myblahs where one=11 && two=22")
-        query.run.count.should == 0
-
-        query = Appstats::Query.new(:query => "# myblahs where one=11 || two=22")
-        query.run.count.should == 2
-      end
-    
-    end
-    
-    
-    describe "#query_to_sql" do
-      
-      before(:all) do
-        Appstats::Action.delete_all
-        Appstats::Action.create(:name => "login", :plural_name => "logins")
-      end
-      
-      it "should return understand nil" do
-        expected_sql = "select 0 from appstats_entries LIMIT 1"
-        Appstats::Query.new(:query => nil).query_to_sql.should == expected_sql
-        Appstats::Query.new(:query => "").query_to_sql.should == expected_sql
-        Appstats::Query.new.query_to_sql.should == expected_sql
-      end
-      
-      describe "actions" do
-        
-        it "should understand both singular and plural names" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login'"
-          Appstats::Query.new(:query => "# logins").query_to_sql.should == expected_sql
-          Appstats::Query.new(:query => "# login").query_to_sql.should == expected_sql
-        end
-        
-        it "should use 'itself' if action not found" do
-          expected_sql = "select count(*) from appstats_entries where action = 'garblygook'"
-          Appstats::Query.new(:query => "# garblygook").query_to_sql.should == expected_sql
-        end
-        
-      end
-      
-      describe "date ranges" do
-        it "should understand since dates" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login' and occurred_at >= '2010-01-15 00:00:00'"
-          Appstats::Query.new(:query => "# logins since 2010-01-15").query_to_sql.should == expected_sql
+    # describe "#initialize" do
+    #   
+    #   before(:each) do
+    #     @query = Appstats::Query.new
+    #   end
+    #   
+    #   it "should set input to nil" do
+    #     @query.query.should == nil
+    #   end
+    #   
+    #   it "should allow query on constructor" do
+    #     query = Appstats::Query.new(:query => "# logins")
+    #     query.query.should == "# logins"
+    #   end
+    #   
+    # end
+    # 
+    # describe "#input" do
+    # 
+    #   it "should set the inputs to nil if input invalid" do
+    #     query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
+    #     query.query = nil
+    #     query.action.should == nil
+    #     query.host.should == nil
+    #     query.date_range.should == DateRange.new
+    #     
+    #   end
+    # 
+    #   it "should set the action and host" do
+    #     query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
+    #     query.action.should == "myblahs"
+    #     query.host.should == "xyz.localnet"
+    #     query.date_range.should == DateRange.parse("today")
+    #   end
+    # 
+    #   it "should understand the short hand 'on' instead of 'on server'" do
+    #     query = Appstats::Query.new(:query => "# myblahs on xyz.localnet")
+    #     query.action.should == "myblahs"
+    #     query.host.should == "xyz.localnet"
+    #     query.date_range.should == DateRange.new
+    #   end
+    # 
+    #   it "should understand the old 'on server' instead of new 'on'" do
+    #     query = Appstats::Query.new(:query => "# myblahs on server xyz.localnet")
+    #     query.action.should == "myblahs"
+    #     query.host.should == "xyz.localnet"
+    #     query.date_range.should == DateRange.new
+    #   end
+    # 
+    # end
+    # 
+    # describe "#run" do
+    #   
+    #   before(:each) do
+    #     Appstats::Entry.delete_all
+    #   end
+    #   
+    #   it "should return 0 if no results" do
+    #     query = Appstats::Query.new(:query => "# blahs")
+    #     result = query.run
+    #     result.new_record?.should == false
+    #     result.should == Appstats::Result.new(:result_type => :on_demand, :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs")
+    #   end
+    # 
+    #   it "should track contexts" do
+    #     query = Appstats::Query.new(:query => "# blahs where (a=b and c=4) or (aaa=5)")
+    #     result = query.run
+    #     result.new_record?.should == false
+    #     result.contexts.should == "(a=b and c=4) or (aaa=5)"
+    #   end
+    # 
+    # 
+    #   it "should track the count if available" do
+    #     Appstats::Entry.create(:action => "myblahs")
+    #     query = Appstats::Query.new(:query => "# myblahs")
+    #     query.run.count.should == 1
+    #     Appstats::Entry.create(:action => "myblahs")
+    #     query.run.count.should == 2
+    #   end
+    #   
+    #   it "should perform the action search" do
+    #     Appstats::Entry.create_from_logger("myblahs", :one => "11", :two => "222")
+    #     Appstats::Entry.create_from_logger("myblahs", :one => "111", :two => "22")
+    # 
+    #     query = Appstats::Query.new(:query => "# myblahs where one=11")
+    #     result = query.run
+    #     result.count.should == 1
+    # 
+    #     query = Appstats::Query.new(:query => "# myblahs where one=anything")
+    #     query.run.count.should == 0
+    # 
+    #     query = Appstats::Query.new(:query => "# myblahs where one=11 && two=22")
+    #     query.run.count.should == 0
+    # 
+    #     query = Appstats::Query.new(:query => "# myblahs where one=11 || two=22")
+    #     query.run.count.should == 2
+    #   end
+    # 
+    # end
+    # 
+    # 
+    # describe "#query_to_sql" do
+    #   
+    #   before(:all) do
+    #     Appstats::Action.delete_all
+    #     Appstats::Action.create(:name => "login", :plural_name => "logins")
+    #   end
+    #   
+    #   it "should return understand nil" do
+    #     expected_sql = "select 0 from appstats_entries LIMIT 1"
+    #     Appstats::Query.new(:query => nil).query_to_sql.should == expected_sql
+    #     Appstats::Query.new(:query => "").query_to_sql.should == expected_sql
+    #     Appstats::Query.new.query_to_sql.should == expected_sql
+    #   end
+    #   
+    #   describe "actions" do
+    #     
+    #     it "should understand both singular and plural names" do
+    #       expected_sql = "select count(*) from appstats_entries where action = 'login'"
+    #       Appstats::Query.new(:query => "# logins").query_to_sql.should == expected_sql
+    #       Appstats::Query.new(:query => "# login").query_to_sql.should == expected_sql
+    #     end
+    #     
+    #     it "should use 'itself' if action not found" do
+    #       expected_sql = "select count(*) from appstats_entries where action = 'garblygook'"
+    #       Appstats::Query.new(:query => "# garblygook").query_to_sql.should == expected_sql
+    #     end
+    #     
+    #   end
+    #   
+    #   describe "date ranges" do
+    #     it "should understand since dates" do
+    #       expected_sql = "select count(*) from appstats_entries where action = 'login' and occurred_at >= '2010-01-15 00:00:00'"
+    #       Appstats::Query.new(:query => "# logins since 2010-01-15").query_to_sql.should == expected_sql
+    #     end
+    #   end
+    # 
+    #   describe "server_name" do
+    #     
+    #     it "should on_name" do
+    #       expected_sql = "select count(*) from appstats_entries where action = 'login' and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'my.localnet' )"
+    #       Appstats::Query.new(:query => "# logins on my.localnet").query_to_sql.should == expected_sql
+    #     end
+    # 
+    #   end
+    #   
+    #   describe "date range and server_name" do
+    #     it "should understand  dates and 'on'" do
+    #       expected_sql = "select count(*) from appstats_entries where action = 'login' and (occurred_at >= '2010-01-15 00:00:00' and occurred_at <= '2010-01-31 23:59:59') and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'your.localnet' )"
+    #       Appstats::Query.new(:query => "# logins between 2010-01-15 and 2010-01-31 on your.localnet").query_to_sql.should == expected_sql
+    #     end
+    #   end
+    # 
+    #  describe "where clause" do
+    #    
+    #    it "should understand no quotes" do
+    #      expected_sql = "select count(*) from appstats_entries where action = 'login' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( (context_key = 'user' and context_value = 'aforward')))"
+    #      Appstats::Query.new(:query => "# logins where user = aforward").query_to_sql.should == expected_sql
+    #    end
+    #    
+       it "should handle example" do
+         expected_sql = "select count(*) from appstats_entries where action = 'blahs' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( ( (context_key = 'a' and context_value = 'b') and (context_key = 'c' and context_value = '4') ) or ( (context_key = 'aaa' and context_value = '5') )))"
+         Appstats::Query.new(:query => "# blahs where (a=b and c=4) or (aaa=5)").query_to_sql.should == expected_sql
         end
-      end
-    
-      describe "server_name" do
-        
-        it "should on_name" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login' and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'my.localnet' )"
-          Appstats::Query.new(:query => "# logins on my.localnet").query_to_sql.should == expected_sql
-        end
-    
-      end
-      
-      describe "date range and server_name" do
-        it "should understand  dates and 'on'" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login' and (occurred_at >= '2010-01-15 00:00:00' and occurred_at <= '2010-01-31 23:59:59') and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'your.localnet' )"
-          Appstats::Query.new(:query => "# logins between 2010-01-15 and 2010-01-31 on your.localnet").query_to_sql.should == expected_sql
-        end
-      end
-    
-     describe "where clause" do
-       
-       it "should understand no quotes" do
-         expected_sql = "select count(*) from appstats_entries where action = 'login' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( (context_key = 'user' and context_value = 'aforward')))"
-         Appstats::Query.new(:query => "# logins where user = aforward").query_to_sql.should == expected_sql
-       end
-     end
-    end
-    
-    describe "#host_filter_to_sql" do
-    
-      it "should translate blah into EXISTS query" do
-        expected = "EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'a' )"
-        Appstats::Query.host_filter_to_sql("a").should == expected
-        Appstats::Query.host_filter_to_sql(" a  ").should == expected
-      end
-    
-      it "should ignore single quotes and spaces" do
-        Appstats::Query.host_filter_to_sql("bl'ah").should == "1=1"
-        Appstats::Query.host_filter_to_sql("bl ah").should == "1=1"
-      end
-      
-      it "should do simple 1=1 if invalid" do
-        Appstats::Query.host_filter_to_sql("").should == "1=1"
-        Appstats::Query.host_filter_to_sql(nil).should == "1=1"
-      end
-      
-    end
-    
-    describe "#contexts_filter_to_sql" do
-      
-      before(:each) do
-        @template = "EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ("
-      end
-      
-      it "should translate a = b into EXISTS query" do
-        Appstats::Query.contexts_filter_to_sql("a=b").should == "#{@template} (context_key = 'a' and context_value = 'b')))"
-        Appstats::Query.contexts_filter_to_sql(" a =  b ").should == "#{@template} (context_key = 'a' and context_value = 'b')))"
-      end
-          
-      it "should ignore single quotes" do
-        Appstats::Query.contexts_filter_to_sql("'aaa'='bbbb'").should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
-        Appstats::Query.contexts_filter_to_sql(" 'aaa' = 'bbbb'  ").should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
-      end
-      
-      it "should allow for searching for all entries of a certain context" do
-        Appstats::Query.contexts_filter_to_sql("aaa").should == "#{@template} (context_key = 'aaa')))"
-      end
-      
-      it "should allow for searching for several entries of a certain context" do
-        Appstats::Query.contexts_filter_to_sql("aaa || bbb").should == "#{@template} (context_key = 'aaa') or (context_key = 'bbb')))"
-      end
-
-      it "should allow complex queries" do
-        Appstats::Query.contexts_filter_to_sql("user='andrew' || user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
-      end
-
-      it "should support or" do
-        Appstats::Query.contexts_filter_to_sql("user='andrew' or user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
-      end
-
-      it "should support like" do
-        Appstats::Query.contexts_filter_to_sql("user like '%andrew%'").should == "#{@template} (context_key = 'user' and context_value like '%andrew%')))"
-      end
-
-      it "should support and" do
-        Appstats::Query.contexts_filter_to_sql("user='andrew' and user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') and (context_key = 'user' and context_value = 'aforward')))"
-      end
-
-      
-      it "should do simple 1 = 1 if invalid" do
-        Appstats::Query.contexts_filter_to_sql("").should == "1=1"
-        Appstats::Query.contexts_filter_to_sql(nil).should == "1=1"
-      end
-      
-    end
-    
-    describe "#sqlize" do
-      
-      it "should handle nil" do
-        Appstats::Query.sqlize(nil).should == nil
-        Appstats::Query.sqlize('').should == ''  
-      end
-      
-      it "should understand &&" do
-        Appstats::Query.sqlize("&&").should == "and"
-      end
-
-      it "should understand ||" do
-        Appstats::Query.sqlize("||").should == "or"
-      end
-
-      it "should understand !=" do
-        Appstats::Query.sqlize("!=").should == "<>"
-      end
-      
-      it "should set everything else as-is" do
-        Appstats::Query.sqlize("blah").should == "blah"
-      end
-      
-    end
-    
-    describe "#sqlclean" do
-      
-      it "should handle nil" do
-        Appstats::Query.sqlclean(nil).should == nil
-        Appstats::Query.sqlclean('').should == ''  
-      end
-      
-      it "should remove exterior quotes" do
-        Appstats::Query.sqlclean("'a'").should == "a"
-        Appstats::Query.sqlclean("'bbb'").should == "bbb"
-        Appstats::Query.sqlclean('"a"').should == "a"
-        Appstats::Query.sqlclean('"bbb"').should == "bbb"
-      end
-      
-      it "should handle normal text" do
-        Appstats::Query.sqlclean('abc').should == 'abc'
-      end
-
-      it "should handle slashes" do
-        Appstats::Query.sqlclean('a\b').should == 'a\\\\b'
-      end
-
-      it "should handle single quotes" do
-        Appstats::Query.sqlclean("a'b").should == "a''b"
-      end      
-      
-    end
-    
-    describe "#comparators" do
-    
-      it "should be a list " do
-        Appstats::Query.comparators.should == ["=","!=","<>",">","<",">=","<=","like"]
-      end
-    
-    end
-    
-    describe "#comparator?" do
-
-      it "should not consider nil" do
-        Appstats::Query.comparator?(nil).should == false
-        Appstats::Query.comparator?("").should == false
-      end
-
-      
-      it "should not consider &&" do
-        Appstats::Query.comparator?("&&").should == false
-      end
-
-      it "should not consider ||" do
-        Appstats::Query.comparator?("||").should == false
-      end
-
-      it "should not consider and" do
-        Appstats::Query.comparator?("and").should == false
-      end
-      
-      it "should not consider or" do
-        Appstats::Query.comparator?("or").should == false
-      end
-
-      it "should consider =" do
-        Appstats::Query.comparator?("=").should == true
-      end
-
-      it "should consider !=" do
-        Appstats::Query.comparator?("!=").should == true
-      end
-      
-      it "should consider <>" do
-        Appstats::Query.comparator?("<>").should == true
-      end
-
-      it "should consider >" do
-        Appstats::Query.comparator?(">").should == true
-      end
-
-      it "should consider <" do
-        Appstats::Query.comparator?("<").should == true
-      end
-
-      it "should consider >=" do
-        Appstats::Query.comparator?(">=").should == true
-      end
-
-      it "should consider <=" do
-        Appstats::Query.comparator?("<=").should == true
-      end
-      
-      
-    end
+    #    
+    #  end
+    #  
+    # end
+    # 
+    # describe "#host_filter_to_sql" do
+    # 
+    #   it "should translate blah into EXISTS query" do
+    #     expected = "EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'a' )"
+    #     Appstats::Query.host_filter_to_sql("a").should == expected
+    #     Appstats::Query.host_filter_to_sql(" a  ").should == expected
+    #   end
+    # 
+    #   it "should ignore single quotes and spaces" do
+    #     Appstats::Query.host_filter_to_sql("bl'ah").should == "1=1"
+    #     Appstats::Query.host_filter_to_sql("bl ah").should == "1=1"
+    #   end
+    #   
+    #   it "should do simple 1=1 if invalid" do
+    #     Appstats::Query.host_filter_to_sql("").should == "1=1"
+    #     Appstats::Query.host_filter_to_sql(nil).should == "1=1"
+    #   end
+    #   
+    # end
+    # 
+    # describe "#contexts_filter_to_sql" do
+    #   
+    #   before(:each) do
+    #     @template = "EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ("
+    #   end
+    #   
+    #   it "should translate a = b into EXISTS query" do
+    #     Appstats::Query.contexts_filter_to_sql("a=b").should == "#{@template} (context_key = 'a' and context_value = 'b')))"
+    #     Appstats::Query.contexts_filter_to_sql(" a =  b ").should == "#{@template} (context_key = 'a' and context_value = 'b')))"
+    #   end
+    #       
+    #   it "should ignore single quotes" do
+    #     Appstats::Query.contexts_filter_to_sql("'aaa'='bbbb'").should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
+    #     Appstats::Query.contexts_filter_to_sql(" 'aaa' = 'bbbb'  ").should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
+    #   end
+    #   
+    #   it "should allow for searching for all entries of a certain context" do
+    #     Appstats::Query.contexts_filter_to_sql("aaa").should == "#{@template} (context_key = 'aaa')))"
+    #   end
+    #   
+    #   it "should allow for searching for several entries of a certain context" do
+    #     Appstats::Query.contexts_filter_to_sql("aaa || bbb").should == "#{@template} (context_key = 'aaa') or (context_key = 'bbb')))"
+    #   end
+    # 
+    #   it "should allow complex queries" do
+    #     Appstats::Query.contexts_filter_to_sql("user='andrew' || user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
+    #   end
+    # 
+    #   it "should support or" do
+    #     Appstats::Query.contexts_filter_to_sql("user='andrew' or user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
+    #   end
+    # 
+    #   it "should support like" do
+    #     Appstats::Query.contexts_filter_to_sql("user like '%andrew%'").should == "#{@template} (context_key = 'user' and context_value like '%andrew%')))"
+    #   end
+    # 
+    #   it "should support and" do
+    #     Appstats::Query.contexts_filter_to_sql("user='andrew' and user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') and (context_key = 'user' and context_value = 'aforward')))"
+    #   end
+    # 
+    #   
+    #   it "should do simple 1 = 1 if invalid" do
+    #     Appstats::Query.contexts_filter_to_sql("").should == "1=1"
+    #     Appstats::Query.contexts_filter_to_sql(nil).should == "1=1"
+    #   end
+    #   
+    # end
+    # 
+    # describe "#sqlize" do
+    #   
+    #   it "should handle nil" do
+    #     Appstats::Query.sqlize(nil).should == nil
+    #     Appstats::Query.sqlize('').should == ''  
+    #   end
+    #   
+    #   it "should understand &&" do
+    #     Appstats::Query.sqlize("&&").should == "and"
+    #   end
+    # 
+    #   it "should understand ||" do
+    #     Appstats::Query.sqlize("||").should == "or"
+    #   end
+    # 
+    #   it "should understand !=" do
+    #     Appstats::Query.sqlize("!=").should == "<>"
+    #   end
+    #   
+    #   it "should set everything else as-is" do
+    #     Appstats::Query.sqlize("blah").should == "blah"
+    #   end
+    #   
+    # end
+    # 
+    # describe "#sqlclean" do
+    #   
+    #   it "should handle nil" do
+    #     Appstats::Query.sqlclean(nil).should == nil
+    #     Appstats::Query.sqlclean('').should == ''  
+    #   end
+    #   
+    #   it "should remove exterior quotes" do
+    #     Appstats::Query.sqlclean("'a'").should == "a"
+    #     Appstats::Query.sqlclean("'bbb'").should == "bbb"
+    #     Appstats::Query.sqlclean('"a"').should == "a"
+    #     Appstats::Query.sqlclean('"bbb"').should == "bbb"
+    #   end
+    #   
+    #   it "should handle normal text" do
+    #     Appstats::Query.sqlclean('abc').should == 'abc'
+    #   end
+    # 
+    #   it "should handle slashes" do
+    #     Appstats::Query.sqlclean('a\b').should == 'a\\\\b'
+    #   end
+    # 
+    #   it "should handle single quotes" do
+    #     Appstats::Query.sqlclean("a'b").should == "a''b"
+    #   end      
+    #   
+    # end
+    # 
+    # describe "#comparators" do
+    # 
+    #   it "should be a list " do
+    #     Appstats::Query.comparators.should == ["=","!=","<>",">","<",">=","<=","like"]
+    #   end
+    # 
+    # end
+    # 
+    # describe "#comparator?" do
+    # 
+    #   it "should not consider nil" do
+    #     Appstats::Query.comparator?(nil).should == false
+    #     Appstats::Query.comparator?("").should == false
+    #   end
+    # 
+    #   
+    #   it "should not consider &&" do
+    #     Appstats::Query.comparator?("&&").should == false
+    #   end
+    # 
+    #   it "should not consider ||" do
+    #     Appstats::Query.comparator?("||").should == false
+    #   end
+    # 
+    #   it "should not consider and" do
+    #     Appstats::Query.comparator?("and").should == false
+    #   end
+    #   
+    #   it "should not consider or" do
+    #     Appstats::Query.comparator?("or").should == false
+    #   end
+    # 
+    #   it "should consider =" do
+    #     Appstats::Query.comparator?("=").should == true
+    #   end
+    # 
+    #   it "should consider !=" do
+    #     Appstats::Query.comparator?("!=").should == true
+    #   end
+    #   
+    #   it "should consider <>" do
+    #     Appstats::Query.comparator?("<>").should == true
+    #   end
+    # 
+    #   it "should consider >" do
+    #     Appstats::Query.comparator?(">").should == true
+    #   end
+    # 
+    #   it "should consider <" do
+    #     Appstats::Query.comparator?("<").should == true
+    #   end
+    # 
+    #   it "should consider >=" do
+    #     Appstats::Query.comparator?(">=").should == true
+    #   end
+    # 
+    #   it "should consider <=" do
+    #     Appstats::Query.comparator?("<=").should == true
+    #   end
+    #   
+    #   
+    # end
     
     
     

data/spec/result_spec.rb

@@ -17,11 +17,13 @@ module Appstats
         @result.query_as_sql.should == nil
         @result.count.should == nil
         @result.action.should == nil
-        @result.action.should == nil
+        @result.contexts.should == nil
+        @result.from_date.should == nil
+        @result.to_date.should == nil
       end
     
       it "should set on constructor" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f')
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
         result.name.should == 'a'
         result.result_type.should == 'b'
         result.query.should == 'c'
@@ -29,6 +31,9 @@ module Appstats
         result.count.should == 10
         result.action.should == 'e'
         result.host.should == 'f'
+        result.contexts.should == 'g'
+        result.from_date_to_s.should == '2010-01-02'
+        result.to_date_to_s.should == '2010-02-03'
       end
     
     end
@@ -36,21 +41,24 @@ module Appstats
     describe "#==" do
       
       it "should be equal on all attributes" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f')
-        same_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f')
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
+        same_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
         (result == same_result).should == true
       end
       
       it "should be not equal if diferent attributes" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f')
-        different_result = Appstats::Result.new(:name => 'xxx', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f')  
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
         
-        [:name,:result_type,:query,:query_as_sql,:count,:action,:host].each do |attr|
-          different_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f')  
-          different_result.send("#{attr}=","XXX")
+        [:name,:result_type,:query,:query_as_sql,:count,:action,:host,:contexts,:from_date,:to_date].each do |attr|
+          different_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))  
+
+          if [:from_date,:to_date].include?(attr)
+            different_result.send("#{attr}=",Time.parse("2011-01-02"))
+          else
+            different_result.send("#{attr}=","XXX")
+          end
           
           different_result.should_not == result
-          (different_result == result).should == false
         end
       end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: appstats
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 55
   prerelease: false
   segments: 
   - 0
-  - 9
-  - 2
-  version: 0.9.2
+  - 10
+  - 0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Andrew Forward
@@ -155,6 +155,7 @@ files:
 - db/migrations/20110217215309_create_appstats_context_keys.rb
 - db/migrations/20110217220154_create_appstats_context_values.rb
 - db/migrations/20110217220357_add_additional_contexts_indexes.rb
+- db/migrations/20110217234136_add_appstats_results_contexts.rb
 - db/schema.rb
 - lib/appstats.rb
 - lib/appstats/action.rb