automateit 0.70923

data/lib/automateit/template_manager/erb.rb

@@ -0,0 +1,17 @@
+# == TemplateManager::ERB
+#
+# Renders ERB templates for TemplateManager.
+class AutomateIt::TemplateManager::ERB < AutomateIt::TemplateManager::BaseDriver
+  depends_on :nothing
+
+  def suitability(method, *args) # :nodoc:
+    return 1
+  end
+
+  # See documentation for TemplateManager#render
+  def render(*options)
+    return _render_helper(*options) do |o|
+      HelpfulERB.new(o[:text], o[:filename]).result(o[:binder])
+    end
+  end
+end

data/lib/ext/metaclass.rb

@@ -0,0 +1,17 @@
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/ext/object.rb

@@ -0,0 +1,18 @@
+class Object
+  # Lists methods unique to an instance.
+  def unique_methods
+    (public_methods - Object.methods).sort
+  end
+
+  # Lists methods unique to a class.
+  def self.unique_methods
+    (public_methods - Object.methods).sort
+  end
+
+  # Returns a list of arguments and an options hash. Source taken from RSpec.
+  def args_and_opts(*args)
+    options = Hash === args.last ? args.pop : {}
+    return args, options
+  end
+end
+

data/lib/hashcache.rb

@@ -0,0 +1,22 @@
+# A very simple cache. Works just like a Hash, but can optionally store values
+# during the fetch process.
+#
+# Example:
+#   hc = HashCache.new
+#   hc.fetch("foo")
+#   => nil
+#   hc.fetch("foo"){:bar} # Block gets called because 'foo' is nil
+#   => :bar
+#   hc.fetch("foo"){raise "Block won't be called because 'foo' is cached"}
+#   => :bar
+class HashCache < Hash
+  def fetch(key, &block)
+    if has_key?(key) 
+      self[key] 
+    elsif block
+      self[key] = block.call
+    else
+      nil
+    end
+  end
+end

data/lib/helpful_erb.rb

@@ -0,0 +1,63 @@
+require 'erb'
+require 'nested_error'
+
+class HelpfulERB
+  class Error < ::NestedError; end
+
+  # ERB object
+  attr_accessor :erb
+
+  attr_accessor :lines_before
+
+  attr_accessor :lines_after
+
+  # Template filename
+  attr_accessor :filename
+
+  def initialize(text, filename=nil, opts={})
+    @text = text
+    @filename = filename
+    @lines_before = opts[:before] || 5
+    @lines_after = opts[:before] || 1
+
+    @erb = ::ERB.new(@text, nil, '-')
+    @erb.filename = @filename if @filename
+  end
+
+  def result(binder=nil)
+    begin
+      return @erb.result(binder)
+    rescue Exception => e
+      stack = caller 0
+      for i in 0..e.backtrace.size
+        l = e.backtrace[i]
+        #puts "%s %s" % [i, l];
+        break if l =~ /^([^:]+):(\d+):in `(render|result)'$/
+      end
+      template = $1
+      line_number = $2.to_i
+      raise Exception.new("Caught ERB error but couldn't find line number in backtrace:\n#{e.backtrace.join("\n")}") unless line_number
+
+      lines = @text.split(/\n/)
+
+      min = line_number - @lines_before
+      min = 0 if min < 0
+
+      max = line_number + @lines_after
+      max = lines.size if max > lines.size
+
+      width = max.to_s.size
+
+      msg = "Problem with template '#{template}' at line #{line_number}:\n"
+      for i in min..max
+        n = i+1
+        marker = n == line_number ? "*" : ""
+        msg << "\n%2s %#{width}i %s" % [marker, n, lines[i]]
+      end
+      msg << "\n\n(#{e.exception.class}) #{e.message}"
+
+
+      raise NestedError.new(msg, e)
+    end
+  end
+end

data/lib/nested_error.rb

@@ -0,0 +1,33 @@
+# == NestedError
+#
+# An exception class that records the cause of another error. Useful when you
+# need to raise a general kind of error, yet still be able to determine the
+# underlying cause.
+#
+# Example:
+#
+#   class MyGeneralError < NestedError; end
+#
+#   begin
+#     begin
+#       # Cause a specific error
+#       1/0 # Divide by zero error
+#     rescue Exception => e
+#       # Wrap the specific error in a general, nested error
+#       raise MyGeneralError("Something bad happened!", e)
+#     end
+#   rescue MyGeneralError => e
+#     # Intercept the nested error and inspect the cause
+#     puts e.message # => "Something bad happened!"
+#     puts e.cause.message # => "divided by 0"
+#   end
+class NestedError < StandardError
+  attr_accessor :cause
+
+  # Create a NestedObject with a +message+ String and a +cause+ Exception.
+  def initialize(message, cause)
+    self.cause = cause
+    super(message)
+  end
+end
+

data/lib/queued_logger.rb

@@ -0,0 +1,68 @@
+require 'logger'
+
+class QueuedLogger < Logger
+  def initialize(*args)
+    super(*args)
+    @queue = []
+    @emitted = false
+  end
+
+  def process_queue
+    if queued?
+      while true
+        entry = @queue.shift or break
+        severity, message = entry
+        raw_method = "#{severity}_without_queue"
+        severity_i = self.class.send(:const_get, severity.to_s.upcase)
+        send(raw_method, message)
+      end
+    end
+  end
+
+  def enqueue(level, message)
+    @queue << [level, message]
+    @emitted = false
+  end
+
+  def dequeue(level=nil, message=nil)
+    if queued?
+      @queue.clear
+    elsif level and message
+      send("%s_without_queue"%level, message) if @emitted
+    end
+    @emitted = false
+  end
+
+  def queued?
+    ! @queue.empty?
+  end
+
+  for level in %w(debug info warn error fatal) do
+    class_eval <<-EOB
+      def #{level}_with_queue(*args)
+        severity = self.class.send(:const_get, "#{level.upcase}")
+        process_queue if severity >= self.level
+        @emitted = true
+        #{level}_without_queue(*args)
+      end
+      alias_method_chain :#{level}, :queue
+    EOB
+  end
+
+end
+
+if __FILE__ == $0
+  # TODO QueuedLogger -- write a spec
+
+  q = QueuedLogger.new($stdout)
+  q.level = Logger::INFO
+  q.info("first message")
+  q.enqueue(:info, "queued message that'll be pushed")
+  q.info("second message, which pushed out queued message")
+  q.enqueue(:error, "ERROR: queued message that'll be discarded")
+  q.debug("ERROR: message that'll be discarded and won't push queue")
+  q.dequeue(:error, "ERROR: dequeue message that'll be discarded")
+  q.enqueue(:info, "queued message that'll be pushed")
+  q.info("message that'll push out the queue and dequeue messages")
+  q.dequeue(:info, "dequeue message that'll be pushed")
+end

data/lib/tempster.rb

@@ -0,0 +1,239 @@
+require 'tmpdir'
+require 'fileutils'
+
+# == Tempster
+#
+# Tempster is a pure-Ruby library for creating temporary files and directories.
+# Unlike other tools, it can create both temporary files and directories, and
+# is designed to be secure, thread-safe, easy-to-use, powerful thanks to
+# user-configurable options, and user-friendly thanks to good defaults so you
+# don't need to provide any arguments.
+#
+# Why write another library for this? The Tempfile standard library provides no
+# way to create temporary directories and always deletes the files it creates,
+# even if you want to keep them. The MkTemp gem is insecure and fails on
+# collisions. Linux "mktemp" works fine but is platform-specific. Therefore, I
+# had to write something.
+#
+# === WARNING: Using 'cd' and :noop together can be dangerous!
+#
+# Tempster will only *pretend* to make directories in :noop (no-operation)
+# mode. In :noop mode, it will also only *pretend* to change into the directory
+# when using :cd or +mktempdircd+.
+#
+# This can be *disastrous* if you're executing non-AutomateIt commands (e.g.
+# +system+) that use *relative* *paths* and expect to be run inside the
+# newly-created temporary directory because the +chdir+ didn't actually happen.
+#
+# Read previews.txt[link:files/docs/previews_txt.html] for instructions on how
+# to write code that can be safely previewed.
+#
+# == Credits
+# * Random string generator taken from
+#   http://pleac.sourceforge.net/pleac_ruby/numbers.html
+class Tempster
+  DEFAULT_NAME = "tempster"
+  DEFAULT_FILE_MODE = 0600
+  DEFAULT_DIRECTORY_MODE = 0700
+  DEFAULT_ARMOR_LENGTH = 10
+  ARMOR_CHARACTERS = ["A".."Z","a".."z","0".."9"].collect{|r| r.to_a}.join
+
+  # Options:
+  # * :name -- Name prefix to usse, defaults to "tempster".
+  # * :kind -- Create a :file or :directory, required.
+  # * :dir -- Base directory to create temporary entries in, uses system-wide temporary directory (e.g., <tt>/tmp</tt>) by default.
+  # * :cd -- Change into the newly directory created using +ch+ within the block, and then switch back to the previous directory. Only used when a block is given and the :kind is :directory. Default is false. See WARNING at the top of this class's documentation!
+  # * :noop -- no-operation mode, pretends to do actions without actually creating or deleting temporary entries. Default is false. WARNING: See WARNING at the top of this class's documentation!
+  # * :verbose -- Print status messages about creating and deleting the temporary entries. Default is false.
+  # * :delete -- Delete the temporary entries when exiting block. Default is true when given a block, false otherwise. If you don't use a block, you're responsible for deleting the entries yourself.
+  # * :tries -- Number of tries to create a temporary entry, usually it'll succeed on the first try. Default is 10.
+  # * :armor -- Length of armor to add to the name. These are random characters padding out the temporary entry names to prevent them from using existing files. If you have a very short armor, you're likely to get a collision and the algorithm will have to try again for the specified number of +tries+.
+  # * :message_callback -- +lambda+ called when there's a message, e.g., <tt>lambda{|message| puts message}</tt>, regardless of :verbose state. By default :messaging is nil and messages are printed to STDOUT only when :verbose is true.
+  # * :message_prefix -- String to put in front of messages, e.g., "# "
+  def self._tempster(opts={}, &block)
+    name = opts.delete(:name) || DEFAULT_NAME
+    kind = opts.delete(:kind) or raise ArgumentError.new("'kind' option not specified")
+    dir = opts.delete(:dir) || Dir.tmpdir
+    cd = opts.delete(:cd) || false
+    noop =  opts.delete(:noop) || false
+    verbose = opts.delete(:verbose) || false
+    delete = opts.delete(:delete) || block ? true : false
+    tries = opts.delete(:tries) || 10
+    armor = opts.delete(:armor) || DEFAULT_ARMOR_LENGTH
+    message_callback = opts.delete(:message_callback) || nil
+    message_prefix = opts.delete(:message_prefix) || ""
+    mode = opts.delete(:mode) || \
+      case kind
+      when :file
+        DEFAULT_FILE_MODE
+      when :directory
+        DEFAULT_DIRECTORY_MODE
+      else
+        raise ArgumentError.new("unknown kind: #{kind}")
+      end
+
+    raise ArgumentError.new("can only use 'delete' option with block") if delete and not block
+    raise ArgumentError.new("can only use 'cd' with directories and blocks") if cd and (not dir or not block)
+    raise ArgumentError.new("unknown extra options: #{opts.inspect}") unless opts.empty?
+
+    messager = Messager.new(verbose, message_callback, message_prefix)
+
+    path = nil
+    success = false
+    for i in 1..tries
+      begin
+        path = File.join(dir, name+"_"+_armor_string(armor))
+        unless noop
+          case kind
+          when :file
+            File.open(path, File::RDWR|File::CREAT|File::EXCL).close
+            File.chmod(mode, path)
+          when :directory
+            Dir.mkdir(path, mode)
+          else
+            raise ArgumentError.new("unknown kind: #{kind}")
+          end
+        end
+        # XXX Should we pretend that it's mktemp? Or give users something more useful?
+        # messager.puts("mktemp -m 0%o%s -p %s %s # => %s" % [mode, kind == :directory ? ' -d' : '', dir, name, path])
+        if block
+          messager.puts("mktempster --mode=0%o --kind=%s --dir=%s --name=%s" % [mode, kind, dir, name])
+        else
+          messager.puts("mktempster --mode=0%o --kind=%s --dir=%s --name=%s # => %s" % [mode, kind, dir, name, path])
+        end
+        success = true
+        break
+      rescue Errno::EEXIST
+        # Try again
+      end
+    end
+    raise IOError.new("couldn't create temporary #{kind}, ") unless success
+    if block
+      previous = Dir.pwd if cd
+      begin
+        if cd
+          Dir.chdir(path) unless noop
+          messager.puts("pushd #{path}")
+        end
+        block.call(path)
+      rescue Exception => e
+        # Re-throw exception after cleaning up
+        raise e
+      ensure
+        if cd
+          Dir.chdir(previous) unless noop
+          messager.puts("popd # => #{previous}")
+        end
+        if delete
+          FileUtils.rm_rf(path) unless noop
+          messager.puts("rm -rf #{path}")
+        end
+      end
+      return true
+    else
+      return path
+    end
+  end
+
+  # Returns a string of random characters.
+  def self._armor_string(length=DEFAULT_ARMOR_LENGTH)
+    (1..length).collect{ARMOR_CHARACTERS[rand(ARMOR_CHARACTERS.size)]}.pack("C*")
+  end
+
+  # Creates a temporary file.
+  def self.mktemp(opts={}, &block)
+    _tempster({:kind => :file}.merge(opts), &block)
+  end
+
+  # Creates a temporary directory.
+  #
+  # *WARNING*: See WARNING text at the top of this class's documentation!
+  def self.mktempdir(opts={}, &block)
+    _tempster({:kind => :directory}.merge(opts), &block)
+
+  end
+
+  # Creates a temporary directory and changes into it using +chdir+. This is a
+  # shortcut for using +mktempdir+ with the <tt>:cd => true</tt> option.
+  #
+  # *WARNING*: See WARNING text at the top of this class's documentation!
+  def self.mktempdircd(opts={}, &block)
+    _tempster({:kind => :directory, :cd => true}.merge(opts), &block)
+  end
+
+  class Messager
+    def initialize(verbose, callback=nil, prefix="")
+      @verbose = verbose
+      @callback = callback
+      @prefix = prefix
+    end
+
+    def puts(message)
+      if @callback
+        @callback.call(@prefix+message)
+      else
+        if @verbose
+          STDOUT.puts @prefix+message
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # TODO Tempster -- write a spec
+
+  # Show a temp file created
+  x = Tempster.mktemp(:verbose => true)
+  File.stat(x)
+  File.unlink(x)
+
+  # Show a temp directory created
+  x = Tempster.mktempdir(:verbose => true)
+  File.directory?(x)
+  FileUtils.rm_r(x)
+
+  # Show a temp file created and removed with block
+  path = nil
+  Tempster.mktemp(:verbose => true) do |file|
+    path = file
+    puts file
+  end
+  begin
+    File.unlink(path)
+    raise "temporary file wasn't deleted when block ended: #{path}"
+  rescue Errno::ENOENT
+    # Expect the error
+  end
+
+  # Show temp directory created and removed with block
+  path = nil
+  Tempster.mktempdir(:verbose => true) do |dir|
+    puts dir
+    path = dir
+    puts File.directory?(path)
+  end
+  puts File.directory?(path)
+
+  # Show temp directory created and removed with block and cd
+  path = nil
+  Tempster.mktempdircd(:verbose => true) do |dir|
+    path = dir
+    puts "block's arg: "+dir
+    puts "block's pwd: "+Dir.pwd
+    puts "block's dir exists?: %s" % File.directory?(path)
+  end
+  puts "after dir exists?: %s" % File.directory?(path)
+  puts "after pwd: "+Dir.pwd
+
+  # Same with message callback
+  path = nil
+  Tempster.mktempdircd(:message_callback => lambda{|message| puts "$$$ "+message}) do |dir|
+    path = dir
+    puts "block's arg: "+dir
+    puts "block's pwd: "+Dir.pwd
+    puts "block's dir exists?: %s" % File.directory?(path)
+  end
+  puts "after dir exists?: %s" % File.directory?(path)
+  puts "after pwd: "+Dir.pwd
+end