glark 1.9.0 → 1.10.0

data/lib/glark/output.rb

@@ -1,266 +0,0 @@
-#!/usr/bin/ruby -w
-#!ruby -w
-# vim: set filetype=ruby : set sw=2
-
-# Glark output.
-
-require 'English'
-
-require 'rubygems'
-require 'riel'
-
-require 'glark/options'
-require 'glark/input'
-
-class Results
-  include Loggable
-  
-end
-
-class OutputFormat < Results
-
-  attr_reader :formatted, :infile, :show_file_name, :has_context
-
-  def initialize(infile, show_file_names)
-    @infile            = infile
-    @show_file_name    = show_file_names
-    @formatted         = []
-    @has_context       = false
-
-    opts               = GlarkOptions.instance
-
-    @label             = opts.label
-    @out               = opts.out
-    @show_break        = opts.show_break
-    @show_line_numbers = opts.show_line_numbers
-  end
-
-  # Prints the line, which is assumed to be 0-indexed, and is thus adjusted by
-  # one.
-  def print_line_number(lnum)
-    @out.printf "%5d ", lnum + 1
-  end
-
-  # prints the line, and adjusts for the fact that in our world, lines are
-  # 0-indexed, whereas they are displayed as if 1-indexed.
-  def print_line(lnum, ch = nil)
-    log { "lnum #{lnum}, ch: '#{ch}'" }
-    begin
-      lnums = @infile.get_range(lnum)
-      log { "lnums(#{lnum}): #{lnums}" }
-      if lnums
-        lnums.each do |ln|
-          if show_line_numbers
-            print_line_number(ln)
-            if ch && has_context
-              @out.printf "%s ", ch
-            end
-          end
-          line = @formatted[ln] || @infile.get_line(ln)
-          @out.puts line
-        end
-      end
-    rescue => e
-      # puts e
-      # puts e.backtrace
-    end
-  end
-
-  def write_matches(matching, from, to)
-    if @infile.count
-      write_count(matching)
-    elsif matching
-      firstline = from ? from : 0
-      lastline  = to   ? to   : @infile.get_lines.length - 1
-
-      (firstline .. lastline).each do |ln|
-        if @infile.stati[ln]
-          unless @infile.stati[ln] == InputFile::WRITTEN
-            if firstline > 0 && !@infile.stati[ln - 1] && has_context && @show_break
-              @out.puts "  ---"
-            end
-            
-            print_line(ln, @infile.stati[ln]) 
-
-            @infile.stati[ln] = InputFile::WRITTEN
-          end
-        end
-
-      end
-    else
-      firstline = from ? from : 0
-      lastline  = to ? to : @infile.get_lines.length - 1
-      (firstline .. lastline).each do |ln|
-        if @infile.stati[ln] != InputFile::WRITTEN && @infile.stati[ln] != ":"
-          log { "printing #{ln}" }
-          print_line(ln)
-          @infile.stati[ln] = InputFile::WRITTEN
-        end
-      end
-    end
-  end
-
-  def write_all
-    (0 ... @infile.get_lines.length).each do |ln|
-      print_line(ln) 
-    end
-  end
-
-  def get_line_to_print(lnum)
-    formatted[lnum] || infile.get_line(lnum)
-  end
-
-  def show_line_numbers
-    @show_line_numbers
-  end
-
-end
-
-
-# -------------------------------------------------------
-# Glark output format
-# -------------------------------------------------------
-
-class GlarkOutputFormat < OutputFormat
-
-  def initialize(infile, show_file_names)
-    super
-
-    opts = GlarkOptions.instance
-
-    @has_context = opts.after != 0 || opts.before != 0
-    @file_header_shown = false
-    if @highlight = opts.highlight
-      @fname_highlighter = opts.file_highlight
-    end
-    @lnum_highlighter = opts.line_number_highlight
-  end
-
-  # prints the line, and adjusts for the fact that in our world, lines are
-  # 0-indexed, whereas they are displayed as if 1-indexed.
-  def print_line(lnum, ch = nil)
-    log { "lnum #{lnum}, ch: '#{ch}'" }
-    begin
-      lnums = @infile.get_range(lnum)
-      log { "lnums(#{lnum}): #{lnums}" }
-      if lnums
-        log { "printing" }
-        lnums.each do |ln|
-          println(ln, ch)
-        end
-      end
-    rescue => e
-      # puts e
-      # puts e.backtrace
-    end
-  end
-
-  def show_file_header
-    if show_file_name && !@file_header_shown
-      fname = @label || @infile.fname
-      fname = @fname_highlighter.highlight(fname) if @highlight
-      
-      @out.puts fname
-    end
-    @file_header_shown = true
-  end
-
-  def print_line_number(lnum)
-    if @lnum_highlighter
-      lnumstr = (lnum + 1).to_s
-      pad = " " * ([5 - lnumstr.length, 0].max)
-      @out.print pad + " " + @lnum_highlighter.highlight(lnumstr) + " "
-    else
-      super
-    end
-  end
- 
-  def write_count(matching = true)
-    ct = matching ? @infile.count : @infile.get_lines.size - @infile.count
-    @out.puts "    " + ct.to_s
-  end
-
-  def write_matches(matching, from = nil, to = nil)
-    show_file_header
-    super(matching, from, to)
-  end
-
-  def write_all
-    show_file_header
-    super
-  end
-
-  def println(ln, ch)
-    if show_line_numbers
-      print_line_number(ln)
-    end
-    
-    if ch && has_context
-      @out.printf "%s ", ch
-    end
-
-    line = get_line_to_print(ln)
-    log { "line: #{line}" }
-    
-    @out.puts line
-  end
-
-end
-
-
-class GlarkMatchList < GlarkOutputFormat
-  attr_reader :matches
-
-  def initialize(infile, show_file_names)
-    super
-    @matches = Array.new
-  end
-
-  def write_matches(matching, from, to)
-    stack "matching: #{matching}"
-    from.upto(to) do |line|
-      @matches[line] = true
-    end
-    log { "matches: #{@matches}" }
-  end
-
-end
-
-
-# -------------------------------------------------------
-# Grep output format
-# -------------------------------------------------------
-
-# This matches grep, mostly. It is for running within emacs, thus,
-# it does not support context or highlighting.
-class GrepOutputFormat < OutputFormat
-
-  def write_count(matching = true)
-    print_file_name
-    ct = matching ? @infile.count : @infile.get_lines.length - @infile.count
-    puts ct
-  end
-
-  # prints the line, and adjusts for the fact that in our world, lines are
-  # 0-indexed, whereas they are displayed as if 1-indexed.
-  def print_line(lnum, ch = nil)
-    ln = get_line_to_print(lnum)
-
-    if ln
-      print_file_name
-      if show_line_numbers
-        printf "%d: ", lnum + 1
-      end
-      
-      print ln
-    end
-  end
-
-  def print_file_name
-    if show_file_name
-      fname = @label || @infile.fname
-      print @infile.fname, ":"
-    end
-  end
-
-end

data/test/lib/glark/glark_test.rb

@@ -1,317 +0,0 @@
-#!/usr/bin/ruby -w
-# -*- ruby -*-
-
-require 'pathname'
-
-testdir = Pathname.new(__FILE__).expand_path.dirname.to_s
-$:.unshift testdir
-
-require 'testcase'
-require 'stringio'
-
-class TC_Glark < GlarkTestCase
-
-  def do_search_test(exprargs, contents, expected)
-    opts = GlarkOptions.instance
-    
-    # Egads, Ruby is fun. Converting a maybe-array into a definite one:
-    args = [ exprargs ].flatten
-
-    expr = ExpressionFactory.new.make_expression(args)
-
-    outfname = infname = nil
-
-    begin
-      outfname = create_file do |outfile|
-        opts.out = outfile
-        infname = write_file(contents)
-
-        files = [ infname ]
-        glark = Glark.new(expr, files)
-        glark.search(infname)
-      end
-
-      do_file_test(outfname, expected)
-    ensure
-      [ outfname, infname ].each do |fname|
-        if fname && File.exists?(fname)
-          File.delete(fname) 
-        end
-      end
-      GlarkOptions.instance.reset
-    end
-  end
-
-  def test_match_invert
-    contents = [
-      "ABC",
-      "DEF",
-      "GHI",
-      "JKL",
-      "MNO",
-      "PQR",
-      "STU",
-    ]
-
-    exprstr = "K"
-
-    expected = contents.collect_with_index do |line, idx|
-      if !line.index(exprstr)
-        sprintf("%5d %s", idx + 1, line)
-      end
-    end.compact
-
-    Log.verbose = false
-    
-    opts = GlarkOptions.instance
-    opts.invert_match = true
-    opts.verbose = false
-    Log.verbose = false
-
-    do_search_test(exprstr, contents, expected)
-  end
-
-  def do_match_test(contents, patterns, regexp, exprargs)
-    defcolors = Text::ANSIHighlighter::DEFAULT_COLORS
-
-    patdata = patterns.collect_with_index do |pat, pidx|
-      color = Text::ANSIHighlighter.make(defcolors[pidx % defcolors.length])
-      [ pat, color ]
-    end
-
-    expected = contents.collect_with_index do |line, li|
-      if line.index(regexp)
-        ln = line.dup
-        patdata.each do |pat|
-          ln.gsub!(pat[0]) { pat[1].highlight(pat[0]) }
-        end
-        sprintf("%5d %s", li + 1, ln)
-      else
-        nil
-      end
-    end.compact
-
-    # Log.verbose = false
-    
-    opts = GlarkOptions.instance
-    opts.verbose = Log.verbose = false
-
-    do_search_test(exprargs, contents, expected)
-  end
-
-  def test_match_plain_old_match
-    contents = [
-      "ABC",
-      "DEF",
-      "GHI",
-      "JKL",
-      "MNO",
-      "PQR",
-      "STU",
-    ]
-    
-    do_match_test(contents, %w{K}, %r{K}, "K")
-    do_match_test(contents, %w{A}, %r{A}, "A")
-  end
-
-  def test_match_regexp_or
-    contents = [
-      "ABC",
-      "DEF",
-      "GHI",
-      "JKL",
-      "MNO",
-      "PQR",
-      "STU",
-    ]
-    
-    do_match_test(contents, %w{K N}, %r{(K)|(N)}, '(K)|(N)')
-  end
-
-  def do_test_match_alteration
-    patternsets = [
-      %w{ nul },
-      %w{ oo ae z },
-      %w{ zoo },
-      %w{ zeff },
-    ]
-
-    contents = [
-      "zaffres",
-      "zoaea",
-      "zoaea's",
-      "zoea",
-      "zoeas",
-      "zonulae",
-      "zooea",
-      "zooeae",
-      "zooeal",
-      "zooeas",
-      "zooecia",
-      "zooecium",
-      "zoogloeae",
-      "zoogloeal",
-      "zoogloeas",
-      "zygaenid",
-    ]
-
-    patternsets.each do |patterns|
-      regexp   = Regexp.new(patterns.collect { |x| "(#{x})" }.join('|'))
-      exprargs = yield patterns
-
-      do_match_test(contents, patterns, regexp, exprargs)
-    end
-  end
-
-  def test_match_multicolor_alt_regexp
-    do_test_match_alteration do |patterns|
-      patterns.collect { |x| "(#{x})" }.join('|')
-    end
-  end
-
-  def test_match_multicolor_or_expression
-    do_test_match_alteration do |patterns|
-      exprargs = [ patterns[-1] ]
-      patterns.reverse[1 .. -1].each do |pat|
-        exprargs.insert(0, "--or", pat)
-      end
-      exprargs
-    end
-  end
-
-  def do_test_match_and_expression(contents, matches, patterns, exprargs)
-    regexp   = Regexp.new(patterns.collect { |x| "(#{x})" }.join('|'))
-
-    defcolors = Text::ANSIHighlighter::DEFAULT_COLORS
-
-    patdata = patterns.collect_with_index do |pat, pidx|
-      color = Text::ANSIHighlighter.make(defcolors[pidx % defcolors.length])
-      [ pat, color ]
-    end
-
-    expected = contents.collect_with_index do |line, li|
-      if matches.include?(line)
-        ln = line.dup
-        patdata.each do |pat|
-          ln.gsub!(pat[0]) { pat[1].highlight(pat[0]) }
-        end
-        sprintf("%5d %s", li + 1, ln)
-      else
-        nil
-      end
-    end.compact
-
-    if false
-      for line in expected
-        $stderr.puts line
-      end
-    end
-
-    Log.verbose = false
-    opts = GlarkOptions.instance
-    opts.verbose = Log.verbose = false
-
-    do_search_test(exprargs, contents, expected)
-  end
-
-  def test_match_and_expression_2_lines_apart
-    contents = [
-      "zaffres",
-      "zoaea",
-      "zoaea's",
-      "zoea",
-      "zoeas",
-      "zonulae",
-      "zooea",
-      "zooeae",
-      "zooeal",
-      "zooeas",
-      "zooecia",
-      "zooecium",
-      "zoogloeae",
-      "zoogloeal",
-      "zoogloeas",
-      "zygaenid",
-    ]
-
-    # 'ea', 'ec' within 2 lines of each other:
-    matches = [
-      "zooeal",
-      "zooeas",
-      "zooecia",
-      "zooecium",
-      "zoogloeae",
-      "zoogloeal",
-    ]
-
-    patterns = %w{ ea ec }
-    
-    exprargs = [ "--and", "2" ] | patterns
-
-    do_test_match_and_expression(contents, matches, patterns, exprargs)
-  end
-
-  def test_match_and_expression_3_lines_apart
-    contents = [
-      "zaffres",
-      "zoaea",
-      "zoaea's",
-      "zoea",
-      "zoeas",
-      "zonulae",
-      "zooea",
-      "zooeae",
-      "zooeal",
-      "zooeas",
-      "zooecia",
-      "zooecium",
-      "zoogloeae",
-      "zoogloeal",
-      "zoogloeas",
-      "zygaenid",
-    ]
-
-    matches = [
-      "zoaea's",
-      "zoea",
-      "zoeas",
-      "zonulae",
-    ]
-
-    patterns = %w{ aea ula }
-    
-    exprargs = [ "--and", "3" ] | patterns
-
-    do_test_match_and_expression(contents, matches, patterns, exprargs)
-  end
-
-  def test_match_and_expression_entire_file
-    contents = [
-      "zaffres",
-      "zoaea",
-      "zoaea's",
-      "zoea",
-      "zoeas",
-      "zonulae",
-      "zooea",
-      "zooeae",
-      "zooeal",
-      "zooeas",
-      "zooecia",
-      "zooecium",
-      "zoogloeae",
-      "zoogloeal",
-      "zoogloeas",
-      "zygaenid",
-    ]
-
-    matches = contents
-
-    patterns = %w{ aff yga }
-    
-    exprargs = [ "--and", "-1" ] | patterns
-
-    do_test_match_and_expression(contents, matches, patterns, exprargs)
-  end
-
-end