indy 0.4.0.pre → 0.5.0

data/lib/indy/log_definition.rb

@@ -19,7 +19,7 @@ class Indy
         @entry_regexp = Regexp.new(params_hash[:entry_regexp])
       end
       @entry_fields = params_hash[:entry_fields]
-      @time_format = params_hash[:time_format]
+      @time_format = params_hash[:time_format] || Indy::LogFormats::DEFAULT_DATE_TIME # '%Y-%m-%d %H:%M:%S'
       define_struct
     end
 
@@ -27,6 +27,7 @@ class Indy
       params_hash = {}
       params_hash[:entry_regexp] = Indy::LogFormats::DEFAULT_ENTRY_REGEXP
       params_hash[:entry_fields] = Indy::LogFormats::DEFAULT_ENTRY_FIELDS
+      params_hash[:time_format] = Indy::LogFormats::DEFAULT_DATE_TIME
       params_hash
     end
 
@@ -54,7 +55,7 @@ class Indy
     end
 
     #
-    # Define Struct::Entry with the fields from @log_definition. Ignore warnings.
+    # Define Struct::Entry. Ignore warnings.
     #
     def define_struct
       fields = (@entry_fields + [:raw_entry]).sort_by{|key|key.to_s}
@@ -85,13 +86,14 @@ class Indy
       match_data = /#{@entry_regexp}/.match(raw_entry)
       return nil unless match_data
       values = match_data.captures
+      values.shift if @multiline
       entry_hash([raw_entry, values].flatten)
     end
 
     #
     # Return a hash of field=>value pairs for the array of captured values from a log entry
     #
-    # @param [Array] capture_array The array of values captured by the @log_definition.entry_regexp
+    # @param [Array] capture_array The array of values captured by the LogDefinition regexp
     #
     def parse_entry_captures( capture_array )
       entire_entry = capture_array.shift
@@ -106,7 +108,7 @@ class Indy
       if values.length == @entry_fields.length + 1 # values also includes raw_entry
         @field_list_is_valid = true
       else
-        raise ArgumentError, "Field mismatch between log pattern and log data. The data is: '#{values.join(':::')}'"
+        raise Indy::Source::FieldMismatchException, "Number of expected fields does not match those captured via the regexp pattern.\nThe expected fields are:\n=> #{@entry_fields.join("\n=> ")}\nThe log entry and captured fields are:\n=> #{values.join("\n=> ")}"
       end
     end
 

data/lib/indy/log_formats.rb

@@ -17,17 +17,18 @@ class Indy
     NUMBER_REGEXP = '(\d+)'
     DQUOTE_DELIM_REGEXP = '"([^"]+)"'
 
-    DEFAULT_DATE_TIME = '\d{4}.\d{2}.\d{2}\s+\d{2}.\d{2}.\d{2}' #"%Y-%m-%d %H:%M:%S"
+    DEFAULT_DATE_TIME = '\d{4}.\d{2}.\d{2}\s+\d{2}.\d{2}.\d{2}'  # "%Y-%m-%d %H:%M:%S"
     DEFAULT_SEVERITY = [:trace,:debug,:info,:warn,:error,:fatal]
     DEFAULT_SEVERITY_PATTERN = "(?:#{DEFAULT_SEVERITY.map{|s| s.to_s.upcase}.join("|")})"
     DEFAULT_APPLICATION = '\w+'
     DEFAULT_MESSAGE = '.+'
 
-    DEFAULT_ENTRY_FIELDS = [:time,:severity,:application,:message]
+    DEFAULT_ENTRY_FIELDS = [:time, :severity, :application, :message]
     DEFAULT_ENTRY_REGEXP = /^(#{DEFAULT_DATE_TIME})\s+(#{DEFAULT_SEVERITY_PATTERN})\s+(#{DEFAULT_APPLICATION})\s+-\s+(#{DEFAULT_MESSAGE})$/
 
     COMMON_FIELDS = [:host, :ident, :authuser, :time, :request, :status, :bytes]
     COMMON_REGEXP = /^#{IPV4_REGEXP} #{SPACE_DELIM_REGEXP} #{SPACE_DELIM_REGEXP} #{BRACKET_DELIM_REGEXP} #{DQUOTE_DELIM_REGEXP} #{HTTP_STATUS_REGEXP} #{NUMBER_REGEXP}$/
+    COMMON_TIME_FORMAT = "%d\/%b\/%Y:%H:%M:%S %z"
 
     COMBINED_FIELDS = COMMON_FIELDS + [:referrer, :user_agent]
     COMBINED_REGEXP = /^#{IPV4_REGEXP} #{SPACE_DELIM_REGEXP} #{SPACE_DELIM_REGEXP} #{BRACKET_DELIM_REGEXP} #{DQUOTE_DELIM_REGEXP} #{HTTP_STATUS_REGEXP} #{NUMBER_REGEXP} #{DQUOTE_DELIM_REGEXP} #{DQUOTE_DELIM_REGEXP}$/
@@ -42,7 +43,7 @@ class Indy
   #
   # Indy default log format 
   # e.g.:
-  # INFO 2000-09-07 MyApp - Entering APPLICATION.
+  # 2000-09-07 INFO MyApp - Entering APPLICATION.
   #
   DEFAULT_LOG_FORMAT = {:entry_regexp => LogFormats::DEFAULT_ENTRY_REGEXP, :entry_fields => LogFormats::DEFAULT_ENTRY_FIELDS}
 
@@ -59,11 +60,11 @@ class Indy
   #
   # NCSA Common Log Format log format
   #
-  COMMON_LOG_FORMAT = {:entry_regexp => LogFormats::COMMON_REGEXP, :entry_fields => LogFormats::COMMON_FIELDS}
+  COMMON_LOG_FORMAT = {:entry_regexp => LogFormats::COMMON_REGEXP, :entry_fields => LogFormats::COMMON_FIELDS, :time_format => LogFormats::COMMON_TIME_FORMAT}
 
   #
   # NCSA Combined Log Format log format
   #
-  COMBINED_LOG_FORMAT = {:entry_regexp => LogFormats::COMBINED_REGEXP, :entry_fields => LogFormats::COMBINED_FIELDS}
+  COMBINED_LOG_FORMAT = {:entry_regexp => LogFormats::COMBINED_REGEXP, :entry_fields => LogFormats::COMBINED_FIELDS, :time_format => LogFormats::COMMON_TIME_FORMAT}
 
 end

data/lib/indy/search.rb

@@ -3,11 +3,10 @@ class Indy
   class Search
 
     attr_accessor :source
-    attr_accessor :log_definition
 
     attr_accessor :start_time, :end_time, :inclusive
 
-    def initialize(params_hash)
+    def initialize(params_hash={})
       while (param = params_hash.shift) do
         send("#{param.first}=",param.last)
       end
@@ -25,7 +24,7 @@ class Indy
       results = []
       results += search do |entry|
         if type == :all || is_match?(type,entry,search_criteria)
-          result_struct = @log_definition.create_struct(entry)
+          result_struct = @source.log_definition.create_struct(entry)
           if block_given?
             block.call(result_struct)
           else
@@ -38,12 +37,12 @@ class Indy
 
     #
     # Search the @source and yield to the block the entry that was found
-    # with @log_definition
+    # with the LogDefinition
     #
     # This method is supposed to be used internally.
     #
     def search(&block)
-      if @log_definition.multiline
+      if @source.log_definition.multiline
         multiline_search(&block)
       else
         standard_search(&block)
@@ -58,9 +57,9 @@ class Indy
       results = []
       source_lines = (is_time_search ? @source.open([@start_time,@end_time]) : @source.open)
       source_lines.each do |single_line|
-        hash = @log_definition.parse_entry(single_line)
+        hash = @source.log_definition.parse_entry(single_line)
         next unless hash
-        next unless Indy::Time.inside_time_window?(hash[:time],@start_time,@end_time,@inclusive) if is_time_search
+        next unless inside_time_window?(hash[:time],@start_time,@end_time,@inclusive) if is_time_search
         results << (block.call(hash) if block_given?)
       end
       results.compact
@@ -72,10 +71,10 @@ class Indy
     def multiline_search(&block)
       is_time_search = use_time_criteria?
       source_io = StringIO.new( (is_time_search ? @source.open([@start_time,@end_time]) : @source.open ).join("\n") )
-      results = source_io.read.scan(@log_definition.entry_regexp).collect do |entry|
-        hash = @log_definition.parse_entry_captures(entry)
+      results = source_io.read.scan(@source.log_definition.entry_regexp).collect do |entry|
+        hash = @source.log_definition.parse_entry_captures(entry)
         next unless hash
-        next unless Indy::Time.inside_time_window?(hash[:time],@start_time,@end_time,@inclusive) if is_time_search
+        next unless inside_time_window?(hash[:time],@start_time,@end_time,@inclusive) if is_time_search
         block.call(hash) if block_given?
       end
       results.compact
@@ -87,8 +86,8 @@ class Indy
     def use_time_criteria?
       if @start_time || @end_time
         # ensure both boundaries are set
-        @start_time ||= Indy::Time.forever_ago(@log_definition.time_format)
-        @end_time ||= Indy::Time.forever(@log_definition.time_format)
+        @start_time ||= Indy::Time.forever_ago(@source.log_definition.time_format)
+        @end_time ||= Indy::Time.forever(@source.log_definition.time_format)
       end
       @start_time && @end_time
     end
@@ -114,8 +113,8 @@ class Indy
       if params_hash[:time]
         time_scope_from_direction(params_hash[:direction], params_hash[:span], params_hash[:time])
       else
-        @start_time = Indy::Time.parse_date(params_hash[:start_time]) if params_hash[:start_time]
-        @end_time = Indy::Time.parse_date(params_hash[:end_time]) if params_hash[:end_time]
+        @start_time = Indy::Time.parse_date(params_hash[:start_time], @source.log_definition.time_format) if params_hash[:start_time]
+        @end_time = Indy::Time.parse_date(params_hash[:end_time], @source.log_definition.time_format) if params_hash[:end_time]
       end
       @inclusive = params_hash[:inclusive]
     end
@@ -124,7 +123,7 @@ class Indy
     # Parse direction, span, and time to set @start_time and @end_time
     #
     def time_scope_from_direction(direction, span, time)
-       time = Indy::Time.parse_date(time)
+      time = Indy::Time.parse_date(time, @source.log_definition.time_format)
       span = (span.to_i * 60).seconds if span
       if direction == :before
         @end_time = time
@@ -142,6 +141,19 @@ class Indy
       @inclusive = @start_time = @end_time = nil
     end
 
-  end
+    #
+    # Evaluate if a log entry satisfies the configured time conditions
+    #
+    def inside_time_window?(time_string,start_time,end_time,inclusive)
+      time = Indy::Time.parse_date(time_string, @source.log_definition.time_format)
+      return false unless time
+      if inclusive
+        return true unless (time > end_time || time < start_time)
+      else
+        return true unless (time >= end_time || time <= start_time)
+      end
+      return false
+    end
 
+  end
 end

data/lib/indy/source.rb

@@ -5,6 +5,12 @@ class Indy
   # 
   class Source
 
+    # Exception raised when entry regexp does not match data
+    class FieldMismatchException < Exception; end
+
+    # log definition
+    attr_accessor :log_definition
+
     # log source type. :cmd, :file, or :string
     attr_reader :type
 
@@ -14,9 +20,6 @@ class Indy
     # the StringIO object
     attr_reader :io
 
-    # log definition
-    attr_reader :log_definition
-
     # Exception raised when unable to open source
     class Invalid < Exception; end
 
@@ -27,7 +30,7 @@ class Indy
     #
     def initialize(param,log_definition=nil)
       raise Indy::Source::Invalid, "No source specified." if param.nil?
-      @log_definition = log_definition || LogDefinition.new()
+      self.log_definition = log_definition || LogDefinition.new()
       return discover_connection(param) unless param.respond_to?(:keys)
       if param[:cmd]
         set_connection(:cmd, param[:cmd])
@@ -155,7 +158,20 @@ class Indy
     # Return the time of a log entry index, with an optional offset
     #
     def time_at(index, delta=0)
-      ::Time.parse(@entries[index + delta])
+      begin
+        entry = @entries[index + delta]
+        time = @log_definition.parse_entry(entry)[:time]
+        result = Indy::Time.parse_date(time, @log_definition.time_format)
+      rescue FieldMismatchException => fme
+        raise
+      rescue Exception => e
+        msg = "Unable to parse time from entry. Time value was #{time.inspect}. Original exception was:\n#{e.class}\n"
+        raise Indy::Time::ParseException, msg + e.message
+      end
+      if result.nil?
+        raise Indy::Time::ParseException, "Unable to parse datetime. Raw value was #{time.inspect}. Entry was #{entry}."
+      end
+      result
     end
 
     #

data/lib/indy/time.rb

@@ -1,38 +1,35 @@
+require 'active_support'
 require 'active_support/core_ext'
 
 class Indy
 
   class Time
 
+    # Exception raised when unable to parse an entry's time value
+    class ParseException < Exception; end
+
     class << self
 
       #
       # Return a valid DateTime object for the log entry string or hash
       #
-      # @param [String, Hash] param The log entry string or hash
+      # @param [String, Hash] time The log entry string or hash
+      #
+      # @param [String] time_format String of #strftime directives to define format
       #
       def parse_date(time,time_format=nil)
         return time if time.kind_of? ::Time or time.kind_of? DateTime
         if time_format
           begin
-            # Attempt the appropriate parse method
             DateTime.strptime(time, time_format)
           rescue
-            # If appropriate, fall back to simple parse method
             DateTime.parse(time) rescue nil
           end
         else
           begin
-            # If appropriate, fall back to simple parse method
             ::Time.parse(time)
           rescue => e
             raise "Failed to create time object. The error was: #{e.message}"
-            #begin
-            #  # one last try!!
-            #  DateTime.parse(time)
-            #rescue Exception => e
-            #  raise "Failed to create time object. The error was: #{e.message}"
-            #end
           end
         end
       end
@@ -56,23 +53,6 @@ class Indy
         end
       end
 
-      #
-      # Evaluate if a log entry satisfies the configured time conditions
-      #
-      # @param [Hash] entry_hash The log entry's hash
-      #
-      def inside_time_window?(time_string,start_time,end_time,inclusive)
-        time = Indy::Time.parse_date(time_string)
-        #return false unless time && entry_hash
-        if inclusive
-          true unless time > end_time or time < start_time
-        else
-          true unless time >= end_time or time <= start_time
-        end
-      end
-
     end
-
   end
-
 end

data/lib/indy/version.rb

@@ -1,7 +1,7 @@
 
 class Indy
 
-  VERSION = '0.4.0.pre'
+  VERSION = '0.5.0'
 
   def self.show_version_changes(version)
     date = ""

data/spec/indy_private_spec.rb

@@ -12,12 +12,12 @@ describe 'Indy' do
     end
 
     it "#last_entries should return an array of Struct::Entry object" do
-      @indy.send(:last_entries, 2).class.should == Array
-      @indy.send(:last_entries, 2).first.class.should == Struct::Entry
+      expect(@indy.send(:last_entries, 2).class).to eq(Array)
+      expect(@indy.send(:last_entries, 2).first.class).to eq(Struct::Entry)
     end
 
     it "#last_entries should return correct Struct::Entry objects" do
-      @indy.send(:last_entries, 2).first.time.should == '2000-09-07 14:07:43'
+      expect(@indy.send(:last_entries, 2).first.time).to eq('2000-09-07 14:07:43')
     end
 
   end

data/spec/indy_spec.rb

@@ -7,20 +7,20 @@ describe 'Indy' do
     it "should accept v0.3.4 initialization params" do
       indy_obj = Indy.new(:source => "foo\nbar\n").with(Indy::DEFAULT_LOG_FORMAT)
       search_obj = indy_obj.search
-      search_obj.log_definition.class.should eq Indy::LogDefinition
-      search_obj.log_definition.entry_regexp.class.should eq Regexp
-      search_obj.log_definition.entry_fields.class.should eq Array
+      expect(search_obj.source.log_definition.class).to eq Indy::LogDefinition
+      expect(search_obj.source.log_definition.entry_regexp.class).to eq Regexp
+      expect(search_obj.source.log_definition.entry_fields.class).to eq Array
     end
 
     it "should not raise error with non-conforming data" do
       @indy = Indy.new(:source => " \nfoobar\n\n baz", :entry_regexp => '([^\s]+) (\w+)', :entry_fields => [:time, :message])
-      @indy.all.class.should == Array
+      expect(@indy.all.class).to eq(Array)
     end
 
     it "should accept time_format parameter" do
       @indy = Indy.new(:time_format => '%d-%m-%Y', :source => "1-13-2000 yes", :entry_regexp => '^([^\s]+) (\w+)$', :entry_fields => [:time, :message])
-      @indy.all.class.should == Array
-      @indy.search.log_definition.time_format.should == '%d-%m-%Y'
+      expect(@indy.all.class).to eq(Array)
+      expect(@indy.search.source.log_definition.time_format).to eq('%d-%m-%Y')
     end
 
     it "should accept an initialization hash passed to #search" do
@@ -29,8 +29,8 @@ describe 'Indy' do
         :entry_regexp => '^([^\s]+) (\w+)$',
         :entry_fields => [:time, :message]}
       @indy = Indy.search(hash)
-      @indy.class.should == Indy
-      @indy.all.length.should == 1
+      expect(@indy.class).to eq(Indy)
+      expect(@indy.all.length).to eq(1)
     end
 
   end
@@ -47,49 +47,51 @@ describe 'Indy' do
     context "method" do
 
       it "#with should return self" do
-        @indy.with().class.should == Indy
+        expect(@indy.with().class).to eq(Indy)
       end
 
       it "#with should use default log pattern when passed :default" do
-        @indy.with(:default).all.length.should == 3
+        expect(@indy.with(:default).all.length).to eq(3)
       end
 
-      it "should raise ArgumentError when regexp captures don't match fields" do
+      it "should raise Exception when regexp captures don't match fields" do
         log = [ "2000-09-07 14:06:41 INFO MyApp - Entering APPLICATION.",
                 "2000-09-07 14:07:42 DEBUG MyApp - Initializing APPLICATION."].join("\n")
-        lambda{ Indy.search(log).
-            with(:entry_regexp => Indy::LogFormats::DEFAULT_ENTRY_REGEXP, :entry_fields => [:field_one]).
-            all.length.should > 0
-        }.should raise_error ArgumentError
+        expect{
+          expect(Indy.search(log).
+                    with(:entry_regexp => Indy::LogFormats::DEFAULT_ENTRY_REGEXP,
+                         :entry_fields => [:field_one]
+                        ).all.length).to be > 0
+        }.to raise_error Indy::Source::FieldMismatchException
       end
 
       [:for, :like, :matching].each do |method|
         it "##{method} should exist" do
-          @indy.should respond_to(method)
+          expect(@indy).to respond_to(method)
         end
 
         it "##{method} should accept a hash of search criteria" do
-          @indy.send(method,:severity => "INFO").should be_kind_of(Array)
+          expect(@indy.send(method,:severity => "INFO")).to be_kind_of(Array)
         end
 
         it "##{method} should return a set of results" do
-          @indy.send(method,:severity => "DEBUG").should be_kind_of(Array)
+          expect(@indy.send(method,:severity => "DEBUG")).to be_kind_of(Array)
         end
       end
 
       it "#last should return self" do
-        @indy.last(:span => 1).should be_kind_of Indy
+        expect(@indy.last(:span => 1)).to be_kind_of Indy
       end
 
       it "#last should set the time scope to the correct number of minutes" do
-        @indy.last(:span => 1).all.count.should == 2
+        expect(@indy.last(:span => 1).all.count).to eq(2)
       end
 
       it "#last should raise an error if passed an invalid parameter" do
-        lambda{ @indy.last('a') }.should raise_error( ArgumentError )
-        lambda{ @indy.last() }.should raise_error( ArgumentError )
-        lambda{ @indy.last(nil) }.should raise_error( ArgumentError )
-        lambda{ @indy.last({}) }.should raise_error( ArgumentError )
+        expect{ @indy.last('a') }.to raise_error( ArgumentError )
+        expect{ @indy.last() }.to raise_error( ArgumentError )
+        expect{ @indy.last(nil) }.to raise_error( ArgumentError )
+        expect{ @indy.last({}) }.to raise_error( ArgumentError )
       end
 
     end
@@ -98,39 +100,39 @@ describe 'Indy' do
   context '#search' do
 
     it "should be a class method" do
-      Indy.should respond_to(:search)
+      expect(Indy).to respond_to(:search)
     end
 
     it "should accept a string parameter" do
-      Indy.search("String Log").class.should == Indy
+      expect(Indy.search("String Log").class).to eq(Indy)
     end
 
     it "should accept a hash with :cmd key" do
-      Indy.search(:cmd => "ls").class.should == Indy
+      expect(Indy.search(:cmd => "ls").class).to eq(Indy)
     end
 
     it "should accept a hash with :file => filepath" do
-      Indy.search(:file => "#{File.dirname(__FILE__)}/data.log").all.length.should == 2
+      expect(Indy.search(:file => "#{File.dirname(__FILE__)}/data.log").all.length).to eq(2)
     end
 
     it "should accept a hash with :file => File" do
-      Indy.search(:file => File.open("#{File.dirname(__FILE__)}/data.log")).all.length.should == 2
+      expect(Indy.search(:file => File.open("#{File.dirname(__FILE__)}/data.log")).all.length).to eq(2)
     end
 
     it "should accept a valid :source hash" do
-      Indy.search(:source => {:cmd => 'ls'}).class.should == Indy
+      expect(Indy.search(:source => {:cmd => 'ls'}).class).to eq(Indy)
     end
 
     it "should create an instance of Indy::Source in Search object" do
-      Indy.search("source string").search.source.should be_kind_of(Indy::Source)
+      expect(Indy.search("source string").search.source).to be_kind_of(Indy::Source)
     end
 
     it "should raise an exception when passed an invalid source: nil" do
-      lambda{ Indy.search(nil) }.should raise_error(Indy::Source::Invalid, /No source specified/)
+      expect{ Indy.search(nil) }.to raise_error(Indy::Source::Invalid, /No source specified/)
     end
 
     it "should raise an exception when the arity is incorrect" do
-      lambda{ Indy.search( ) }.should raise_error Indy::Source::Invalid
+      expect{ Indy.search( ) }.to raise_error Indy::Source::Invalid
     end
 
     context "with explicit source hash" do
@@ -142,48 +144,46 @@ describe 'Indy' do
         end
 
         it "should attempt open the command" do
-          IO.stub!(:popen).with('ssh user@system "bash --login -c \"cat /var/log/standard.log\" "')
+          allow(IO).to receive(:popen).with('ssh user@system "bash --login -c \"cat /var/log/standard.log\" "')
           Indy.search(:cmd => 'ssh user@system "bash --login -c \"cat /var/log/standard.log\" "')
         end
 
         it "should not throw an error for an invalid command" do
-          IO.stub!(:popen).with('an invalid command').and_return('')
-          Indy.search(:cmd => "an invalid command").class.should == Indy
+          allow(IO).to receive(:popen).with('an invalid command').and_return('')
+          expect(Indy.search(:cmd => "an invalid command").class).to eq(Indy)
         end
 
         it "should use IO.popen on cmd value" do
-          IO.stub!(:popen).with("a command").and_return(StringIO.new("2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION."))
-          Indy.search(:cmd => "a command").for(:application => 'MyApp').length.should == 1
+          allow(IO).to receive(:popen).with("a command").and_return(StringIO.new("2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION."))
+          expect(Indy.search(:cmd => "a command").for(:application => 'MyApp').length).to eq(1)
         end
 
         it "should handle a real command" do
           log_file = "data.log"
           cat_cmd = (is_windows? ? 'type' : 'cat')
-          Indy.search(:cmd => "#{cat_cmd} #{log_file}").for(:application => 'MyApp').length.should == 2
+          expect(Indy.search(:cmd => "#{cat_cmd} #{log_file}").for(:application => 'MyApp').length).to eq(2)
         end
 
         it "should raise Source::Invalid for an invalid command" do
-          IO.stub!(:popen).with("zzzzzzzzzzzz").and_return('Invalid command')
-          lambda{ Indy.search(:cmd => "zzzzzzzzzzzz").all }.should raise_error( Indy::Source::Invalid, /Unable to open log source/)
+          allow(IO).to receive(:popen).with("zzzzzzzzzzzz").and_return('Invalid command')
+          expect{ Indy.search(:cmd => "zzzzzzzzzzzz").all }.to raise_error( Indy::Source::Invalid, /Unable to open log source/)
         end
 
       end
 
       it "using :file" do
-        require 'tempfile'
-        file = stub!(:size).and_return(1)
-        lambda{ Indy.search(:file => file) }
+        expect(Indy.search(:file => "#{File.dirname(__FILE__)}/data.log").all.length).to eq(2)
       end
 
       it "using :string" do
         string = "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION."
         string_io = StringIO.new(string)
-        StringIO.should_receive(:new).with(string).ordered.and_return(string_io)
-        Indy.search(:string => string).for(:application => 'MyApp').length.should == 1
+        expect(StringIO).to receive(:new).with(string).ordered.and_return(string_io)
+        expect(Indy.search(:string => string).for(:application => 'MyApp').length).to eq(1)
       end
 
       it "should raise error when given an invalid key" do
-        lambda{ Indy.search(:foo => "a string").all }.should raise_error( Indy::Source::Invalid )
+        expect{ Indy.search(:foo => "a string").all }.to raise_error( Indy::Source::Invalid )
       end
 
     end
@@ -196,7 +196,7 @@ describe 'Indy' do
       log = [ "2000-09-07 14:06:41 INFO MyApp - Entering APPLICATION.",
               "2000-09-07 14:07:42 DEBUG MyApp - Initializing APPLICATION.",
               "2000-09-07 14:07:43 INFO MyApp - Exiting APPLICATION."].join("\n")
-      Indy.search(log).all.length.should == 3
+      expect(Indy.search(log).all.length).to eq(3)
     end
 
     it "should ignore invalid entries" do
@@ -204,13 +204,13 @@ describe 'Indy' do
             "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.\n",
             " bad \n",
             "2000-09-07 14:07:41 INFO  MyApp - Entering APPLICATION.\n\n"].join("\n")
-      Indy.search(log).all.length.should == 3
+      expect(Indy.search(log).all.length).to eq(3)
     end
 
     it "should handle no matching entries" do
       log = ["2000-09-07   MyApp - Entering APPLICATION.\n \n",
             "2000-09-07 14:07:41\n"].join
-      Indy.search(log).all.length.should == 0
+      expect(Indy.search(log).all.length).to eq(0)
     end
 
     context "with explicit time format" do
@@ -223,7 +223,7 @@ describe 'Indy' do
                         :time_format => '%d-%Y-%m',
                         :entry_regexp => /^(\d\d-\d\d\d\d-\d\d)\s+(#{Indy::LogFormats::DEFAULT_SEVERITY_PATTERN})\s+(#{Indy::LogFormats::DEFAULT_APPLICATION})\s+-\s+(#{Indy::LogFormats::DEFAULT_MESSAGE})$/,
                         :entry_fields => Indy::LogFormats::DEFAULT_ENTRY_FIELDS)
-        indy.all.length.should == 2
+        expect(indy.all.length).to eq(2)
       end
     end
 
@@ -242,20 +242,20 @@ describe 'Indy' do
     end
 
     it "should return all entries using #all" do
-      @indy.all.count.should == 5
+      expect(@indy.all.count).to eq(5)
     end
 
     it "should return correct number of entries with #for" do
-      @indy.for(:severity => 'INFO').count.should == 3
+      expect(@indy.for(:severity => 'INFO').count).to eq(3)
     end
 
     it "should return correct number of entries with #like" do
-      @indy.like(:message => 'ntering').count.should == 2
+      expect(@indy.like(:message => 'ntering').count).to eq(2)
     end
 
     it "should return correct number of entries using #after time scope" do
       results = @indy.after(:time => '2000-09-07 14:07:43', :inclusive => false).all
-      results.length.should == 2
+      expect(results.length).to eq(2)
     end
 
   end
@@ -270,7 +270,7 @@ describe 'Indy' do
     
     it "with #for should yield Struct::Entry" do
       Indy.search(log).all do |result|
-        result.should be_kind_of(Struct::Entry)
+        expect(result).to be_kind_of(Struct::Entry)
       end
     end
 
@@ -279,7 +279,7 @@ describe 'Indy' do
       Indy.search(log).all do |result|
         actual_yield_count += 1
       end
-      actual_yield_count.should == 3
+      expect(actual_yield_count).to eq(3)
     end
 
     it "with #for should yield each entry" do
@@ -287,7 +287,7 @@ describe 'Indy' do
       Indy.search(log).for(:severity => 'INFO') do |result|
         actual_yield_count += 1
       end
-      actual_yield_count.should == 2
+      expect(actual_yield_count).to eq(2)
     end
 
     it "with #like should yield each entry" do
@@ -295,7 +295,7 @@ describe 'Indy' do
       Indy.search(log).like(:message => '\be\S+ing') do |result|
         actual_yield_count += 1
       end
-      actual_yield_count.should == 2
+      expect(actual_yield_count).to eq(2)
     end
 
   end