rubycut-babushka 0.10.6

data/lib/babushka/meta_dep_context.rb

@@ -0,0 +1,15 @@
+module Babushka
+  class MetaDepContext < DepContext
+
+    def self.template &block
+      @template = block unless block.nil?
+      @template
+    end
+
+    def define!
+      instance_eval(&self.class.template) unless self.class.template.nil?
+      super
+    end
+
+  end
+end

data/lib/babushka/parameter.rb

@@ -0,0 +1,143 @@
+module Babushka
+  class Parameter
+    attr_reader :name
+
+    def self.for name, value = nil
+      value.is_a?(Parameter) ? value : Parameter.new(name, value)
+    end
+
+    def initialize(name, value = nil)
+      @name = name
+      @value = value
+    end
+
+    # If #default! is set, the parameter's value will default to it lazily when
+    # it's requested, without prompting. If the parameter is set, though (i.e.
+    # if an explicit value was supplied, say on the command line), it will
+    # override the #default! value.
+    #
+    # This is useful for setting parameters that have a "standard" value of some
+    # kind that won't usually need to be customised.
+    #
+    # For example, the deps that install babushka itself use a :branch parameter
+    # that has #default! set to 'master'. This means that the installation
+    # process will install the 'master' branch without asking the user to choose
+    # a branch, but a custom branch can still be specified by passing an
+    # explicit value, for example by passing 'branch=next' on the command line.
+    def default! value
+      tap { @default_bang = value }
+    end
+
+    # If #default is set, then when this parameter lazily prompts for a value,
+    # it will pass #default to Prompt as the default. That is, Prompt will
+    # return #default's value if the user just hits 'enter', if '--defaults' was
+    # passed on the commandline, or if babushka is running on a non-terminal
+    # STDIN.
+    #
+    # This is useful for setting parameters that should be customised, or maybe
+    # just confirmed by the user, each time the dep is run.
+    #
+    # For example, the deps that install babushka itself use a :path parameter
+    # that has #default set to '/usr/local/babushka' (unless babushka is already
+    # in the path, in which case it's a non-prompting default). This means that
+    # babushka will ask for a path when it's installed, providing
+    # '/usr/local/babushka' as the "just-hit-enter" default.
+    def default value
+      tap { @default = value }
+    end
+
+    # If #ask is set, then when this parameter lazily prompts for a value, it
+    # will pass #ask to Prompt as the message. That is, Prompt will use this
+    # string, ending it with a question mark, as the question it shows to the
+    # user to give them information about the value it's requesting.
+    #
+    # For example, the deps that install babushka itself use a :path parameter.
+    # if #ask wasn't specified, it would prompt the user with just 'path?',
+    # which isn't very clear. Instead, #ask is set to 'Where would you like
+    # babushka installed', which, along with the default value, makes it clear
+    # to the user what they're being asked for.
+    def ask value
+      tap { @ask = value }
+    end
+
+    # If #choose is set, then when this parameter lazily prompts for a value, it
+    # will only accept a value that is in #choose's list.
+    #
+    # You can pass either an array or a hash to #choose. If you pass an array of
+    # values, Prompt will only accept a value that's included in the array. If
+    # you pass a hash of {value => description}, Prompt will only accept a value
+    # that's included in the hash's keys, printing a list of the corresponding
+    # descriptions before asking for the value.
+    def choose *value
+      tap {
+        @choose = if [[Hash], [Array]].include?(value.map(&:class))
+          value.first
+        else
+          value
+        end
+      }
+    end
+
+    def set?
+      !!@value
+    end
+
+    def == other
+      value == other
+    end
+
+    def / other
+      value / other
+    end
+
+    def [] other
+      value[other]
+    end
+
+    def p
+      value.p
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def to_str
+      if !value.respond_to?(:to_str)
+        raise TypeError, "Can't coerce #{value}:#{value.class.name} into a String"
+      else
+        value.to_str
+      end
+    end
+
+    def inspect
+      "#<Babushka::Parameter:#{object_id} #{description}>"
+    end
+
+    def description
+      if @value
+        "#{name}: #{@value.inspect}"
+      elsif @default_bang
+        "#{name}: [default!: #{@default_bang.inspect}]"
+      elsif @default
+        "#{name}: [default: #{@default.inspect}]"
+      else
+        "#{name}: [unset]"
+      end
+    end
+
+  private
+
+    def value
+      @value ||= @default_bang || Prompt.get_value((@ask || name).to_s, prompt_opts)
+    end
+
+    def prompt_opts
+      {}.tap {|hsh|
+        hsh[:default] = @default unless @default.nil?
+        hsh[:choices] = @choose if @choose.is_a?(Array)
+        hsh[:choice_descriptions] = @choose if @choose.is_a?(Hash)
+      }
+    end
+  end
+end

data/lib/babushka/pkg_helper.rb

@@ -0,0 +1,81 @@
+module Babushka
+  class PkgHelper
+  class << self
+    include LogHelpers
+    include ShellHelpers
+    include VersionOf::Helpers
+
+    def pkg_binary; pkg_cmd end
+
+    def all_manager_keys
+      [:apt, :brew, :macports, :yum, :binpkgsrc, :binports]
+    end
+
+    def manager_dep
+      manager_key.to_s
+    end
+
+    def has? pkg, opts = {}
+      pkg = VersionOf(pkg)
+      _has?(pkg).tap {|matching_version|
+        matching_pkg = VersionOf(pkg.name, (matching_version if matching_version.is_a?(VersionStr)))
+        unless opts[:log] == false
+          log "system #{matching_version ? "has" : "doesn't have"} #{matching_pkg} #{pkg_type}", :as => (:ok if matching_version)
+        end
+      }
+    end
+    def install! pkgs, opts = nil
+      _install! [*pkgs].map {|pkg| VersionOf(pkg) }, opts
+    end
+    def _install! pkgs, opts
+      log_shell "Installing #{pkgs.to_list} via #{manager_key}", "#{pkg_cmd} -y install #{pkgs.join(' ')} #{opts}", :sudo => should_sudo?
+    end
+    def prefix
+      cmd_dir(pkg_binary).p.dir
+    end
+    def bin_path
+      prefix / 'bin'
+    end
+    def present?
+      which pkg_binary
+    end
+    def cmd_in_path? cmd_name
+      if (_cmd_dir = cmd_dir(cmd_name)).nil?
+        log_error "The '#{cmd_name}' command is not available. You probably need to add #{bin_path} to your PATH."
+      else
+        _cmd_dir.starts_with?(prefix)
+      end
+    end
+    def should_sudo?
+      !File.writable?(bin_path)
+    end
+
+    def update_pkg_lists_if_required
+      if pkg_update_timeout.nil?
+        true # not required
+      else
+        list_age = Time.now - pkg_list_dir.mtime
+        if list_age > pkg_update_timeout
+          update_pkg_lists "#{manager_dep.capitalize} package lists are #{list_age.round.xsecs} old. Updating"
+        else
+          debug "#{manager_dep.capitalize} package lists are #{list_age.round.xsecs} old (up to date)."
+          true # up to date
+        end
+      end
+    end
+    def update_pkg_lists message = "Updating #{manager_dep.capitalize} package lists"
+      log_shell message, pkg_update_command, :sudo => should_sudo?
+    end
+    def pkg_update_timeout
+      nil # not required by default
+    end
+    def pkg_update_command
+      "#{pkg_cmd} update"
+    end
+
+    def cmdline_spec_for pkg
+      "#{pkg.name}#{" --version '#{pkg.version}'" unless pkg.version.nil?}"
+    end
+  end
+  end
+end

data/lib/babushka/pkg_helpers/apt_helper.rb

@@ -0,0 +1,61 @@
+module Babushka
+  class AptHelper < PkgHelper
+  class << self
+    def pkg_type; :deb end
+    def pkg_cmd; "env DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND='noninteractive' #{pkg_binary}" end
+    def pkg_binary
+      @_cached_pkg_binary ||= which('aptitude') ? 'aptitude' : 'apt-get'
+    end
+    def manager_key; :apt end
+
+    def _install! pkgs, opts
+      wait_for_dpkg
+      log_shell "Downloading", "#{pkg_cmd} -y -d install #{pkgs.join(' ')}", :sudo => should_sudo?
+      super
+    end
+
+    def update_pkg_lists_if_required
+      wait_for_dpkg
+      if !File.exists? '/var/lib/apt/lists/lock'
+        update_pkg_lists "Looks like apt hasn't been used on this system yet. Updating"
+      else
+        super
+      end
+    end
+
+    def source_for_system
+      {
+        :debian => 'http://archive.debian.org/debian',
+        :ubuntu => 'http://archive.ubuntu.com/ubuntu'
+      }[Base.host.flavour]
+    end
+
+    private
+    def _has? pkg_name
+      wait_for_dpkg
+      status = raw_shell("dpkg -s #{pkg_name}").stdout.val_for('Status')
+      status && status.split(' ').include?('installed')
+    end
+
+    def pkg_update_timeout
+      3600 * 24 # 1 day
+    end
+    def pkg_list_dir
+      '/var/lib/apt/lists'.p
+    end
+
+    def wait_for_dpkg
+      if dpkg_locked?
+        log_block "Looks like dpkg is already in use - waiting" do
+          sleep 1 while dpkg_locked?
+          true
+        end
+      end
+    end
+
+    def dpkg_locked?
+      which('fuser') and raw_shell('fuser -v /var/lib/dpkg/lock').stderr[/\bF..../]
+    end
+  end
+  end
+end

data/lib/babushka/pkg_helpers/base_helper.rb

@@ -0,0 +1,19 @@
+module Babushka
+  class BaseHelper < PkgHelper
+  class << self
+    def pkg_type; :unknown end
+    def manager_key; :unknown end
+    def manager_dep; nil end
+
+    private
+
+    def _install! pkgs, opts
+      raise DepDefiner::UnmeetableDep, "I don't know how to use the package manager on this system."
+    end
+
+    def _has? pkg
+      raise DepDefiner::UnmeetableDep, "I don't know how to use the package manager on this system."
+    end
+  end
+  end
+end

data/lib/babushka/pkg_helpers/binpkgsrc_helper.rb

@@ -0,0 +1,48 @@
+module Babushka
+  class BinPkgSrcHelper < PkgHelper
+  class << self
+    def existing_packages
+      shell("pkg_info -a").lines.to_a.map {|i| i.split(/\s+/)[0] }
+    end
+
+    # Note that with pkg_radd it is possible to override the default
+    # repository using PKG_PATH environment variable. See man 1 pkg_add.
+
+    def pkg_binary; 'pkg_radd' end
+    def pkg_cmd; pkg_binary end
+    def pkg_type; :pkg end
+    def manager_key; :binpkgsrc end
+
+    def update_pkg_lists_if_required
+      if !File.exists? pkg_list_dir
+        update_pkg_lists "Looks like pkg summary hasn't been fetched on this system yet. Updating"
+      else
+        super
+      end
+    end
+
+    def pkg_update_timeout
+      3600 * 24 * 14 # 2 weeks
+    end
+
+    def pkg_list_dir
+      '/usr/pkgsrc/pkg_summary'.p
+    end
+
+    def pkg_update_command
+      "pkg_search -d"
+    end
+
+    def _install! pkgs, opts
+      log_shell "Installing #{pkgs.join(', ')}", "pkg_radd #{pkgs.join(' ')}", :sudo => should_sudo?
+    end
+
+    private
+
+    def _has? pkg
+      existing_packages.any? {|i| i.match(/#{pkg}/)}
+    end
+
+  end
+  end
+end

data/lib/babushka/pkg_helpers/binports_helper.rb

@@ -0,0 +1,34 @@
+module Babushka
+  class BinPortsHelper < PkgHelper
+  class << self
+    def existing_packages
+      shell("pkg_info").lines.to_a.map {|i| i.split(/\s+/)[0] }
+    end
+
+    # Regarding FreeBSD binary packages the following should be noted:
+    #   pkg_add uses PACKAGESITE and PACKAGEROOT environment variables
+    #   to calculate the URL to download packages from.
+    #
+    #   If you're using outdated FreeBSD RELEASE branch (like 6.2-release)
+    #   that does not have anymore it's public package repository, please
+    #   either consider to move to the STABLE one (like 6-release)
+    #   or set PACKAGESITE var to point to appropriate package repository.
+
+    def pkg_binary; 'pkg_add' end
+    def pkg_cmd; "#{pkg_binary} -r" end
+    def pkg_type; :tbz end
+    def manager_key; :binports end
+
+    private
+
+    def _install! pkgs, opts
+      log_shell "Installing #{pkgs.join(', ')}", "#{pkg_cmd} #{pkgs.join(' ')}", :sudo => should_sudo?
+    end
+
+    def _has? pkg
+      existing_packages.any? {|i| i.match(/#{pkg}/)}
+    end
+
+  end
+  end
+end

data/lib/babushka/pkg_helpers/brew_helper.rb

@@ -0,0 +1,110 @@
+module Babushka
+  class BrewHelper < PkgHelper
+  class << self
+    def pkg_type; :brew end
+    def pkg_cmd; 'brew' end
+    def manager_key; :brew end
+    def manager_dep; 'homebrew' end
+
+    def _install! pkgs, opts
+      check_for_formulas(pkgs) && pkgs.all? {|pkg|
+        log "Installing #{pkg} via #{manager_key}" do
+          shell(
+            "#{pkg_cmd} install #{cmdline_spec_for pkg} #{opts}",
+            :sudo => should_sudo?,
+            :log => true,
+            :closing_status => :status_only
+          )
+        end
+      }
+    end
+
+    def update_pkg_lists_if_required
+      super.tap {|result|
+        pkg_list_dir.touch if result
+      }
+    end
+
+    def brew_path_for pkg_name
+      if active_version = active_version_of(pkg_name)
+        installed_pkgs_path / pkg_name / active_version
+      end
+    end
+
+    def should_sudo?
+      super || !installed_pkgs_path.hypothetically_writable?
+    end
+
+
+    private
+
+    class LibraryDep
+      attr_reader :names
+      def initialize *names
+        @names = names
+      end
+    end
+
+    def _has? pkg
+      versions_of(pkg).sort.reverse.detect {|version| pkg.matches? version }
+    end
+
+    def check_for_formulas pkgs
+      pkgs.all? {|pkg|
+        has_formula_for?(pkg).tap {|result|
+          log_error "There is no formula for '#{pkg}' in #{formulas_path}." unless result
+        }
+      }
+    end
+
+    def has_formula_for? pkg
+      existing_formulas.include? pkg.name
+    end
+
+    def existing_formulas
+      Dir[formulas_path / '*.rb'].map {|i| File.basename i, '.rb' }
+    end
+
+    def active_version_of pkg_name
+      shell("brew info #{pkg_name}").split("\n\n", 2).first.split("\n").map {|i|
+        i.scan(/^#{Regexp.escape(installed_pkgs_path.to_s.end_with('/'))}([^\s]+)/)
+      }.flatten.select {|i|
+        i[/\d/] # For it to be a version, it has to have at least 1 digit.
+      }.map {|i|
+        VersionOf i.split('/', 2)
+      }.max.version
+    end
+
+    def versions_of pkg
+      pkg_name = pkg.respond_to?(:name) ? pkg.name : pkg
+      Dir[
+        installed_pkgs_path / pkg_name / '*'
+      ].map {|i|
+        File.basename i.chomp('/')
+      }.reject {|i|
+        i[/\d|HEAD/].nil? # reject paths that aren't versions, like 'bin' etc
+      }.map(&:to_version)
+    end
+
+    def pkg_update_timeout
+      3600 # 1 hour
+    end
+    def pkg_list_dir
+      prefix
+    end
+
+    def installed_pkgs_path
+      prefix / 'Cellar'
+    end
+    def formulas_path
+      prefix / 'Library/Formula'
+    end
+    def formula_path_for pkg
+      formulas_path / pkg.to_s.end_with('.rb')
+    end
+    def homebrew_lib_path
+      prefix / 'Library/Homebrew'
+    end
+  end
+  end
+end