appstats 0.6.1 → 0.7.0

data/Gemfile.lock

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

data/db/migrations/20110210225606_create_appstats_results.rb

@@ -0,0 +1,33 @@
+class CreateAppstatsResults < ActiveRecord::Migration
+  def self.up
+    create_table :appstats_results do |t|
+      t.string :name
+      t.string :result_type
+      t.text :query
+      t.text :query_as_sql
+      t.integer :count
+      t.string :action
+      t.string :host
+      t.integer :page
+      t.datetime :from_date
+      t.datetime :to_date
+      t.timestamps
+    end
+    
+    add_index :appstats_results, :name
+    add_index :appstats_results, :action
+    add_index :appstats_results, :host
+    add_index :appstats_results, :page
+    
+  end
+
+  def self.down
+    
+    remove_index :appstats_results, :name
+    remove_index :appstats_results, :action
+    remove_index :appstats_results, :host
+    remove_index :appstats_results, :page
+    
+    drop_table :appstats_results
+  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 => 20110210185911) do
+ActiveRecord::Schema.define(:version => 20110210225606) do
 
   create_table "appstats_actions", :force => true do |t|
     t.string   "name"
@@ -66,6 +66,26 @@ ActiveRecord::Schema.define(:version => 20110210185911) do
 
   add_index "appstats_log_collectors", ["host"], :name => "index_appstats_log_collectors_on_host"
 
+  create_table "appstats_results", :force => true do |t|
+    t.string   "name"
+    t.string   "result_type"
+    t.text     "query"
+    t.text     "query_as_sql"
+    t.integer  "count"
+    t.string   "action"
+    t.string   "host"
+    t.integer  "page"
+    t.datetime "from_date"
+    t.datetime "to_date"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  add_index "appstats_results", ["action"], :name => "index_appstats_results_on_action"
+  add_index "appstats_results", ["host"], :name => "index_appstats_results_on_host"
+  add_index "appstats_results", ["name"], :name => "index_appstats_results_on_name"
+  add_index "appstats_results", ["page"], :name => "index_appstats_results_on_page"
+
   create_table "appstats_test_objects", :force => true do |t|
     t.string   "name"
     t.datetime "created_at"

data/lib/appstats.rb

@@ -11,6 +11,7 @@ require "#{File.dirname(__FILE__)}/appstats/tasks"
 require "#{File.dirname(__FILE__)}/appstats/logger"
 require "#{File.dirname(__FILE__)}/appstats/log_collector"
 require "#{File.dirname(__FILE__)}/appstats/query"
+require "#{File.dirname(__FILE__)}/appstats/result"
 require "#{File.dirname(__FILE__)}/appstats/test_object"
 
 # required in the appstats.gemspec

data/lib/appstats/date_range.rb

@@ -10,16 +10,26 @@ module Appstats
       @format = data[:format] || :inclusive
     end
     
-    def from_to_s
+    def from_date
       return nil if @from.nil?
       mode = @format == :inclusive ? :start : :end
-      @from.to_time(mode).strftime('%Y-%m-%d %H:%M:%S')
+      @from.to_time(mode)
     end
-
-    def to_to_s
+    
+    def to_date
       return nil if @to.nil?
       mode = @format == :exclusive ? :start : :end
-      @to.to_time(mode).strftime('%Y-%m-%d %H:%M:%S')
+      @to.to_time(mode)
+    end
+    
+    def from_date_to_s
+      return nil if from_date.nil?
+      from_date.strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+    def to_date_to_s
+      return nil if to_date.nil?
+      to_date.strftime('%Y-%m-%d %H:%M:%S')
     end
     
     def to_sql
@@ -28,9 +38,9 @@ module Appstats
       if !@from.nil? && @to.nil?
         return case @format
           when :inclusive then 
-            "occurred_at >= '#{from_to_s}'"
+            "occurred_at >= '#{from_date_to_s}'"
           when :exclusive then 
-            "occurred_at > '#{from_to_s}'"
+            "occurred_at > '#{from_date_to_s}'"
           when :fixed_point then 
             answer = "("
             [:year,:month,:day,:hour,:min,:sec].each do |t|
@@ -43,14 +53,14 @@ module Appstats
         end
       elsif @from.nil? && !@to.nil?
         return case @format
-          when :inclusive then "occurred_at <= '#{to_to_s}'"
-          when :exclusive then "occurred_at < '#{to_to_s}'"
+          when :inclusive then "occurred_at <= '#{to_date_to_s}'"
+          when :exclusive then "occurred_at < '#{to_date_to_s}'"
           else "1=1"
         end
       else
         return case @format
-          when :inclusive then "(occurred_at >= '#{from_to_s}' and occurred_at <= '#{to_to_s}')"
-          when :exclusive then "(occurred_at > '#{from_to_s}' and occurred_at < '#{to_to_s}')"
+          when :inclusive then "(occurred_at >= '#{from_date_to_s}' and occurred_at <= '#{to_date_to_s}')"
+          when :exclusive then "(occurred_at > '#{from_date_to_s}' and occurred_at < '#{to_date_to_s}')"
           else "1=1"
         end
       end

data/lib/appstats/query.rb

@@ -3,40 +3,22 @@ module Appstats
   class Query
 
     @@default = "1=1"
-    attr_accessor :input
+    attr_accessor :query, :action, :host, :date_range, :query_to_sql
 
     def initialize(data = {})
-      @input = data[:input]
+      self.query=(data[:query])
     end
     
-    def run
-      ActiveRecord::Base.connection.select_one(to_sql)["count(*)"].to_i
+    def query=(value)
+      @query = value
+      parse_query
     end
     
-    def to_sql
-      sql = "select count(*) from appstats_entries"
-      return sql if @input.nil?
-      current_input = @input
-      
-      m = current_input.match(/^\s*(\#)\s*([^\s]*)\s*(.*)/)
-      return sql if m.nil?
-      if m[1] == "#"
-        sql += " where action = '#{normalize_action_name(m[2])}'"
-      end
-      current_input = m[3]
-      
-      m_on_server = current_input.match(/^(.*)?\s*on\s*server\s*(.*)$/)
-      date_range = m_on_server.nil? ? current_input : m_on_server[1]
-      if date_range.size > 0
-        range = DateRange.parse(date_range)
-        sql += " and #{range.to_sql}" unless range.to_sql == "1=1"
-      end
-      return sql if m_on_server.nil?
-      
-      host_name = m_on_server[2]
-      sql += " and exists (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = '#{host_name}')"
-
-      sql
+    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.count = ActiveRecord::Base.connection.select_one(@query_to_sql)["count(*)"].to_i
+      result.save
+      result
     end
     
     def self.host_filter_to_sql(raw_input)
@@ -65,6 +47,36 @@ module Appstats
         action = Appstats::Action.where("plural_name = ?",action_name).first
         action.nil? ? action_name : action.name 
       end
+      
+      def parse_query
+        @query_to_sql = "select count(*) from appstats_entries"
+        @action = nil
+        @host = nil
+        @date_range = DateRange.new
+        return @query_to_sql if @query.nil?
+        current_query = @query
+
+        m = current_query.match(/^\s*(\#)\s*([^\s]*)\s*(.*)/)
+        return @query_to_sql if m.nil?
+        if m[1] == "#"
+          @action = normalize_action_name(m[2])
+          @query_to_sql += " where action = '#{@action}'"
+        end
+        current_query = m[3]
+
+        m_on_server = current_query.match(/^(.*)?\s*on\s*server\s*(.*)$/)
+        date_range_text = m_on_server.nil? ? current_query : m_on_server[1]
+        if date_range_text.size > 0
+          @date_range = DateRange.parse(date_range_text)
+          @query_to_sql += " and #{@date_range.to_sql}" unless @date_range.to_sql == "1=1"
+        end
+        return @query_to_sql if m_on_server.nil?
+
+        @host = m_on_server[2]
+        @query_to_sql += " and exists (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = '#{@host}')"
+
+        @query_to_sql
+      end      
     
     
   end

data/lib/appstats/result.rb

@@ -0,0 +1,20 @@
+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
+
+    def ==(o)
+       o.class == self.class && o.send(:state) == state
+    end
+    alias_method :eql?, :==
+
+    private
+
+      def state
+        [name, result_type, query, query_as_sql, count, action, host, from_date, to_date]
+      end
+
+    
+  end
+end

data/lib/appstats/version.rb

@@ -1,3 +1,3 @@
 module Appstats
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/spec/date_range_spec.rb

@@ -197,41 +197,76 @@ module Appstats
     end
    
    
-    describe "#from_to_s" do
+    describe "#from_date_to_s" do
       it "should handle nil" do
-        DateRange.new.from_to_s.should == nil
+        DateRange.new.from_date_to_s.should == nil
       end
 
       it "should be based on time" do
-        DateRange.new(:from => EntryDate.new(:year => 2010)).from_to_s.should == "2010-01-01 00:00:00"
+        DateRange.new(:from => EntryDate.new(:year => 2010)).from_date_to_s.should == "2010-01-01 00:00:00"
       end
       
       it "should be based on end_of time as-is for exclusive" do
-        DateRange.new(:from => EntryDate.new(:year => 2009), :format => :exclusive).from_to_s.should == "2009-12-31 23:59:59"
-        DateRange.new(:from => EntryDate.new(:year => 2009, :month => 2), :format => :exclusive).from_to_s.should == "2009-02-28 23:59:59"
-        DateRange.new(:from => EntryDate.new(:year => 2009, :month => 2, :day => 15), :format => :exclusive).from_to_s.should == "2009-02-15 23:59:59"
+        DateRange.new(:from => EntryDate.new(:year => 2009), :format => :exclusive).from_date_to_s.should == "2009-12-31 23:59:59"
+        DateRange.new(:from => EntryDate.new(:year => 2009, :month => 2), :format => :exclusive).from_date_to_s.should == "2009-02-28 23:59:59"
+        DateRange.new(:from => EntryDate.new(:year => 2009, :month => 2, :day => 15), :format => :exclusive).from_date_to_s.should == "2009-02-15 23:59:59"
       end
       
     end
 
-    describe "#to_to_s" do
+    describe "#to_date_to_s" do
       it "should handle nil" do
-        DateRange.new.to_to_s.should == nil
+        DateRange.new.to_date_to_s.should == nil
       end
 
       it "should be based on time as-is for exclusive" do
-        DateRange.new(:to => EntryDate.new(:year => 2009), :format => :exclusive).to_to_s.should == "2009-01-01 00:00:00"
+        DateRange.new(:to => EntryDate.new(:year => 2009), :format => :exclusive).to_date_to_s.should == "2009-01-01 00:00:00"
       end
 
       it "should be based on end_of time as-is for inclusive" do
-        DateRange.new(:to => EntryDate.new(:year => 2009), :format => :inclusive).to_to_s.should == "2009-12-31 23:59:59"
-        DateRange.new(:to => EntryDate.new(:year => 2009, :month => 2), :format => :inclusive).to_to_s.should == "2009-02-28 23:59:59"
-        DateRange.new(:to => EntryDate.new(:year => 2009, :month => 2, :day => 15), :format => :inclusive).to_to_s.should == "2009-02-15 23:59:59"
+        DateRange.new(:to => EntryDate.new(:year => 2009), :format => :inclusive).to_date_to_s.should == "2009-12-31 23:59:59"
+        DateRange.new(:to => EntryDate.new(:year => 2009, :month => 2), :format => :inclusive).to_date_to_s.should == "2009-02-28 23:59:59"
+        DateRange.new(:to => EntryDate.new(:year => 2009, :month => 2, :day => 15), :format => :inclusive).to_date_to_s.should == "2009-02-15 23:59:59"
       end
 
 
     end
     
+    describe "#from_date" do
+      it "should handle nil" do
+        DateRange.new.from_date.should == nil
+      end
+
+      it "should be based on time" do
+        DateRange.new(:from => EntryDate.new(:year => 2010)).from_date.to_s.should == Time.parse("2010-01-01 00:00:00").to_s
+      end
+      
+      it "should be based on end_of time as-is for exclusive" do
+        DateRange.new(:from => EntryDate.new(:year => 2009), :format => :exclusive).from_date.to_s.should == Time.parse("2009-12-31 23:59:59").to_s
+        DateRange.new(:from => EntryDate.new(:year => 2009, :month => 2), :format => :exclusive).from_date.to_s.should == Time.parse("2009-02-28 23:59:59").to_s
+        DateRange.new(:from => EntryDate.new(:year => 2009, :month => 2, :day => 15), :format => :exclusive).from_date.to_s.should == Time.parse("2009-02-15 23:59:59").to_s
+      end
+      
+    end
+
+    describe "#to_date" do
+      it "should handle nil" do
+        DateRange.new.to_date.should == nil
+      end
+
+      it "should be based on time as-is for exclusive" do
+        DateRange.new(:to => EntryDate.new(:year => 2009), :format => :exclusive).to_date.to_s.should == Time.parse("2009-01-01 00:00:00").to_s
+      end
+
+      it "should be based on end_of time as-is for inclusive" do
+        DateRange.new(:to => EntryDate.new(:year => 2009), :format => :inclusive).to_date.to_s.should == Time.parse("2009-12-31 23:59:59").to_s
+        DateRange.new(:to => EntryDate.new(:year => 2009, :month => 2), :format => :inclusive).to_date.to_s.should == Time.parse("2009-02-28 23:59:59").to_s
+        DateRange.new(:to => EntryDate.new(:year => 2009, :month => 2, :day => 15), :format => :inclusive).to_date.to_s.should == Time.parse("2009-02-15 23:59:59").to_s
+      end
+
+
+    end    
+    
     describe "#to_sql" do
     
       before(:each) do

data/spec/entry_spec.rb

@@ -188,18 +188,18 @@ module Appstats
       end
       
       it "should understand an entry without contexts" do
-        entry = Entry.load_from_logger_entry("0.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+        entry = Entry.load_from_logger_entry("0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        entry.raw_entry.should == "0.7.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.load_from_logger_entry("0.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+        entry = Entry.load_from_logger_entry("0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        entry.raw_entry.should == "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
+        Appstats::Logger.raw_read.should == ["0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
+        Appstats::Logger.raw_read.should == ["0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+         actual = Appstats::Logger.entry_to_hash("0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.7.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.6.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
+         actual = Appstats::Logger.entry_to_hash("0.7.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.6.1 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
+         actual = Appstats::Logger.entry_to_hash("0.7.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.6.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
+         actual = Appstats::Logger.entry_to_hash("0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        expected = "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
+        expected = "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
+        expected = "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        expected = "0.7.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.6.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
+        expected = "0.7.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.6.1 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
+        expected = "0.7.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.6.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
+        expected = "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
+        expected = "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
+        expected = "0.7.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.6.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
+        expected = "0.7.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.6.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
+        expected = "0.7.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/query_spec.rb

@@ -10,15 +10,35 @@ module Appstats
       end
       
       it "should set input to nil" do
-        @query.input.should == nil
+        @query.query.should == nil
       end
       
-      it "should allow input on constructor" do
-        query = Appstats::Query.new(:input => "# logins")
-        query.input.should == "# logins"
+      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 server 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 server xyz.localnet")
+        query.action.should == "myblahs"
+        query.host.should == "xyz.localnet"
+        query.date_range.should == DateRange.parse("today")
+      end
+    
+    end
     
     describe "#run" do
       
@@ -27,22 +47,24 @@ module Appstats
       end
       
       it "should return 0 if no results" do
-        query = Appstats::Query.new(:input => "# blahs")
-        query.run.should == 0
+        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(:input => "# myblahs")
-        query.run.should == 1
+        query = Appstats::Query.new(:query => "# myblahs")
+        query.run.count.should == 1
         Appstats::Entry.create(:action => "myblahs")
-        query.run.should == 2
+        query.run.count.should == 2
       end
-      
+
     end
     
     
-    describe "#to_sql" do
+    describe "#query_to_sql" do
       
       before(:all) do
         Appstats::Action.delete_all
@@ -51,22 +73,22 @@ module Appstats
       
       it "should return understand nil" do
         expected_sql = "select count(*) from appstats_entries"
-        Appstats::Query.new(:input => nil).to_sql.should == expected_sql
-        Appstats::Query.new(:input => "").to_sql.should == expected_sql
-        Appstats::Query.new.to_sql.should == expected_sql
+        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(:input => "# logins").to_sql.should == expected_sql
-          Appstats::Query.new(:input => "# login").to_sql.should == expected_sql
+          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(:input => "# garblygook").to_sql.should == expected_sql
+          Appstats::Query.new(:query => "# garblygook").query_to_sql.should == expected_sql
         end
         
       end
@@ -74,7 +96,7 @@ module Appstats
       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(:input => "# logins since 2010-01-15").to_sql.should == expected_sql
+          Appstats::Query.new(:query => "# logins since 2010-01-15").query_to_sql.should == expected_sql
         end
       end
 
@@ -82,7 +104,7 @@ module Appstats
         
         it "should on server_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(:input => "# logins on server my.localnet").to_sql.should == expected_sql
+          Appstats::Query.new(:query => "# logins on server my.localnet").query_to_sql.should == expected_sql
         end
 
       end
@@ -90,7 +112,7 @@ module Appstats
       describe "date range and server_name" do
         it "should understand  dates and 'on server'" 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(:input => "# logins between 2010-01-15 and 2010-01-31 on server your.localnet").to_sql.should == expected_sql
+          Appstats::Query.new(:query => "# logins between 2010-01-15 and 2010-01-31 on server your.localnet").query_to_sql.should == expected_sql
         end
       end
     end

data/spec/result_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Appstats
+  describe Result do
+
+    before(:each) do
+      @result = Appstats::Result.new
+    end
+
+    describe "#initialize" do
+    
+      it "should set attributes to nil" do
+        @result.name.should == nil
+        @result.result_type.should == nil
+        @result.query.should == nil
+        @result.query_as_sql.should == nil
+        @result.count.should == nil
+        @result.action.should == nil
+        @result.action.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.name.should == 'a'
+        result.result_type.should == 'b'
+        result.query.should == 'c'
+        result.query_as_sql.should == 'd'
+        result.count.should == 10
+        result.action.should == 'e'
+        result.host.should == 'f'
+      end
+    
+    end
+    
+    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 == 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')  
+        
+        [: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")
+          
+          different_result.should_not == result
+          (different_result == result).should == false
+        end
+      end
+
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: appstats
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 3
   prerelease: false
   segments: 
   - 0
-  - 6
-  - 1
-  version: 0.6.1
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Andrew Forward
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-10 00:00:00 -05:00
+date: 2011-02-11 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -150,6 +150,7 @@ files:
 - db/migrations/20110207213514_create_appstats_actions.rb
 - db/migrations/20110208210921_align_entry_time_names.rb
 - db/migrations/20110210185911_create_appstats_test_object.rb
+- db/migrations/20110210225606_create_appstats_results.rb
 - db/schema.rb
 - lib/appstats.rb
 - lib/appstats/action.rb
@@ -162,6 +163,7 @@ files:
 - lib/appstats/log_collector.rb
 - lib/appstats/logger.rb
 - lib/appstats/query.rb
+- lib/appstats/result.rb
 - lib/appstats/tasks.rb
 - lib/appstats/test_object.rb
 - lib/appstats/version.rb
@@ -194,6 +196,7 @@ files:
 - spec/log_collector_spec.rb
 - spec/logger_spec.rb
 - spec/query_spec.rb
+- spec/result_spec.rb
 - spec/spec_helper.rb
 - spec/test_object_spec.rb
 has_rdoc: true
@@ -241,5 +244,6 @@ test_files:
 - spec/log_collector_spec.rb
 - spec/logger_spec.rb
 - spec/query_spec.rb
+- spec/result_spec.rb
 - spec/spec_helper.rb
 - spec/test_object_spec.rb