rubycut-babushka 0.10.6

data/lib/babushka/helpers/git_helpers.rb

@@ -0,0 +1,32 @@
+module Babushka
+  module GitHelpers
+    def git uri, opts = {}, &block
+      repo = GitRepo.new(opts[:to] || (BuildPrefix / File.basename(uri.to_s).chomp('.git')))
+
+      if git_update(uri, repo)
+        repo.root.touch # so we can tell when it was last updated
+        block.nil? || cd(repo.path, &block)
+      end
+    end
+
+    private
+
+    def git_update uri, repo
+      if !repo.exists?
+        repo.clone! uri
+      else
+        log_block "Updating #{uri}" do
+          if repo.repo_shell('git fetch origin').nil?
+            log_error " Couldn't fetch,", :newline => false
+          elsif !repo.behind?
+            log " Already up-to-date at #{repo.current_head.colorize('yellow')},", :newline => false
+            true
+          else
+            log " #{repo.current_head.colorize('yellow')}..#{repo.repo_shell("git rev-parse --short origin/#{repo.current_branch}").colorize('yellow')} (#{repo.repo_shell("git log -1 --pretty=format:%s origin/#{repo.current_branch}").chomp('.')}),", :newline => false
+            repo.reset_hard! "origin/#{repo.current_branch}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/babushka/helpers/log_helpers.rb

@@ -0,0 +1,176 @@
+# coding: utf-8
+
+module Babushka
+  module LogHelpers
+    # Log +message+ as an error. This is a shortcut for
+    #   log(message, :as => :error)
+    def log_error message, opts = {}, &block
+      log message, opts.merge(:as => :error), &block
+    end
+
+    # Log +message+ as a warning. This is a shortcut for
+    #   log(message, :as => :warning)
+    def log_warn message, opts = {}, &block
+      log message, opts.merge(:as => :warning), &block
+    end
+
+    def log_verbose message, opts = {}, &block
+      log_error "#{caller.first}: #log_verbose has been deprecated. Instead, just use #log." # deprecated
+      log message, opts, &block
+    end
+
+    # Yield the block, writing a note to the log about it beforehand and
+    # afterwards.
+    #
+    # As an example, suppose we called #log_block as follows:
+    #   log_block('Sleeping for a bit') { sleep 10 }
+    #
+    # While the block yields, the log would show
+    #   Sleeping for a bit... (without a newline)
+    #
+    # Once the block returns, the log would be completed to show
+    #   Sleeping for a bit... done.
+    def log_block message, opts = {}, &block
+      log "#{message}...", :newline => false
+      block.call.tap {|result|
+        log result ? ' done.' : ' failed', :as => (result ? nil : :error), :indentation => false
+      }
+    end
+
+    # Write +message+ to the debug log, prefixed with +TickChar+, returning +true+.
+    #
+    # This is used to report events that have succeeded, or items that are
+    # already working. For example, when the package manager reports that a
+    # package is already installed, that's an 'OK' that babushka can move on to
+    # the next job, and so +log_ok+ is used to report that fact.
+    def log_ok message, opts = {}, &block
+      log message.end_with('.'), opts.merge(:as => :ok), &block
+      true
+    end
+
+    # Write +message+ to the debug log.
+    #
+    # The message will be written to the log in the normal style, but will only
+    # appear on STDOUT if debug logging is enabled.
+    def debug message, opts = {}, &block
+      log message, opts.merge(:debug => !opts[:log]), &block
+    end
+
+    # Write +message+ to the log.
+    #
+    # By default, the log is written to STDOUT, and to ~/.babushka/logs/<dep_name>.
+    # The log in ~/.babushka/logs is always a full debugging log, but STDOUT
+    # only includes debug logging if +--debug+ was supplied on the command
+    # line.
+    #
+    # By default, the message is ended with a newline. You can pass
+    # :newline => false to prevent the newline character being added.
+    #
+    # To specify the message type, you can use :as. There are four custom
+    # types supported:
+    #   :ok      The message is printed in grey with +TickChar+ prepended, as
+    #            used by +log_ok+.
+    #   :warning The message is printed in yellow, as used by +log_warn+.
+    #   :error   The message is printed in red, as used by +log_error+.
+    #   :stderr  The message (representing STDERR output) is printed in bold,
+    #            as used by +Shell+ for debug logging.
+    #
+    # If a block is given, the block is yielded with the indentation level
+    # incremented. Opening and closing braces are printed to the log to represent
+    # the nesting. (This is the logging style used to show the nesting during dep
+    # runs - so please consider other logging styles before using this one, so as
+    # not to visually confuse dep runs with other operations.)
+    def log message, opts = {}, &block
+      # now = Time.now
+      # print "#{now.to_i}.#{now.usec}: ".ljust(20) unless opts[:debug]
+      printable = !opts[:debug] || Base.task.opt(:debug)
+      Logging.print_log Logging.indentation, printable unless opts[:indentation] == false
+      if block_given?
+        Logging.print_log "#{message} {\n".colorize('grey'), printable
+        Logging.indent! if printable
+        yield.tap {|result|
+          Logging.undent! if printable
+          log Logging.closing_log_message(message, result, opts), opts
+        }
+      else
+        message = message.to_s.rstrip.gsub "\n", "\n#{Logging.indentation}"
+        message = "#{Logging::TickChar.colorize('grey')} #{message}" if opts[:as] == :ok
+        message = message.colorize 'red' if opts[:as] == :error
+        message = message.colorize 'yellow' if opts[:as] == :warning
+        message = message.colorize 'bold' if opts[:as] == :stderr
+        message = message.end_with "\n" unless opts[:newline] == false
+        Logging.print_log message, printable
+        $stdout.flush
+        nil
+      end
+    end
+  end
+
+  class Logging
+    extend LogHelpers
+
+    TickChar = '✓'
+    CrossChar = '✗'
+
+    def self.closing_log_message message, result = true, opts = {}
+      message = opts[:closing_status] if opts[:closing_status].is_a?(String)
+
+      if opts[:closing_status] == :status_only
+        '}'.colorize('grey') + ' ' + "#{result ? TickChar : CrossChar}".colorize(result ? 'green' : 'red')
+      elsif opts[:closing_status] == :dry_run
+        '}'.colorize('grey') + ' ' + "#{result ? TickChar : '~'} #{message}".colorize(result ? 'green' : 'blue')
+      elsif opts[:closing_status]
+        '}'.colorize('grey') + ' ' + "#{result ? TickChar : CrossChar} #{message}".colorize(result ? 'green' : 'red')
+      else
+        "}".colorize('grey')
+      end
+    end
+
+    def self.log_table headings, rows
+      all_rows = rows.map {|row|
+        row.map(&:to_s)
+      }.unshift(
+        headings
+      ).transpose.map {|col|
+        max_length = col.map(&:length).max
+        col.map {|cell| cell.ljust(max_length) }
+      }.transpose
+
+      [
+        all_rows.first.join(' | '),
+        all_rows.first.map {|i| '-' * i.length }.join('-+-')
+      ].concat(
+        all_rows[1..-1].map {|row| row.join(' | ') }
+      ).each {|row|
+        log row
+      }
+    end
+
+
+    private
+
+    def self.print_log message, printable
+      print message if printable
+      write_to_persistent_log message
+    end
+
+    def self.write_to_persistent_log message
+      Base.task.persistent_log.write message unless Base.task.persistent_log.nil?
+    end
+
+    def self.indentation
+      ' ' * indentation_level * 2
+    end
+    def self.indentation_level
+      @indentation_level ||= 0
+    end
+    def self.indent!
+      @indentation_level ||= 0
+      @indentation_level += 1
+    end
+    def self.undent!
+      @indentation_level ||= 0
+      @indentation_level -= 1
+    end
+  end
+end

data/lib/babushka/helpers/path_helpers.rb

@@ -0,0 +1,34 @@
+module Babushka
+  module PathHelpers
+    def cd dir, opts = {}, &block
+      if dir.nil?
+        yield Dir.pwd.p
+      else
+        path = dir.p
+        shell("mkdir -p '#{path}'", :sudo => opts[:sudo]) if opts[:create] unless path.exists?
+        if Dir.pwd == path
+          yield path
+        else
+          Dir.chdir path do
+            debug "in dir #{dir} (#{path})" do
+              yield path
+            end
+          end
+        end
+      end
+    end
+
+    def in_dir dir, opts = {}, &block
+      log_error "#{caller.first}: #in_dir has been renamed to #cd." # deprecated
+      cd dir, opts, &block
+    end
+
+    def in_build_dir path = '', &block
+      cd Babushka::BuildPrefix / path, :create => true, &block
+    end
+
+    def in_download_dir path = '', &block
+      cd Babushka::DownloadPrefix / path, :create => true, &block
+    end
+  end
+end

data/lib/babushka/helpers/run_helpers.rb

@@ -0,0 +1,145 @@
+module Babushka
+  module RunHelpers
+    include LogHelpers
+    include ShellHelpers
+    include PathHelpers
+
+    def hostname
+      shell 'hostname -f'
+    end
+
+    def rake cmd, &block
+      sudo "rake #{cmd} RAILS_ENV=#{var :app_env}", :as => var(:username), &block
+    end
+
+    def bundle_rake cmd, &block
+      cd var(:rails_root) do
+        shell "bundle exec rake #{cmd} --trace RAILS_ENV=#{var :app_env}", :as => var(:username), :log => true, &block
+      end
+    end
+
+    def check_file file_name, method_name
+      File.send(method_name, file_name).tap {|result|
+        log_error "#{file_name} failed #{method_name.to_s.sub(/[?!]$/, '')} check." unless result
+      }
+    end
+
+    def grep pattern, file
+      if (path = file.p).exists?
+        output = if pattern.is_a? String
+          path.readlines.select {|l| l[pattern] }
+        elsif pattern.is_a? Regexp
+          path.readlines.grep pattern
+        end
+        output unless output.blank?
+      end
+    end
+
+    def change_line line, replacement, filename
+      path = filename.p
+
+      log "Patching #{path}"
+      shell "cat > #{path}", :as => path.owner, :input => path.readlines.map {|l|
+        l.gsub(/^(\s*)(#{Regexp.escape(line)})/, "\\1# #{edited_by_babushka}\n\\1# was: \\2\n\\1#{replacement}")
+      }.join("")
+    end
+
+    def insert_into_file insert_before, path, lines, opts = {}
+      opts.defaults! :comment_char => '#', :insert_after => nil
+      nlines = lines.split("\n").length
+      before, after = path.p.readlines.cut {|l| l.strip == insert_before.strip }
+
+      log "Patching #{path}"
+      if after.empty? || (opts[:insert_after] && before.last.strip != opts[:insert_after].strip)
+        log_error "Couldn't find the spot to write to in #{path}."
+      else
+        shell "cat > #{path}", :as => path.owner, :sudo => !File.writable?(path), :input => [
+          before,
+          added_by_babushka(nlines).start_with(opts[:comment_char] + ' ').end_with("\n"),
+          lines.end_with("\n"),
+          after
+        ].join
+      end
+    end
+
+    def change_with_sed keyword, from, to, file
+      # Remove the incorrect setting if it's there
+      shell("#{sed} -ri 's/^#{keyword}\s+#{from}//' #{file}", :sudo => !File.writable?(file))
+      # Add the correct setting unless it's already there
+      grep(/^#{keyword}\s+#{to}/, file) or shell("echo '#{keyword} #{to}' >> #{file}", :sudo => !File.writable?(file))
+    end
+
+    def sed
+      Base.host.linux? ? 'sed' : 'gsed'
+    end
+
+    def append_to_file text, file, opts = {}
+      text = text.to_s
+      shell %Q{echo "\n# #{added_by_babushka(text.split("\n").length)}\n#{text.gsub('"', '\"')}" >> #{file}}, opts
+    end
+
+    def _by_babushka
+      "by babushka-#{VERSION} at #{Time.now}"
+    end
+    def edited_by_babushka
+      "This line edited #{_by_babushka}"
+    end
+    def added_by_babushka nlines
+      if nlines == 1
+        "This line added #{_by_babushka}"
+      else
+        "These #{nlines} lines added #{_by_babushka}"
+      end
+    end
+
+    def babushka_config? path
+      if !path.p.exists?
+        unmet "the config hasn't been generated yet"
+      elsif !grep(/Generated by babushka/, path)
+        unmet "the config needs to be regenerated"
+      else
+        true
+      end
+    end
+
+    def yaml path
+      require 'yaml'
+      YAML.load_file path.p
+    end
+
+    def render_erb erb, opts = {}
+      if (path = erb_path_for(erb)).nil?
+        log_error "If you use #render_erb within a dynamically defined dep, you have to give the full path to the erb template."
+      elsif !File.exists?(path) && !opts[:optional]
+        log_error "Couldn't find erb to render at #{path}."
+      elsif File.exists?(path)
+        Renderable.new(opts[:to]).render(path, opts.merge(:context => self)).tap {|result|
+          if result
+            log "Rendered #{opts[:to]}."
+          else
+            log_error "Couldn't render #{opts[:to]}."
+          end
+        }
+      end
+    end
+
+    def erb_path_for erb
+      if erb.to_s.starts_with? '/'
+        erb # absolute path
+      elsif load_path
+        File.dirname(load_path) / erb # directory this dep is in, plus relative path
+      end
+    end
+
+    def log_and_open message, url
+      log "#{message} Hit Enter to open the download page.", :newline => false
+      read_from_prompt ' '
+      shell "open #{url}"
+    end
+
+    def mysql cmd, username = 'root', include_password = true
+      password_segment = "--password='#{var :db_password}'" if include_password
+      shell "echo \"#{cmd.gsub('"', '\"').end_with(';')}\" | mysql -u #{username} #{password_segment}"
+    end
+  end
+end

data/lib/babushka/helpers/shell_helpers.rb

@@ -0,0 +1,229 @@
+module Babushka
+  module ShellHelpers
+    include LogHelpers
+
+    # Run +cmd+.
+    #
+    # If the command succeeds (i.e. returns 0), its output will be returned
+    # with a trailing newline stripped, if there was one. If the command fails
+    # (i.e. returns a non-zero value), nil will be returned.
+    #
+    # If a block is given, it will be yielded once the command has run, with a
+    # Babushka::Shell object as its sole argument. Details of the shell command
+    # are contained in this object - see the methods +cmd+, +ok?+, +result+,
+    # +stdout+, and +stderr+.
+    #
+    # Several options can be provided to alter #shell's behaviour.
+    #   <tt>:sudo => true</tt> runs the the command as root. If the command
+    #     contains piping or redirection, a 'sudo su' variant will be used
+    #     instead so that the pipe receiver or redirect targets are also
+    #     included in the sudo.
+    #   <tt>:as => 'user'</tt> causes sudo to run as the specified user instead
+    #     of root.
+    #   <tt>:sudo => 'user'</tt> is a shortcut that has the same effect as
+    #     <tt>:sudo => true, :as => 'user'</tt>
+    #   <tt>:cd</tt> specifies the directory in which the command should run.
+    #     If the path doesn't exist or isn't a directory, an error is raised
+    #     unless the <tt>:create</tt> option is also set.
+    #     To achieve the directory change, the command is rewritten to change
+    #     directory first: `cd #{dir} && #{cmd}`.
+    #   <tt>:create</tt> causes the directory specified by the <tt>:cd</tt>
+    #     option to be created if it doesn't already exist.
+    #   <tt>:input</tt> can be used to supply input for the shell command. It
+    #     be any object that can be written to an IO with <tt>io << obj</tt>.
+    #     When passed, it will be written to the command's stdin pipe before
+    #     any output is read.
+    #   <tt>:spinner => true</tt> When this option is passed, a /-\| spinner
+    #     is printed to stdout, and advanced whenever a line is read on the
+    #     command's stdout or stderr pipes. This is useful for monitoring the
+    #     progress of a long-running command, like a build or an installer.
+    def shell *cmd, &block
+      shell!(*cmd, &block)
+    rescue Shell::ShellCommandFailed => e
+      if cmd.extract_options[:log]
+        # Don't log the error if the command already logged
+      elsif e.stdout.empty? && e.stderr.empty?
+        log "$ #{e.cmd.join(' ')}".colorize('grey') + ' ' + "#{Logging::CrossChar} shell command failed".colorize('red')
+      else
+        log "$ #{e.cmd.join(' ')}", :closing_status => 'shell command failed' do
+          log_error(e.stderr.empty? ? e.stdout : e.stderr)
+        end
+      end
+    end
+
+    # Run +cmd+, returning true if its exit code was 0.
+    #
+    # This is useful to run shell commands whose output isn't important,
+    # but whose exit code is. Unlike +#shell+, which logs the output of shell
+    # commands that exit with non-zero status, +#shell?+ runs silently.
+    #
+    # The idea is that +#shell+ is for when you're interested in the command's
+    # output, and +#shell?+ is for when you're interested in the exit status.
+    def shell? *cmd
+      shell(*cmd) {|s| s.stdout.chomp if s.ok? }
+    end
+
+    # Run +cmd+ via #shell, raising an exception if it doesn't exit
+    # with success.
+    def shell! *cmd, &block
+      opts = cmd.extract_options!
+      cmd = cmd.first if cmd.map(&:class) == [Array]
+
+      if opts[:dir] # deprecated
+        log_error "#{caller.first}: #shell's :dir option has been renamed to :cd."
+        opts[:cd] = opts[:dir]
+      end
+      if opts[:cd]
+        if !opts[:cd].p.exists?
+          if opts[:create]
+            opts[:cd].p.mkdir
+          else
+            raise Errno::ENOENT, opts[:cd]
+          end
+        end
+      end
+      shell_method = (opts[:as] || opts[:sudo]) ? :sudo : :shell_cmd
+      send shell_method, *cmd.dup.push(opts), &block
+    end
+
+    # This method is a shortcut for accessing the results of a shell command
+    # without using a block. The method itself returns the shell object that
+    # is yielded to the block by +#shell+.
+    # As an example, this shell command:
+    #   shell('grep rails Gemfile') {|shell| shell.stdout }.empty?
+    # can be simplified to this:
+    #   raw_shell('grep rails Gemfile').stdout.empty?
+    def raw_shell *cmd
+      shell(*cmd) {|s| s }
+    end
+
+    def failable_shell *cmd
+      log_error "#failable_shell has been renamed to #raw_shell." # deprecated
+      raw_shell(*cmd)
+    end
+
+    # Run +cmd+ in a separate interactive shell. This is useful for running
+    # commands that depend on something shell-related that was changed during
+    # this run, like changing the user's shell. It's also useful for running
+    # commands that are only valid on an interactive shell, like rvm-related
+    # commands.
+    # TODO: specs.
+    def login_shell cmd, opts = {}, &block
+      if shell('echo $SHELL').p.basename == 'zsh'
+        shell %Q{zsh -i -c "#{cmd.gsub('"', '\"')}"}, opts, &block
+      else
+        shell %Q{bash -l -c "#{cmd.gsub('"', '\"')}"}, opts, &block
+      end
+    end
+
+    # Run +cmd+ via `sudo`, bypassing it if possible (i.e. if we're running as
+    # root already, or as the user that was requested).
+    #
+    # The return behaviour and block handling of +#sudo+ are identical to that
+    # of +#shell+. In fact, +#sudo+ constructs a sudo command, and then uses
+    # +#shell+ internally to run the command.
+    #
+    # All the options that can be passed to +#shell+ are valid for +#sudo+ as
+    # well. The :sudo and :as options can be ommitted, though, which will cause
+    # the command to be run as root. Hence, this sudo call:
+    #   sudo('ls')
+    # is equivalent to these two shell calls:
+    #   shell('ls', :sudo => true)
+    #   shell('ls', :as => 'root')
+    #
+    # In the same manner, this sudo call:
+    #   sudo('ls', :as => 'ben')
+    # is equivalent to these two shell calls:
+    #   shell('ls', :sudo => 'ben')
+    #   shell('ls', :as => 'ben')
+    def sudo *cmd, &block
+      opts = cmd.extract_options!
+      env = cmd.first.is_a?(Hash) ? cmd.shift : {}
+
+      if cmd.map(&:class) != [String]
+        raise ArgumentError, "#sudo commands have to be passed as a single string, not splatted strings or an array, since the `sudo` is composed from strings."
+      end
+
+      as = opts[:as] || (opts[:sudo].is_a?(String) ? opts[:sudo] : 'root')
+      cmd = cmd.last
+
+      sudo_cmd = if current_username == as
+        cmd # Don't sudo if we're already running as the specified user.
+      else
+        if opts[:su] || cmd[' |'] || cmd[' >']
+          "sudo su - #{as} -c \"#{cmd.gsub('"', '\"')}\""
+        else
+          "sudo -u #{as} #{cmd}"
+        end
+      end
+
+      shell [env, sudo_cmd], opts.discard(:as, :sudo, :su), &block
+    end
+
+    # This method returns the full path to the specified command in the PATH,
+    # if that command appears anywhere in the PATH. If it doesn't, nil is
+    # returned.
+    #
+    # For example, on a stock OS X machine:
+    #   which('ruby')     #=> "/usr/bin/ruby"
+    #   which('babushka') #=> nil
+    #
+    # This is roughly equivalent to using `which` or `type` on the shell.
+    # However, because those commands' behaviour and ouptut vary across
+    # platforms and shells, we instead use the logic in #cmd_dir.
+    def which cmd_name
+      matching_dir = cmd_dir(cmd_name)
+      File.join(matching_dir, cmd_name.to_s) unless matching_dir.nil?
+    end
+
+    # Return the directory from which the specified command would run if
+    # invoked via the PATH. If the command doesn't appear in the PATH, nil is
+    # returned.
+    #
+    # For example, on a stock OS X machine:
+    #   cmd_dir('ruby')     #=> "/usr/bin"
+    #   cmd_dir('babushka') #=> nil
+    #
+    # This is a direct implementation because the behaviour and output of
+    # `which` and `type` vary across different platforms and shells. It's
+    # also faster to not shell out.
+    def cmd_dir cmd_name
+      ENV['PATH'].split(':').detect {|path|
+        File.executable? File.join(path, cmd_name.to_s)
+      }
+    end
+
+    # Run a shell command, logging before and after using #log_block, and using
+    # a spinner while the command runs.
+    # The first argument, +message+, is the message to print before running the
+    # command, and the remaining arguments are identical to those of #shell.
+    #
+    # As an example, suppose we called #log_shell as follows:
+    #   log_shell('Sleeping for a bit', 'sleep 10')
+    #
+    # While the command runs, the log would show
+    #   Sleeping for a bit... (without a newline)
+    #
+    # The command runs with a /-\| spinner that animates each time a line of
+    # output is emitted by the command. Once the command terminates, the log
+    # would be completed to show
+    #   Sleeping for a bit... done.
+    def log_shell message, *cmd, &block
+      opts = cmd.extract_options!
+      log_block message do
+        shell *cmd.dup.push(opts.merge(:spinner => true)), &block
+      end
+    end
+
+    private
+
+    def shell_cmd *cmd, &block
+      Shell.new(*cmd).run(&block)
+    end
+
+    def current_username
+      require 'etc'
+      Etc.getpwuid(Process.euid).name
+    end
+  end
+end