epitools 0.4.49 → 0.5.0

data/lib/epitools/browser.rb

@@ -1,4 +1,5 @@
 require 'epitools'
+gem 'mechanize', '~> 1.0'
 require 'mechanize'
 require 'epitools/browser/cache'
 require 'epitools/browser/mechanize_progressbar'

data/lib/epitools/clitools.rb

@@ -1,4 +1,4 @@
-require 'epitools'
+#require 'epitools'
 
 class String
 
@@ -67,8 +67,9 @@ def lesspipe(*args)
       yield less
     end
   end
-
-rescue Errno::EPIPE
+  
+rescue Errno::EPIPE, Interrupt
+  # less just quit -- eat the exception.
 end
 
 
@@ -175,3 +176,6 @@ def autoinstall(*packages)
     cmd(["sudo apt-get install ?", packages.join(' ')])
   end
 end
+
+
+

data/lib/epitools/colored.rb

@@ -1,28 +1,49 @@
-require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
-require 'set'
-
 #
-# ANSI Colour-coding for terminals that support it.
+# ANSI Colour-coding (for terminals that support it.)
+#
 # Originally by defunkt (Chris Wanstrath)
+#   Enhanced by epitron (Chris Gahan)
+#
+# It adds methods to String to allow easy coloring.
+#
+# (Note: Colors are automatically disabled if your program is piped to another program,
+#        ie: if STDOUT is not a TTY)
+#
+# Basic examples:
 #
-# It extends String with methods that insert terminal codes.
+#   >> "this is red".red
+#   >> "this is red with a blue background (read: ugly)".red_on_blue
+#   >> "this is light blue".light_blue
+#   >> "this is red with an underline".red.underline
+#   >> "this is really bold and really blue".bold.blue
 #
-# Examples:
+# Color tags:
+# (Note: You don't *need* to close color tags, but you can!)
 #
-#    >> "this is red".red
-#  
-#    >> "this is red with a blue background (read: ugly)".red_on_blue
+#   >> "<yellow>This is using <green>color tags</green> to colorize.".colorize
+#   >> "<1>N<9>u<11>m<15>eric tags!".colorize
+#   (For those who still remember the DOS color palette and want more terse tagged-colors.)
 #
-#    >> "this is light blue".light_blue
+# Highlight search results:
 #
-#    >> "<yellow>This is using <green>tags</green> to colorize.".colorize
+#   >> string.gsub(pattern) { |match| "<yellow>#{match}</yellow>" }.colorize
 #
-#    >> "this is red with an underline".red.underline
+# Forcing colors:
 #
-#    >> "this is really bold and really blue".bold.blue
+# Since the presence of a terminal is detected automatically, the colors will be
+# disabled when you pipe your program to another program. However, if you want to
+# show colors when piped (eg: when you pipe to `less -R`), you can force it: 
 #
-#    >> Colored.red "This is red" # but this part is mostly untested
+#   >> Colored.enable!
+#   >> Colored.disable!
+#   >> Colored.enable_temporarily { puts "whee!".red }
 #
+
+require 'set'
+require 'rbconfig'
+require 'Win32/Console/ANSI' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+#require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+
 module Colored
   extend self
 
@@ -127,7 +148,7 @@ module Colored
   end
 
   #
-  # A class/instance method to colorize a string.
+  # Colorize a string (this method is called by #red, #blue, #red_on_green, etc.)
   #
   # Accepts options:
   #   :foreground
@@ -137,6 +158,15 @@ module Colored
   #   :extra
   #       Extra styling, like 'bold', 'light', 'underline', 'reversed', or 'clear'.
   #
+  #
+  # With no options, it uses tagged colors:
+  #
+  #    puts "<light_green><magenta>*</magenta> Hey mom! I am <light_blue>SO</light_blue> colored right now.</light_green>".colorize
+  #
+  # Or numeric ANSI tagged colors (from the BBS days):
+  #    puts "<10><5>*</5> Hey mom! I am <9>SO</9> colored right now.</10>".colorize
+  #
+  #
   def colorize(string=nil, options = {})
     if string == nil
       return self.tagged_colors
@@ -227,14 +257,6 @@ module Colored
   #
   # Colorize a string that has "color tags".
   #
-  # Examples:
-  #
-  # Colors as words:
-  #    puts "<light_green><magenta>*</magenta> Hey mom! I am <light_blue>SO</light_blue> colored right now.</light_green>".colorize
-  #
-  # Numeric ANSI colors (from the BBS days):
-  #    puts "<10><5>*</5> Hey mom! I am <9>SO</9> colored right now.</10>".colorize
-  #
   def tagged_colors
     stack = []
 

data/lib/epitools/ezdb.rb

@@ -0,0 +1,100 @@
+require 'epitools'
+require 'dbm'
+require 'delegate'
+
+class Ezdc < DelegateClass(Hash)
+
+  attr_reader :db, :path, :dirty
+
+  @@dirty = Set.new
+  
+  def initialize(filename)
+    @path = Path[filename]
+    
+    if @path.ext.nil?
+      @path.ext = "db"
+    else
+      @path.ext += ".db" if @path.ext != 'db'
+    end
+    
+    @db = DBM::open(@path.with(:ext=>nil))
+    
+    super
+  end
+  
+  class Observed < BasicObject
+    MUTATORS = ::Set.new [
+      :<<, :push, :pop, :slice, :[]=
+    ]
+  
+    def __send__(meth, *args)
+      if MUTATORS.include? meth
+        @@dirty.add self
+      end
+      
+    end
+  end
+  
+  def observed(obj)
+    obj.using(Observed)
+  end
+  
+  def [](key)
+    observed(super[key])
+  end
+  
+  def []=(key, val)
+  end
+  
+  def keys
+    db.keys.map(&:unmarshal)
+  end
+  
+  def delete!
+    @path.rm
+  end
+  
+  def flush!
+    dirty.each do |key|
+      db[key.marshal] = super[key].marshal
+    end
+  end
+  
+end
+
+
+class Ezdb
+
+  attr_reader :db, :path
+
+  def initialize(filename)
+    @path = Path[filename]
+    
+    if @path.ext.nil?
+      @path.ext = "db"
+    else
+      @path.ext += ".db" if @path.ext != 'db'
+    end
+    
+    @db = DBM::open(@path.with(:ext=>nil))
+  end
+  
+  def [](key)
+    val = db[key.marshal]
+    val = val.unmarshal if val
+    val
+  end
+  
+  def []=(key, val)
+    db[key.marshal] = val.marshal
+  end
+  
+  def keys
+    db.keys.map(&:unmarshal)
+  end
+  
+  def delete!
+    @path.rm
+  end
+  
+end

data/lib/epitools/path.rb

@@ -1,5 +1,58 @@
+#
+# TODOs:
+#   Relative paths
+#   Rename bugs
+#   tmp bugs
+#
+
 require 'epitools'
 
+#
+# Path: An object-oriented wrapper for files.
+#       (Combines useful methods from FileUtils, File, Dir, and more!)
+#
+# Each Path object has the following attributes:
+#
+#    path            => the entire path
+#    filename        => just the name and extension
+#    basename        => just the filename
+#    ext             => just the extension
+#    dir             => just the directory
+#    dirs            => an array of directories
+#
+# Note: all of the above attributes can be modified to produce new paths!
+# Here's a useful example:
+#   
+#   # Check if there's a '.git' directory in the current or parent directories.
+#   def inside_a_git_repository?
+#     path = Path.pwd # get the current directory
+#     while path.dirs.any?
+#       return true if (path/".git").exists?
+#       path.dirs.pop
+#     end
+#     false
+#   end
+#    
+#
+# Examples:
+#
+#   Path["*.jpeg"].each { |path| path.rename(:ext=>"jpg") }
+#
+#   Path["filename.txt"] << "Append data!"
+#
+#   entries = Path["/etc"].ls
+#
+#   Path
+#
+# Swap two files:
+#
+#   a, b = Path["file_a", "file_b"]
+#   temp = a.with(:ext=>a.ext+".swapping")
+#   a.mv(temp)
+#   b.mv(a)
+#   temp.mv(b)
+#   
+#
 class Path
   
   ## initializers
@@ -13,7 +66,6 @@ class Path
   end
   
   def self.[](path)
-  
     case path
     when Path
       path
@@ -21,17 +73,22 @@ class Path
     
       if path =~ %r{^[a-z\-]+://}i # URL?
         Path::URL.new(path)
+      elsif path =~ /^javascript:/
+        Path::JS.new(path)
       else
-        path = expand_path path
+      
+        # todo: highlight backgrounds of codeblocks to show indent level & put boxes (or rules?) around (between?) double-spaced regions
+        
+        path = Path.expand_path(path)
         if path =~ /(^|[^\\])[\?\*\{\}]/ # contains unescaped glob chars? 
           glob(path)
         else
           new(path)
         end
+        
       end
       
     end
-    
   end
 
   ## setters
@@ -77,6 +134,8 @@ class Path
     @dirs = File.expand_path(newdir).split(File::SEPARATOR)[1..-1]
   end
   
+  # TODO: Figure out how to fix the 'path.with(:ext=>ext+".other")' problem (when 'ext == nil')...
+  
   def ext=(newext)
     if newext.blank?
       @ext = nil
@@ -107,6 +166,28 @@ class Path
     end
   end
   
+  def relative_to(anchor=nil)
+    anchor ||= Path.pwd 
+    
+    # operations to transform anchor into self
+    
+    # stage 1: go ".." until we find a common dir prefix
+    #          (discard everything and go '/' if there's no common dir)
+    # stage 2: append the rest of the other path 
+    
+    # find common prefix
+    smaller, bigger = [ anchor.dirs, self.dirs ].sort_by(&:size)
+    common_prefix_end = bigger.zip(smaller).index { |a,b | a != b }
+    common_prefix = bigger[0...common_prefix_end] 
+    
+    if common_prefix.any?
+      dots = nil
+    end
+    
+    self.dirs & anchor.dirs
+    
+  end
+  
   # The current directory (with a trailing /)
   def dir
     if dirs 
@@ -168,6 +249,10 @@ class Path
     File.symlink? path
   end
   
+  def broken_symlink?
+    File.symlink?(path) and not File.exists?(path)
+  end
+  
   def uri?
     false
   end
@@ -177,32 +262,23 @@ class Path
   end
   
   
-  ## aliases
-  
-  alias_method :to_path,    :path
-  alias_method :to_str,     :path
-  alias_method :to_s,       :path
-
-  alias_method :pathname,   :path
-  alias_method :basename,   :base
-  alias_method :basename=,  :base=
-  alias_method :extname,    :ext
-  alias_method :extname=,   :ext=
-  alias_method :dirname,    :dir
-  alias_method :dirname=,   :dir=
-  alias_method :extension,  :ext
-  alias_method :extension=, :ext=
-  alias_method :directory,  :dir
-  alias_method :directory=, :dir=
-
-  alias_method :directory?, :dir?
-  
   ## comparisons
 
   include Comparable
   
   def <=>(other)
-    self.path <=> other.path
+    case other
+    when Path
+      self.path <=> other.path
+    when String
+      self.path == other
+    else
+      raise "Invalid comparison: Path to #{other.class}"
+    end
+  end
+  
+  def ==(other)
+    self.path == other.to_s
   end
 
   
@@ -212,7 +288,10 @@ class Path
   # Path["/etc"]/"passwd" == Path["/etc/passwd"]
   #
   def /(other)
-    Path.new( File.join(self, other) )
+    # / <- fixes jedit syntax highlighting bug.
+    # TODO: make it work for "/dir/dir"/"/dir/file" 
+    #Path.new( File.join(self, other) )
+    Path[ File.join(self, other) ]
   end  
   
   ## opening/reading files
@@ -230,11 +309,31 @@ class Path
   def read(length=nil, offset=nil)
     File.read(path, length, offset)
   end
+
+  #
+  # All the lines in this file, chomped.
+  #  
+  def lines
+    io.lines.map(&:chomp)
+  end
+  
+  def unmarshal
+    read.unmarshal
+  end
   
   def ls; Path[File.join(path, "*")]; end
 
   def ls_r; Path[File.join(path, "**/*")]; end
 
+
+  def siblings
+    ls - [self]
+  end
+  
+  def touch
+    open("a") { }
+    self
+  end
   
   ## modifying files
 
@@ -248,7 +347,8 @@ class Path
       else
         yield f
       end
-    end    
+    end
+    self
   end
   alias_method :<<, :append
   
@@ -272,39 +372,68 @@ class Path
   #   Path["Songy Song.aac"].rename(:dir=>"/music2")
   #   Path["/music2/Songy Song.aac"].exists? #=> true
   #  
+  def rename!(options)
+raise "Broken!"
+    
+    dest = rename(options)
+    self.path = dest.path # become dest
+    self
+  end
+  
   def rename(options)
+raise "Broken!"
+    
     raise "Options must be a Hash" unless options.is_a? Hash
     dest = self.with(options)
     
     raise "Error: destination (#{dest.inspect}) already exists" if dest.exists?
     File.rename(path, dest)
     
-    self.path = dest.path # become dest
+    dest
   end
 
   #
   # Renames the file the specified full path (like Dir.rename.)
   #  
   def rename_to(path)
-    rename :path=>path
+raise "Broken!"
+  
+    rename :path=>path.to_s
   end
   alias_method :mv,       :rename_to
   
+  def rename_to!(path)
+raise "Broken!"
+    rename! :path=>path.to_s
+  end
+  alias_method :mv!,       :rename_to!
+  
+  def reload!
+    self.path = to_s
+  end
+  
+  #
+  # Generate two almost identical methods: mkdir and mkdir_p 
+  #
   {
     :mkdir => "Dir.mkdir", 
     :mkdir_p =>"FileUtils.mkdir_p"
-  }.each do |method, expression|
+  }.each do |method, command|
     class_eval %{
       def #{method}
         if exists?
           if directory?
-            false
+            Path[path]
           else
-            raise "Error: Tried to make a directory over top of an existing file."
+            raise "Error: A file by this name already exists."
           end
         else
-          #{expression}(path)
-          true
+          #{command}(path)
+          #Path[path]
+          p [:path, path]
+          self.path = path # regenerate object
+          p [:path, path]
+          self
         end
       end
     }
@@ -314,6 +443,10 @@ class Path
     FileUtils.cp_r(path, dest) #if Path[dest].exists?
   end
   
+  def mv(dest)
+    FileUtils.mv(path, dest)
+  end
+
   def join(other)
     if uri?
       Path[URI.join(path, other).to_s]
@@ -322,11 +455,44 @@ class Path
     end
   end
 
+
   def ln_s(dest)
     dest = Path[dest]
     FileUtils.ln_s self, dest 
   end
 
+  ## Owners and permissions
+  
+  def chmod(mode)
+    FileUtils.chmod(mode, self)
+    self
+  end
+  
+  def chown(usergroup)
+    user, group = usergroup.split(":")
+    FileUtils.chown(user, group, self)
+    self
+  end
+  
+  def chmod_R(mode)
+    if directory?
+      FileUtils.chmod_R(mode, self)
+      self
+    else
+      raise "Not a directory."
+    end
+  end
+  
+  def chown_R(usergroup)
+    user, group = usergroup.split(":")
+    if directory?
+      FileUtils.chown_R(user, group, self)
+      self
+    else
+      raise "Not a directory."
+    end
+  end
+  
   ## Dangerous methods.
   
   def rm
@@ -341,7 +507,7 @@ class Path
   alias_method :"remove!", :rm
   
   def truncate(offset=0)
-    File.truncate(self, offset)
+    File.truncate(self, offset) if exists?
   end
 
   
@@ -412,27 +578,25 @@ class Path
   alias_method :stream, :io
   
   def =~(pattern)
-    path =~ pattern
+    to_s =~ pattern
+  end
+
+  def lstat
+    #@lstat ||= File.lstat self
+    File.lstat self
   end
   
-  ## Class method versions of FileUtils-like things
+  def mode
+    lstat.mode
+  end
   
-  %w[
-    mkdir
-    mkdir_p 
-    sha1 
-    sha2 
-    md5
-    rm
-    truncate
-  ].each do |method|
-    class_eval %{
-      def self.#{method}(path)
-        Path[path].#{method}
-      end
-    }
+  def parent
+    if file?
+      with(:filename=>nil)
+    else
+      with(:dirs=>dirs[0...-1])
+    end
   end
-
   
   # Mimetype finding and magic (requires 'mimemagic' gem)
 
@@ -458,6 +622,8 @@ class Path
     open { |io| MimeMagic.by_magic(io) }
   end
   
+  # TODO: rename type => magicext
+  
   #
   # The filetype (as a standard file extension), verified with Magic.
   #
@@ -467,31 +633,93 @@ class Path
   # Note: Prefers long extensions (eg: jpeg over jpg)
   #
   def type
-    @magictype ||= proc do 
+    @cached_type ||= begin
       
-      ext   = self.ext
-      magic = self.magic
+      if file? or symlink?
       
-      if !ext and magic
-        magic.ext
-      elsif ext and !magic
-        ext
-      elsif !ext and !magic
-        :unknown
-      else # ext and magic
-        if magic.extensions.include? ext
+        ext   = self.ext
+        magic = self.magic
+        
+        if ext and magic
+          if magic.extensions.include? ext
+            ext
+          else
+            magic.ext # in case the supplied extension is wrong...
+          end
+        elsif !ext and magic
+          magic.ext
+        elsif ext and !magic
           ext
-        else
-          magic.ext # in case the supplied extension is wrong...
+        else # !ext and !magic
+          :unknown
         end
+        
+      elsif dir?
+        :directory
       end
       
-    end.call
+    end
   end
   
+  ## aliases
+  
+  alias_method :to_path,    :path
+  alias_method :to_str,     :path
+  alias_method :to_s,       :path
+
+  alias_method :pathname,   :path
+  alias_method :basename,   :base
+  alias_method :basename=,  :base=
+  alias_method :extname,    :ext
+  alias_method :extname=,   :ext=
+  alias_method :dirname,    :dir
+  alias_method :dirname=,   :dir=
+  alias_method :extension,  :ext
+  alias_method :extension=, :ext=
+  alias_method :directory,  :dir
+  alias_method :directory=, :dir=
+
+  alias_method :directory?, :dir?
+  
+  alias_method :exist?,     :exists?
+  
   ############################################################################
   ## Class Methods
 
+  #
+  # FileUtils-like class-method versions of instance methods
+  # (eg: `Path.mv(src, dest)`)
+  #
+  # Note: Methods with cardinality 1 (`method/1`) are instance methods that take
+  # one parameter, and hence, class methods that take two parameters.
+  #
+  AUTOGENERATED_CLASS_METHODS = %w[
+    mkdir
+    mkdir_p 
+    sha1 
+    sha2 
+    md5
+    rm
+    truncate
+    mv/1
+    move/1
+    chmod/1
+    chown/1
+    chown_R/1
+    chmod_R/1
+  ].each do |spec|
+    method, cardinality = spec.split("/")
+    cardinality = cardinality.to_i
+  
+    class_eval %{
+      def self.#{method}(path#{", *args" if cardinality > 0})
+        Path[path].#{method}#{"(*args)" if cardinality > 0}
+      end
+    }
+  end
+  
+  
+  
   #
   # Same as File.expand_path, except preserves the trailing '/'.
   #
@@ -510,6 +738,7 @@ class Path
     path
   end
   alias_class_method :tempfile, :tmpfile  
+  alias_class_method :tmp,      :tmpfile  
   
   def self.home
     Path[ENV['HOME']]
@@ -548,13 +777,24 @@ class Path
     PATH_SEPARATOR    = ":"
     BINARY_EXTENSION  = ""
   end
-  
-  def self.which(bin)
-    ENV["PATH"].split(PATH_SEPARATOR).find do |path|
-      result = (Path[path] / (bin + BINARY_EXTENSION))
-      return result if result.exists?
+
+  #
+  # A clone of `/usr/bin/which`: pass in the name of a binary, and it'll search the PATH
+  # returning the absolute location of the binary if it exists, or `nil` otherwise.
+  #
+  # (Note: If you pass more than one argument, it'll return an array of `Path`s instead of
+  #        a single path.)
+  #  
+  def self.which(bin, *extras)
+    if extras.empty?
+      ENV["PATH"].split(PATH_SEPARATOR).find do |path|
+        result = (Path[path] / (bin + BINARY_EXTENSION))
+        return result if result.exists?
+      end
+      nil
+    else
+      ([bin] + extras).map { |bin| which(bin) }
     end
-    nil
   end  
   
 end
@@ -566,6 +806,10 @@ end
 class Path::URL < Path
 
   attr_reader :uri
+
+  #
+  # TODO: only include certain methods from Path (delegate style)
+  #       (eg: remove commands that write)
   
   def initialize(uri)
     @uri = URI.parse(uri)
@@ -575,11 +819,42 @@ class Path::URL < Path
   def uri?
     true
   end
+
+  #
+  # Example:
+  #
+  # When this is: http://host.com:port/path/filename.ext?param1=value1&param2=value2&...
+  #
+  def to_s
+    uri.to_s
+  end
+  
+
+  #
+  # ...this is: 'http'
+  #  
+  def scheme
+    uri.scheme
+  end
+  alias_method :protocol, :scheme
   
+  #
+  # ...and this is: 'host.com'
+  #
   def host
     uri.host
   end
   
+  #
+  # ...and this is: 80
+  #
+  def port
+    uri.host
+  end
+  
+  #
+  # ...and this is: {param1: value1, param2: value2, ...etc... }
+  #
   def query
     if query = uri.query
       query.to_params
@@ -588,9 +863,7 @@ class Path::URL < Path
     end
   end
   
-  def to_s
-    uri.to_s
-  end
+  # ...and `path` is /path/filename.ext
   
 end
 
@@ -602,10 +875,11 @@ def Path(*args)
   Path[*args]
 end
 
-if $0 == __FILE__
-  require 'ruby-debug'
-  #Path.pry
-  #Path["http://google.com/"].pry
-  debugger
-  Path["?"]
+class String
+  def to_Path
+    Path.new self
+  end
+  
+  alias_method :to_P, :to_Path
 end
+