glark 1.9.0 → 1.10.0

data/lib/glark/input/options.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Options for input.
+
+require 'rubygems'
+require 'glark/input/spec'
+require 'glark/util/io/fileset'
+require 'glark/util/options'
+
+module Glark
+  class InputOptions < InputSpec
+    include OptionUtil, Loggable
+    
+    def initialize optdata
+      super()
+      add_as_options optdata
+    end
+
+    def create_fileset files
+      fsargs = Hash.new
+      fsargs[:max_depth] = @max_depth
+      fsargs[:binary_files] = @binary_files
+      fsargs[:dir_criteria] = @dir_criteria
+      fsargs[:file_criteria] = @file_criteria
+      fsargs[:split_as_path] = @split_as_path
+      
+      FileSet.new files, fsargs
+    end
+
+    def set_record_separator sep
+      $/ = if sep && sep.to_i > 0
+             begin
+               sep.oct.chr
+             rescue RangeError => e
+               # out of range (e.g., 777) means nil:
+               nil
+             end
+           else
+             "\n\n"
+           end
+    end
+
+    def config_fields
+      fields = {
+        "binary-files" => binary_files,
+        "split-as-path" => @split_as_path,
+      }
+      fields.merge! @dir_criteria.config_fields
+      fields.merge! @file_criteria.config_fields
+    end
+
+    def dump_fields
+      fields = {
+        "binary_files" => binary_files,
+        "directory" => @directory,
+        "exclude_matching" => @exclude_matching,
+        "split-as-path" => @split_as_path,
+      }
+      fields.merge! @dir_criteria.dump_fields
+      fields.merge! @file_criteria.dump_fields
+      fields
+    end
+
+    def update_fields fields
+      @dir_criteria.update_fields fields
+      @file_criteria.update_fields fields
+
+      fields.each do |name, value|
+        case name
+        when 'split-as-path'
+          @split_as_path = to_boolean value
+        end
+      end
+    end
+
+    def set_directory val
+      @max_depth = val == 'list' ? 0 : nil
+      @dir_criteria.skip_all = val == 'skip'
+      # otherwise, it's recurse
+    end
+    
+    def add_as_options optdata    
+      optdata << record_separator_option = {
+        :res => [ Regexp.new('^ -0 (\d{1,3})? $ ', Regexp::EXTENDED) ],
+        :set => Proc.new { |md| rs = md ? md[1] : 0; set_record_separator rs }
+      }
+
+      @range.add_as_option optdata
+
+      optdata << recurse_option = {
+        :tags => %w{ -r --recurse },
+        :set  => Proc.new { set_directory("recurse") }
+      }
+
+      optdata << directories_option = {
+        :tags => %w{ --directories -d },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| set_directory val },
+      }
+
+      re = Regexp.new '^[\'\"]?(' + VALID_BINARY_FILE_TYPES.join('|') + ')[\'\"]?$'
+      optdata << binary_files_option = {
+        :tags => %w{ --binary-files },
+        :arg  => [ :required, :regexp, re ],
+        :set  => Proc.new { |md| @binary_files = md[1] },
+        :rc   => %w{ binary-files },
+      }
+      
+      @file_criteria.add_as_options optdata
+      @dir_criteria.add_as_options optdata
+
+      add_opt_true optdata, :exclude_matching, %w{ -M --exclude-matching }
+
+      add_opt_false optdata, :split_as_path, %w{ --no-split-as-path }
+      add_opt_true optdata, :split_as_path, %w{ --split-as-path }
+    end
+  end
+end

data/lib/glark/input/range.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Glark
+  class RangeError < RuntimeError
+  end
+
+  class Range
+    include Loggable, Comparable
+
+    PCT_RE = Regexp.new '([\.\d]+)%'
+    
+    attr_accessor :from
+    attr_accessor :to
+
+    def initialize from = nil, to = nil
+      @from = from
+      @to = to
+    end
+
+    def bound?
+      @from.nil? && @to.nil?
+    end
+
+    def to_line var, linecount
+      return nil unless var
+
+      if pct = as_pct(var) 
+        count = linecount
+        count * pct.to_f / 100
+      else
+        var.to_f
+      end
+    end
+
+    def as_pct val
+      (md = PCT_RE.match(val)) && md[1]
+    end
+
+    def validate!
+      return true if @from.nil? || @to.nil?
+
+      frompct, topct = [ @from, @to ].collect { |val| as_pct val }
+
+      # both or neither are percentages:
+      return true if frompct.nil? != topct.nil?
+      
+      if frompct
+        check_range! frompct, topct
+      else
+        check_range! @from, @to
+      end
+      true
+    end
+
+    def check_range! from, to
+      if from.to_f > to.to_f
+        raise RangeError.new "error: range start (#{@from}) follows range end (#{@to})"
+      end
+    end
+
+    # there is no nil <=> nil in Ruby
+    def compare x, y
+      x.nil? && y.nil? ? nil : (x <=> y).nonzero?
+    end
+
+    def <=> other
+      compare(from, other.from) || compare(to, other.to) || 0
+    end
+
+    def clear
+      @from = nil
+      @to = nil
+    end
+
+    def add_as_option optdata
+      optdata << range_after_option = {
+        :tags    => %w{ --after },
+        :arg     => [ :required, :regexp, %r{ (\d+%?) $ }x ],
+        :set     => Proc.new { |md| @from = md[1] }
+      }
+
+      optdata << range_before_option = { 
+        :tags    => %w{ --before },
+        :arg     => [ :required, :regexp, %r{ (\d+%?) $ }x ],
+        :set     => Proc.new { |md| @to = md[1] }
+      }
+
+      optdata << range_option = {
+        :tags     => %w{ -R --range },
+        :arg      => [ :required, :regexp, Regexp.new('(\d+%?),(\d+%?)') ],
+        :set      => Proc.new do |md, opt, args|
+          if md && md[1] && md[2]
+            @from = md[1]
+            @to = md[2]
+          else
+            @from = args.shift
+            @to = args.shift
+          end
+        end
+      }
+    end
+  end
+end

data/lib/glark/input/spec.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/input/range'
+require 'glark/input/filter/dir_criteria_opts'
+require 'glark/input/filter/file_criteria_opts'
+
+module Glark
+  class InputSpec  
+    VALID_BINARY_FILE_TYPES = [ 'text', 'without-match', 'skip', 'binary', 'list', 'decompress', 'read' ]
+
+    attr_accessor :binary_files     # how to handle binary files
+    attr_accessor :directory        # read, skip, or recurse, a la grep
+    attr_accessor :exclude_matching # exclude files whose names match the expression
+    attr_accessor :range            # range to start and stop searching; nil => the entire file
+    attr_accessor :split_as_path    # use file arguments as path elements
+
+    attr_accessor :dir_criteria
+    attr_accessor :file_criteria
+    attr_accessor :max_depth    
+
+    def initialize
+      @binary_files = 'skip'
+      @directory = 'list'
+      @exclude_matching = false
+
+      @range = Range.new
+      @split_as_path = true
+      
+      @file_criteria = FileCriteriaOpts.new
+      @dir_criteria = DirCriteriaOpts.new nil
+
+      @max_depth = 0            # list directories
+
+      $/ = "\n"
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'glark/io/file/file'
+
+module Glark
+  class ArchiveFile
+    def initialize fname, range
+      @fname = fname
+      @range = range
+    end
+
+    def search_list expr, output_cls, output_opts
+      contents = StringIO.new list.collect { |x| x + "\n" }.join('')
+      contents.rewind
+
+      file = Glark::File.new @fname, contents, @range
+      output_type = output_cls.new file, output_opts
+      file.search expr, output_type
+    end
+
+    def list
+      contents = Array.new
+      each do |entry|
+        contents << entry_name(entry)
+      end
+      contents
+    end
+
+    def each &blk
+      reader = get_reader
+      reader.each do |entry|
+        blk.call entry
+      end
+      reader.close
+    end
+
+    def search_archive_file expr, entry, output_type_cls, output_opts
+      name = entry_name entry
+      data = read entry
+      contents = StringIO.new data
+      
+      file = Glark::File.new name + " (in #{@fname})", contents, @range
+      output = output_type_cls.new file, output_opts
+      file.search expr, output
+    end
+
+    def read entry
+      entry.read
+    end
+
+    def search expr, output_type_cls, output_opts
+      matched = nil
+      each do |entry|
+        # a glitch with zlib doesn't seem to recognize some tarball entries
+        # (with entry.header.typeflag == "") as being a file, so we test for
+        # directory:
+        next if entry.directory?
+        matched = search_archive_file(expr, entry, output_type_cls, output_opts) || matched
+      end
+      matched
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'glark/io/file/file'
+
+module Glark
+  class BinaryFile < Glark::File
+    def initialize fname
+      file = ::File.new fname
+      file.binmode            # for MSDOS/WinWhatever
+      super fname, file, nil
+    end
+
+    def search_as_binary expr, output_opts
+      output_type = BinaryFileSummary.new self, output_opts
+      search expr, output_type
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/util/io/lines'
+
+module Glark
+  # A thing that can be grepped (er, glarked).
+  class File
+    attr_reader :fname
+    
+    def initialize fname, io, range
+      @fname = fname
+      @range = range
+
+      linescls = $/ == "\n" ? Glark::IO::LinesCR : Glark::IO::LinesNonCR
+      @lines = linescls.new fname, io
+    end
+    
+    def linecount
+      @lines.count
+    end
+
+    def each_line &blk
+      @lines.each_line(&blk)
+    end
+
+    # Returns the lines for this file, separated by end of line sequences.
+    def get_lines
+      @lines.get_lines
+    end
+    
+    # Returns the given line for this file. For this method, a line ends with a
+    # CR, as opposed to the "lines" method, which ends with $/.
+    def get_line lnum
+      @lines.get_line lnum
+    end
+
+    # Returns the region/range that is represented by the region number.
+    def get_region rnum
+      @lines.get_region rnum
+    end
+
+    def get_range_start
+      @range && @range.from && @range.to_line(@range.from, linecount)
+    end
+
+    def get_range_end
+      @range && @range.to && @range.to_line(@range.to, linecount)
+    end
+
+    def search expr, output
+      expr.process self, output
+      output.matched?
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'glark/io/file/file'
+require 'zlib'
+
+module Glark
+  class GzFile < Glark::File
+    def initialize fname, range, &blk
+      if blk
+        Zlib::GzipReader.open(fname) do |gz|
+          super fname, gz, range
+          blk.call [ self, gz ]
+        end
+      else
+        gz = Zlib::GzipReader.new fname
+        super fname, gz, range
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'glark/io/file/file'
+require 'glark/io/file/archive_file'
+
+module Glark
+  class TarFile < ArchiveFile
+    def initialize fname, range, io = nil, &blk
+      super fname, range
+
+      # 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.
+      
+      # module Gem::Package is declared in 'rubygems/package', not in
+      # .../tar_reader.
+      require 'rubygems/package'
+      require 'rubygems/package/tar_reader'
+      @io = io
+    end
+
+    def get_reader 
+      io = @io || ::File.new(@fname)
+      Gem::Package::TarReader.new io
+    end
+
+    def entry_name entry
+      entry.full_name
+    end
+
+    def read entry
+      entry.read
+    end
+  end
+end