glark 1.9.0 → 1.10.0

data/lib/glark/io/file/tar_gz_file.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'glark/io/file/gz_file'
+require 'glark/io/file/tar_file'
+
+module Glark
+  class TarGzFile
+    include Loggable
+    
+    def initialize fname, range
+      @fname = fname
+      @range = range
+    end
+
+    def list
+      contents = Array.new
+      each_file do |entry|
+        contents << entry.full_name
+      end
+      contents
+    end
+
+    def run_search &blk
+      # a glitch with zlib results in a warning ("attempt to close unfinished
+      # zstream; reset forced.") for some tarballs, so we turn off warnings for
+      # a moment:
+      $-w = false
+      
+      Zlib::GzipReader.open(@fname) do |gzio|
+        tarfile = Glark::TarFile.new @fname, @range, gzio
+        blk.call tarfile
+      end
+
+      $-w = true
+    end
+
+    def search_list expr, output_cls, output_opts
+      run_search do |tarfile|
+        tarfile.search_list expr, output_cls, output_opts
+      end
+    end
+
+    def search expr, output_type_cls, output_opts
+      matched = nil
+      run_search do |tarfile|
+        matched = tarfile.search(expr, output_type_cls, output_opts) || matched
+      end
+      matched
+    end
+  end
+end

data/lib/glark/io/file/zip_file.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'glark/io/file/archive_file'
+
+module Glark
+  class ZipFile < ArchiveFile
+    include Loggable
+    
+    def initialize fname, range, &blk
+      super fname, range
+      
+      # Same caveat as ZipFile. Given that this is a gem, I'm not sure if it is
+      # installed with other package managers. So the require is down here, used
+      # only if needed.
+
+      begin
+        require 'zip/zip'
+      rescue LoadError => e
+        msg = "error loading zip gem: #{e}\n"
+        msg << "to install this dependency, run 'gem install rubyzip'"
+        info "msg: #{msg}".on_red
+        raise msg
+      end
+    end
+
+    def get_reader 
+      @zipfile = Zip::ZipFile.new @fname
+    end
+
+    def read entry
+      @zipfile.read entry
+    end
+
+    def entry_name entry
+      entry.name
+    end
+  end
+end

data/lib/glark/match/and.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/match/compound'
+
+# Evaluates both expressions, and is satisfied when both return true.
+class AndExpression < CompoundExpression
+  
+  def initialize dist, op1, op2
+    @dist = dist
+    super op1, op2
+  end
+
+  def match_within_distance op, lnum
+    op.matches.size > 0 and (op.matches[-1] - lnum <= @dist)
+  end
+
+  def inspect
+    str = "("+ @ops[0].to_s
+    if @dist == 0
+      str += " same line as "
+    elsif @dist.kind_of?(Float) && @dist.infinite?
+      str += " same file as "
+    else 
+      str += " within " + @dist.to_s + " lines of "
+    end
+    str += @ops[1].to_s + ")"
+    str
+  end
+
+  def match? line, lnum, file, formatter
+    matches = (0 ... @ops.length).select do |oi|
+      @ops[oi].evaluate line, lnum, file, formatter
+    end
+
+    matches.each do |mi|
+      oidx  = (1 + mi) % @ops.length
+      other = @ops[oidx]
+      if match_within_distance other, lnum
+        # search for the maximum match within the distance limit
+        other.matches.each do |m|
+          if lnum - m <= @dist
+            @last_start = m
+            return true
+          end
+        end
+        return false
+      end
+    end
+
+    false
+  end
+  
+  def end_position
+    @ops.collect { |op| op.end_position }.max
+  end
+
+  def evaluate line, lnum, file, formatter
+    if match? line, lnum, file, formatter
+      @match_line_number = lnum
+      true
+    else
+      false
+    end
+  end
+
+  def explain level = 0
+    str = ""
+    if @dist == 0
+      str += " " * level + "on the same line:\n"
+    elsif @dist.kind_of?(Float) && @dist.infinite?
+      str += " " * level + "in the same file:\n"
+    else 
+      lnstr = @dist == 1 ? "line" : "lines"
+      str += " " * level + "within #{@dist} #{lnstr} of each other:\n"
+    end
+    str += @ops[0].explain(level + 4)
+    str += " " * level + "and\n"
+    str += @ops[1].explain(level + 4)
+    str
+  end
+end

data/lib/glark/match/and_distance.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Distance for and expression
+
+require 'rubygems'
+require 'riel/string'
+require 'glark/match/re'
+require 'glark/match/ior'
+require 'glark/match/xor'
+require 'glark/match/and'
+
+class AndDistance
+  include Loggable
+
+  # signifies no limit to the distance between matches, i.e., anywhere within
+  # the entire file is valid.
+  INFINITE_DISTANCE = -1
+
+  AND_EQ_NUM_RE = Regexp.new '^--and=(\-?\d+)?$'
+
+  attr_reader :distance
+
+  def initialize arg, args
+    @distance = if arg == "-a"
+                  args.shift
+                elsif arg == "--and"
+                  if args.size > 0 && numeric?(args[0])
+                    args.shift
+                  else
+                    "0"
+                  end
+                elsif md = AND_EQ_NUM_RE.match(arg)
+                  md[1]
+                else
+                  raise "invalid 'and' option: '#{arg}'"
+                end
+    
+    # check to ensure that this is numeric
+    if !numeric? @distance
+      raise "invalid distance for 'and' expression: '#{@distance}'\n" +
+        "    expecting an integer, or #{INFINITE_DISTANCE} for 'infinite'" 
+    end
+    
+    if @distance.to_i == INFINITE_DISTANCE
+      @distance = 1.0 / 0.0            # infinity
+    else
+      @distance = @distance.to_i
+    end
+
+    @distance
+  end
+  
+  def numeric? x
+    x && (x.kind_of?(Fixnum) || x.to_i == INFINITE_DISTANCE || x.num)
+  end  
+end

data/lib/glark/match/compound.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/match/expression'
+
+# -------------------------------------------------------
+# Compound expression function object
+# -------------------------------------------------------
+
+# Associates a collection of expressions.
+class CompoundExpression < Expression
+  attr_reader :ops
+
+  def initialize(*ops)
+    @ops = ops
+    super()
+  end
+
+  def reset_file file
+    @ops.each do |op|
+      op.reset_file file
+    end
+    super
+  end
+
+  def start_position
+    @last_start
+  end
+  
+  def == other
+    self.class == other.class && @ops == other.ops
+  end  
+end

data/lib/glark/match/expression.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Extended regular-expression-based expressions.
+
+require 'rubygems'
+require 'riel'
+
+# An expression, which can be applied (processed) against a Glark::File.
+class Expression
+  include Loggable
+  
+  attr_accessor :matches
+
+  def initialize
+    @match_line_number = nil
+    @matches = Array.new
+  end
+
+  def add_match lnum
+    @matches.push lnum
+  end
+
+  def start_position
+    @match_line_number
+  end
+
+  def end_position
+    start_position
+  end
+
+  def reset_file file
+    @match_line_number = nil
+    @matches = Array.new
+  end
+
+  def process file, formatter
+    reset_file file.fname
+
+    rgstart = file.get_range_start
+    rgend = file.get_range_end
+    
+    lastmatch = 0
+    lnum = 0
+    file.each_line do |line|
+      if ((!rgstart || lnum >= rgstart) && 
+          (!rgend   || lnum < rgend)   &&
+          evaluate(line, lnum, file, formatter))
+
+        break if formatter.process_match start_position, end_position, lastmatch, lnum
+        lastmatch = lnum + 1
+      end
+      lnum += 1
+    end
+
+    formatter.process_end lnum
+  end
+
+  def to_s
+    inspect
+  end
+end

data/lib/glark/match/factory.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Expression factory.
+
+require 'rubygems'
+require 'riel/regexp'
+require 'riel/log/loggable'
+require 'glark/match/and'
+require 'glark/match/and_distance'
+require 'glark/match/ior'
+require 'glark/match/re_factory'
+require 'glark/match/xor'
+
+class ExpressionFactory
+  include Loggable
+
+  attr_reader :expr
+
+  def initialize matchspec
+    @regexp_factory = RegexpExpressionFactory.new matchspec
+  end
+
+  # reads a file containing one regular expression per line.
+  def read_file fname
+    expr = nil
+    File.open(fname) do |file|
+      file.each_line do |line|
+        line.strip!
+        next if 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
+    expr
+  end
+
+  def make_regular_expression pattern, negated = false
+    @regexp_factory.create_expression pattern, negated
+  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
+      raise "'not' expression takes one argument"
+    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
+      raise "'" + type + "' expression takes two arguments"
+    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 make_and_distance arg, args
+    adist = AndDistance.new arg, args
+    adist.distance
+  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
+        expr = make_regular_expression arg
+        break
+      end
+      arg = args.shift
+    end
+
+    if !expr
+      raise "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(%r{^\-{1,2}\w})
+          raise "option not understood: #{arg}"
+        end
+
+        args.shift
+        make_regular_expression arg
+      end
+    else
+      nil
+    end
+  end
+end