glark 1.9.0 → 1.10.0

data/lib/glark/util/highlight.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+$rielold = false
+
+require 'rubygems'
+require 'rainbow'
+require 'singleton'
+
+if $rielold
+  require 'riel/ansicolor'
+else
+  require 'riel/text/ansi/ansi_highlight'
+end
+
+module Highlight
+  RESET = "\x1b[0m"
+  
+  def adorn hl, str
+    if $rielold
+      hl.highlight str
+    else
+      hl + str + RESET
+    end
+  end
+end
+
+module Sickill
+  module Rainbow
+    class AnsiColor
+      $-w = false
+      # includes the aberrant color name in the error message.
+      def validate_color_name #:nodoc:
+        color_names = TERM_COLORS.keys
+
+        unless color_names.include?(@color)
+          raise ArgumentError.new "Unknown color name: '#{@color}'; valid names: #{color_names.join(', ')}"
+        end
+      end
+      $-w = true
+    end
+  end
+end
+
+class RainbowHighlighter
+  include Singleton
+
+  COLORS      = %w{ black red green yellow blue magenta cyan white [\dA-Fa-f]{6} }
+  DECORATIONS = %w{ none reset bold underscore underline blink reverse inverse negative concealed }
+
+  BACKGROUND_COLORS = COLORS.collect { |color| "on_#{color}" }
+  FOREGROUND_COLORS = COLORS
+  
+  COLORS_RE = Regexp.new('(?: ' + 
+                         # background will be in capture 0
+                         'on(?:\s+|_) ( ' + COLORS.join(' | ') + ' ) | ' +
+                         # foreground will be in capture 1
+                         '( ' + (COLORS + DECORATIONS).join(' | ') + ' ) ' +
+                         ')', Regexp::EXTENDED)
+
+  def get_code color, type
+    case color
+    when 'bold', 'bright'
+      Sickill::Rainbow::TERM_EFFECTS[:bright]
+    when 'reverse', 'negative', 'inverse'
+      Sickill::Rainbow::TERM_EFFECTS[:inverse]
+    when 'underline'
+      Sickill::Rainbow::TERM_EFFECTS[:underline]
+    when 'blink'
+      Sickill::Rainbow::TERM_EFFECTS[:blink]
+    when %r{^[\dA-Fa-f]{6}$}
+      ac = Sickill::Rainbow::AnsiColor.new type, color
+      ac.code
+    else
+      ac = Sickill::Rainbow::AnsiColor.new type, color.to_sym
+      ac.code
+    end
+  end
+
+  def to_codes color
+    codes = ""
+    return codes unless Sickill::Rainbow.enabled
+    color.scan(COLORS_RE).collect do |md|
+      color, type = md[0] ? [ md[0], :background ] : [ md[1], :foreground ]
+      code = get_code color, type
+      "\e[#{code}m"
+    end.join ''
+  end
+end
+
+class HlWrapper
+  def initialize
+    # @hl = $rielold ? Text::ANSIHighlighter : Text::ANSIHighlighter.instance
+    @hl = RainbowHighlighter.instance
+  end
+  
+  def make_color color
+    if $rielold
+      result = @hl.make color
+    else
+      @hl.to_codes color
+    end
+  end
+  
+  def make_rgb_color red, green, blue, fgbg
+    @hl.instance.to_rgb_code red, green, blue, fgbg
+  end
+end

data/lib/glark/util/io/depth.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+module Glark
+  # Depth for recursing directories.
+  class Depth
+    INFINITY = :infinity
+
+    attr_reader :value
+    
+    def initialize value
+      @value = value
+    end
+
+    def infinity?
+      @value == INFINITY
+    end
+
+    def - num
+      return self if infinity? || @value.nil?
+      self.class.new @value - 1
+    end
+
+    def nonzero?
+      infinity? || @value.nil? || @value >= 0
+    end
+  end
+end

data/lib/glark/util/io/fileset.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'rubygems'
+require 'glark/util/io/depth'
+require 'riel/filetype'
+
+module Glark
+  # Files and directories. And standard input, just for fun.
+  class FileSet
+    include Loggable, Enumerable
+
+    attr_reader :files
+
+    DEPTH_RE = Regexp.new '\.\.\.(\d*)$'
+    
+    def initialize fnames, args
+      @max_depth = Depth.new args[:max_depth]
+      @binary_files = args[:binary_files] || 'skip'
+      @dir_criteria = args[:dir_criteria]
+      @file_criteria = args[:file_criteria]
+      @split_as_path = args[:split_as_path]
+
+      @dir_to_max_depth = Hash.new
+      @files = Array.new
+      
+      if fnames.size == 0
+        @files << '-'
+      else
+        add_files fnames
+      end
+    end
+
+    def size
+      @files.size
+    end
+
+    def add_files fnames
+      fnames.each do |fname|
+        if @split_as_path
+          add_as_path fname
+        else
+          add_fd fname
+        end
+      end      
+    end
+
+    # this is a path in the form /usr/bin:/home/me/projects
+    def add_as_path path
+      path.to_s.split(::File::PATH_SEPARATOR).each do |element|
+        add_fd element
+      end
+    end
+
+    def add_fd fname
+      pn = nil
+
+      if md = DEPTH_RE.match(fname)
+        val = md[1].empty? ? nil : md[1].to_i
+        fname.sub! DEPTH_RE, ''
+        fname = '.' if fname.empty?
+        pn = Pathname.new fname
+        @dir_to_max_depth[pn] = Depth.new val
+      else
+        pn = Pathname.new fname
+      end
+
+      return if pn.file? && @file_criteria.skipped?(pn)
+      @files << pn
+    end
+
+    def stdin?
+      @files.size == 1 && @files.first == '-'
+    end
+
+    def each &blk
+      # to keep from cycling through links:
+      @yielded_files = Array.new
+
+      (0 ... @files.size).each do |idx|
+        pn = @files[idx]
+        type = FileType.type pn.to_s
+        
+        if stdin?
+          blk.call [ :text, '-' ]
+          next
+        end
+        
+        unless pn.readable?
+          write "directory not readable: #{pn}"
+          next
+        end
+        
+        dirmax = @dir_to_max_depth[pn] || @max_depth
+        handle_pathname pn, dirmax, &blk
+      end
+    end
+
+    def handle_pathname pn, depth, &blk
+      if pn.directory?
+        handle_directory pn, depth, &blk
+      elsif pn.file?
+        handle_file pn, &blk
+      else
+        write "unknown file type: #{pn}"
+      end
+    end
+
+    def handle_directory pn, depth, &blk
+      return if @dir_criteria.skipped? pn, depth
+
+      subdepth = depth - 1
+
+      pn.children.sort.each do |entry|
+        next if @yielded_files.include?(entry)
+        if entry.file?
+          type = FileType.type entry.to_s
+          next if type == FileType::BINARY && @binary_files == 'skip'
+        end
+        @yielded_files << entry
+        handle_pathname entry, subdepth, &blk
+      end
+    end
+
+    def handle_file pn, &blk
+      return if @file_criteria.skipped? pn
+
+      type = FileType.type pn.to_s
+      case type
+      when FileType::TEXT
+        handle_text pn, &blk
+      when FileType::BINARY
+        handle_binary pn, &blk
+      when FileType::NONE
+        write "no such file: #{pn}"
+      when FileType::UNKNOWN
+        write "unknown file type: #{pn}"
+      end
+    end
+
+    def handle_text pn, &blk
+      blk.call [ :text, pn ]
+    end
+
+    def handle_binary pn, &blk
+      type = case @binary_files
+             when 'binary'
+               :binary
+             when 'skip', 'without-match'
+               return
+             when 'decompress', 'read'
+               :read
+             when 'list'
+               :list
+             else
+               :text
+             end
+      blk.call [ type, pn ]
+    end
+  end
+end

data/lib/glark/util/io/filter/criteria.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+require 'glark/util/io/filter/filter'
+
+module Glark
+  class Criteria
+    include Loggable
+
+    def initialize
+      # by type (hash) => by positive/negative (hash) => filter list (array)
+      @type_to_posneg = Hash.new
+    end
+
+    def add type, posneg, filter
+      posneg_to_filters = (@type_to_posneg[type] ||= Hash.new)
+      filters = (posneg_to_filters[posneg] ||= Array.new)
+      filters << filter
+    end
+
+    def get type, posneg
+      return nil unless posneg_to_filters = @type_to_posneg[type]
+      posneg_to_filters[posneg]
+    end
+
+    def find_by_class type, posneg, cls
+      return unless filters = get(type, posneg)
+      filters.detect { |filter| filter.kind_of? cls }
+    end
+    
+    def skipped? pn
+      !match? pn
+    end
+
+    def match? pn
+      @type_to_posneg.values.each do |typefilters|
+        if (posf = typefilters[:positive]) && !posf.empty?
+          return false unless posf.detect { |fl| fl.match? pn }
+        end
+
+        if (negf = typefilters[:negative]) && !negf.empty?
+          return false if negf.detect { |fl| fl.match? pn }
+        end
+      end
+      true
+    end
+  end
+end

data/lib/glark/util/io/filter/filter.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+module Glark
+  class Filter
+    def match? pn
+    end
+  end
+end

data/lib/glark/util/io/lines.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+module Glark
+  module IO
+    # Lines of input. Handles non-default ("\n") record separator.
+    class Lines
+      def initialize fname
+        @fname = fname
+        @count = nil
+      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
+        get_lines[lnum]
+      end
+
+      # this reads the entire file and returns the number of lines
+      def count
+        unless @count
+          @count = ::IO::readlines(@fname).size
+        end
+        @count
+      end
+    end
+
+    class LinesCR < Lines
+      def initialize fname, io
+        super fname
+        @lines = Array.new
+        @io = io
+      end
+
+      # Returns the lines for this file, separated by end of line sequences.
+      def get_lines
+        return @lines
+      end
+
+      def each_line &blk
+        while (line = @io.gets) && line.length > 0
+          @lines << line
+          blk.call line
+        end
+        @io.close
+      end
+
+      def get_region rnum
+        # easy case: range is the range number, unless it is out of range.
+        return rnum < @lines.length ? (rnum .. rnum) : nil
+      end
+    end
+
+    class LinesNonCR < Lines
+      # cross-platform end of line:   DOS  UNIX  MAC
+      ANY_END_OF_LINE = Regexp.new '(?:\r\n|\n|\r)'
+      
+      def initialize fname, io
+        super fname
+        @extracted = nil
+        @regions = nil
+        @lines = ::IO::readlines fname
+      end
+
+      def each_line &blk
+        @lines.each do |line|
+          blk.call line
+        end
+      end
+      
+      # Returns the lines for this file, separated by end of line sequences.
+      def get_lines
+        @extracted ||= create_extracted
+      end
+      
+      # returns the region/range that is represented by the region number
+      def get_region rnum
+        @regions ||= create_regions
+        @regions[rnum]
+      end
+
+      private
+      def create_extracted
+        # This is much easier. Just resplit the whole thing at end of line
+        # sequences.
+        
+        eoline    = "\n"             # should be OS-dependent
+        srclines  = @lines
+        reallines = @lines.join("").split ANY_END_OF_LINE
+
+        # "\n" after all but the last line
+        @extracted = (0 ... (reallines.length - 1)).collect { |lnum| reallines[lnum] + eoline }
+        @extracted << reallines[-1]
+
+        @extracted
+      end
+
+      def create_regions
+        @regions = []           # keys = region number; values = range of lines
+
+        lstart = 0
+        @lines.each do |line|
+          lend = lstart
+          line.scan(ANY_END_OF_LINE).each do |cr|
+            lend += 1
+          end
+
+          @regions << ::Range.new(lstart, lend - 1)
+
+          lstart = lend
+        end
+        @regions
+      end
+    end
+  end
+end