appstats 0.1.0 → 0.3.1

data/lib/appstats/query.rb

@@ -0,0 +1,71 @@
+
+module Appstats
+  class Query
+
+    @@default = "1=1"
+    attr_accessor :input
+
+    def initialize(data = {})
+      @input = data[:input]
+    end
+    
+    def run
+      ActiveRecord::Base.connection.select_one(to_sql)["count(*)"].to_i
+    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
+    end
+    
+    def self.host_filter_to_sql(raw_input)
+      return @@default if raw_input.nil?
+      input = raw_input.strip
+      m = raw_input.strip.match(/(^[^\s']*$)/)
+      return @@default if m.nil?
+      host = m[1]
+      return @@default if host == '' or host.nil?
+      "EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = id and host = '#{host}' )"
+    end
+
+    def self.context_filter_to_sql(raw_input)
+      return @@default if raw_input.nil?
+      m = raw_input.match(/([^']+)=([^']+)/)
+      return @@default if m.nil?
+      key = m[1].strip
+      value = m[2].strip
+      return @@default if key == '' or key.nil?
+      "EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and context_key='#{key}' and context_value='#{value}' )"
+    end
+    
+    private
+    
+      def normalize_action_name(action_name)
+        action = Appstats::Action.where("plural_name = ?",action_name).first
+        action.nil? ? action_name : action.name 
+      end
+    
+    
+  end
+end

data/lib/appstats/version.rb

@@ -1,3 +1,3 @@
 module Appstats
-  VERSION = "0.1.0"
+  VERSION = "0.3.1"
 end

data/lib/daemons/appstats_log_collector.rb

@@ -32,11 +32,13 @@ require File.join(File.dirname(__FILE__),"..","appstats")
 
 Appstats.log(:info,"Started Appstats Log Collector")
 while($running) do
+  ActiveRecord::Base.connection.reconnect!
   appstats_config["remote_servers"].each do |remote_server|
     Appstats::LogCollector.find_remote_files(remote_server,remote_server[:path],remote_server[:template])
   end
   Appstats::LogCollector.download_remote_files(appstats_config["remote_servers"])
   Appstats::LogCollector.process_local_files
+  ActiveRecord::Base.connection.disconnect!
   a_day_in_seconds = 60*60*24
   sleep a_day_in_seconds
 end

data/spec/action_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Appstats
+  describe Action do
+
+    before(:each) do
+      Appstats::Entry.delete_all
+      Appstats::Action.delete_all
+      @action = Appstats::Action.new
+    end
+    
+    describe "#initialize" do
+
+      it "should set name to nil" do
+        @action.name.should == nil
+      end
+
+      it "should set plural_name to nil" do
+        @action.plural_name.should == nil
+      end
+
+      it "should set status to nil" do
+        @action.status.should == nil
+      end
+      
+      it "should set on constructor" do
+        action = Appstats::Action.new(:name => 'a', :plural_name => 'b', :status => 'c')
+        action.name.should == 'a'
+        action.plural_name.should == 'b'
+        action.status.should == 'c'
+      end
+    
+    end
+    
+    describe "#update_actions" do
+      
+      it "should do nothing if no events" do
+        Appstats::Action.update_actions.should == 0
+        Appstats::Action.count.should == 0
+      end
+      
+      it "should add entry action names" do
+        Appstats::Entry.create(:action => 'a')
+        Appstats::Action.update_actions.should == 1
+        Appstats::Action.count.should == 1
+        
+        action = Appstats::Action.last
+        action.name = 'a'
+        action.plural_name = 'as'
+        action.status = 'derived'
+      end
+      
+    end
+    
+
+  end
+end

data/spec/date_range_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+module Appstats
+  describe DateRange do
+
+
+    before(:each) do
+      @time = Time.parse('2010-01-15 10:20:30')
+      Time.stub!(:now).and_return(@time)
+    end
+
+    describe "#initialize" do
+      
+      it "should set format to true if not set" do
+        DateRange.new.format.should == :inclusive
+        DateRange.new(:format => :exclusive).format.should == :exclusive
+      end
+      
+      it "should understand from date and to date" do
+        date_range = DateRange.new(:from => EntryDate.new(:year => 2009), :to => EntryDate.new(:year => 2010), :format => :inclusive)
+        date_range.from.year.should == 2009
+        date_range.to.year.should == 2010
+        date_range.format.should == :inclusive
+      end
+      
+      it "should understand equality" do
+        date_range = DateRange.new(:from => EntryDate.new(:year => 2009), :to => EntryDate.new(:year => 2010))
+        same_date_range = DateRange.new(:from => EntryDate.new(:year => 2009), :to => EntryDate.new(:year => 2010))
+        another_date_range = DateRange.new(:from => EntryDate.new(:year => 2007), :to => EntryDate.new(:year => 2010))
+        
+        date_range.should == date_range
+        date_range.should == same_date_range
+        date_range.should_not == another_date_range
+      end
+    end
+    
+    describe "#parse" do
+      
+      it "should understand nil" do
+        DateRange.parse(nil).should == DateRange.new
+        DateRange.parse("").should == DateRange.new
+      end
+      
+      it "should understand between" do
+        range = DateRange.parse("  between Mar, 2010 and Jun, 2011  ")
+        range.should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 3), :to => EntryDate.new(:year => 2011, :month => 6), :format => :inclusive )
+      end
+
+      it "should understand in" do
+        range = DateRange.parse("  in Mar, 2010  ")
+        range.should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 3), :to => nil, :format => :fixed_point )
+      end
+
+      it "shouldunderstand since" do
+        DateRange.parse("  since Mar, 2010  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 3), :to => nil, :format => :inclusive )
+        DateRange.parse("  since 2010-04-15  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 4, :day => 15), :to => nil, :format => :inclusive )
+      end
+
+      it "should understand on" do
+        range = DateRange.parse("  on Mar, 2010  ")
+        range.should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 3), :to => nil, :format => :fixed_point )
+      end
+      
+      describe "before and after dates" do
+
+        it "should understand before" do
+          range = DateRange.parse("  before Mar, 2010  ")
+          range.should == DateRange.new(:from => nil, :to => EntryDate.new(:year => 2010, :month => 3), :format => :exclusive )
+        end
+
+        it "should understand after" do
+          range = DateRange.parse("  after Mar, 2010  ")
+          range.should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 3), :to => nil, :format => :exclusive )
+        end
+        
+      end
+      
+      
+      it "should understand YTD, today, yesterday" do
+        DateRange.parse("  YTD  ").should == DateRange.new(:from => EntryDate.new(:year => 2010), :to => nil, :format => :fixed_point )
+        DateRange.parse("  today  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 15), :to => nil, :format => :fixed_point )
+        DateRange.parse("  yesterday  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 14), :to => nil, :format => :fixed_point )
+      end
+
+      describe "this (year|month|week|day)" do
+
+        it "should understand this year" do
+          DateRange.parse("  this year  ").should == DateRange.new(:from => EntryDate.new(:year => 2010), :to => nil, :format => :fixed_point )
+        end
+
+        it "should understand this month" do
+          DateRange.parse("  this month  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1), :to => nil, :format => :fixed_point )
+        end
+
+        it "should understand this week" do
+          DateRange.parse("  this week  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 11), :to => nil, :format => :inclusive )
+        end
+
+        it "should understand this day" do
+          DateRange.parse("  this day  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 15), :to => nil, :format => :fixed_point )
+        end
+                
+      end
+
+      describe "(last|previous) (year|month|week|day)" do
+
+        it "should understand last year" do
+          DateRange.parse("  last year  ").should == DateRange.new(:from => EntryDate.new(:year => 2009), :to => nil, :format => :fixed_point )
+        end
+
+        it "should understand last month" do
+          DateRange.parse("  last month  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12), :to => nil, :format => :fixed_point )
+        end
+
+        it "should understand last week" do
+          DateRange.parse("  last week  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 4), :to => EntryDate.new(:year => 2010, :month => 1, :day => 10), :format => :inclusive )
+        end
+
+        it "should understand last day" do
+          DateRange.parse("  last day  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 14), :to => nil, :format => :fixed_point )
+        end
+        
+        it "should understand previous year" do
+          DateRange.parse("  previous year  ").should == DateRange.new(:from => EntryDate.new(:year => 2009), :to => nil, :format => :fixed_point )
+        end
+
+        it "should understand previous month" do
+          DateRange.parse("  previous month  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12), :to => nil, :format => :fixed_point )
+        end
+
+        it "should understand previous week" do
+          DateRange.parse("  previous week  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 4), :to => EntryDate.new(:year => 2010, :month => 1, :day => 10), :format => :inclusive )
+        end
+
+        it "should understand previous day" do
+          DateRange.parse("  previous day  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 14), :to => nil, :format => :fixed_point )
+        end
+                
+      end
+
+      describe "last X (year|month|week|day)s" do
+        
+        it "should understand last X years" do
+          DateRange.parse("  last 1 year  ").should == DateRange.new(:from => EntryDate.new(:year => 2010), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 2 years  ").should == DateRange.new(:from => EntryDate.new(:year => 2009), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 3 years  ").should == DateRange.new(:from => EntryDate.new(:year => 2008), :to => nil, :format => :inclusive )
+        end
+
+        it "should understand last X months" do
+          DateRange.parse("  last 1 month  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 2 months  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 3 months  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 11), :to => nil, :format => :inclusive )
+        end
+
+        it "should understand last X weeks" do
+          DateRange.parse("  last 1 week  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 11), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 2 weeks  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 4), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 3 weeks  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12, :day => 28), :to => nil, :format => :inclusive )
+        end
+
+        it "should understand last X days" do
+          DateRange.parse("  last 1 day  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 15), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 2 days  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 14), :to => nil, :format => :inclusive )
+          DateRange.parse("  last 3 days  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 13), :to => nil, :format => :inclusive )
+        end
+
+      end
+
+      describe "previous X (year|month|week|day)s" do
+      
+        it "should understand previous X years" do
+          DateRange.parse("  previous 1 year  ").should == DateRange.new(:from => EntryDate.new(:year => 2009), :to => EntryDate.new(:year => 2009), :format => :inclusive )
+          DateRange.parse("  previous 2 years  ").should == DateRange.new(:from => EntryDate.new(:year => 2008), :to => EntryDate.new(:year => 2009), :format => :inclusive )
+          DateRange.parse("  previous 3 years  ").should == DateRange.new(:from => EntryDate.new(:year => 2007), :to => EntryDate.new(:year => 2009), :format => :inclusive )
+        end
+
+        it "should understand previous Y months" do
+          DateRange.parse("  previous 1 month  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12), :to => EntryDate.new(:year => 2009, :month => 12), :format => :inclusive )
+          DateRange.parse("  previous 2 months  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 11), :to => EntryDate.new(:year => 2009, :month => 12), :format => :inclusive )
+          DateRange.parse("  previous 3 months  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 10), :to => EntryDate.new(:year => 2009, :month => 12), :format => :inclusive )
+        end
+
+        it "should understand previous 2 weeks" do
+          DateRange.parse("  previous 1 week  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 4), :to => EntryDate.new(:year => 2010, :month => 1, :day => 10), :format => :inclusive )
+          DateRange.parse("  previous 2 weeks  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12, :day => 28), :to => EntryDate.new(:year => 2010, :month => 1, :day => 10), :format => :inclusive )
+          DateRange.parse("  previous 3 weeks  ").should == DateRange.new(:from => EntryDate.new(:year => 2009, :month => 12, :day => 21), :to => EntryDate.new(:year => 2010, :month => 1, :day => 10), :format => :inclusive )
+        end
+
+        it "should understand previous 2 days" do
+          DateRange.parse("  previous 1 day  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 14), :to => EntryDate.new(:year => 2010, :month => 1, :day => 14), :format => :inclusive )
+          DateRange.parse("  previous 2 days  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 13), :to => EntryDate.new(:year => 2010, :month => 1, :day => 14), :format => :inclusive )
+          DateRange.parse("  previous 3 days  ").should == DateRange.new(:from => EntryDate.new(:year => 2010, :month => 1, :day => 12), :to => EntryDate.new(:year => 2010, :month => 1, :day => 14), :format => :inclusive )
+        end      
+
+      end
+      
+    end
+   
+   
+    describe "#from_to_s" do
+      it "should handle nil" do
+        DateRange.new.from_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"
+      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"
+      end
+      
+    end
+
+    describe "#to_to_s" do
+      it "should handle nil" do
+        DateRange.new.to_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"
+      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"
+      end
+
+
+    end
+    
+    describe "#to_sql" do
+    
+      before(:each) do
+        @date1 = EntryDate.new(:year => 2010, :month => 10)
+        @date2 = EntryDate.new(:year => 2011, :month => 3)
+      end
+      
+      it "should support an empty date range" do
+        DateRange.new.to_sql.should == "1=1"
+      end
+    
+      it "should support from, inclusive" do
+        DateRange.new(:from => @date1, :format => :inclusive).to_sql.should == "occurred_at >= '2010-10-01 00:00:00'"
+      end
+    
+      it "should support from, exclusive" do
+        DateRange.new(:from => @date1, :format => :exclusive).to_sql.should == "occurred_at > '2010-10-31 23:59:59'"
+      end
+    
+      it "should support from, fixed_point" do
+        DateRange.new(:from => @date1, :format => :fixed_point).to_sql.should == "(year=2010 and month=10)"
+      end
+    
+      it "should support to, inclusive" do
+        DateRange.new(:to => @date1, :format => :inclusive).to_sql.should == "occurred_at <= '2010-10-31 23:59:59'"
+      end
+    
+      it "should support to, exclusive" do
+        DateRange.new(:to => @date1, :format => :exclusive).to_sql.should == "occurred_at < '2010-10-01 00:00:00'"
+      end
+
+      it "should not support to, fixed_point" do
+        DateRange.new(:to => @date1, :format => :fixed_point).to_sql.should == "1=1"
+      end
+
+      it "should support to and from, inclusive" do
+        DateRange.new(:from => @date1, :to => @date2, :format => :inclusive).to_sql.should == "(occurred_at >= '2010-10-01 00:00:00' and occurred_at <= '2011-03-31 23:59:59')"
+      end
+    
+      it "should support to and from, exclusive" do
+        DateRange.new(:from => @date1, :to => @date2, :format => :exclusive).to_sql.should == "(occurred_at > '2010-10-31 23:59:59' and occurred_at < '2011-03-01 00:00:00')"
+      end
+
+      it "should not support to and from fixed_point" do
+        DateRange.new(:to => @date1, :format => :fixed_point).to_sql.should == "1=1"
+      end
+
+    end
+    
+    
+  end
+end

data/spec/entry_date_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+module Appstats
+  describe EntryDate do
+
+    before(:each) do
+      @time = Time.parse('2010-01-15 10:20:30') # Friday
+      Time.stub!(:now).and_return(@time)
+    end
+
+    describe "#initialize" do
+      
+      it "should understand year, month, day, hour, min, sec" do
+        date = EntryDate.new(:year => 2010, :month => 1, :day => 2, :hour => 3, :min => 4, :sec => 5)
+        date.year.should == 2010
+        date.month.should == 1
+        date.day.should == 2
+        date.hour.should == 3
+        date.min.should == 4
+        date.sec.should == 5
+      end
+      
+      it "should understand equality" do
+        date = EntryDate.new(:year => 2010, :month => 1, :day => 2, :hour => 3, :min => 4, :sec => 5)
+        same_date = EntryDate.new(:year => 2010, :month => 1, :day => 2, :hour => 3, :min => 4, :sec => 5)
+        another_date = EntryDate.new(:year => 2011, :month => 1, :day => 2, :hour => 3, :min => 4, :sec => 5)
+        
+        date.should == date
+        date.should == same_date
+        date.should_not == another_date
+      end
+      
+      
+    end
+    
+    describe "#to_time" do
+
+      it "should handle full dates" do
+        EntryDate.new(:year => 2010, :month => 1, :day => 2, :hour => 3, :min => 4, :sec => 5).to_time.should == Time.parse("2010-01-02 03:04:05")
+      end
+
+      it "should handle partial dates" do
+        EntryDate.new(:year => 2010, :month => 2).to_time.should == Time.parse("2010-02-01 00:00:00")
+      end
+
+      it "should handle now" do
+        EntryDate.new.to_time.should == Time.now
+      end
+      
+      it "should handle end_of" do
+        EntryDate.new(:year => 2009).to_time(:end).to_s.should == Time.parse("2009-12-31 23:59:59").to_s
+        EntryDate.new(:year => 2009, :month => 2).to_time(:end).to_s.should == Time.parse("2009-02-28 23:59:59").to_s
+        EntryDate.new(:year => 2009, :month => 2, :day => 15).to_time(:end).to_s.should == Time.parse("2009-02-15 23:59:59").to_s
+      end
+
+      
+    end
+    
+
+    describe "#to_s" do
+      it "should handle full dates" do
+        EntryDate.new(:year => 2010, :month => 1, :day => 2, :hour => 3, :min => 4, :sec => 5).to_s.should == "2010-01-02 03:04:05"
+      end
+
+      it "should handle partial dates" do
+        EntryDate.new(:year => 2010, :month => 1).to_s.should == "2010-01"
+      end
+    end
+    
+    describe "#end_of_week" do
+      it "should return the same 'level' data points" do
+        now = EntryDate.new(:year => 2010, :month => 1, :day => 5, :hour => 10) # tuesday
+        expected = EntryDate.new(:year => 2010, :month => 1, :day => 10, :hour => 10)
+        now.end_of_week.should == expected
+      end
+    end
+
+    describe "#parse" do
+
+      it "should deal with nil" do
+         EntryDate.parse(nil).should == EntryDate.new
+         EntryDate.parse("").should == EntryDate.new
+      end
+      
+      it "should undestand years" do
+        EntryDate.parse("2010").should == EntryDate.new(:year => 2010)
+        EntryDate.parse("2011").should == EntryDate.new(:year => 2011)
+      end
+      
+      it "should understand month, year" do
+        EntryDate.parse("February, 2010").should == EntryDate.new(:year => 2010, :month => 2)
+        EntryDate.parse("Mar, 2011").should == EntryDate.new(:year => 2011, :month => 3)
+      end
+      
+      it "should understand YYYY-mm-dd" do
+        EntryDate.parse("2010-04-25").should == EntryDate.new(:year => 2010, :month => 4, :day => 25)
+        EntryDate.parse("2011-05-15").should == EntryDate.new(:year => 2011, :month => 5, :day => 15)
+      end
+
+      it "should understand YYYY-mm-dd HH:MM:SS" do
+        EntryDate.parse("2010-04-25 10:11:12").should == EntryDate.new(:year => 2010, :month => 4, :day => 25, :hour => 10, :min => 11, :sec => 12)
+      end
+
+      it "should understand YTD" do
+        EntryDate.parse("YTD").should == EntryDate.new(:year => 2010)
+        EntryDate.parse("ytd").should == EntryDate.new(:year => 2010)
+      end
+
+      it "should understand yesterday" do
+        EntryDate.parse("yesterday").should == EntryDate.new(:year => 2010, :month => 1, :day => 14)
+      end
+
+      it "should understand today" do
+        EntryDate.parse("today").should == EntryDate.new(:year => 2010, :month => 1, :day => 15)
+      end
+      
+      it "should understand last year" do
+        EntryDate.parse("last year").should == EntryDate.new(:year => 2009)
+      end
+
+      it "should understand last month" do
+        EntryDate.parse("last month").should == EntryDate.new(:year => 2009, :month => 12)
+      end
+
+      it "should understand last week" do
+        EntryDate.parse("last week").should == EntryDate.new(:year => 2010, :month => 1, :day => 4)
+      end
+
+      it "should understand last day" do
+        EntryDate.parse("last day").should == EntryDate.new(:year => 2010, :month => 1, :day => 14)
+      end
+
+      it "should understand previous year" do
+        EntryDate.parse("previous year").should == EntryDate.new(:year => 2009)
+      end
+
+      it "should understand previous month" do
+        EntryDate.parse("previous month").should == EntryDate.new(:year => 2009, :month => 12)
+      end
+
+      it "should understand previous week" do
+        EntryDate.parse("previous week").should == EntryDate.new(:year => 2010, :month => 1, :day => 4)
+      end
+
+      it "should understand previous day" do
+        EntryDate.parse("previous day").should == EntryDate.new(:year => 2010, :month => 1, :day => 14)
+      end
+
+      it "should understand this year" do
+        EntryDate.parse("this year").should == EntryDate.new(:year => 2010)
+      end
+
+      it "should understand this month" do
+        EntryDate.parse("this month").should == EntryDate.new(:year => 2010, :month => 1)
+      end
+
+      it "should understand this week" do
+        EntryDate.parse("this week").should == EntryDate.new(:year => 2010, :month => 1, :day => 11)
+      end
+
+      it "should understand this day" do
+        EntryDate.parse("this day").should == EntryDate.new(:year => 2010, :month => 1, :day => 15)
+      end
+
+      it "should understand last X years" do
+        EntryDate.parse("last 1 year").should == EntryDate.new(:year => 2010)
+        EntryDate.parse("last 2 years").should == EntryDate.new(:year => 2009)
+        EntryDate.parse("last 3 years").should == EntryDate.new(:year => 2008)
+      end
+
+      it "should understand last X months" do
+        EntryDate.parse("last 1 month").should == EntryDate.new(:year => 2010, :month => 1)
+        EntryDate.parse("last 2 months").should == EntryDate.new(:year => 2009, :month => 12)
+        EntryDate.parse("last 3 months").should == EntryDate.new(:year => 2009, :month => 11)
+      end
+
+      it "should understand last X weeks" do
+        EntryDate.parse("last 1 week").should == EntryDate.new(:year => 2010, :month => 1, :day => 11)
+        EntryDate.parse("last 2 weeks").should == EntryDate.new(:year => 2010, :month => 1, :day => 4)
+        EntryDate.parse("last 3 weeks").should == EntryDate.new(:year => 2009, :month => 12, :day => 28)
+      end
+
+      it "should understand last X days" do
+        EntryDate.parse("last 1 day").should == EntryDate.new(:year => 2010, :month => 1, :day => 15)
+        EntryDate.parse("last 2 days").should == EntryDate.new(:year => 2010, :month => 1, :day => 14)
+        EntryDate.parse("last 3 days").should == EntryDate.new(:year => 2010, :month => 1, :day => 13)
+      end
+
+      it "should understand previous X years" do
+        EntryDate.parse("previous 1 year").should == EntryDate.new(:year => 2009)
+        EntryDate.parse("previous 2 years").should == EntryDate.new(:year => 2008)
+        EntryDate.parse("previous 3 years").should == EntryDate.new(:year => 2007)
+      end
+
+      it "should understand previous X months" do
+        EntryDate.parse("previous 1 month").should == EntryDate.new(:year => 2009, :month => 12)
+        EntryDate.parse("previous 2 months").should == EntryDate.new(:year => 2009, :month => 11)
+        EntryDate.parse("previous 3 months").should == EntryDate.new(:year => 2009, :month => 10)
+      end
+
+      it "should understand previous X weeks" do
+        EntryDate.parse("previous 1 week").should == EntryDate.new(:year => 2010, :month => 1, :day => 4)
+        EntryDate.parse("previous 2 weeks").should == EntryDate.new(:year => 2009, :month => 12, :day => 28)
+        EntryDate.parse("previous 3 weeks").should == EntryDate.new(:year => 2009, :month => 12, :day => 21)
+      end
+
+      it "should understand previous X days" do
+        EntryDate.parse("previous 1 day").should == EntryDate.new(:year => 2010, :month => 1, :day => 14)
+        EntryDate.parse("previous 2 days").should == EntryDate.new(:year => 2010, :month => 1, :day => 13)
+        EntryDate.parse("previous 3 days").should == EntryDate.new(:year => 2010, :month => 1, :day => 12)
+      end
+
+      it "should accept garbage input" do
+        EntryDate.parse("1234asdf1234 1234fds123").should == EntryDate.new
+      end
+      
+      
+    end
+
+  end
+end