glark 1.9.0

data/lib/glark/exprfactory.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Expression factory.
+
+require 'English'
+
+require 'rubygems'
+require 'riel'
+
+require 'glark/options'
+require 'glark/expression'
+
+class ExpressionFactory
+  include Loggable
+
+  # signifies no limit to the distance between matches, i.e., anywhere within
+  # the entire file is valid.
+  INFINITE_DISTANCE = -1
+
+  attr_reader :expr
+
+  def initialize
+    @regexps         = 0
+    opts             = GlarkOptions.instance
+    @ignorecase      = opts.nocase
+    @wholewords      = opts.whole_words
+    @wholelines      = opts.whole_lines
+    @extended        = opts.extended
+    @multiline       = opts.multiline
+    @highlight       = opts.highlight
+    @text_highlights = opts.text_highlights
+    @extract_matches = opts.extract_matches
+  end
+
+  # reads a file containing one regular expression per line.
+  def read_file(fname)
+    log { "reading file: #{fname}" }
+    expr = nil
+    File.open(fname) do |file|
+      file.each_line do |line|
+        log { "line: #{line}" }
+        line.strip!
+        unless line.empty?
+          # flatten the or expression instead of nesting it, to avoid
+          # stack overruns for very large files.
+          re = make_regular_expression(line.chomp)
+          if expr 
+            expr.ops << re
+          else
+            expr = InclusiveOrExpression.new(re)
+          end
+        end
+      end
+    end
+    
+    log { "returning expression #{expr}" }
+    
+    expr
+  end
+
+  def make_regular_expression(pattern, negated = false)
+    # this check is because they may have omitted the pattern, e.g.:
+    #   % glark *.cpp
+    if File.exists?(pattern)
+      warn "pattern '#{pattern}' exists as a file.\n    Pattern may have been omitted."
+    end
+
+    regex = Regexp.create(pattern.dup, 
+                          :negated    => negated, 
+                          :ignorecase => @ignorecase,
+                          :wholewords => @wholewords,
+                          :wholelines => @wholelines,
+                          :extended   => @extended,
+                          :multiline  => @multiline)
+
+    regex_args = {
+      :highlight       => @highlight,
+      :text_highlights => @text_highlights,
+      :extract_matches => @extract_matches
+    }    
+
+    re = RegexpFuncObj.new(regex, @regexps, regex_args)
+    @regexps += 1
+    re
+  end
+
+  # creates two expressions and returns them.
+  def make_expressions(args)
+    a1 = make_expression(args)
+    a2 = make_expression(args)
+    
+    [ a1, a2 ]
+  end
+
+  # removes optional end tag
+  def shift_end_tag(name, args)
+    # explicit end tag is optional:
+    args.shift if args[0] == ("--end-of-" + name)
+  end
+  
+  def make_not_expression(args)
+    expr = make_regular_expression(args, true)
+    unless expr
+      error "'not' expression takes one argument"
+      exit 2
+    end
+
+    # explicit end tag is optional:
+    shift_end_tag("not", args)
+    expr
+  end
+
+  def make_two_expressions(args, type)
+    a1, a2 = make_expressions(args)
+    unless a1 && a2
+      error "'" + type + "' expression takes two arguments"
+      exit 2
+    end
+
+    shift_end_tag(type, args)
+    [ a1, a2 ]
+  end
+
+  def make_or_expression(args)
+    a1, a2 = make_two_expressions(args, "or")
+    InclusiveOrExpression.new(a1, a2)
+  end
+
+  def make_xor_expression(args)
+    a1, a2 = make_two_expressions(args, "xor")
+    ExclusiveOrExpression.new(a1, a2)
+  end
+
+  def numeric?(x)
+    x && (x.kind_of?(Fixnum) || (x.to_i == INFINITE_DISTANCE || x.num))
+  end  
+
+  def make_and_distance(arg, args)
+    dist = nil
+    if arg == "-a"
+      dist = args.shift
+    elsif arg == "--and"
+      if args.size > 0 && numeric?(args[0])
+        dist = args.shift
+      else
+        dist = "0"
+      end
+    elsif arg.index(/^--and=(\-?\d+)?$/)
+      dist = $1
+    end
+
+    # check to ensure that this is numeric
+    if !numeric?(dist)
+      error "invalid distance for 'and' expression: '#{dist}'\n" +
+        "    expecting an integer, or #{INFINITE_DISTANCE} for 'infinite'" 
+      exit 2
+    end
+    
+    if dist.to_i == INFINITE_DISTANCE
+      dist = 1.0 / 0.0            # infinity
+    else
+      dist = dist.to_i
+    end
+
+    dist
+  end
+  
+  def make_and_expression(arg, args)
+    dist = make_and_distance(arg, args)
+
+    a1, a2 = make_two_expressions(args, "and")
+    AndExpression.new(dist, a1, a2)
+  end
+
+  def make_infix_expression(arg, args = [])
+    expr = nil
+
+    while arg
+      case arg
+      when '('
+        arg  = args.shift
+        expr = make_infix_expression(arg, args)
+      when '--or', '-o'
+        arg  = args.shift
+        rhs  = make_infix_expression(arg, args)
+        expr = InclusiveOrExpression.new(expr, rhs)
+      when '--xor'
+        arg  = args.shift
+        rhs  = make_infix_expression(arg, args)
+        expr = ExclusiveOrExpression.new(expr, rhs)
+      when Regexp.new('^--and'), '-a'
+        dist = make_and_distance(arg, args)
+        arg  = args.shift
+        rhs  = make_infix_expression(arg, args)
+        expr = AndExpression.new(dist, expr, rhs)
+      when ')'
+        break
+      else
+        # blather "assuming the last argument #{arg} is a pattern"
+        expr = make_regular_expression(arg)
+        break
+      end
+      arg = args.shift
+    end
+
+    if !expr
+      puts "arg: #{arg}; args: #{args.inspect}"
+      error "No expression provided."
+    end
+
+    expr
+  end
+
+  def make_expression(args, warn_option = false)
+    arg = args[0]
+    
+    if arg
+      case arg
+      when "--or", "-o"
+        args.shift
+        make_or_expression(args)
+      when "--xor"
+        args.shift
+        make_xor_expression(args)
+      when %r{^\-\-and}, %r{^\-a}
+        args.shift
+        make_and_expression(arg, args)
+      when '('
+        args.shift
+        make_infix_expression(arg, args)
+      else
+        if warn_option && arg.index(/^\-{1,2}\w/)
+          warn "option not understood: #{arg}"
+          exit 2
+        end
+
+        # blather "assuming the last argument #{arg} is a pattern"
+        args.shift
+        make_regular_expression(arg)
+      end
+    else
+      nil
+    end
+  end
+
+end

data/lib/glark/glark.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# An extended grep, with extended functionality including full regular
+# expressions, contextual output, highlighting, detection and exclusion of
+# nontext files, and complex matching criteria.
+
+require 'English'
+require 'pathname'
+
+require 'rubygems'
+require 'riel'
+
+require 'glark/options'
+require 'glark/input'
+require 'glark/output'
+require 'glark/expression'
+require 'glark/exprfactory'
+
+$stdout.sync = true             # unbuffer
+$stderr.sync = true             # unbuffer
+
+$PACKAGE = "glark"
+$VERSION = "1.9.0"
+
+# The main processor.
+class Glark 
+  include Loggable
+
+  attr_reader :exit_status
+  
+  def initialize(func, files)
+    @opts  = GlarkOptions.instance
+    @func  = func
+    @searched_files = Array.new          # files searched, so we don't cycle through links
+    
+    @files = files
+
+    @show_file_names = (@opts.show_file_names ||
+                        (@opts.show_file_names.nil? && 
+                         (@opts.label ||
+                          @files.size > 1 ||
+                          (@files[0] != "-" && FileType.type(@files[0]) == FileType::DIRECTORY))))
+
+    @out_class = case @opts.output
+                 when "grep"
+                   GrepOutputFormat
+                 when "ansi", "xterm", nil
+                   GlarkOutputFormat
+                 when "match"
+                   error "output to match list is not yet supported"
+                   GlarkMatchList
+                   # exit 2
+                 end
+
+    @count        = @opts.count
+    @invert_match = @opts.invert_match
+
+    @after  = @opts.after
+    @before = @opts.before
+    @output = @opts.output
+
+    # 0 == matches, 1 == no matches, 2 == error
+    @exit_status = @invert_match ? 0 : 1
+
+    @skip_methods = Array.new
+
+    if @opts.with_basename || @opts.without_basename
+      @skip_methods << Proc.new { |fn| skip?(File.basename(fn), @opts.with_basename, @opts.without_basename) }
+    end
+
+    if @opts.with_fullname || @opts.without_fullname
+      @skip_methods << Proc.new { |fn| skip?(fn, @opts.with_fullname, @opts.without_fullname) }
+    end
+    
+    if @opts.size_limit
+      @skip_methods << Proc.new { |fn| File.size(fname) > @opts.size_limit }
+    end    
+  end
+
+  def search_file(input)
+    output       = @out_class.new(input, @show_file_names)
+    input.output = output
+
+    input.count        = 0    if @count
+    input.invert_match = true if @invert_match
+    
+    @func.process(input)
+
+    if input.matched?
+      @exit_status = @invert_match ? 1 : 0
+    end
+  end
+
+  def skip?(name, opts_with, opts_without)
+    inc = opts_with    && !opts_with.match(name)
+    exc = opts_without &&  opts_without.match(name)
+    inc || exc
+  end
+
+  def skipped?(fname)
+    @skip_methods.detect { |meth| meth.call(fname) }
+  end
+
+  def search_text(fname)
+    if skipped?(fname)
+      log { "skipping file: #{fname}" }
+    else
+      log { "searching text" }
+      if false
+        # readlines doesn't work with $/ == nil, so we'll use gets instead.
+        # this has been fixed in the CVS version of Ruby (on 26 Dec 2003).
+        text = []
+        File.open(fname) do |f|
+          while ((line = f.gets) && line.length > 0)
+            text << line
+          end
+        end
+        log { "got text #{text.length}" }
+      end
+      log { "searching #{fname} for #{@func}" }
+
+      ifile_args = {
+        :after  => @after,
+        :before => @before,
+        :output => @output
+      }
+
+      io = fname == "-" ? $stdin : File.new(fname)
+
+      input = InputFile.new(fname, io, ifile_args)
+      search_file(input)
+    end
+  end
+
+  def search_binary(fname)
+    if skipped?(fname)
+      log { "skipping file: #{fname}" }
+    else
+      log { "handling binary" }
+      
+      case @opts.binary_files
+      when "without-match"
+        log { "skipping binary file #{fname}" }
+        
+      when "binary"
+        log { "searching binary file #{fname} for #{@func}" }
+        f = File.new(fname)
+        f.binmode                # for MSDOS/WinWhatever
+        bf = BinaryFile.new(fname, f)
+        search_file(bf)
+        
+      when "text"
+        log { "processing binary file #{name} as text" }
+        search_text(fname)
+      end
+    end
+  end
+
+  def search_directory(fname)
+    log { "processing directory" }
+    case @opts.directory
+    when "read"
+      write "#{fname}: Is a directory"
+    when "recurse"
+      log { "recursing into directory #{fname}" }
+      begin
+        entries = Dir.entries(fname).reject { |x| x == "." || x == ".." }
+        entries.each do |e|
+          entname = fname + "/" + e
+          inode = File.exists?(entname) && File.stat(entname).ino
+          if inode && @searched_files.include?(inode)
+            Log.verbose && log("file already processed: #{entname}")
+          else
+            @searched_files << inode
+            search(entname)
+          end
+        end
+      rescue Errno::EACCES => e
+        write "directory not readable: #{fname}"
+      end
+    when "skip"
+      log { "skipping directory #{fname}" }
+    else
+      log { "directory: #{@opts.directory}" }
+    end
+  end
+
+  def search_unknown(fname)
+    warn "unknown file type: #{fname}"
+  end
+        
+  def search_none(fname)
+    write "no such file: #{fname}"
+  end
+
+  def search_unreadable(fname)
+    log { "skipping unreadable: #{fname}" }
+  end
+
+  def search(name)
+    if @opts.exclude_matching
+      expr = @opts.expr
+      if expr.respond_to?(:re) && expr.re.match(name)
+        log { "skipping file #{name} with matching name" }
+        return
+      else
+        log { "not skipping file #{name}" }
+      end
+    end
+        
+    if name == "-" 
+      write "reading standard input..."
+      search_text("-")
+    else
+      type = FileType.type(name)
+
+      case type
+      when FileType::BINARY
+        search_binary(name)
+      when FileType::DIRECTORY
+        search_directory(name)
+      when FileType::NONE
+        search_none(name)
+      when FileType::TEXT
+        search_text(name)
+      when FileType::UNKNOWN
+        search_unknown(name)
+      when FileType::UNREADABLE
+        search_unreadable(name)
+      else
+        error "type unknown: file: #{name}; type: #{type}"
+        exit(-2)
+      end
+    end
+  end
+
+  def end_processing
+  end
+  
+  def self.create_options
+    GlarkOptions.instance
+  end
+
+  def self.main
+    begin
+      Log.set_widths(-15, -40, -40)
+      
+      Log.log { "loading options" }
+      opts = self.create_options
+      
+      opts.run(ARGV)
+      Log.log { "done loading options" }
+
+      # To get rid of the annoying stack trace on ctrl-C:
+      trap("INT") { abort }
+      
+      if opts.explain
+        puts opts.expr.explain
+      end
+
+      files = if ARGV.size > 0 then
+                if opts.split_as_path
+                  ARGV.collect { |f| f.split(File::PATH_SEPARATOR) }.flatten
+                else
+                  ARGV
+                end
+              else 
+                [ '-' ]
+              end
+
+      glark = self.new(opts.expr, files)
+
+      files.each do |f|
+        glark.search(f) 
+      end
+
+      glark.end_processing
+
+      exit glark.exit_status
+    rescue => e
+      # show the message, and the stack trace only if verbose:
+      $stderr.puts "error: #{e}"
+      if opts.verbose || true
+        $stderr.puts e.backtrace
+        raise
+      else
+        exit 2
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  Glark.main
+end