#!/usr/bin/env ruby
# Start Date: Saturday January 26, 2008
# Most Recent Update: Thursday March 6, 2008
# Current Version: 1.0
# Author: Joseph Pecoraro
# Contact: joepeck02@gmail.com
# Decription: Default behavior is a multiple regular expressions grep
#  utility.  Multiple regular expressions are provided and the desire
#  of the regular expression matching or not matching each line of
#  text.  If everything succeeds the filename, line number, and line
#  of text is printed.

# Load
require 'find'

# Global States
$all_mode   = false
$search_hidden = false
$regex_list = []
$regex_neg  = []


# Usage Message to print
$program_name = $0.split(/\//).last
usage = <<USAGE
usage: #{$program_name} [options] [-#] ( [-n] regex ) [filenames]
  #         - the number of regular expressions, defaults to 1
  ( ... )   - there should be # of these
  regex     - regular expessions to be checked on the line
  filenames - names of the input files to be parsed, if blank uses STDIN

options:
  --all or -a            instead of line-by-line this scans the entire file
  --hidden or -h         search hidden files and hidden directories

before regex:
  --neg, --not, or -n    line must not match this regular expression

special note:
  When using bash, if you want backslashes in the replace portion make sure
  to use the multiple argument usage with single quotes for the replacement.

USAGE

# Print an error message and exit
def err(msg)  
  puts "#{$program_name}: #{msg}"
  exit 1
end

# Check existence and permissions for the file
def check_file(filename)
  if !File.exists? filename
    err("#{filename}: No such file")
  elsif !File.readable? filename
    err("#{filename}: File is not readable by this user.")
  end
  check_stream(filename, filename+' ')
end

def check_stream( stream, print_name )
  
  # Default Behavior
  # 1. Open the file
  # 2. Read text line by line
  # 3. Run each regular expression, and check if it should match or
  #    if it should not match based on the command line switches
  # 4. Print the filename, line number, and line which successfully
  #    match all conditions
  if ( !$all_mode )
    line_num = 0
    File.new(stream).readlines.each do |line|
      line_num += 1
      temp_negs = []
      $regex_list.each do |regex|
        temp_negs.push( !line.match(regex).nil? )
      end
      puts "#{print_name}[#{line_num}]: #{line}" if $regex_neg.eql? temp_negs
    end

  # all mode
  # 1. Setup an array (all_array) we hope will end up like $regex_neg
  # 2. Open the file
  # 3. Read text line by line
  # 4. Run the regular expression, set all found regexs in the temp array
  # 5. Test the temp array against $regex_neg, if there is a match print the filename
  else
    all_array = Array.new($regex_neg.size, false)
    File.new(stream).readlines.each do |line|
      $regex_list.each_index do |i|
        regex = $regex_list[i]
        all_array[i] = true if !line.match(regex).nil?
      end
    end
    if $regex_neg.eql? all_array
      if stream == STDIN.fileno
        puts "STDIN matches all regular expressions"
      else
        puts print_name
      end
    end
  end
  
end



# Script starts here
# Check for options, make them nils, then delete nils
ARGV.each_index do |i|
  arg = ARGV[i]
  if arg.match /^-(-all|a)$/
    $all_mode = true
    ARGV[i] = nil
  elsif arg.match /^-(-hidden|h)$/
    $search_hidden = true
    ARGV[i] = nil
  else
    break
  end
end

# Remove the nils from ARGV
ARGV.delete_if { |elem| elem.nil? }

# Must be at least 1 argument (a regex)
if ARGV.size < 1
  puts usage
  exit
end

# Check the first argument
num_regex = 1
argv_index = 0
if ARGV[argv_index].match( /^-(\d+)$/ )
  num_regex = $1.to_i
  argv_index += 1
end

# Pull out that many regular expressions
1.upto(num_regex) do |i|
  
  # Check if it is a negation option
  if ARGV[argv_index].match( /^-(-neg|-not|n)$/ )
    $regex_neg.push( false )
    argv_index += 1
  else
    $regex_neg.push( true )
  end
  
  # Get the regular expressions
  find_str = ARGV[argv_index]
  argv_index += 1
  
  # User is allowed to wrap the find regex in /'s (this removes them)
  find_str = find_str[1..(find_str.length-2)] if find_str =~ /^\/.*?\/$/
  
  # Convert to a regular expression and add to the collection
  $regex_list.push( Regexp.new( find_str, Regexp::IGNORECASE ) )

end

# If no more args, add nil for STDIN processing
ARGV << nil if argv_index == ARGV.size

# Start to parse the files
argv_index.upto( ARGV.size-1 ) do |i|

  # STDIN
  filename = ARGV[i]
  if filename.nil?
    filename = STDIN.fileno
    check_stream(filename, '')
  
  # If it is a directory
  elsif File.directory? filename
    
    # Check each file recursively
    # NOTE: Find will recurse down all layers, so just skip dirs
    Find.find(filename) do |new_filename|
      if (!$search_hidden && new_filename.match(/^(.*\/)?\.\w/)) || (File.symlink? new_filename)
        Find.prune
      elsif File.directory? new_filename
        next
      else
        check_file(new_filename)
      end
    end
  
  # If it is a file go and check it [even if hidden]
  else
    check_file(filename)
  end

end

# Successful
exit 0