rubycut-babushka 0.10.8 → 0.15.6.1

data/lib/babushka/helpers/uri_helpers.rb

@@ -2,13 +2,7 @@ module Babushka
   module UriHelpers
 
     def setup_source_uris
-      parse_uris
-      requires_when_unmet(@uris.map(&:scheme).uniq & %w[ git ])
-    end
-
-    def parse_uris
-      @uris = source.map(&uri_processor(:escape)).map(&uri_processor(:parse))
-      @extra_uris = extra_source.map(&uri_processor(:escape)).map(&uri_processor(:parse)) if respond_to?(:extra_source)
+      deprecated! '2013-04-21', :method_name => "#setup_source_uris isn't required anymore and now has no effect, and so"
     end
 
     def uri_processor(method_name)
@@ -16,20 +10,17 @@ module Babushka
     end
 
     def process_sources &block
-      @extra_uris.each {|uri| handle_source uri } unless @extra_uris.nil?
-      @uris.all? {|uri| handle_source uri, &block } unless @uris.nil?
+      deprecated! '2013-04-21', :instead => 'sources.each {|uri| Resource.extract(uri) { ... } }'
+      uris = source.map(&uri_processor(:escape)).map(&uri_processor(:parse))
+      extra_uris = extra_source.map(&uri_processor(:escape)).map(&uri_processor(:parse)) if respond_to?(:extra_source)
+
+      extra_uris.each {|uri| Resource.extract(uri) } unless extra_uris.nil?
+      uris.all? {|uri| Resource.extract(uri, &block) } unless uris.nil?
     end
 
     def handle_source uri, &block
-      uri = uri_processor(:parse).call(uri) unless uri.is_a?(URI)
-      case uri.scheme
-      when 'git'
-        git uri, &block
-      when 'http', 'https', 'ftp', nil # We let `curl` work out the protocol if it's nil.
-        Resource.extract uri, &block
-      else
-        log_error "Babushka can't handle #{uri.scheme}:// URLs yet. But it can if you write a patch! :)"
-      end
+      deprecated! '2013-04-21', :instead => 'Resource.extract(uri) { ... }'
+      Resource.extract uri, &block
     end
 
   end

data/lib/babushka/lambda_chooser.rb

@@ -1,5 +1,8 @@
 module Babushka
   class LambdaChooser
+    DEPRECATED_CHOICES = {
+      :macports => ['2012-12-13', :brew]
+    }
 
     attr_reader :owner
 
@@ -14,26 +17,30 @@ module Babushka
     end
 
     def choose choices, method_name = nil
-      self.class.send :alias_method, (method_name || :on), :process_choice
+      self.metaclass.send :alias_method, method_name, :on unless method_name.nil?
       block_result = instance_eval(&@block)
-      @results.empty? ? block_result : [*choices].push(:otherwise).pick {|c| @results[c] }
+      @results.empty? ? block_result : [choices].flatten(1).push(:otherwise).pick {|c| @results[c] }
     end
 
     def otherwise first = nil, *rest, &block
-      process_choice :otherwise, first, *rest, &block
+      on :otherwise, first, *rest, &block
     end
 
-    def process_choice choice, first = nil, *rest, &block
+    def on choices, first = nil, *rest, &block
       raise "You can supply values or a block, but not both." if first && block
-      raise "The choice '#{choice}' isn't valid." unless @possible_choices.include?(choice)
-
-      @results[choice] = if block
-        block
-      elsif first.is_a? Hash
-        first
-      else
-        [*first].concat(rest)
-      end
+
+      [choices].flatten(1).each {|choice|
+        raise "The choice '#{choice}' isn't valid." unless @possible_choices.include?(choice)
+        LogHelpers.log_warn "The #{choice.inspect} choice has been deprecated and will be removed on #{DEPRECATED_CHOICES[choice].first}. Use #{DEPRECATED_CHOICES[choice].last.inspect} instead." if DEPRECATED_CHOICES.keys.include?(choice)
+
+        @results[choice] = if block
+          block
+        elsif first.is_a? Hash
+          first
+        else
+          [first].flatten(1).concat(rest)
+        end
+      }
     end
 
   end

data/lib/babushka/parameter.rb

@@ -102,6 +102,10 @@ module Babushka
       value.to_s
     end
 
+    def to_a
+      value.to_a
+    end
+
     def to_str
       if !value.respond_to?(:to_str)
         raise TypeError, "Can't coerce #{value}:#{value.class.name} into a String"
@@ -110,17 +114,21 @@ module Babushka
       end
     end
 
+    def current_value
+      @value
+    end
+
     def inspect
       "#<Babushka::Parameter:#{object_id} #{description}>"
     end
 
     def description
       if @value
-        "#{name}: #{@value.inspect}"
+        "#{name}: #{inspect_truncated(@value)}"
       elsif @default_bang
-        "#{name}: [default!: #{@default_bang.inspect}]"
+        "#{name}: [default!: #{inspect_truncated(@default_bang)}]"
       elsif @default
-        "#{name}: [default: #{@default.inspect}]"
+        "#{name}: [default: #{inspect_truncated(@default)}]"
       else
         "#{name}: [unset]"
       end
@@ -129,7 +137,15 @@ module Babushka
   private
 
     def value
-      @value ||= @default_bang || Prompt.get_value((@ask || name).to_s, prompt_opts)
+      @value || @default_bang || prompted_value
+    end
+
+    def prompted_value
+      @prompted_value ||= Prompt.get_value((@ask || name).to_s, prompt_opts)
+    end
+
+    def inspect_truncated value
+      value.inspect.sub(/^(.{50})(.{3}).*/m, '\1...')
     end
 
     def prompt_opts

data/lib/babushka/path_checker.rb

@@ -0,0 +1,72 @@
+module Babushka
+  class PathChecker
+    extend ShellHelpers
+
+    def self.in_path? provided_list
+      commands = [provided_list].flatten(1).versions
+
+      cmds_in_path?(commands) and matching_versions?(commands) {|cmd|
+        shell("#{cmd.name} --version 2>&1")
+      }
+    end
+
+    private
+
+    def self.cmds_in_path? commands
+      dir_hash = [*commands].group_by {|cmd| cmd_dir(cmd.name) }
+
+      if dir_hash.keys.compact.length > 1
+        log_error "These commands run from more than one place."
+        log_error dir_hash.values.map {|cmds|
+            cmd_location_str_for cmds
+          }.to_list(:oxford => true, :conj => 'but').end_with('.')
+        unmeetable! unless Prompt.confirm("Multiple installations might indicate a problem. Meet anyway?", :default => 'n')
+      else
+        dir_hash[nil].blank?.tap {|result|
+          if result
+            cmds = dir_hash.values.first
+            log cmd_location_str_for(cmds).end_with('.') unless cmds.blank?
+          else
+            log "#{dir_hash[nil].map {|i| "'#{i}'" }.to_list} #{dir_hash[nil].length == 1 ? 'is' : 'are'} missing."
+          end
+        }
+      end
+    end
+
+    def self.matching_versions? commands
+      versions = commands.select {|cmd|
+        !cmd.version.nil?
+      }.inject({}) {|hsh,cmd|
+        potential_versions = match_potential_versions(yield(cmd), cmd.version)
+        if potential_versions.empty?
+          # No potential versions to check against.
+        else
+          hsh[cmd] = potential_versions.detect {|piece| cmd.matches?(piece) }
+          if hsh[cmd] == cmd.version
+            log_ok "#{cmd.name} is #{cmd.version}."
+          else
+            log "#{cmd.name} is #{hsh[cmd] || potential_versions.first}, which is#{"n't" unless hsh[cmd]} #{cmd.version}.", :as => (:ok if hsh[cmd])
+          end
+        end
+        hsh
+      }
+      versions.values.all?
+    end
+
+    def self.match_potential_versions str, example = ''
+      (str || '').split(/[^\w\.\-]+/).map {|piece|
+        begin
+          piece.to_version
+        rescue VersionStrError
+          nil
+        end
+      }.compact.reject {|piece|
+        piece.to_s['.'].nil? if example.to_s['.']
+      }
+    end
+
+    def self.cmd_location_str_for cmds
+      "#{cmds.map {|i| "'#{i.name}'" }.to_list(:conj => '&')} run#{'s' if cmds.length == 1} from #{cmd_dir(cmds.first.name)}"
+    end
+  end
+end

data/lib/babushka/pkg_helper.rb

@@ -3,42 +3,52 @@ module Babushka
   class << self
     include LogHelpers
     include ShellHelpers
-    include VersionOf::Helpers
 
     def pkg_binary; pkg_cmd end
 
+    def manager_dep
+      'package manager'.with(pkg_binary)
+    end
+
     def all_manager_keys
-      [:apt, :brew, :macports, :yum, :binpkgsrc, :binports]
+      [:apt, :pacman, :brew, :macports, :yum, :binpkgsrc, :binports]
     end
 
-    def manager_dep
-      manager_key.to_s
+    def present?
+      which pkg_binary
     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)))
+      pkg = Babushka.VersionOf(pkg)
+      has_pkg?(pkg).tap {|matching_version|
+        matching_pkg = Babushka.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
+      install_pkgs! [*pkgs].map {|pkg| Babushka.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?
+
+    def handle_install! pkgs, opts = nil
+      if [*pkgs].empty?
+        log "Nothing to install on #{manager_key}-based systems."
+      else
+        update_pkg_lists_if_required
+        install! pkgs, opts
+      end
     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."
@@ -46,6 +56,7 @@ module Babushka
         _cmd_dir.starts_with?(prefix)
       end
     end
+
     def should_sudo?
       !File.writable?(bin_path)
     end
@@ -63,12 +74,25 @@ module Babushka
         end
       end
     end
+
     def update_pkg_lists message = "Updating #{manager_dep.capitalize} package lists"
       log_shell message, pkg_update_command, :sudo => should_sudo?
     end
+
+    private
+
+    def has_pkg? pkg_name
+      raise RuntimeError, "#{self.class.name}#has_pkg? is unimplemeneted."
+    end
+
+    def install_pkgs! pkgs, opts
+      log_shell "Installing #{pkgs.to_list} via #{manager_key}", "#{pkg_cmd} -y install #{pkgs.join(' ')} #{opts}", :sudo => should_sudo?
+    end
+
     def pkg_update_timeout
       nil # not required by default
     end
+
     def pkg_update_command
       "#{pkg_cmd} update"
     end
@@ -76,6 +100,7 @@ module Babushka
     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

@@ -3,15 +3,14 @@ module Babushka
   class << self
     def pkg_type; :deb end
     def pkg_cmd; "env DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND='noninteractive' #{pkg_binary}" end
+    def manager_key; :apt 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
+    def manager_dep
+      'apt'
     end
 
     def update_pkg_lists_if_required
@@ -25,21 +24,29 @@ module Babushka
 
     def source_for_system
       {
-        :debian => 'http://archive.debian.org/debian',
+        :debian => 'http://ftp.debian.org/debian',
         :ubuntu => 'http://archive.ubuntu.com/ubuntu'
-      }[Base.host.flavour]
+      }[Babushka.host.flavour]
     end
 
     private
-    def _has? pkg_name
+
+    def has_pkg? pkg
+      pkg_name = pkg.name.sub(/\=.*$/, '') # Strip versions like git=1.7.11
       wait_for_dpkg
       status = raw_shell("dpkg -s #{pkg_name}").stdout.val_for('Status')
       status && status.split(' ').include?('installed')
     end
 
+    def install_pkgs! pkgs, opts
+      wait_for_dpkg
+      super
+    end
+
     def pkg_update_timeout
       3600 * 24 # 1 day
     end
+
     def pkg_list_dir
       '/var/lib/apt/lists'.p
     end

data/lib/babushka/pkg_helpers/binpkgsrc_helper.rb

@@ -1,10 +1,6 @@
 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.
 
@@ -13,6 +9,7 @@ module Babushka
     def pkg_type; :pkg end
     def manager_key; :binpkgsrc end
 
+    # TODO can this be removed?
     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"
@@ -21,6 +18,20 @@ module Babushka
       end
     end
 
+    private
+
+    def has_pkg? pkg
+      existing_packages.any? {|i| i.match(/#{pkg}/)}
+    end
+
+    def install_pkgs! pkgs, opts
+      log_shell "Installing #{pkgs.join(', ')}", "pkg_radd #{pkgs.join(' ')}", :sudo => should_sudo?
+    end
+
+    def existing_packages
+      shell("pkg_info -a").lines.to_a.map {|i| i.split(/\s+/)[0] }
+    end
+
     def pkg_update_timeout
       3600 * 24 * 14 # 2 weeks
     end
@@ -33,16 +44,6 @@ module Babushka
       "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

@@ -1,10 +1,6 @@
 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.
@@ -21,12 +17,16 @@ module Babushka
 
     private
 
-    def _install! pkgs, opts
+    def has_pkg? pkg
+      existing_packages.any? {|i| i.match(/#{pkg}/)}
+    end
+
+    def install_pkgs! 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}/)}
+    def existing_packages
+      shell("pkg_info").lines.to_a.map {|i| i.split(/\s+/)[0] }
     end
 
   end