automate-it 0.9.0

data/lib/automateit/common.rb

@@ -0,0 +1,65 @@
+module AutomateIt
+  # == Common
+  #
+  # Common is the abstract class that most AutomateIt classes inherit from.
+  class Common
+    include AutomateIt::Constants
+
+    # Interpreter instance for this class.
+    attr_accessor :interpreter
+
+    # Calls #setup with +options+ for processing.
+    def initialize(options={})
+      setup(options)
+    end
+
+    # Setup the class. Options:
+    # * :interpreter - Set the Interpreter.
+    def setup(options={})
+      @interpreter = options[:interpreter] if options[:interpreter]
+    end
+
+    #---[ Interpreter aliases ]---------------------------------------------
+
+    unless defined?(AutomateIt::Interpreter) and AutomateIt::Interpreter === self
+      # See Interpreter#log
+      def log() @interpreter.log end
+
+      # See Interpreter#noop=
+      def noop=(value) @interpreter.noop=(value) end
+
+      # See Interpreter#noop
+      def noop(value) @interpreter.noop(value) end
+
+      # See Interpreter#noop?
+      def noop?() @interpreter.noop?() end
+
+      # See Interpreter#writing=
+      def writing=(value) @interpreter.writing=(value) end
+
+      # See Interpreter#writing
+      def writing(value) @interpreter.writing(value) end
+
+      # See Interpreter#writing?
+      def writing?() @interpreter.writing?() end
+
+      # See Interpreter#preview?
+      def preview?() @interpreter.preview?() end
+
+      # See Interpreter#preview
+      def preview(value=nil) @interpreter.preview(value) end
+
+      # See Interpreter#preview=
+      def preview=(value) @interpreter.preview=(value) end
+
+      # See Interpreter#preview_for
+      def preview_for(message, &block) @interpreter.preview_for(message, &block) end
+
+      # See Interpreter#superuser?
+      def superuser?() @interpreter.superuser? end
+      
+      # See Interpreter#nitpick
+      def nitpick(value=nil) @interpreter.nitpick(value) end
+    end
+  end
+end

data/lib/automateit/constants.rb

@@ -0,0 +1,35 @@
+module AutomateIt # :nodoc:
+  # === AutomateIt::Constants
+  #
+  # Various constants.
+  module AutomateIt::Constants
+    INSTALL_DIR = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+
+    HELPERS_DIR = File.join(INSTALL_DIR, "helpers")
+
+    # Output prefix for command execution, e.g., "** ls -la"
+    PEXEC = "** "
+
+    # Output prefix for notes, e.g., "=> Something happened"
+    PNOTE = "=> "
+
+    # Output prefix for errors, e.g., "!! Something bad happened"
+    PERROR = "!! "
+
+    # Boilerplate to add to tops of generated files, warning people not to edit
+    # them directly.
+    WARNING_BOILERPLATE = <<-HERE
+# +---------------------------------------------------------------------+
+# | WARNING: Do NOT edit this file directly or your changes will be     |
+# | lost. If you need to change this file, you must incorporate your    |
+# | changes into the AutomateIt project that created it. If you don't   |
+# | know what this means, please talk to your system administrator.     |
+# +---------------------------------------------------------------------+
+#
+    HERE
+  end
+
+  # Inject constants back into top, providing AutomateIt::VERSION and such.
+  module_eval { include Constants }
+end
+

data/lib/automateit/download_manager.rb

@@ -0,0 +1,48 @@
+# == DownloadManager
+#
+# The DownloadManager provides a way of downloading files.
+module AutomateIt
+  class DownloadManager < Plugin::Manager
+    alias_methods :download
+
+    # Downloads the +source+ document.
+    #
+    # Options:
+    # * :to -- Saves source to this filename or directory. Defaults to current directory.
+    def download(*arguments) dispatch(*arguments) end
+
+    # == DownloadManager::BaseDriver
+    #
+    # Base class for all DownloadManager drivers.
+    class BaseDriver < Plugin::Driver
+    end
+
+    # == DownloadManager::OpenURI
+    #
+    # A DownloadManager driver using the OpenURI module for handling HTTP and FTP transfers.
+    class OpenURI < BaseDriver
+      depends_on :libraries => %w(open-uri)
+
+      def suitability(method, *args) # :nodoc:
+        return available? ? 1 : 0
+      end
+
+      # See DownloadManager#download
+      def download(*arguments)
+        args, opts = args_and_opts(*arguments)
+        source = args[0] or raise ArgumentError.new("No source specified")
+        target = args[1] || opts[:to] || File.basename(source)
+        target = File.join(target, File.basename(source)) if File.directory?(target)
+        log.info(PNOTE+"Downloading #{target}")
+        if writing?
+          open(target, "w+") do |writer|
+            open(source) do |reader|
+              writer.write(reader.read)
+            end
+          end
+        end
+        return writing?
+      end
+    end
+  end
+end

data/lib/automateit/edit_manager.rb

@@ -0,0 +1,321 @@
+# == EditManager
+#
+# The EditManager provides a way of editing files and strings
+# programmatically.
+#
+# See documentation for EditManager::EditSession.
+class AutomateIt::EditManager < AutomateIt::Plugin::Manager
+  alias_methods :edit
+
+  # Creates an editing session. See documentation for EditManager::EditSession.
+  def edit(*opts, &block) dispatch(*opts, &block) end
+end
+
+# == EditManager::BaseDriver
+#
+# Base class for all EditManager drivers.
+class AutomateIt::EditManager::BaseDriver < AutomateIt::Plugin::Driver
+end
+
+# == EditManager::Simple
+#
+# Provides a way to edit files and strings.
+#
+# See documentation for EditSession.
+class AutomateIt::EditManager::Simple < AutomateIt::EditManager::BaseDriver
+  depends_on :nothing
+
+  def suitability(method, *args) # :nodoc:
+    1
+  end
+
+  # Creates an editing session. See documentation for EditSession#edit.
+  def edit(*opts, &block)
+    AutomateIt::EditManager::EditSession.new(:interpreter => @interpreter).edit(*opts, &block)
+  end
+end # class Base
+
+# == EditSession
+#
+# EditSession provides a way to edit files and strings.
+#
+# For example, here's how to edit a string from the Interpreter:
+#
+#   edit(:text => "# hello") do
+#     uncomment "llo"
+#     append "world"
+#   end
+#   # => "hello\nworld"
+#
+# The above example edits a text string containing "# hello". The editing
+# session uncomments the line containing "llo" and then appends a line with the
+# word "world". The edited result is returned, containing two lines: "hello"
+# and "world".
+#
+# The edit session only makes changes if they're needed. In the above example,
+# once the "hello" line is uncommented, the "uncomment" command won't do
+# anything. Similarly, once the word "world" has been appended, it won't be
+# appended again. So if you re-edit the resulting string, it won't be changed
+# because it's already in the desired state.
+#
+# This approach simplifies editing because you only need to specify the
+# commands that are needed to change the file, and the session will figure out
+# which ones to run.
+class AutomateIt::EditManager::EditSession < AutomateIt::Common
+  # Create an EditSession.
+  #
+  # Options:
+  # * :interpreter -- AutomateIt Interpreter, required. Will be automatically
+  #   set if you use AutomateIt::Interpreter#edit.
+  def initialize(*args)
+    super(*args)
+    interpreter.add_method_missing_to(self)
+  end
+
+  # Edit a file or string.
+  #
+  # Requires a filename argument or options hash -- e.g.,.
+  # <tt>edit("foo")</tt> and <tt>edit(:file => "foo")</tt> will both edit a
+  # file called +foo+.
+  #
+  # Options:
+  # * :file -- File to edit.
+  # * :text -- String to edit.
+  # * :params -- Hash to make available to editor session.
+  # * :create -- Create the file if it doesn't exist? Defaults to false.
+  # * :mode, :user, :group -- Set permissions on generated file, see ShellManager#chperm
+  # * :backup -- Make a backup of original file? Defaults to true.
+  #
+  # Edit a string:
+  #
+  #   edit(:text => "foo") do
+  #     replace "o", "@"
+  #   end
+  #   # => "f@@"
+  #
+  # Edit a file and pass parameters to the editing session:
+  #
+  #   edit(:file => "myfile", :params => {:greet => "world"} do
+  #     prepend "MyHeader"
+  #     append "Hello "+params[:greet]
+  #   end
+  #
+  # Edit a file, create it and set permissions if necessary:
+  #
+  #   edit("/tmp/foo", :create => true, :mode => 0600, :user => :root) do
+  #     prepend "Hello world!"
+  #   end
+  def edit(*a, &block)
+    args, opts = args_and_opts(*a)
+    if args.first
+      @filename = args.first
+    else
+      raise ArgumentError.new("no file or text specified for editing") unless opts[:file] or opts[:text]
+      @filename = opts[:file]
+      @contents = opts[:text]
+    end
+    @params = opts[:params] || {}
+    @is_backup = opts[:backup].nil? ? true : opts[:backup]
+    @comment_prefix = "# "
+    @comment_suffix = ""
+    begin
+      @contents ||= _read || ""
+    rescue Errno::ENOENT => e
+      if opts[:create]
+        @contents = ""
+      else
+        raise e
+      end
+    end
+    @original_contents = @contents.clone
+
+    raise ArgumentError.new("no block given") unless block
+    instance_eval(&block)
+    if @filename
+      if different?
+        _backup if @is_backup
+        _write
+      end
+
+      chperm_opts = {}
+      for key in [:owner, :user, :group, :mode]
+        chperm_opts[key] = opts[key] if opts[key]
+      end
+      chperm(@filename, chperm_opts) unless chperm_opts.empty?
+
+      return different?
+    else
+      return contents
+    end
+  end
+
+  # File that was read for editing.
+  attr_accessor :filename
+
+  # Current contents of the editing buffer.
+  attr_accessor :contents
+
+  # Original contents of the editing buffer before any changes were made.
+  attr_accessor :original_contents
+
+  # Hash of parameters to make available to the editing session.
+  attr_accessor :params
+
+  # Comment prefix, e.g., "/*"
+  attr_accessor :comment_prefix
+
+  # Comment suffix, e.g., "*/"
+  attr_accessor :comment_suffix
+
+  # Prepend +line+ to the top of the buffer, but only if it's not in this
+  # file already.
+  #
+  # Options:
+  # * :unless -- Look for this String or Regexp instead and don't prepend
+  #   if it matches.
+  #
+  # Example:
+  #   # Buffer's contents are 'add    this line'
+  #
+  #   # This will prepend a line because they're not identical.
+  #   prepend("add this line")
+  #
+  #   # Won't prepend line because Regexp matches exisint line in buffer.
+  #   prepend("add this line", :unless => /add\s*this\*line/)
+  def prepend(line, opts={})
+    query = opts[:unless] || line
+    if query.is_a?(String)
+      query = Regexp.new(Regexp.escape(query))
+    end
+    return if contains?(query)
+    @contents = "%s\n%s" % [line.chomp, @contents]
+  end
+
+  # Append +line+ to the bottom of the buffer, but only if it's not in
+  # this file already.
+  #
+  # Options:
+  # * :unless -- Look for this String or Regexp instead and don't append
+  #   if it matches.
+  #
+  # See example for #prepend.
+  def append(line, opts={})
+    query = opts[:unless] || line
+    if query.is_a?(String)
+      query = Regexp.new(Regexp.escape(query))
+    end
+    return if contains?(query)
+    @contents = "%s\n%s\n" % [@contents.chomp, line]
+  end
+
+  # Does the buffer contain anything that matches the String or Regexp +query+?
+  def contains?(line)
+    query = line.is_a?(String) ? Regexp.new(Regexp.escape(line)) : line
+    ! @contents.match(query).nil?
+  end
+
+  # Delete lines matching the String or Regexp +query+
+  def delete(line, opts={})
+    query = line.is_a?(String) ? Regexp.escape(line) : line
+    query = Regexp.new("^[^\n]*%s[^\n]*\n?" % query)
+    @contents.gsub!(query, "")
+  end
+
+  # Specify the comment style's +prefix+ and +suffix+.
+  #
+  # Example:
+  #   # C style comments
+  #   comment_style "/*", "*/"
+  def comment_style(prefix, suffix="")
+    @comment_prefix = prefix
+    @comment_suffix = suffix
+  end
+
+  # Comment out lines matching the String or Regexp +query+.
+  def comment(line, opts={})
+    query = line.is_a?(String) ? Regexp.escape(line) : line
+    query = Regexp.new("^(?!#{comment_prefix})([^\n]*%s[^\n]*)(\n*)" % query)
+    return false unless @contents.match(query)
+    @contents.gsub!(query, "%s%s%s%s" % [@comment_prefix, $1, @comment_suffix, $2])
+  end
+
+  # Uncomment lines matching the String or Regexp +query+.
+  def uncomment(line, opts={})
+    query = line.is_a?(String) ? Regexp.escape(line) : line
+    query = Regexp.new("^(%s)([^\n]*%s[^\n]*)(%s)(\n*)" % [@comment_prefix, query, @comment_suffix])
+    return false unless @contents.match(query)
+    @contents.gsub!(query, "%s%s" % [$2, $4])
+  end
+
+  # Replace contents matching the String or Regexp +query+ with the +string+.
+  def replace(line, string, opts={})
+    query = line.is_a?(String) ? Regexp.new(Regexp.escape(line)) : line
+    @contents.gsub!(query, string)
+  end
+
+  # Manipulate the buffer. The result of your block will replace the
+  # buffer. This is very useful for complex edits.
+  #
+  # Example:
+  #   manipulate do |buffer|
+  #     buffer.gsub(/foo/, "bar")
+  #   end
+  def manipulate(&block) # :yields: buffer
+    @contents = block.call(@contents)
+  end
+
+  # Is the buffer currently different than its original contents?
+  def different?
+    @contents != @original_contents
+  end
+
+protected
+
+  # Read contents from #filename. Called by the #edit command to load text
+  # into the buffer.
+  def _read
+    @contents = \
+      if writing? or (preview? and @filename and _exists? and _readable?)
+        File.read(@filename)
+      elsif preview? and not _readable?
+        log.info(PNOTE+"Not allowed to read file, previewing edits as if it doesn't exist: #{@filename}")
+        nil
+      else
+        nil
+      end
+  end
+
+  # Write contents to #filename. Used by the #edit command to write the buffer
+  # to a file.
+  def _write
+    return false unless @filename
+    log.info(PNOTE+"Edited '#{@filename}'")
+    if preview?
+      true
+    else
+      File.open(@filename, "w+"){|writer| writer.write(@contents)}
+    end
+  end
+
+  # Backup the original file.
+  def _backup
+    return false unless @filename and File.exists?(@filename)
+    result = nil
+    log.silence(Logger::WARN) do
+      result = backup(@filename)
+    end
+    log.debug(PNOTE+"Saved '#{@filename}' to '#{result}'")
+  end
+
+  # Does the file exist?
+  def _exists?
+    File.exists?(@filename)
+  end
+
+  # Is the file readable?
+  def _readable?
+    FileTest.readable?(@filename)
+  end
+
+
+end # class EditSession