rubycut-babushka 0.10.6

data/lib/babushka/pkg_helpers/gem_helper.rb

@@ -0,0 +1,120 @@
+module Babushka
+  class GemHelper < PkgHelper
+  class << self
+    def pkg_type; :gem end
+    def pkg_cmd; 'gem' end
+    def manager_key; :gem end
+    def manager_dep; 'rubygems' end
+
+    def _install! pkgs, opts
+      pkgs.each {|pkg|
+        log_shell "Installing #{pkg} via #{manager_key}",
+          "#{pkg_cmd} install #{cmdline_spec_for pkg} #{opts}",
+          :sudo => should_sudo?
+      }
+    end
+
+    def gem_path_for gem_name, version = nil
+      unless (detected_version = has?(VersionOf(gem_name, version), :log => false)).nil?
+        gem_root / VersionOf(gem_name, detected_version)
+      end
+    end
+
+    def bin_path
+      # The directory in which the binaries from gems are found. This is
+      # sometimes different to where `gem` itself is running from.
+      env_info.val_for('EXECUTABLE DIRECTORY').p
+    end
+
+    def gem_root
+      gemdir / 'gems'
+    end
+
+    def gemspec_dir
+      gemdir / 'specifications'
+    end
+
+    def gemdir
+      env_info.val_for('INSTALLATION DIRECTORY')
+    end
+
+    def ruby_path
+      env_info.val_for('RUBY EXECUTABLE').p
+    end
+
+    def ruby_wrapper_path
+      if ruby_path.to_s['/.rvm/rubies/'].nil?
+        ruby_path
+      else
+        ruby_path.sub(
+          # /Users/ben/.rvm/rubies/ruby-1.9.2-p0/bin/ruby
+          /^(.*)\/\.rvm\/rubies\/([^\/]+)\/bin\/ruby/
+        ) {
+          # /Users/ben/.rvm/wrappers/ruby-1.9.2-p0/ruby
+          "#{$1}/.rvm/wrappers/#{$2}/ruby"
+        }
+      end
+    end
+
+    def ruby_arch
+      if RUBY_PLATFORM =~ /universal/
+        "universal"
+      elsif RUBY_PLATFORM == "java"
+        "java"
+      elsif RUBY_PLATFORM =~ /darwin/
+        # e.g. "/opt/ruby-enterprise/bin/ruby: Mach-O 64-bit executable x86_64"
+        shell("file -L '#{ruby_path}'").sub(/.* /, '')
+      else
+        Base.host.cpu_type
+      end
+    end
+
+    def ruby_binary_slug
+      [
+        (defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'),
+        RUBY_VERSION,
+        ruby_arch,
+        (RUBY_PLATFORM['darwin'] ? 'macosx' : RUBY_PLATFORM.sub(/^.*?-/, ''))
+      ].join('-')
+    end
+
+    def slug_for ruby
+      shell %Q{#{ruby} -e "require '#{Babushka::Path.lib / 'babushka'}'; puts Babushka::GemHelper.ruby_binary_slug"}
+    end
+
+    def should_sudo?
+      super || (gem_root.exists? && !gem_root.writable?)
+    end
+
+    def version
+      env_info.val_for('RUBYGEMS VERSION').to_version
+    end
+
+
+    private
+
+    def _has? pkg
+      versions_of(pkg).sort.reverse.detect {|version| pkg.matches? version }
+    end
+
+    def versions_of pkg
+      pkg_name = pkg.respond_to?(:name) ? pkg.name : pkg
+      gemspecs_for(pkg_name).select {|i|
+        i.p.read.val_for('s.name')[/^[\'\"\%qQ\{]*#{pkg_name}[\'\"\}]*$/]
+      }.map {|i|
+        File.basename(i).scan(/^#{pkg_name}-(.*).gemspec$/).flatten.first
+      }.map {|i|
+        i.to_version
+      }.sort
+    end
+
+    def gemspecs_for pkg_name
+      gemspec_dir.glob("#{pkg_name}-*.gemspec")
+    end
+
+    def env_info
+      @_cached_env_info ||= shell('gem env')
+    end
+  end
+  end
+end

data/lib/babushka/pkg_helpers/macports_helper.rb

@@ -0,0 +1,22 @@
+module Babushka
+  class MacportsHelper < PkgHelper
+  class << self
+    def existing_packages
+      Dir.glob(prefix / "var/macports/software/*").map {|i| File.basename i }
+    end
+    def pkg_type; :port end
+    def pkg_cmd; 'port' end
+    def manager_key; :macports end
+
+    def _install! pkgs, opts
+      log_shell "Fetching #{pkgs.join(', ')}", "#{pkg_cmd} fetch #{pkgs.join(' ')}", :sudo => should_sudo?
+      super
+    end
+
+    private
+    def _has? pkg
+      existing_packages.include? pkg.name.split(/\s+/, 2).first
+    end
+  end
+  end
+end

data/lib/babushka/pkg_helpers/npm_helper.rb

@@ -0,0 +1,45 @@
+module Babushka
+  class NpmHelper < PkgHelper
+  class << self
+    def pkg_type; :npm end
+    def pkg_cmd; "#{pkg_binary} --color false" end
+    def pkg_binary; "npm" end
+    def manager_key; :npm end
+
+    private
+
+    def _install! pkgs, opts
+      pkgs.each {|pkg|
+        log_shell "Installing #{pkg} via #{manager_key}",
+          "#{pkg_cmd} install -g #{cmdline_spec_for pkg} #{opts}",
+          :sudo => should_sudo?
+      }
+    end
+
+    def _has? pkg
+      # Some example output:
+      #   socket.io@0.6.15      =rauchg active installed remote
+      shell("#{pkg_cmd} ls -g").split("\n").grep(
+        /^\W*#{Regexp.escape(pkg.name)}\@/
+      ).any? {|match|
+        pkg.matches? match.scan(/\@(.*)$/).flatten.first
+      }
+    end
+
+    def cmdline_spec_for pkg
+      if pkg.version.nil?
+        # e.g. 'socket.io'
+        "'#{pkg.name}'"
+      else
+        # e.g. 'socket.io@==0.12.0'
+        "'#{pkg.name}@#{pkg.version.operator}#{pkg.version.version}'"
+      end
+    end
+
+    def should_sudo?
+      !File.writable?(bin_path / pkg_binary)
+    end
+
+  end
+  end
+end

data/lib/babushka/pkg_helpers/pacman_helper.rb

@@ -0,0 +1,27 @@
+module Babushka
+  class PacmanHelper < PkgHelper
+  class << self
+    def pkg_type; :package end # a description of the type of package, that makes sense in the context of, e.g. "the zsh deb"
+    def pkg_cmd; "#{pkg_binary}" end # The full command to run the package manager
+    def pkg_binary; "pacman" end # The name of the binary itself
+    def manager_key; :pacman end # How packages should be specified in deps, e.g. "via :apt, 'zsh'"
+
+    private
+
+    # NOTE By default, Arch has sudo's `tty_tickets` option enabled. This will
+    # result in sudo asking for your password every single time it's run from
+    # Babushka. If you find this annoying, please refer to
+    # https://wiki.archlinux.org/index.php/Sudo#Disable_per-terminal_sudo
+    #
+    # tl;dr - Add the following line to /etc/sudoers:
+    #         Defaults !tty_tickets
+    def _install! pkgs, opts
+      log_shell "Downloading", "#{pkg_cmd} -S --noconfirm #{pkgs.join(' ')}", :sudo => should_sudo?
+    end
+
+    def _has? pkg_name
+      raw_shell("pacman -Q #{pkg_name}").stderr !~ /not found$/
+    end
+  end
+  end
+end

data/lib/babushka/pkg_helpers/pip_helper.rb

@@ -0,0 +1,45 @@
+module Babushka
+  class PipHelper < PkgHelper
+  class << self
+    def pkg_type; :pip end
+    def pkg_cmd; pkg_binary end
+    def pkg_binary; "pip" end
+    def manager_key; :pip end
+
+    private
+
+    def _install! pkgs, opts
+      pkgs.each {|pkg|
+        log_shell "Installing #{pkg} via #{manager_key}",
+          "#{pkg_cmd} install #{cmdline_spec_for pkg} #{opts}",
+          :sudo => should_sudo?
+      }
+    end
+
+    def _has? pkg
+      # Some example output:
+      #   gunicorn==0.12.0
+      raw_shell("pip freeze '#{pkg.name}'").stdout.split("\n").select {|line|
+        line[/^#{Regexp.escape(pkg.name)}\=\=/]
+      }.any? {|match|
+        pkg.matches? match.scan(/\=\=(.*)$/).flatten.first
+      }
+    end
+
+    def cmdline_spec_for pkg
+      if pkg.version.nil?
+        # e.g. 'gunicorn'
+        "'#{pkg.name}'"
+      else
+        # e.g. 'gunicorn==0.12.0'
+        "'#{pkg.name}#{pkg.version.operator}#{pkg.version.version}'"
+      end
+    end
+
+    def should_sudo?
+      !File.writable?(bin_path / pkg_binary)
+    end
+
+  end
+  end
+end

data/lib/babushka/pkg_helpers/src_helper.rb

@@ -0,0 +1,16 @@
+module Babushka
+  class SrcHelper < PkgHelper
+  class << self
+    def pkg_type; :src end
+
+    def install_src! cmd, opts = {}
+      log_shell "install", cmd, :sudo => (opts[:sudo] || should_sudo?)
+    end
+
+    def prefix
+      '/usr/local'
+    end
+
+  end
+  end
+end

data/lib/babushka/pkg_helpers/yum_helper.rb

@@ -0,0 +1,25 @@
+module Babushka
+  class YumHelper < PkgHelper
+  class << self
+    def pkg_type; :rpm end
+    def pkg_cmd; pkg_binary end
+    def pkg_binary; "yum" end
+    def manager_key; :yum end
+
+    private
+
+    def _has? pkg_name
+      # Some example output, with 'wget' installed:
+      #   fedora-13:  'wget.x86_64  1.12-2.fc13       @fedora'
+      #   centos-5.5: 'wget.x86_64  1.11.4-2.el5_4.1  installed'
+      raw_shell("#{pkg_binary} list -q '#{pkg_name}'").stdout.split("\n").select {|line|
+        line[/^#{Regexp.escape(pkg_name.to_s)}\.\w+\b/] # e.g. wget.x86_64
+      }.any? {|match|
+        final_word = match[/[^\s]+$/] || ''
+        (final_word == 'installed') || final_word.starts_with?('@')
+      }
+    end
+
+  end
+  end
+end

data/lib/babushka/popen.rb

@@ -0,0 +1,40 @@
+module Babushka
+  class Open3
+    def self.popen3 cmd, opts = {}, &block
+      pipes = { :in => IO::pipe, :out => IO::pipe, :err => IO::pipe }
+      near = { :in => pipes[:in][1], :out => pipes[:out][0], :err => pipes[:err][0] }
+      far = { :in => pipes[:in][0], :out => pipes[:out][1], :err => pipes[:err][1] }
+
+      pid = fork {
+        reopen_pipe_for :read, pipes[:in], STDIN
+        reopen_pipe_for :write, pipes[:out], STDOUT
+        reopen_pipe_for :write, pipes[:err], STDERR
+
+        Dir.chdir opts[:chdir] if opts[:chdir]
+        ENV.update opts[:env] if opts[:env]
+
+        exec(*cmd)
+      }
+
+      far.values.each(&:close)
+      near.values.each {|p| p.sync = true }
+
+      begin
+        yield near[:in], near[:out], near[:err]
+        Process.waitpid2(pid).last.exitstatus
+      ensure
+        near.values.each {|p| p.close unless p.closed? }
+      end
+    end
+
+  private
+
+    def self.reopen_pipe_for task, pipe, io
+      to_close = pipe[task == :read ? 1 : 0]
+      to_reopen = pipe[task == :read ? 0 : 1]
+      to_close.close
+      io.reopen to_reopen
+      to_reopen.close
+    end
+  end
+end

data/lib/babushka/prompt.rb

@@ -0,0 +1,176 @@
+module Babushka
+
+  class DefaultUnavailable < RuntimeError
+    def initialize message
+      super %{Not prompting for "#{message}" because we're running with '--defaults'.}
+    end
+  end
+
+  class PromptUnavailable < RuntimeError
+    def initialize message
+      super %{Can't prompt for "#{message}" because STDIN isn't a terminal.}
+    end
+  end
+
+  class Prompt
+    extend LogHelpers
+
+    module Helpers
+      def confirm message, opts = {}, &block
+        Prompt.confirm message, opts, &block
+      end
+    end
+
+  class << self
+    def confirm message, opts = {}, &block
+      prompter = (!opts[:always_ask] && respond_to?(:var)) ? :var : :get_value
+      answer = send(prompter, message,
+        :message => message,
+        :confirmation => true,
+        :default => (opts[:default] || 'y')
+      ).starts_with?('y')
+
+      if block.nil?
+        answer
+      elsif answer
+        block.call
+      elsif opts[:otherwise]
+        log opts[:otherwise]
+      end
+    end
+
+    def get_ip message, opts = {}
+      get_value(message, opts.merge(
+        :retry => "That's not an IP, like '10.0.1.1'."
+      )) {|value|
+        IP.new(value).valid?
+      }
+    end
+
+    def get_ip_range message, opts = {}
+      get_value(message, opts.merge(
+        :retry => "That's not an IP range, like '10.0.1.x'."
+      )) {|value|
+        IPRange.new(value).valid?
+      }
+    end
+
+    def get_path message, opts = {}
+      get_value(message, opts.merge(
+        :retry => "Doesn't exist, or not a directory."
+      )) {|value|
+        (value || '').p.dir?
+      }
+    end
+
+    def get_value message, opts = {}, &block
+      if opts[:choices] && opts[:choice_descriptions]
+        raise ArgumentError, "You can't use the :choices and :choice_descriptions options together."
+      elsif opts[:choice_descriptions]
+        opts[:choices] = opts[:choice_descriptions].keys
+      end
+      if opts[:choices] && opts[:choices].any? {|c| !c.is_a?(String) }
+        raise ArgumentError, "Choices must be passed as strings."
+      end
+      opts.defaults! :prompt => '? '
+      prompt_and_read_value prompt_message(message, opts), opts.merge(:ask => !Base.task.opt(:defaults)), &block
+    end
+
+
+    private
+
+    def prompt_message message, opts
+      if opts[:choices] && opts[:choice_descriptions].nil?
+        "#{message.chomp '?'} (#{opts[:choices] * ','})"
+      else
+        message.chomp '?'
+      end + "#{" #{opts[:dynamic] ? '{' : '['}#{opts[:default]}#{opts[:dynamic] ? '}' : ']'}" if opts[:default]}"
+    end
+
+    def log_choice_descriptions descriptions
+      unless descriptions.nil?
+        max_length = descriptions.keys.map(&:length).max
+        log "There are #{descriptions.length} choices:"
+        descriptions.each_pair {|choice,description|
+          log "#{choice.ljust(max_length)} - #{description}"
+        }
+      end
+    end
+
+    def prompt_and_read_value message, opts, &block
+      if !opts[:default] && !opts[:ask]
+        raise DefaultUnavailable.new(message)
+      elsif opts[:ask] && !$stdin.tty?
+        raise PromptUnavailable.new(message)
+      else
+        log_choice_descriptions opts[:choice_descriptions]
+        log message, :newline => false
+
+        if opts[:default] && !opts[:ask]
+          puts '.'
+          opts[:default]
+        else
+          read_value_from_prompt message, opts, &block
+        end
+      end
+    end
+
+    def read_value_from_prompt message, opts, &block
+      value = nil
+
+      value = read_from_prompt(opts[:prompt].end_with(' '), opts[:choices]).try(:chomp)
+      value = opts[:default].to_s if value.blank? && !(opts[:default] && opts[:default].to_s.empty?)
+
+      error = if opts[:choices] && !opts[:choices].include?(value)
+        "That's not a valid choice"
+      elsif block_given? && !yield(value)
+        opts[:retry] || "That wasn't valid"
+      elsif value.blank? && !(opts[:default] && opts[:default].empty?)
+        "That was blank"
+      elsif !opts[:confirmation] && value == 'y' && !confirm("Wait, do you mean the literal value 'y'?", :default => 'n', :always_ask => true)
+        "Thought so :) Hit enter for the [default]"
+      end
+
+      if error
+        log "#{error.end_with('.')} #{message}", :newline => false
+        read_value_from_prompt message, opts, &block
+      else
+        value
+      end
+    end
+
+    begin
+      require 'readline'
+      def read_from_prompt prompt, choices = nil
+        using_libedit = !Readline.respond_to?(:vi_editing_mode)
+        Readline.completion_append_character = nil
+
+        Readline.completion_proc = if !choices.nil?
+          L{|str| choices.select {|i| i.starts_with? choice } }
+        else
+          L{|str|
+            Dir["#{str}*"].map {|path|
+              path.end_with(if File.directory?(path)
+                using_libedit ? '' : '/' # libedit adds its own trailing slash to dirs
+              else
+                ' ' # Add a trailing space to files
+              end)
+            }
+          }
+        end
+
+        # This is required in addition to the call in bin/babushka.rb for
+        # interrupts to work during Readline calls.
+        Base.exit_on_interrupt!
+
+        Readline.readline(prompt, true).try(:strip)
+      end
+    rescue LoadError
+      def read_from_prompt prompt, choices = nil
+        print prompt
+        $stdin.gets.try(:strip)
+      end
+    end
+  end
+  end
+end