glark 1.9.0 → 1.10.0

data/lib/glark/exprfactory.rb

@@ -1,248 +0,0 @@
-#!/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

@@ -1,297 +0,0 @@
-#!/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