glark 1.9.0 → 1.10.0

data/lib/glark/match/ior.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/match/or'
+
+# Evaluates the expressions, and is satisfied when any one returns true.
+class InclusiveOrExpression < OrExpression
+  def is_match? matched_ops
+    return matched_ops.size > 0
+  end
+
+  def operator
+    "or"
+  end
+
+  def criteria
+    ops.size == 2 ? "either" : "any of"
+  end
+end

data/lib/glark/match/options.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Options for matching.
+
+require 'rubygems'
+require 'riel/log'
+require 'glark/match/spec'
+require 'glark/util/options'
+
+module Glark
+  class MatchOptions < MatchSpec
+    include OptionUtil
+    
+    def initialize colors, optdata
+      super colors    
+      add_as_options optdata
+    end
+
+    def config_fields
+      fields = {
+        "ignore-case" => @ignorecase,
+        "text-color" => text_colors.join(' '),
+      }
+    end
+
+    def dump_fields
+      fields = {
+        "expr" => @expr,
+        "extract_matches" => @extract_matches,
+        "ignorecase" => @ignorecase,
+        "text_colors" => text_colors.compact.collect { |hl| colorize(hl, "text") }.join(", "),
+        "whole_lines" => @whole_lines,
+        "whole_words" => @whole_words,
+      }
+    end
+
+    def update_fields fields
+      fields.each do |name, values|
+        case name
+        when "ignore-case"
+          @ignorecase = to_boolean values.last
+        end
+      end
+    end
+
+    def add_as_options optdata
+      add_opt_true optdata, :whole_words, %w{ -w --word }
+      add_opt_true optdata, :ignorecase, %w{ -i --ignore-case }
+      add_opt_true optdata, :whole_lines, %w{ -x --line-regexp }
+      add_opt_true optdata, :extended, %w{ --extended }
+
+      optdata << expr_file_option = {
+        :tags => %w{ -f --file },
+        :arg  => [ :string ],
+        :set  => Proc.new { |fname| @expr = create_expression_factory.read_file fname }
+      }
+
+      add_opt_blk(optdata, %w{ -o -a }) do |md, opt, args|
+        args.unshift opt
+        @expr = create_expression_factory.make_expression args
+      end
+
+      optdata << text_color_option = {
+        :tags => %w{ --text-color },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @colors.text_colors = [ @colors.create_color("text-color", val) ] }
+      }
+
+      add_opt_true optdata, :extract_matches, %w{ -y --extract-matches }
+    end
+  end
+end

data/lib/glark/match/or.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/match/compound'
+
+# A collection of expressions, evaluated as 'or'.
+class OrExpression < CompoundExpression
+
+  def evaluate line, lnum, file, formatter
+    matched_ops = @ops.select do |op|
+      op.evaluate line, lnum, file, formatter
+    end
+
+    if is_match? matched_ops
+      lastmatch          = matched_ops[-1]
+      @last_start        = lastmatch.start_position
+      @last_end          = lastmatch.end_position
+      @match_line_number = lnum
+      
+      add_match lnum
+      true
+    else
+      false
+    end
+  end
+
+  def inspect
+    "(" + @ops.collect { |op| op.to_s }.join(" " + operator + " ") + ")"
+  end
+
+  def end_position
+    @last_end
+  end
+
+  def explain level = 0
+    str  = " " * level + criteria + ":\n"
+    str += @ops.collect { |op| op.explain(level + 4) }.join(" " * level + operator + "\n")
+    str
+  end  
+end

data/lib/glark/match/re.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/match/expression'
+require 'glark/util/highlight'
+
+# Applies a regular expression against a File.
+class RegexpExpression < Expression
+  include Highlight
+  
+  attr_reader :re
+
+  def initialize re, hlidx, text_colors = nil, extract_matches = false
+    @re = re
+
+    if @text_colors = text_colors
+      @hlidx = if @text_colors.length > 0
+                 hlidx % @text_colors.length
+               else
+                 0
+               end 
+    end    
+    @extract_matches = extract_matches
+    
+    super()
+  end
+
+  def == other
+    @re == other.re
+  end
+
+  def inspect
+    @re.inspect
+  end
+
+  def match? line
+    @re.match line
+  end
+
+  def evaluate line, lnum, file, formatter
+    md = match? line
+    return false unless md
+
+    if @extract_matches
+      if md.kind_of? MatchData
+        line.replace md[-1] + "\n"
+      else
+        warn "--not is incompatible with -v"
+      end
+    end
+    
+    @match_line_number = lnum
+
+    if @text_colors && @text_colors.size > 0
+      highlight_match lnum, file, formatter
+    end
+    
+    add_match lnum
+    true
+  end
+  
+  def explain level = 0
+    " " * level + to_s + "\n"
+  end
+
+  def highlight_match lnum, file, formatter
+    lnums = file.get_region lnum
+    return unless lnums
+
+    lnums.each do |ln|
+      str = formatter.formatted[ln] || file.get_line(ln)
+      formatter.formatted[ln] = str.gsub(@re) do |m|
+        lastcapts = Regexp.last_match.captures
+        # the index of the first non-nil capture:
+        miidx = (0 ... lastcapts.length).find { |mi| lastcapts[mi] } || @hlidx
+        adorn(@text_colors[miidx], m)
+      end
+    end
+  end
+end

data/lib/glark/match/re_factory.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# RegexpExpression factory.
+
+require 'rubygems'
+require 'riel/regexp'
+require 'glark/match/re'
+
+class RegexpExpressionFactory
+  include Loggable
+
+  attr_reader :count
+
+  def initialize exprspec
+    @count = 0
+    @extended = exprspec[:extended]
+    @extract_matches = exprspec[:extract_matches]
+    @ignorecase = exprspec[:ignorecase]
+    @text_colors = exprspec[:text_colors]
+    @wholelines = exprspec[:whole_lines]
+    @wholewords = exprspec[:whole_words]
+  end
+
+  def create_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)
+
+    re = RegexpExpression.new regex, @count, @text_colors, @extract_matches
+    @count += 1
+    re
+  end
+end

data/lib/glark/match/spec.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Options for matching.
+
+require 'rubygems'
+require 'riel/log'
+require 'glark/match/factory'
+require 'glark/util/colors/spec'
+
+module Glark
+  class MatchSpec
+    attr_accessor :expr           # the expression to be evaluated
+    attr_accessor :extended       # whether to use extended regular expressions
+    attr_accessor :extract_matches
+    attr_accessor :ignorecase     # match case
+    attr_accessor :whole_lines    # true means patterns must match the entire line
+    attr_accessor :whole_words    # true means all patterns are '\b'ed front and back
+
+    def initialize colors
+      @colors = colors
+      @expr = nil
+      @extended = false
+      @extract_matches = false
+      @ignorecase = false
+      @whole_lines = false
+      @whole_words = false
+    end
+    
+    def create_expression_factory
+      exprargs = Hash.new
+      exprargs[:extended] = @extended
+      exprargs[:extract_matches] = @extract_matches
+      exprargs[:ignorecase] = @ignorecase
+      exprargs[:text_colors] = text_colors
+      exprargs[:whole_lines] = @whole_lines
+      exprargs[:whole_words] = @whole_words
+      
+      ExpressionFactory.new exprargs
+    end
+    
+    def read_expression args, warn_option = false
+      @expr = create_expression_factory.make_expression args, warn_option
+    end
+
+    def text_colors
+      @colors.text_colors
+    end
+
+    def set_text_colors text_colors
+      @colors.text_colors = text_colors
+    end
+
+    def set_text_color index, text_color
+      @colors.text_colors[index] = text_color
+    end
+  end
+end

data/lib/glark/match/xor.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/match/or'
+
+# Evaluates the expressions, and is satisfied if only one returns true.
+class ExclusiveOrExpression < OrExpression
+  def is_match? matched_ops
+    return matched_ops.size == 1
+  end
+
+  def operator
+    "xor"
+  end
+
+  def criteria
+    "only one of"
+  end
+end

data/lib/glark/output/binary_file_summary.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/output/common'
+
+class BinaryFileSummary < Common
+  def display_matches?
+    false
+  end
+
+  def process_end lnum
+    if matched?
+      @out.puts "Binary file " + @file.fname.to_s + " matches"
+    end
+  end
+end

data/lib/glark/output/common.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Generic output.
+
+require 'glark/io/file/file'
+require 'glark/output/formatted'
+
+class Common < Formatted
+  def initialize file, spec
+    super()
+
+    @file = file
+    @invert_match = spec.invert_match
+    @label = spec.label
+    @match_limit = spec.match_limit
+    @out = spec.out
+    @show_file_name = spec.show_file_names
+    @show_line_numbers = spec.show_line_numbers
+  end
+
+  def display_matches?
+    true
+  end
+
+  def at_match_limit?
+    @match_limit && @count >= @match_limit
+  end
+
+  def displayed_name
+    @label || @file.fname
+  end
+
+  def add_match startline, endline
+    super()
+  end
+
+  def process_match startline, endline, fromline, toline
+    add_match startline, endline
+    return at_match_limit?
+  end
+end

data/lib/glark/output/context.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Glark
+  class Context
+    attr_accessor :after
+    attr_accessor :before
+
+    def initialize 
+      @after = 0
+      @before = 0
+    end
+
+    def clear
+      @after = 0
+      @before = 0
+    end
+
+    def update_fields fields
+      fields.each do |name, values|
+        case name
+        when 'context'
+          @after = @before = values.last.to_i
+        when 'after', 'after-context'
+          @after = values.last.to_i
+        when 'before', 'before-context'
+          @before = values.last.to_i 
+        end
+      end
+    end
+
+    def add_as_option optdata
+      optdata << context_option = {
+        :tags => %w{ -C --context },
+        :res  => %r{ ^ - ([1-9]\d*) $ }x,
+        :arg  => [ :optional, :integer ],
+        :set  => Proc.new { |val, opt, args| @after = @before = val || 2 },
+        :rc   => %w{ context },
+      }
+
+      optdata << context_after_option = {
+        :tags => %w{ --after-context -A },
+        :arg  => [ :integer ],
+        :set  => Proc.new { |val| @after = val },
+        :rc   => %w{ after-context },
+      }
+
+      optdata << context_before_option = {
+        :tags => %w{ --before-context -B },
+        :arg  => [ :integer ],
+        :set  => Proc.new { |val| @before = val },
+        :rc   => %w{ before-context },
+      }
+    end
+  end
+end
+