riel 1.0.0

data/lib/riel/ansicolor.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+#     Attribute codes:
+#         00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
+#     Text color codes:
+#         30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
+#     Background color codes:
+#         40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
+
+module ANSIColor
+
+  ATTRIBUTES = Hash[
+    'none'       => '0', 
+    'reset'      => '0',
+    'bold'       => '1',
+    'underscore' => '4',
+    'underline'  => '4',
+    'blink'      => '5',
+    'reverse'    => '7',
+    'concealed'  => '8',
+    'black'      => '30',
+    'red'        => '31',
+    'green'      => '32',
+    'yellow'     => '33',
+    'blue'       => '34',
+    'magenta'    => '35',
+    'cyan'       => '36',
+    'white'      => '37',
+    'on_black'   => '40',
+    'on_red'     => '41',
+    'on_green'   => '42',
+    'on_yellow'  => '43',
+    'on_blue'    => '44',
+    'on_magenta' => '45',
+    'on_cyan'    => '46',
+    'on_white'   => '47',
+  ]
+
+  ATTRIBUTES.each do |name, val|
+    eval <<-EODEF
+      def ANSIColor.#{name}
+        "\\e[#{val}m"
+      end
+    EODEF
+  end
+
+  def ANSIColor.attributes
+    ATTRIBUTES.collect { |name, val| name }
+  end
+  
+  # returns the code for the given color string, which is in the format:
+  # [foreground] on [background]. Note that the foreground and background sections
+  # can have modifiers (attributes). Examples:
+  #     black
+  #     blue on white
+  #     bold green on yellow
+  #     underscore bold magenta on cyan
+  #     underscore red on bold cyan
+
+  def ANSIColor.code(str)
+    fg, bg = str.split(/\s*\bon_?\s*/)
+    (fg ? foreground(fg) : "") + (bg ? background(bg) : "")
+  end
+
+  # returns the code for the given background color(s)
+  def ANSIColor.background(bgcolor)
+    make_code("on_" + bgcolor)
+  end
+
+  # returns the code for the given foreground color(s)
+  def ANSIColor.foreground(fgcolor)
+    make_code(fgcolor)
+  end
+
+  protected
+
+  def ANSIColor.make_code(str)
+    if str
+      str.split.collect do |s|
+        if attr = ATTRIBUTES[s]
+          "\e[#{attr}m"
+        else
+          $stderr.puts "WARNING: ANSIColor::make_code(" + str + "): unknown color: " + s
+          return ""
+        end
+      end.join("")
+    else
+      ""
+    end
+  end
+
+end

data/lib/riel/array.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+class Array 
+
+  $-w = false
+
+  # Wraps the array with brackets, and inserts a comma and a space between
+  # elements.
+
+  def to_s
+    "[ " + collect { |e| e.to_s }.join(", ") + " ]"
+  end
+  $-w = true
+
+  def rand
+    return self[Kernel.rand(length)]
+  end
+  
+end

data/lib/riel/command.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+#!ruby -w
+
+class Command
+
+  # Runs the given command and arguments, returning the lines of output. If a
+  # block is provided, then it will be called with each line of output. If the
+  # block takes two arguments, then the line number is also passed to the block.
+
+  def self.run(cmd, *args, &blk)
+    lines = Array.new
+    
+    IO.popen("#{cmd} #{args.join(' ')}") do |io|
+      lnum = 0
+      io.each_line do |line|
+        lines << line
+        if blk
+          args = [ line ]
+          args << lnum if blk.arity > 1
+          blk.call(*args)
+        end
+        lnum += 1
+      end
+    end
+    
+    lines
+  end
+
+end

data/lib/riel/date.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+#!ruby -w
+
+require 'date'
+
+
+class Date
+
+  # Returns the number of days in the given month.
+  
+  def self.days_in_month(year, month)
+    (Date.new(year, 12, 31) << (12 - month)).day
+  end
+
+end

data/lib/riel/dir.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+
+class Dir
+
+  # Returns the home directory, for both Unix and Windows.
+  def self.home
+    ENV["HOME"] || begin
+                     hd = ENV["HOMEDRIVE"]
+                     hp = ENV["HOMEPATH"]
+                     if hd || hp
+                       (hd || "") + (hp || "\\")
+                     end
+                   end
+  end
+
+  # Removes directories containing no files or files matching only those in
+  # args[:deletable_files], which are basenames.
+  def self.remove_if_empty(dir, args = Hash.new)
+    deletable = args[:deletable] || Array.new
+    verbose   = args[:verbose]
+    level     = args[:level] || 0
+
+    subargs = args.dup
+    subargs[:level] = level + 1
+
+    dir = Pathname.new(dir) unless dir.kind_of?(Pathname)
+
+    if level <= 1 && verbose
+      puts "dir: #{dir}"
+    end
+
+    if dir.readable?
+      dir.children.sort.each do |child|
+        if child.exist? && child.directory?
+          self.remove_if_empty(child, subargs)
+        end
+      end
+      
+      if dir.expand_path == Pathname.pwd.expand_path
+        puts "skipping current directory: #{dir}" if verbose
+      else
+        can_delete = dir.children.all? do |x| 
+          bname = x.basename.to_s
+          deletable.any? do |del|
+            if del.kind_of?(String)
+              bname == del
+            elsif del.kind_of?(Regexp)
+              del.match(bname)
+            else
+              false
+            end
+          end
+        end
+
+        if can_delete
+          dir.children.each do |x|
+            puts "removing file: #{x}" if verbose
+            x.delete
+          end
+
+          puts "removing directory: #{dir}" if verbose
+
+          dir.delete
+        else
+          # puts "#{dir} not empty"
+        end
+      end
+    elsif verbose
+      puts "#{dir} not readable"
+    end
+  end
+
+  # Moves and copies files to the given directory, creating
+  # it if it does not exist.
+  def self.move_and_copy_files(dir, move_files, copy_files)
+    dir.mkdir unless dir.exist?
+
+    move_files.each do |mfile|
+      File.move(mfile.to_s, dir.to_s)
+    end
+
+    copy_files.each do |cfile|
+      File.copy(cfile.to_s, dir.to_s)
+    end
+  end
+
+end

data/lib/riel/enumerable.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Enumerable
+
+  def collect_with_index(&blk)
+    ary = []
+    self.each_with_index do |item, idx|
+      ary << blk.call(item, idx)
+    end
+    ary
+  end
+
+  NOT_NIL = Object.new
+
+  def select_with_index(arg = NOT_NIL, &blk)
+    ary = []
+    self.each_with_index do |item, idx|
+      ary << item if _match?(arg, item, idx, &blk)
+    end
+    ary
+  end
+
+  def detect_with_index(arg = NOT_NIL, &blk)
+    self.each_with_index do |item, idx|
+      return item if _match?(arg, item, idx, &blk)
+    end
+    nil
+  end
+
+  alias :orig_select  :select
+  alias :orig_collect :collect
+  alias :orig_detect  :detect
+  alias :orig_reject  :reject
+
+  origw = $-w
+  $-w = false
+  def select(arg = NOT_NIL, &blk)
+    ary = []
+    self.each_with_index do |item, idx|
+      ary << item if _match?(arg, item, idx, &blk)
+    end
+    ary
+  end
+
+  def detect(arg = NOT_NIL, &blk)
+    self.each_with_index do |item, idx|
+      return item if _match?(arg, item, idx, &blk)
+    end
+    nil
+  end
+  $-w = origw
+
+  def _match?(arg, item, idx, &blk)
+    if blk 
+      args = [ item ]
+      args << idx if idx && blk.arity > 1
+      blk.call(*args)
+    elsif arg == NOT_NIL
+      !item.nil?
+    else
+      arg == item
+    end
+  end
+  
+end

data/lib/riel/env.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Env
+
+  # Returns the home directory, for both Unix and Windows.
+
+  def self.home_directory
+    if hm = ENV["HOME"]
+      hm
+    else
+      hd = ENV["HOMEDRIVE"]
+      hp = ENV["HOMEPATH"]
+      if hd || hp
+        (hd || "") + (hp || "\\")
+      else
+        nil
+      end
+    end
+  end
+
+  # matches single and double quoted strings:
+  REGEXP = /                    # either:
+              ([\"\'])          #     start with a quote, and save it ($1)
+              (                 #     save this ($2)
+                (?:             #         either (and don't save this):
+                    \\.         #             any escaped character
+                  |             #         or
+                    [^\1\\]     #             anything that is not a quote ($1), and is not a backslash
+                )*?             #         only up to the next quote
+              )                 #         end of $2
+              \1                #     end with the same quote we started with
+            |                   # or
+              (:?\S+)           #     plain old nonwhitespace
+           /x
+      
+  # amazing that ruby-mode (Emacs) handled all that.
+  
+  # Reads the environment variable, splitting it according to its quoting.
+
+  def self.split(varname)
+    if v = ENV[varname]
+      v.scan(REGEXP).collect { |x| x[1] || x[2] }
+    else
+      []
+    end
+  end
+
+end

data/lib/riel/file.rb

@@ -0,0 +1,212 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'riel/filetype'
+require 'riel/pathname'
+require 'riel/tempfile'
+require 'fileutils'
+
+# this eliminates the world-writable warning when running file operations
+# (opening, finding, executing):
+
+orig_verbose = $VERBOSE
+$VERBOSE = nil
+path = ENV['PATH'].dup
+$VERBOSE = orig_verbose
+
+class File
+
+  def self.text?(file)
+    return File.file?(file) && FileType.instance.text?(file)
+  end
+
+  def self.binary?(file)
+    return !self.text?(file)
+  end
+
+  # Returns whether the given object is a file. Ignores errors.
+  def self.is_file?(fd)
+    begin 
+      return self.stat(fd).file?
+    rescue
+      # ignore files that could not be read, etc.
+      return false
+    end
+  end
+  
+  # Returns whether the given file is writable. Ignores errors.
+  def self.is_writable?(file)
+    begin 
+      return self.stat(file).writable?
+    rescue
+      # ignore files that could not be read, etc.
+      return false
+    end
+  end
+  
+  # Returns whether the given object is a directory. Ignores errors.
+  def self.is_directory?(fd)
+    begin 
+      return self.stat(fd).directory?
+    rescue
+      # ignore files that could not be read, etc.
+      return false
+    end
+  end
+
+  # Returns an array of all files under the given directory.
+  def self.find_files(dir)
+    files = Array.new
+    Find.find(dir) { |f| files.push(f) if is_file?(f) }
+    files
+  end
+
+  # Returns an array of all directory under the given directory.
+  def self.find_directories(dir)
+    dirs = Array.new
+    Find.find(dir) { |d| dirs.push(d) if is_directory?(d) }
+    dirs
+  end
+
+  # Removes the file/directory, including all subelements. Use with caution!
+  def self.remove_recursively(fd)
+    #$$$ this is rmtree
+    if fd.directory?
+      fd.children.each { |x| remove_recursively(x) }
+    end
+    fd.unlink
+  end
+
+  # Creates the given directory.
+  def self.mkdir(dir)
+    pn = Pathname.new(dir)
+    pn.mkdir unless pn.exist?
+  end
+
+  # Moves the files to the given directory, creating it if it does not exist.
+  def self.move_files(dir, files)
+    mkdir(dir)
+
+    files.each do |file|
+      FileUtils.move(file.to_s, dir.to_s)
+    end
+  end
+
+  # Copies the files to the given directory, creating it if it does not exist.
+  def self.copy_files(dir, files)
+    mkdir(dir)
+
+    files.each do |file|
+      FileUtils.copy(file.to_s, dir.to_s)
+    end
+  end
+
+  # Converts the argument to a Pathname.
+  def self._to_pathname(file)
+    file.kind_of?(Pathname) ? file : Pathname.new(file.to_s)
+  end
+
+  # Reads a file line by line. Returns the pathname for the file, or nil if it
+  # does not exist.
+  def self.read_file(file, &blk)
+    fpn = _to_pathname(file)
+    if fpn.exist?
+      fpn.open do |f|
+        blk.call f.read
+      end
+      fpn
+    else
+      nil
+    end
+  end
+
+  # Reads a file line by line, calling the given block. Returns the pathname for
+  # the file, or nil if it does not exist.
+  def self.read_file_lines(file, &blk)
+    fpn = _to_pathname(file)
+    if fpn.exist?
+      fpn.open do |f|
+        f.each_line do |line|
+          blk.call line
+        end
+        fpn
+      end
+    else
+      nil
+    end
+  end
+
+  # Opens a file for writing and delegates to the given block.
+  def self.open_writable_file(file, &blk)
+    fpn = _to_pathname(file)
+    
+    fpn.open(File::WRONLY | File::TRUNC | File::CREAT) do |f|
+      blk.call(f)
+    end
+
+    fpn
+  end
+
+  # Writes a file, using the <code>write</code> method.
+  def self.write_file(file, &blk)
+    open_writable_file(file) do |io|
+      io.write blk.call
+    end
+  end
+
+  # Writes a file, using puts (thus making it better for text files).
+  def self.put_file(file, &blk)
+    open_writable_file(file) do |io|
+      io.puts blk.call
+    end
+  end
+
+  # Opens a tempfile for writing, delegates to the given block, and renames the
+  # temp file to <code>file</code>. If <code>tempfile</code> is specified, it
+  # will be used as the temp file name. Ditto for <code>tempdir</code>, which
+  # defaults to Dir::tmpdir (e.g. "/tmp")
+
+  def self.open_via_temp_file(file, tempfile = nil, tempdir = Dir::tmpdir, &blk)
+    tempname = nil
+    
+    fpn = _to_pathname(file)
+    tempfile ||= fpn.rootname
+
+    Tempfile.open(tempfile) do |tf|
+      blk.call(tf)
+      tempname = tf.path
+    end
+    
+    FileUtils.mv(tempname, file.to_s)
+  end
+
+  # Writes a file, using write, buffering it via a temp file.
+  def self.write_via_temp_file(file, &blk)
+    open_via_temp_file(file) do |io|
+      io.write blk.call
+    end
+  end
+
+  # Writes a file, using puts, buffering it via a temp file.
+  def self.put_via_temp_file(file, &blk)
+    open_via_temp_file(file) do |io|
+      io.puts blk.call
+    end
+  end
+
+  # Returns a file for the given basename, sequentially appending an integer
+  # until one is found that does not exist. For example, "foo.3" if "foo",
+  # "foo.1", and "foo.2" already exist.
+  def self.get_unused_file_name(basename)
+    tgt = basename
+    if tgt.exist?
+      i = 1
+      while tgt.exist?
+        tgt = Pathname.new(basename.to_s + "." + i.to_s)
+        i += 1
+      end
+    end
+    tgt
+  end
+  
+end