interactive_grep 0.0.1 → 0.0.2

data/.gitignore

@@ -1,3 +1,4 @@
+*.DS_Store
 .ignore
 .rvmrc
 *.gem

data/README.txt

@@ -3,39 +3,55 @@ Interactively Grep for patterns.
 This works particularly well for files with muli-line patterns (like
 weblogs) and it handles zipped files.
 
-The code: horrible. This is my very first ruby program!
-I keep it simply because it's useful.
-One day I'll actually fix the code ;-)
+The code: pretty-yucky. This is based on my very first Ruby program (and
+the code was a total hack)!
+
+But I've kept it because it's actually useful.
+And hopefully by the time you see this the code will serve as an example
+of the power of refactoring ;)
 
 Basic use-case(s):
   gem install interactive_grep
-  # from the commandline:
+  # Then, from the commandline:
   igrep -h
 
-  # in your code:
+  # OR in your code:
   irb
-    # standard 'grep' (for optionally gzipped files)
-    ig = InteractiveGrep::Grepper.new("/path/to/my/weblog.gz", search_pattern_string)
-    results = ig.run
-    puts results
+    # normal ('grep') mode - support(s) regular or gzipped files
+    ig = InteractiveGrep::Grepper.new("files" => "/path/to/weblog.gz",
+                                      "pattern" => search_string
+    )
+    puts ig.run
     # => [matching_line1, matching_line2, matching_line3, etc...]
 
-    # standard 'grep -c' (for optionally gzipped files)
-    ig = InteractiveGrep::Grepper.new("/path/to/my/weblog.gz", search_pattern_string, true)
+    # count ('grep -c') mode - support(s) regular or gzipped files
+    ig = InteractiveGrep::Grepper.new("files" => "/path/to/weblog.gz",
+                                      "pattern" => search_string,
+                                      "mode" => "count"
+    )
     ig.run
-    # => 20  <-- yes, that third 'magic' initialization param caused
-                 the grepper to merely "count" the number of matches
+    # => 20
 
-    # *** interactive grep (for optionally gzipped files) ***
-    ig = InteractiveGrep::Grepper.new("/path/to/my/weblog.gz", search_pattern_string)
+    # interactive mode - oh yeah!!!
+    ig = InteractiveGrep::Grepper.new(files => "/path/to/weblog.gz",
+                                      "pattern" => search_string
+    )
     ig.interactive = true
     ig.run
-      # every time your *current* pattern is matched, the output is
-      # displayed ane you are prompted to:
-      # repeat the pattern search (just hit return)
-      # update the pattern (i.e. to find the next level of detail)
-
-(See specs for more detailed use-cases.)
+      # every time your *current* pattern is matched,
+      # the match is displayed
+      # and you are prompted to:
+      #   repeat the same search pattern (press enter)
+      #   'S'ee what's on the next line of the file (enter S)
+      #   adjust the search pattern (whatever you enter)
+      #   turn 'O'ff interactive-mode (enter O)
+      #    ...at which point the rest of the results will be 
+      #    automatically matched using the current pattern
+
+(See specs for more detailed use-cases ...and short-comings)
 rake rspec
 
-# TODO: re-write this TDD-style
+# TODO:
+# add specs for the behavior I described above
+# test-drive an API I can be proud of ;-)
+# ability to record & replay grep-sessions

data/bin/igrep

@@ -1,44 +1,46 @@
 #!/usr/bin/env ruby
 
 # the "i" is for interactive
-require 'interactive_grep'
-
-if __FILE__ == $0
-	if '-h' == ARGV[0] || 0 == ARGV.size
-		puts	"usage $0 -h"
-		puts	"\tproduces this help-message"
-		puts	""
-		
-		puts	"usage $0 <input_file> [<pattern>] [<display count-only>] [<interactive-mode=on>]"
-		puts	""
-		puts 	"e.g."
-		puts 	"./igrep.rb big_test.txt.gz"
-		puts 	'./igrep.rb "/reporting/access*.gz" cvsfa=63'
-		puts	""
-		exit
-	end
-
-	in_file = ARGV[0]
-	pattern = nil
-	interactive = nil
-	just_count = false
-	prompt = nil
-	if 2 <= ARGV.size
-		pattern = ARGV[1]
-	end
-	if 3 <= ARGV.size
-		# ARGV[2]
-		just_count = true
-		puts "true count: #{ARGV[2]}"
-	end
-	if 4 <= ARGV.size
-		interactive = ARGV[3]
-		puts "interactive mode: #{interactive}"
-	end
-
-	prompt = 'ready to continue' if interactive
-	igrep = InteractiveGrep::Grepper.new(in_file,pattern,just_count,interactive)
-	puts "#{prompt}\n\n" if interactive
-	igrep.run()
-	exit
+begin
+  require 'rubygems'
+  gem 'interactive_grep'
+rescue LoadError
 end
+file_or_gem = File.expand_path( '../../lib/interactive_grep/grepper.rb', __FILE__ )
+file_or_gem = 'interactive_grep' unless File.exists?( file_or_gem )
+require file_or_gem
+
+# TODO: replace this w/ a real cmd-line options parser!
+if 0 == ARGV.size || InteractiveGrep::Grepper.contains_option?(ARGV,'h')
+  puts InteractiveGrep::Grepper.usage
+end
+
+pattern = nil; interactive = true
+
+in_file = ARGV[0]
+
+if 2 <= ARGV.size
+  pattern = ARGV[1]
+end
+
+if 3 <= ARGV.size
+  mode = case ARGV[2]
+         when /^i/i
+           interactive = true
+           "interactive"
+         when /^c/i
+           interactive = false
+           "count"
+         else
+           interactive = false
+           "normal"
+         end
+end
+
+mode ||= interactive ? "interactive" : "normal"
+igrep = InteractiveGrep::Grepper.new( { "files" => in_file, "pattern" => pattern, "mode" => mode, "verbose" => "true" } )
+
+puts "Welcome..." if interactive
+igrep.run()
+
+exit

data/interactive_grep.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["JayTeeSr"]
   s.email       = ["jaytee_sr_at_his-service_dot_net"]
   s.homepage    = "https://github.com/JayTeeSF/interactive_grep"
-  s.summary     = %q{My very first Ruby program, which helped me interactively grep for multi-line patterns in gzipped weblogs}
-  s.description = %q{Interactively grep for stuff in (optionally gzipped) files}
+  s.summary     = %q{My very first Ruby program, for interactively grepping through gzipped weblogs for unexpected patterns}
+  s.description = %q{grep for stuff in (optionally gzipped) files ...even before you fully know what that 'stuff' looks like}
   s.rubyforge_project = "interactive_grep"
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/interactive_grep/grepper.rb

@@ -1,133 +1,196 @@
+require 'zlib'
+
 module InteractiveGrep
   class Grepper
-    require 'zlib'
+    DEFAULT_PATTERN = %r{.}.freeze
+    DEFAULT_NUMBER_OF_LINES_TO_INDICATE = 100.freeze
+    DEBUG = false.freeze
 
-    @@DEBUG = false
-    attr_accessor :in_file, :ending, :def_pattern, :interactive, :counter, :just_count, :gz
+    attr_accessor :file_names, :current_pattern, :initial_pattern, :gz, :file_index, :enough_lines_to_indicate
 
-    def initialize(in_file,def_pattern=".",just_count=false,interactive=nil)
-      @counter = 0
-      @file_index = 0
-      @in_file = [ in_file.chomp ]
-      m = /(\.[^\.]+)$/.match(@in_file[0])
+    def initialize( options = nil )
+      options ||= {}
+      @enough_lines_to_indicate = options[:line_indicator_count] || DEFAULT_NUMBER_OF_LINES_TO_INDICATE
+      @verbose = DEBUG || !!options[ "verbose" ]
+      reset_file_index
+      @file_names = options[ "files" ]
+      if ( !@file_names.is_a?( Array ) ) && @file_names[/\*/]
+        @file_names = Dir.glob( @file_names ).map{|fname| fname}
+      end
+      @file_names = [ @file_names ] unless @file_names.is_a? Array
+      unless current_file && File.exists?( current_file )
+        raise "must specify at least one valid file (and/or file_glob)"
+      end
 
-      @ending = m[1] || ''
+      @initial_pattern = !!options[ "pattern" ] ? %r{#{options[ "pattern" ]}} : DEFAULT_PATTERN
+      @current_pattern = @initial_pattern
 
-      # handle glob...
-      if /\*/.match(@in_file[0])
-        @in_file = Dir.glob(@in_file[0]).map{|fname| fname}
-      end
+      @mode = options[ "mode" ] || "normal"
 
-      @def_pattern = /#{def_pattern}/; #%r{ #{def_pattern} }
-      if interactive && just_count
-        just_count = false
-      end
+      @gz = options[ "gz" ]
 
-      @just_count = just_count
-      @interactive = interactive
-      @gz = false
-      if '.gz' == @ending
-        @gz = true
+      if verbose?
+        puts "using:\n\tfiles: #{file_names}\n\tending in: #{ending}\n\tinitial_pattern: #{current_pattern_string}\n"
       end
+    end
 
-      if @@DEBUG
-        print "using:\n\tin_file: #{@in_file}\n\tw/ ending:"
-        print "#{@ending}\n\tdef_pattern: #{@def_pattern}\n"
-      end
+    def self.contains_option?(input_options, option_string)
+      input_options.any?{|o| o[/^\s*\-+#{option_string}/] }
     end
 
-    def prompt(pattern, msg, display=true)
-      if display && msg
-        @counter += 1
-        if !@just_count
-          if @@DEBUG
-            puts "" 
-            puts ">>"
-          end
-          print msg
-          if @@DEBUG
-            puts "<<"
+    def self.usage
+      puts	"usage $0 [-h]"
+      puts	"\tproduces this help-message"
+      puts	""
+
+      puts	"usage $0 <input_file> [<pattern>] [<mode>]"
+      puts	""
+      puts 	"modes: 'interactive' (default), 'count', or 'normal'"
+      puts 	"e.g."
+      puts 	"./igrep.rb big_test.txt.gz"
+      puts 	'./igrep.rb "/reporting/access*.gz" cvsfa=63 interactive'
+      puts 	'./igrep.rb "/reporting/access*.gz" cvsfa=63 count'
+      puts 	'./igrep.rb "/reporting/access*.gz" cvsfa=63 # normal-grep mode'
+      puts	""
+      exit
+    end
+
+    def default_pattern?
+      DEFAULT_PATTERN == current_pattern
+    end
+
+    def current_pattern_string
+      default_pattern? ? "<match every line>" : current_pattern
+    end
+
+    def ending
+      File.extname( current_file )
+    end
+
+    def gz?
+      @gz || ending[/.?gz$/]
+    end
+
+    def current_file
+      file_names[ file_index ]
+    end
+
+    def reset_file_index
+      @file_index = 0
+    end
+
+    def increment_file_index
+      @file_index += 1
+    end
+
+    def run
+      counter = 0
+      results = []
+      @current_pattern = initial_pattern
+      while line = next_line
+        if line[@current_pattern]
+          line.strip!
+          counter += 1
+          unless just_count? || ( verbose? && interactive? )
+            results << line
           end
-          puts ""
+          @current_pattern = prompt( line )
+        end
+        if verbose?
+          puts "." if 0 == (counter % enough_lines_to_indicate)
         end
       end
-
-      if @interactive.nil?
-        if @@DEBUG
-          puts "interactive mode is off"
+      reset_file_index
+      puts "no more files.\n" if verbose?
+      if just_count?
+        if verbose?
+          puts "matched #{counter} line(s)"
+          puts "done.\n"
         end
-        pattern
+        counter
       else
-        puts "S | O | <pattern: [#{pattern}]> ? "
-        user_input = STDIN.gets.chomp
+        puts "done.\n" if verbose?
+        results
+      end
+    end
+
+    private
+
+    def verbose?
+      !!@verbose
+    end
+
+    def just_count?
+      @mode == "count"
+    end
+
+    def interactive?
+      @mode == "interactive"
+    end
+
+    def prompt( msg )
+      if verbose? && msg && !just_count?
+        puts "\n>>\n#{msg}\n<<"
+      end
+
+      if interactive?
+        puts "S | O | <pattern: [#{current_pattern_string}]> ? "
+        user_input = STDIN.gets.strip
         puts ""
-        if @@DEBUG
-          puts "user_input: >>#{user_input}<<"
+        if DEBUG
+          puts "user_input: >>#{user_input.inspect}<<"
         end
 
         case
-        when /^\s*$/.match(user_input) #corresponds w/ <enter> (or <return>)
-          if @@DEBUG
-            puts "user hit <return> (cont w/ same pattern)"
+        when /^\s*$/.match( user_input ) #corresponds w/ <enter> (or <return>)
+          if verbose?
+            puts " => continuing w/ the previous pattern"
           end
-          pattern
-        when ( (user_input == "o") || (user_input == "O") ) #interactive mode Off
-          @interactive = nil
-          if @@DEBUG
-            puts "turned interactive mode off"
+          @current_pattern
+        when [ "O", "o" ].include?( user_input ) #interactive mode Off
+          @mode = "normal"
+          if verbose?
+            puts " => interactive switched mode off"
           end
-          pattern
-        when ( (user_input == "s") || (user_input == "S") ) #Show every line
-          if @@DEBUG
-            puts "show next line"
+          @current_pattern
+        when [ "S", "s" ].include?( user_input ) #Show every line
+          if verbose?
+            puts " => showing the next line"
           end
           /./
         else #use whatever was entered
-          if @@DEBUG
-            puts "use whatever was entered"
+          if verbose?
+            puts " => using your input as the new search pattern"
           end
           %r{#{user_input}}
         end
+      else
+        @current_pattern
       end
     end
 
-    def run(display_results=true)
-      results = []
-      while (1 + @file_index) < @in_file.count
-        myfh = get_file_handle()
-        pattern = @def_pattern
-        while line = myfh.gets
-          if pattern.match(line)
-            if @@DEBUG
-              puts ""
-            end
-            if line
-              line.strip!
-              results << line
-            end
-            pattern = prompt( pattern, line, display_results )
-            if @@DEBUG
-              puts ""
-            end
-          end
-          if @@DEBUG
-            puts "."
-          end
-        end
+    def next_line
+      @handle ||= get_file_handle
+      while @handle.eof?
+        @handle.close
+        puts "trying next file..." if verbose?
+        return if not_another_file?
+        increment_file_index
+        return unless @handle = get_file_handle
       end
-      puts "count: #{@counter}" if @just_count
-      results
+      return @handle.gets
+    end
+
+    def not_another_file?
+      ! (file_names.count > file_index + 1)
     end
 
     def get_file_handle
-      handle = nil
-      if @gz
-        handle = Zlib::GzipReader.open(@in_file[@file_index]);
+      if gz?
+        Zlib::GzipReader.open( current_file );
       else
-        handle = File.open(@in_file[@file_index], 'r')
+        File.open( current_file, 'r' )
       end
-      @file_index += 1
-      handle
     end
   end
 end

data/lib/interactive_grep/version.rb

@@ -1,3 +1,3 @@
 module InteractiveGrep
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/lib/interactive_grep/grepper_spec.rb

@@ -1,17 +1,98 @@
 require  "spec_helper"
 describe InteractiveGrep::Grepper do
-  context "initialization" do
+  describe "instantiation" do
+    let(:params) { {} }
+    let(:grepper) { InteractiveGrep::Grepper.new( params ) }
     context "with invalid params" do
       it "should raise an error" do
-        expect { InteractiveGrep::Grepper.new }.to raise_error(ArgumentError)
         expect { InteractiveGrep::Grepper.new(:one) }.to raise_error
+        expect { InteractiveGrep::Grepper.new("./*.gz") }.to raise_error
+        expect { InteractiveGrep::Grepper.new( { "files" => "" } ) }.to raise_error
+        expect { InteractiveGrep::Grepper.new }.to raise_error
       end
     end
     context "with valid params" do
       it "should not raise an error" do
-        expect { InteractiveGrep::Grepper.new( "./*.gz" ) }.not_to raise_error
+        expect { InteractiveGrep::Grepper.new( { "files" => "#{file_dir}/**/*", "verbose" => nil, "pattern" => "", "mode" => "", "gz" => "" } ) }.not_to raise_error
+      end
+    end
+
+    describe "detecting files" do
+      context "when specifying an ungzipped file" do
+        let(:params) { { "files" => "#{ungzipped_file}" } }
+
+        it "should have an array consisting of the ungzipped file" do
+          grepper.file_names.should == [ ungzipped_file ]
+        end
+
+        it "should have gz set to false" do
+          grepper.gz.should be_false
+        end
+      end
+
+      context "when specifying a gzipped file" do
+        let(:params) { { "files" => "#{gzipped_file}" } }
+
+        it "should have an array consisting of the gzipped file" do
+          grepper.file_names.should == [ gzipped_file ]
+        end
+
+        it "should have gz set to true" do
+          grepper.gz.should be_true
+        end
+      end
+
+      context "when specifying a gzip glob " do
+        let(:params) { { "files" => "#{gzip_glob}" } }
+
+        it "should have an array consisting of the gzipped file" do
+          grepper.file_names.should == [ gzipped_file ]
+        end
+
+        it "should have gz set to true" do
+          grepper.gz.should be_true
+        end
+      end
+
+      context "when specifying a ungzipped glob " do
+        let(:params) { { "files" => "#{ungzip_glob}" } }
+
+        it "should have an array consisting of the ungzipped file" do
+          grepper.file_names.should == [ ungzipped_file ]
+        end
+
+        it "should have gz set to false" do
+          grepper.gz.should be_false
+        end
       end
     end
-  end
 
+    describe "detecting file-patterns" do
+      context "in gzipped files" do
+        context "counting matches" do
+          let(:params) { { "files" => "#{gzipped_file}", "pattern" => "pattern", "mode" => "count" } }
+          it "should be in 'count' mode" do
+            grepper.should be_just_count
+          end
+          it "should match two lines" do
+            grepper.run.should == 2
+          end
+        end
+      end
+
+      # test w/ default pattern
+      context "in ungzipped files" do
+        context "counting matches" do
+          let(:params) { { "files" => "#{ungzipped_file}", "pattern" => "pattern", "mode" => "count" } }
+          it "should be in 'count' mode" do
+            grepper.should be_just_count
+          end
+          it "should match two lines" do
+            grepper.run.should == 2
+          end
+        end
+      end
+    end
+
+  end
 end

data/spec/spec_helper.rb

@@ -3,3 +3,35 @@ Bundler.setup
 
 require "rspec"
 require "interactive_grep"
+
+def file_dir
+  File.expand_path( '../tmp', __FILE__ )
+end
+
+def ungzipped_file_dir
+  "#{file_dir}/ungzipped_files"
+end
+
+def all_file_glob
+  "#{file_dir}/*/*"
+end
+
+def ungzip_glob
+  "#{ungzipped_file_dir}/*"
+end
+
+def gzip_glob
+  "#{gzipped_file_dir}/*"
+end
+
+def gzipped_file
+  "#{gzipped_file_dir}/file.txt.gz"
+end
+
+def ungzipped_file
+  "#{ungzipped_file_dir}/file.txt"
+end
+
+def gzipped_file_dir
+  "#{file_dir}/gzipped_files"
+end

data/spec/tmp/ungzipped_files/file.txt

@@ -0,0 +1,5 @@
+non matching line
+pattern1|pattern2|pattern3
+non matching line
+patternA|patternB|patternC
+non matching line

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: interactive_grep
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000Z
+date: 2012-07-21 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70239385100440 !ruby/object:Gem::Requirement
+  requirement: &70175694399860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,8 +21,9 @@ dependencies:
         version: 2.11.0
   type: :development
   prerelease: false
-  version_requirements: *70239385100440
-description: Interactively grep for stuff in (optionally gzipped) files
+  version_requirements: *70175694399860
+description: grep for stuff in (optionally gzipped) files ...even before you fully
+  know what that 'stuff' looks like
 email:
 - jaytee_sr_at_his-service_dot_net
 executables:
@@ -37,13 +38,13 @@ files:
 - Rakefile
 - bin/igrep
 - interactive_grep.gemspec
-- lib/.DS_Store
 - lib/interactive_grep.rb
-- lib/interactive_grep/.DS_Store
 - lib/interactive_grep/grepper.rb
 - lib/interactive_grep/version.rb
 - spec/lib/interactive_grep/grepper_spec.rb
 - spec/spec_helper.rb
+- spec/tmp/gzipped_files/file.txt.gz
+- spec/tmp/ungzipped_files/file.txt
 homepage: https://github.com/JayTeeSF/interactive_grep
 licenses: []
 post_install_message: 
@@ -67,8 +68,10 @@ rubyforge_project: interactive_grep
 rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: My very first Ruby program, which helped me interactively grep for multi-line
-  patterns in gzipped weblogs
+summary: My very first Ruby program, for interactively grepping through gzipped weblogs
+  for unexpected patterns
 test_files:
 - spec/lib/interactive_grep/grepper_spec.rb
 - spec/spec_helper.rb
+- spec/tmp/gzipped_files/file.txt.gz
+- spec/tmp/ungzipped_files/file.txt