grepper 0.9.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.9.0 / 2008-12-21
+
+* 1 major enhancement
+
+  * First release
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/grepper.rb
+test/input.1
+test/input.2
+test/input.3
+test/input.4
+test/input.6
+test/test_grepper.rb

data/README.txt

@@ -0,0 +1,97 @@
+Grepper -- simple way to grep through files and save results
+
+== Version
+
+0.9.0, December 21, 2008
+
+== Author
+
+David A. Black (dblack@rubypal.com)
+
+== Copyright and license
+
+Copyright (c) 2008, Ruby Power and Light, LLC
+
+Released under the Ruby license. No warranty of any kind. Use
+entirely at your own risk. 
+
+== Description
+
+The Grepper class greps through files, and returns a result
+set of Grepper::Result objects. Each Result object represents the matches
+found in a single file. The Result contains a set of
+Grepper::Match objects. Each Match object represents a line (the
+line that matched) and before- and after-context arrays. If no before
+or after lines were requested, those context values will be nil. 
+
+To use, you prepare a Grepper object; call <tt>run</tt> on it; and
+walk through the result set. 
+
+== Preparing a Grepper object
+
+You instantiate Grepper, and provide it with:
+
+* a pattern, in the form of a regular expression
+* zero or more options, as an array
+* an array of filenames
+ 
+=== Setting the grepper's pattern
+
+To specify a pattern for the Grepper object:
+
+  grepper.pattern = /abc/
+
+=== Setting the grepper's file list
+
+  grepper.files = ["file1.txt", "file2.txt"]
+  grepper.files = Dir["grep_me/*.txt"]
+
+=== Options
+
+To set options, you provide an array of strings. For example, for a
+reverse grep with two lines of after-context you would do:
+
+  grepper.options = %w{ v A2 }
+
+Available options are:
+
+* <tt>v</tt> -- negate the sense of the match
+* <tt>An</tt> -- provide n lines of after-context
+* <tt>Bn</tt> -- provide b lines of before-context
+
+== Generating the result set
+
+To generate the result set, you call <tt>run</tt>.
+
+  grepper.run
+
+Now you can access grepper.results, and walk through all the
+matches. 
+
+== Walking through the result set and match set
+
+Given a <tt>Grepper</tt> object <tt>grepper</tt>, the result set 
+will be at <tt>grepper.results</tt>.
+It will iterate per entry, yielding
+the filename and the corresponding set of matches.
+
+  grepper.results.each do |filename, matches|
+    ...
+  end
+
+For each match set, you can iterate like this:
+
+  matches.each do |lineno, before, line, after|
+    ...
+  end
+
+If you want to walk through either set and just get the
+objects, not broken out into their properties, you can do:
+
+  grepper.results.each_result do |result|
+
+and
+
+  matches.each_match do |match|
+
+

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/grepper.rb'
+
+Hoe.new('grepper', Grepper::VERSION) do |p|
+  # p.rubyforge_name = 'grepperx' # if different than lowercase project name
+   p.developer('David A. Black', 'dblack@rubypal.com')
+end
+
+# vim: syntax=Ruby

data/lib/grepper.rb

@@ -0,0 +1,229 @@
+# Grepper -- simple way to grep through files and save results
+#
+# == Version
+#
+# 0.9.0, December 21, 2008
+#
+# == Author
+#
+# David A. Black (dblack@rubypal.com)
+#
+# == Copyright and license
+#
+# Copyright (c) 2008, Ruby Power and Light, LLC
+#
+# Released under the Ruby license. No warranty of any kind. Use
+# entirely at your own risk. 
+#
+# == Description
+#
+# The Grepper class greps through files, and returns a result
+# set of Grepper::Result objects. Each Result object represents the matches
+# found in a single file. The Result contains a set of
+# Grepper::Match objects. Each Match object represents a line (the
+# line that matched) and before- and after-context arrays. If no before
+# or after lines were requested, those context values will be nil. 
+#
+# To use, you prepare a Grepper object; call <tt>run</tt> on it; and
+# walk through the result set. 
+#
+# == Preparing a Grepper object
+#
+# You instantiate Grepper, and provide it with:
+# 
+# * a pattern, in the form of a regular expression
+# * zero or more options, as an array
+# * an array of filenames
+#  
+# === Setting the grepper's pattern
+#
+# To specify a pattern for the Grepper object:
+#
+#   grepper.pattern = /abc/
+#
+# === Setting the grepper's file list
+#
+#   grepper.files = ["file1.txt", "file2.txt"]
+#   grepper.files = Dir["grep_me/*.txt"]
+#
+# === Options
+#
+# To set options, you provide an array of strings. For example, for a
+# reverse grep with two lines of after-context you would do:
+#
+#   grepper.options = %w{ v A2 }
+#
+# Available options are:
+# 
+# * <tt>v</tt> -- negate the sense of the match
+# * <tt>An</tt> -- provide n lines of after-context
+# * <tt>Bn</tt> -- provide b lines of before-context
+#
+# == Generating the result set
+#
+# To generate the result set, you call <tt>run</tt>.
+#
+#   grepper.run
+#
+# Now you can access grepper.results, and walk through all the
+# matches. 
+#
+# == Walking through the result set and match set
+# 
+# Given a <tt>Grepper</tt> object <tt>grepper</tt>, the result set 
+# will be at <tt>grepper.results</tt>.
+# It will iterate per entry, yielding
+# the filename and the corresponding set of matches.
+# 
+#   grepper.results.each do |filename, matches|
+#     ...
+#   end
+# 
+# For each match set, you can iterate like this:
+# 
+#   matches.each do |lineno, before, line, after|
+#     ...
+#   end
+# 
+# If you want to walk through either set and just get the
+# objects, not broken out into their properties, you can do:
+#
+#   grepper.results.each_result do |result|
+#
+# and
+#
+#   matches.each_match do |match|
+#
+
+class Grepper
+  VERSION = '0.9.0'
+
+  attr_accessor :files, :pattern, :options
+  attr_reader :results
+
+  def initialize
+    @files = []
+    @options = []
+    @results = [].extend(ResultsExtension)
+    @negate = false
+  end
+
+  private 
+
+  def get_after_context(fh, after_count)
+    res = []
+    after_count.times do |i|
+      line = fh.gets
+      break unless line
+      if match?(line)
+        fh.pos -= line.size
+        break
+      else
+        res << line
+      end
+    end
+    res.empty? ? nil : res
+  end
+
+  def match?(line)
+    m = line =~ @pattern
+    @negate ? !m : m
+  end
+  
+  public
+
+# Generate the result set. 
+  def run
+    @negate = true if options.include?('v')
+    
+    after_count = $1.to_i if options.find {|o| /A(\d)/.match(o) }
+    before_count = $1.to_i if options.find {|o| /B(\d)/.match(o) }
+
+    files.each do |file|
+      result = Result.new(file)
+      results << result
+      buffer = []
+      File.open(file) do |fh|
+        fh.each_with_index do |line,i|
+          if match?(line)
+            match = Match.new(line)
+            match.lineno = i + 1
+            if after_count
+              match.after = get_after_context(fh, after_count)
+            end
+
+            if before_count
+              match.before = buffer.empty? ? nil : buffer
+              buffer = []
+            end
+
+            result.matches << match
+
+          else
+            if before_count
+              buffer << line
+              buffer.shift if buffer.size > before_count
+            end
+          end
+        end
+      end
+    end
+  end
+
+# Grepper::Match represents a match on a single line, possibly
+# with before- and/or after-context. 
+#
+# Match instances are created automatically by the Grepper
+# object when you run it. 
+class Match
+  attr_accessor :before, :line, :after, :lineno
+  def initialize(line)
+    @before = @after = nil
+    @line = line
+  end
+end
+
+# Grepper::Result represents the matches from a single file. It
+# connects the filename (the <tt>file</tt> attribute) with a
+# set of Match objects (the <tt>matches</tt> attribute).
+#
+# Result objects are created automatically by the Grepper object
+# when you run it. 
+  class Result
+    attr_reader :file, :matches
+    def initialize(file)
+      @file = file
+      @matches = [].extend(MatchesExtension)
+    end
+  end
+
+  # Provides the iteration intelligence for result sets.  
+  module ResultsExtension
+    def each(&block)
+      (0...size).each do |i|
+        yield(self[i].file, self[i].matches)
+      end
+    end
+    def each_result(&block)
+      (0...size).each do |i|
+        yield self[i]
+      end
+    end
+  end
+
+  # Provides the iteration intelligence for match sets. 
+  module MatchesExtension
+    def each
+      (0...size).each do |i|
+        m = self[i]
+        yield(m.lineno,m.before,m.line,m.after)
+      end
+    end
+  
+    def each_match
+      (0...size).each do |i|
+        yield(self[i])
+      end
+    end
+  end
+end

data/test/input.1

@@ -0,0 +1,3 @@
+This is a file
+This matches abc.
+This doesn't.

data/test/input.2

@@ -0,0 +1,4 @@
+This doesn't match.
+However, this:
+So does this abc.
+does.

data/test/input.3

@@ -0,0 +1,3 @@
+This file
+has no
+matching lines.

data/test/input.4

@@ -0,0 +1,8 @@
+this abc
+blah one
+blah two
+blah three
+that abc
+one
+two
+three

data/test/input.6

@@ -0,0 +1,9 @@
+one
+two
+abc
+three
+four
+abc
+five
+six
+abc

data/test/test_grepper.rb

@@ -0,0 +1,139 @@
+require 'test/unit'
+require 'English'
+require "lib/grepper.rb"
+
+class GrepTest < Test::Unit::TestCase
+  def setup
+    @g = Grepper.new
+    @g.files = %w{ test/input.1 test/input.2 test/input.3 test/input.4 }
+    @g.pattern = /abc/
+  end
+  
+  def test_basic_lines_from_one_file
+    @g.files = ["test/input.1"]
+    exp = ["This matches abc.\n"]
+    @g.run
+    @g.results.each do |file,matches|
+      assert_equal("test/input.1", file)
+      matches.each do |no,before,line,after|
+        assert_equal(nil, before)
+        assert_equal(nil, after)
+        assert_equal(exp.shift, line)
+      end
+    end
+  end
+
+  def test_basic_negation_from_one_file
+    @g.files =["test/input.4"]
+    @g.pattern = /a/
+    @g.options = ['v']
+    @g.run
+    assert_equal(["one\n","two\n","three\n"],
+      @g.results[0].matches.map {|m| m.line })
+  end
+  
+  def test_case_insensitive_pattern
+    @g.files = ["test/input.1"]
+    @g.pattern = /ABC/i
+    exp = "This matches abc.\n"
+    @g.options = ['i']
+    @g.run
+    assert_equal(exp, @g.results[0].matches[0].line)
+  end
+
+  def test_basic_lines_from_multiple_files  
+    @g.run
+    files = @g.files.dup
+    exp = <<EOM.scan(/.*\n/)
+This matches abc.
+So does this abc.
+this abc
+that abc
+EOM
+    @g.results.each do |file,matches|
+      assert_equal(files.shift, file)
+      matches.each_match do |match|
+        assert_equal(nil, match.before)
+        assert_equal(nil, match.after)
+        assert_equal(exp.shift, match.line)
+      end
+    end
+  end
+  
+  def test_after_context_from_one_file
+    @g.options = %w{ A2 }
+    @g.files = ["test/input.4"]
+    exp = <<EOM.scan(/.*\n/)
+this abc
+blah one
+blah two
+that abc
+one
+two
+EOM
+    @g.run
+    @g.results.each do |file,matches|
+      assert_equal("test/input.4", file)
+      matches.each do |no,before,line,after|
+        assert_equal(nil, before)
+        assert_equal(exp.shift, line)
+        assert_equal([exp.shift, exp.shift], after)
+      end
+    end   
+  end
+  
+  def test_overlapping_context_from_one_file
+    @g.options = "A4"
+    @g.files = ["test/input.4"]
+    @g.run
+    assert_equal(1, @g.results.size)
+    assert_equal(3, @g.results[0].matches[0].after.size)
+    assert_equal(2, @g.results[0].matches.size)
+  end
+
+  def test_lines_from_multiple_files
+    @g.files.pop  # just 3 files
+    @g.run
+    assert_equal(3, @g.results.size)
+    assert_equal(@g.files, @g.results.map {|r| r.file})
+    assert_equal("This matches abc.\n", @g.results[0].matches[0].line)
+    assert_equal("So does this abc.\n", @g.results[1].matches[0].line)
+    assert(@g.results[2].matches.empty?)
+  end
+  
+  def test_before_buffer
+    @g.files = ["test/input.4"]
+    @g.options = "B2"
+    @g.run
+    r = @g.results[0]
+    assert_equal(1, @g.results.size)
+    assert_equal(2, r.matches.size)
+    assert_equal("this abc\n", r.matches[0].line)
+    assert_equal(["blah two\n", "blah three\n"], r.matches[1].before)
+    assert_equal("that abc\n", r.matches[1].line)
+  end
+
+  def test_before_and_after
+    @g.files = ["test/input.6"]
+    @g.options = %w{A2 B2}
+    @g.run
+
+    r = @g.results[0]
+    assert_equal(1, @g.results.size)
+    assert_equal(3, r.matches.size)
+    assert_equal(["one\n", "two\n"], r.matches[0].before)
+    assert(r.matches.all? {|no,b,l,a| l == "abc\n"})
+    assert_equal(["three\n", "four\n"], r.matches[0].after)
+    assert_equal(["five\n", "six\n"], r.matches[1].after)
+  end
+
+  def test_line_numbering
+    test_basic_lines_from_one_file
+    assert_equal(2, @g.results[0].matches[0].lineno)
+  end
+  
+  def test_line_numbering_in_multiple_files
+    test_basic_lines_from_multiple_files
+    assert_equal(3, @g.results[1].matches[0].lineno)
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: grepper
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- David A. Black
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-22 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: The Grepper class greps through files, and returns a result set of Grepper::Result objects. Each Result object represents the matches found in a single file. The Result contains a set of Grepper::Match objects. Each Match object represents a line (the line that matched) and before- and after-context arrays. If no before or after lines were requested, those context values will be nil.   To use, you prepare a Grepper object; call <tt>run</tt> on it; and walk through the result set.
+email: 
+- dblack@rubypal.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/grepper.rb
+- test/input.1
+- test/input.2
+- test/input.3
+- test/input.4
+- test/input.6
+- test/test_grepper.rb
+has_rdoc: true
+homepage: 0.9.0, December 21, 2008
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: grepper
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: The Grepper class greps through files, and returns a result set of Grepper::Result objects
+test_files: 
+- test/test_grepper.rb