automateit 0.80116 → 0.80624

data/lib/automateit/package_manager.rb.orig

@@ -1,256 +0,0 @@
-# == PackageManager
-#
-# The PackageManager provides a way to manage packages, e.g., install,
-# uninstall and query if the Apache package is installed with APT.
-#
-# Examples:
-#
-#   package_manager.installed?("apache2") # => false
-#   package_manager.install("apache2") # => true
-#   package_manager.installed?("apache2") # => true
-#   package_manager.uninstall("apache2") # => true
-#   package_manager.not_installed("apache2") # => true
-#
-# Commands can accept arrays:
-#
-#   package_manager.install("apache2", "bash")
-#   package_manager.installed? %w(apache2 bash)
-#
-# Commands can also accept a single, annotated string as a manifest -- useful
-# for installing large numbers of packages at once:
-#
-#   package_manager.install <<HERE, :with => :apt
-#     # One per line
-#     apache
-#     bash
-#
-#     # Or many on the same line
-#     sysvconfig sysv-rc-conf
-#   HERE
-#
-# Commands can also accept a hash of names to paths -- necessary for installing
-# packages stored on the filesystem:
-#
-#   # Is the package called "TracTags" installed? If not, run the installer
-#   # with the "/tmp/tractags_latest" path as an argument:
-#   package.manager.install({"TracTags" => "/tmp/tractags_latest"}, :with => :egg)
-class AutomateIt::PackageManager < AutomateIt::Plugin::Manager
-  # Alias for #install
-  def add(*packages) dispatch_to(:install, *packages) end
-
-  # Alias for #uninstall
-  def remove(*packages) dispatch_to(:uninstall, *packages) end
-
-  # Are these +packages+ installed?
-  #
-  # Options:
-  # * :details -- Returns an array containing the boolean result value and an
-  #   array with a subset of installed +packages+. Boolean, defaults to false.
-  def installed?(*packages) dispatch(*packages) end
-
-  # Are these +packages+ not installed? 
-  #
-  # Options:
-  # * :details -- Returns an array containing the boolean result value and an
-  #   array with a subset of +packages+ not installed. Boolean, defaults to false.
-  def not_installed?(*packages) dispatch(*packages) end
-
-  # Install these +packages+. Returns +true+ if any packages are installed
-  # successfully; or +false+ if all packages were already installed.
-  def install(*packages) dispatch(*packages) end
-
-  # Uninstall these +packages+. Returns +true+ if any packages are uninstalled
-  # successfully; or +false+ if none of the packages are installed.
-  def uninstall(*packages) dispatch(*packages) end
-end
-
-# == PackageManager::BaseDriver
-#
-# Base class for all PackageManager drivers.
-class AutomateIt::PackageManager::BaseDriver < AutomateIt::Plugin::Driver
-  protected
-
-  # Are these +packages+ installed? Works like PackageManager#installed?
-  # but calls a block that actually checks whether the packages are
-  # installed and returns an array of packages installed.
-  #
-  # For example:
-  #   _installed_helper?("package1", "package2", :details => true) do |packages, opts|
-  #     # Dummy code which reports that these packages are installed:
-  #     ["package1]
-  #   end
-  def _installed_helper?(*packages, &block) # :yields: filtered_packages, opts
-    _raise_unless_available
-
-    packages, opts = args_and_opts(*packages)
-    packages = _list_normalizer(packages)
-    packages = packages.keys if Hash === packages
-
-    available = block.call(packages, opts)
-    truth = (packages - available).empty?
-    result = opts[:details] ? [truth, available] : truth
-    log.debug(PNOTE+"installed?(#{packages.inspect}) => #{truth}: #{available.inspect}")
-    return result
-  end
-
-  # Are these +packages+ not installed?
-  def _not_installed_helper?(*packages)
-    _raise_unless_available
-
-    # Requires that your PackageManager#installed? method is implemented.
-    packages, opts = args_and_opts(*packages)
-    packages = _list_normalizer(packages)
-    packages = packages.keys if Hash === packages
-
-    available = [installed?(packages, :details => true)].flatten
-    missing = packages - available
-    truth = (packages - missing).empty?
-    result = opts[:details] ? [truth, missing] : truth
-    log.debug(PNOTE+"not_installed?(#{packages.inspect}) => #{truth}: #{missing.inspect}")
-    return result
-  end
-
-  # Install these +packages+. Works like PackageManager#install but calls a
-  # block that's responsible for actually installing the packages and
-  # returning true if the installation succeeded. This block is only called
-  # if packages need to be installed and receives a filtered list of
-  # packages that are guaranteed not to be installed on the system already.
-  #
-  # For example:
-  #   _install_helper("package1", "package2", :quiet => true) do |packages, opts|
-  #     # Dummy code that installs packages here, e.g:
-  #     system("apt-get", "install", "-y", packages)
-  #   end
-  def _install_helper(*packages, &block) # :yields: filtered_packages, opts
-    _raise_unless_available
-
-    packages, opts = args_and_opts(*packages)
-    packages = _list_normalizer(packages)
-
-    check_packages = \
-      case packages
-      when Hash
-        packages.keys
-      else 
-        packages
-      end
-
-    missing = not_installed?(check_packages, :details => true)[1]
-    return false if missing.blank?
-
-    install_packages = \
-      case packages
-      when Hash
-        missing.map{|t| packages[t]}
-      else 
-        missing
-      end
-    block.call(install_packages, opts)
-
-    return true if preview?
-    unless (failed = not_installed?(check_packages, :details => true)[1]).empty?
-      raise ArgumentError.new("Couldn't install: #{failed.join(' ')}")
-    else
-      return true
-    end
-  end
-
-  # Uninstall these +packages+. Works like PackageManager#uninstall but calls a
-  # block that's responsible for actually uninstalling the packages and
-  # returning true if the uninstall succeeded. This block is only called
-  # if packages need to be uninstalled and receives a filtered list of
-  # packages that are guaranteed to be installed on the system.
-  #
-  # For example:
-  #   _uninstall_helper("package1", "package2", :quiet => true) do |packages, opts|
-  #     # Dummy code that removes packages here, e.g:
-  #     system("apt-get", "remove", "-y", packages)
-  #   end
-  def _uninstall_helper(*packages, &block) # :yields: filtered_packages, opts
-    _raise_unless_available
-
-    packages, opts = args_and_opts(*packages)
-    packages = _list_normalizer(packages)
-
-    check_packages = \
-      case packages
-      when Hash
-        packages.keys
-      else 
-        packages
-      end
-
-    present = installed?(check_packages, :details => true)[1]
-    return false if present.blank?
-
-    uninstall_packages = \
-      case packages
-      when Hash
-        present.map{|t| packages[t]}
-      else 
-        present
-      end
-    block.call(uninstall_packages, opts)
-
-    return true if preview?
-    unless (failed = installed?(check_packages, :details => true)[1]).empty?
-      raise ArgumentError.new("Couldn't uninstall: #{failed.join(' ')}")
-    else
-      return true
-    end
-  end
-
-  # Returns a normalized array of packages. Transforms manifest string into
-  # packages. Turns symbols into string, strips blank lines and comments.
-  def _list_normalizer(*packages)
-    packages = [packages].flatten
-    if packages.size == 1
-      packages = packages.first
-      nitpick "LN SI %s" % packages.inspect
-      nitpick "LN Sc %s" % packages.class
-      case packages
-      when Symbol
-        nitpick "LN Sy"
-        packages = [packages.to_s]
-      when String
-        nitpick "LN Ss"
-        packages = packages.scan(LIST_NORMALIZER_RE).join(" ").split
-      when Hash
-        # Don't do anything
-        nitpick "LN Sh"
-      else
-        nitpick "LN S?"
-        raise TypeError.new("Unknown input type: #{packages.class}")
-      end
-      nitpick "LN SO %s" % packages.inspect
-    end
-
-    case packages
-    when Array
-      result = packages.map(&:to_s).grep(LIST_NORMALIZER_RE)
-    when Hash
-      result = packages.stringify_keys
-    when Symbol, String
-      result = packages.to_s
-    else
-      raise TypeError.new("Unknown input type: #{packages.class}")
-    end
-
-    nitpick "LN RR %s" % result.inspect
-    return result
-  end
-
-  # Expression for matching packages in arguments
-  LIST_NORMALIZER_RE = /^\s*([^\s#]+)/
-end
-
-# Drivers
-require 'automateit/package_manager/dpkg'
-require 'automateit/package_manager/apt'
-require 'automateit/package_manager/yum'
-require 'automateit/package_manager/gem'
-require 'automateit/package_manager/egg'
-require 'automateit/package_manager/portage'
-require 'automateit/package_manager/pear'
-require 'automateit/package_manager/pecl'
-require 'automateit/package_manager/cpan'

data/misc/setup_ruby-dbi.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env automateit
-
-# Install ruby-dbi package and the basic drivers
-
-package_manager.install <<-HERE, :with => :gem
-  postgres-pr
-  sqlite3-ruby
-  ### mysql # FIXME Fails because of compile dependencies
-HERE
-
-mktempdircd do
-  download "http://rubyforge.org/frs/download.php/12368/dbi-0.1.1.tar.gz"
-  sh "tar xvfz *.tar.gz"
-  extracted_to = Dir.entries(".").select{|t| t=~/\w+/ && File::directory?(t)}.first
-  cd extracted_to do
-    # FIXME mysql and sqlite fail due to compile dependencies
-    ### ruby setup.rb config --with=dbi,dbd_pg,dbd_mysql,dbd_sqlite && \
-    sh <<-HERE
-      ruby setup.rb config --with=dbi,dbd_pg && \
-      ruby setup.rb setup && \
-      ruby setup.rb install
-    HERE
-  end
-end

data/spec/integration/package_manager_spec.rb.orig

@@ -1,123 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
-
-PACKAGE_FOUND_ERROR = %q{ERROR: Found the '%s' package installed for %s. You're probably not using this obscure package and should remove it so that this test can run. In the unlikely event that you actually rely on this package, change the spec to test with another unused package.}
-PACKAGE_DRIVER_MISSING_ERROR = "NOTE: Can't check %s on this platform, #{__FILE__}"
-
-if not INTERPRETER.euid?
-  puts "NOTE: Can't check 'euid' on this platform, #{__FILE__}"
-elsif not INTERPRETER.superuser?
-  puts "NOTE: Must be root to check #{__FILE__}"
-else
-  describe "AutomateIt::PackageManager", :shared => true do
-    before(:all) do
-      @level = Logger::WARN
-      @a = AutomateIt.new(:verbosity => @level)
-      @m = @a.package_manager
-      @fake_package = "not_a_real_package"
-    end
-
-    after(:all) do
-      @d.uninstall(@package, :quiet => true)
-    end
-
-    def uninstall_package(packages, opts={})
-      opts[:quiet] = true
-      return @d.uninstall(packages, opts)
-    end
-
-    def install_package(packages, opts={})
-      opts[:quiet] = true
-      opts[:force] = [:pecl, :pear].include?(@d.token)
-      return @d.install(packages, opts)
-    end
-
-    # Some specs below leave side-effects which others depend on, although
-    # these are clearly documented within the specs. This is necessary
-    # because doing proper setup/teardown for each test would make it run 5x
-    # slower and take over a minute. Although this approach is problematic,
-    # the performance boost is worth it.
-
-    it "should not install an invalid package" do
-      @d.log.silence(Logger::FATAL) do
-        lambda{ install_package(@fake_package) }.should raise_error(ArgumentError)
-      end
-    end
-
-    it "should install a package" do
-      install_package(@package).should be_true
-      # Leaves behind an installed package
-    end
-
-    it "should not re-install an installed package" do
-      # Expects package to be installed
-      install_package(@package).should be_false
-    end
-
-    it "should find an installed package" do
-      # Expects package to be installed
-      @d.installed?(@package).should be_true
-      @d.not_installed?(@package).should be_false
-    end
-
-    it "should not find a package that's not installed" do
-      @d.installed?(@fake_package).should be_false
-      @d.not_installed?(@fake_package).should be_true
-    end
-
-    it "should find group of packages" do
-      @d.installed?(@package, @fake_package, :details => true).should == [false, [@package]]
-      @d.not_installed?(@package, @fake_package, :details => true).should == [false, [@fake_package]]
-      # Leaves behind an installed package
-    end
-
-    it "should uninstall a package" do
-      # Expects package to be installed
-      uninstall_package(@package).should be_true
-    end
-
-    it "should not uninstall a package that's not installed" do
-      uninstall_package(@package).should be_false
-    end
-  end
-
-  #-----------------------------------------------------------------------
-
-  targets = {
-#    :apt => "nomarch", # Obscure package for extracting ARC files from the 80's
-#    :yum => "nomarch", # Obscure package for extracting ARC files from the 80's
-#    :portage => "arc", # Obscure package for extracting ARC files from the 80's
-#    :gem => "s33r", # Alpha-grade package its author deprecated in favor of another
-#    :egg => "_sre.py", # Slower reimplementation of ancient Python Regexps
-#    :pear => "File_DICOM", # Obscure package for DICOM X-rays, abandoned in 2003
-#    :pecl => "ecasound", # Obscure package for Ecasound libs, abandoned in 2003
-    :cpan => "Acme::please", # Insane gimmick port of intercal's please statements
-  }
-
-  if INTERPRETER.tagged?(:centos)
-    # CentOS lacks "nomarch", so use a less obscure archiver from the early 90's.
-    targets[:yum] = "arj"
-  end
-
-  targets.each_pair do |driver_token, package|
-    # Run the following from the shell to skip package tests:
-    #   export AUTOMATEIT_SPEC_SKIP_PACKAGES=1
-    # Or clear it out:
-    #   unset AUTOMATEIT_SPEC_SKIP_PACKAGES
-    next unless ENV["AUTOMATEIT_SPEC_SKIP_PACKAGES"].nil?
-
-    driver = INTERPRETER.package_manager[driver_token]
-    if driver.available?
-      describe driver.class.to_s do
-        it_should_behave_like "AutomateIt::PackageManager"
-
-        before(:all) do
-          @d = @m[driver_token]
-          @package = package
-          raise PACKAGE_FOUND_ERROR % [@package, @d.class] if @d.installed?(@package)
-        end
-      end
-    else
-      puts PACKAGE_DRIVER_MISSING_ERROR % driver.class
-    end
-  end
-end