automate-it 0.9.0

data/lib/nitpick.rb

@@ -0,0 +1,33 @@
+module Nitpick
+  module ClassMethods
+    # Use to manage nitpick message for debugging AutomateIt internals.
+    #
+    # Arguments:
+    # * nil -- Returns boolean of whether nitpick messages will be displayed.
+    # * Boolean -- Sets nitpick state.
+    # * String or Symbol -- Displays nitpick message if state is on.
+    #
+    # Example:
+    #   nitpick true
+    #   nitpick "I'm nitpicking"
+    def nitpick(value=nil)
+      case value
+      when NilClass
+        @nitpick
+      when TrueClass, FalseClass
+        @nitpick = value
+      when String, Symbol
+        puts "%% #{value}" if @nitpick
+      else 
+        raise TypeError.new("Unknown nitpick type: #{value.class}")
+      end
+    end
+  end
+
+	def self.included(receiver)
+		receiver.extend(ClassMethods)
+	end
+
+  include ClassMethods
+  extend ClassMethods
+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,250 @@
+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_PREFIX = "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
+
+  # Alias for ::tempster.
+  def self._tempster(opts={}, &block) # :nodoc:
+    tempster(opts, &block)
+  end
+
+  # Options:
+  # * :kind -- Create a :file or :directory, required.
+  # * :prefix -- String to prefix the temporary name with, defaults to "tempster".
+  # * :suffix -- String to suffix the temporary name with, defaults is no suffix.
+  # * :name -- Same as :prefix
+  # * :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 append to the prefix. 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)
+    kind = opts.delete(:kind) or raise ArgumentError.new("'kind' option not specified")
+    prefix = opts.delete(:prefix) || opts.delete(:name) || DEFAULT_PREFIX
+    suffix = opts.delete(:suffix) || nil
+    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
+        name = prefix+"_"+_armor_string(armor)
+        name << suffix if suffix
+        path = File.join(dir, name)
+
+        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
+        message = "mktempster --mode=0%o --kind=%s --dir=%s --prefix=%s" % [mode, kind, dir, prefix]
+        message << (" --suffix=%s" % suffix) if suffix
+        message << (" # => %s" % path) if block
+        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
+
+=begin
+# Mostly recreated this in spec/integration/tempster_spec.rb
+
+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
+=end

data/misc/index_gem_repository.rb

@@ -0,0 +1,304 @@
+#!/usr/bin/env jruby
+# http://svn.codehaus.org/jruby/trunk/jruby/bin/index_gem_repository.rb
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+# Generate the yaml/yaml.Z index files for a gem server directory.
+#
+# Usage:  generate_yaml_index.rb --dir DIR [--verbose]
+
+$:.unshift '~/rubygems' if File.exist? "~/rubygems"
+
+require 'optparse'
+require 'rubygems'
+require 'rubygems/format' #IK# Fix for RubyGems 0.9.5
+require 'zlib'
+require 'digest/sha2'
+begin
+  require 'builder/xchar'
+rescue LoadError
+  fail "index_gem_repository requires that the XML Builder library be installed"
+end
+
+Gem.manage_gems
+
+######################################################################
+# Mixin that provides a +compress+ method for compressing files on
+# disk.
+#
+module Compressor
+  # Compress the given file.
+  def compress(filename, ext="rz")
+    File.open(filename + ".#{ext}", "w") do |file|
+      file.write(zip(File.read(filename)))
+    end
+  end
+
+  # Return a compressed version of the given string.
+  def zip(string)
+    Zlib::Deflate.deflate(string)
+  end
+
+  # Return an uncompressed version of a compressed string.
+  def unzip(string)
+    Zlib::Inflate.inflate(string)
+  end
+end
+
+######################################################################
+# Announcer provides a way of announcing activities to the user.
+#
+module Announcer
+  # Announce +msg+ to the user.
+  def announce(msg)
+    puts msg if @options[:verbose]
+  end
+end
+
+######################################################################
+# Abstract base class for building gem indicies.  Uses the template
+# pattern with subclass specialization in the +begin_index+,
+# +end_index+ and +cleanup+ methods.
+#
+class AbstractIndexBuilder
+  include Compressor
+  include Announcer
+
+  # Build a Gem index.  Yields to block to handle the details of the
+  # actual building.  Calls +begin_index+, # +end_index+ and +cleanup+
+  # at appropriate times to customize basic operations.
+  def build
+    if ! @enabled
+      yield
+    else
+      unless File.exist?(@directory)
+        FileUtils.mkdir_p(@directory)
+      end
+      fail "not a directory: #{@directory}" unless File.directory?(@directory)
+      File.open(File.join(@directory, @filename), "w") do |file|
+        @file = file
+        start_index
+        yield
+        end_index
+      end
+      cleanup
+    end
+  ensure
+    @file = nil
+  end
+
+  # Called immediately before the yield in build.  The index file is
+  # open and availabe as @file.
+  def start_index
+  end
+
+  # Called immediately after the yield in build.  The index file is
+  # still open and available as @file.
+  def end_index
+  end
+
+  # Called from within builder after the index file has been closed.
+  def cleanup
+  end
+end
+
+######################################################################
+# Construct the master Gem index file.
+#
+class MasterIndexBuilder < AbstractIndexBuilder
+  def initialize(filename, options)
+    @filename = filename
+    @options = options
+    @directory = options[:directory]
+    @enabled = true
+  end
+
+  def start_index
+    super
+    @file.puts "--- !ruby/object:Gem::Cache"
+    @file.puts "gems:"
+  end
+
+  def cleanup
+    super
+    index_file_name = File.join(@directory, @filename)
+    compress(index_file_name, "Z")
+    paranoid(index_file_name, "#{index_file_name}.Z")
+  end
+
+  def add(spec)
+    @file.puts "  #{spec.full_name}: #{nest(spec.to_yaml)}"
+  end
+
+  def nest(yaml_string)
+    yaml_string[4..-1].gsub(/\n/, "\n    ")
+  end
+
+  private
+
+  def paranoid(fn, compressed_fn)
+    data = File.read(fn)
+    compressed_data = File.read(compressed_fn)
+    if data != unzip(compressed_data)
+      fail "Compressed file #{compressed_fn} does not match uncompressed file #{fn}"
+    end
+  end
+end
+
+######################################################################
+# Construct a quick index file and all of the individual specs to
+# support incremental loading.
+#
+class QuickIndexBuilder < AbstractIndexBuilder
+  def initialize(filename, options)
+    @filename = filename
+    @options = options
+    @directory = options[:quick_directory]
+    @enabled = options[:quick]
+  end
+
+  def cleanup
+    compress(File.join(@directory, @filename))
+  end
+
+  def add(spec)
+    return unless @enabled
+    @file.puts spec.full_name
+    fn = File.join(@directory, "#{spec.full_name}.gemspec.rz")
+    File.open(fn, "w") do |gsfile|
+      gsfile.write(zip(spec.to_yaml))
+    end
+  end
+end
+
+######################################################################
+# Top level class for building the repository index.  Initialize with
+# an options hash and call +build_index+.
+#
+class Indexer
+  include Compressor
+  include Announcer
+
+  # Create an indexer with the options specified by the options hash.
+  def initialize(options)
+    @options = options.dup
+    @directory = @options[:directory]
+    @options[:quick_directory] = File.join(@directory, "quick")
+    @master_index = MasterIndexBuilder.new("yaml", @options)
+    @quick_index = QuickIndexBuilder.new("index", @options)
+  end
+
+  # Build the index.
+  def build_index
+    announce "Building Server Index"
+    FileUtils.rm_r(@options[:quick_directory]) rescue nil
+    @master_index.build do
+      @quick_index.build do 
+        gem_file_list.each do |gemfile|
+          spec = Gem::Format.from_file_by_path(gemfile).spec
+          abbreviate(spec)
+          sanitize(spec)
+          announce "   ... adding #{spec.full_name}"
+          @master_index.add(spec)
+          @quick_index.add(spec)
+        end
+      end
+    end
+  end
+
+  # List of gem file names to index.
+  def gem_file_list
+    Dir.glob(File.join(@directory, "gems", "*.gem"))
+  end
+
+  # Abbreviate the spec for downloading.  Abbreviated specs are only
+  # used for searching, downloading and related activities and do not
+  # need deployment specific information (e.g. list of files).  So we
+  # abbreviate the spec, making it much smaller for quicker downloads.
+  def abbreviate(spec)
+    spec.files = []
+    spec.test_files = []
+    spec.rdoc_options = []
+    spec.extra_rdoc_files = []
+    spec.cert_chain = []
+    spec
+  end
+
+  # Sanitize the descriptive fields in the spec.  Sometimes non-ASCII
+  # characters will garble the site index.  Non-ASCII characters will
+  # be replaced by their XML entity equivalent.
+  def sanitize(spec)
+    spec.summary = sanitize_string(spec.summary)
+    spec.description = sanitize_string(spec.description)
+    spec.post_install_message = sanitize_string(spec.post_install_message)
+    spec.authors = spec.authors.collect { |a| sanitize_string(a) }
+    spec
+  end
+
+  # Sanitize a single string.
+  def sanitize_string(string)
+    string ? string.to_xs : string
+  end
+end
+
+######################################################################
+# Top Level Functions 
+######################################################################
+
+def handle_options(args)
+  # default options
+  options = {
+    :directory => '.',
+    :verbose => false,
+    :quick => true,
+  }
+  
+  args.options do |opts|
+    opts.on_tail("--help", "show this message") do
+      puts opts
+      exit
+    end
+    opts.on(
+      '-d', '--dir=DIRNAME', '--directory=DIRNAME',
+      "repository base dir containing gems subdir",
+      String) do |value|
+      options[:directory] = value
+    end
+    opts.on('--[no-]quick', "include quick index") do |value|
+      options[:quick] = value
+    end
+    opts.on('-v', '--verbose', "show verbose output") do |value|
+      options[:verbose] = value
+    end
+    opts.on('-V', '--version',
+      "show version") do |value|
+      puts Gem::RubyGemsVersion
+      exit
+    end
+    opts.parse!
+  end
+  
+  if options[:directory].nil?
+    puts "Error, must specify directory name. Use --help"
+    exit
+  elsif ! File.exist?(options[:directory]) ||
+      ! File.directory?(options[:directory])
+    puts "Error, unknown directory name #{directory}."
+    exit
+  end
+  options
+end
+
+# Main program.
+def main_index(args)
+  options = handle_options(args)
+  Indexer.new(options).build_index
+end
+
+if __FILE__ == $0 then
+  main_index(ARGV)
+end