rubycut-babushka 0.10.8 → 0.15.6.1

data/lib/babushka/helpers/git_helpers.rb

@@ -1,16 +1,17 @@
 module Babushka
   module GitHelpers
+    # Make these helpers directly callable, and private when included.
+    module_function
+
     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)
+        block.nil? || PathHelpers.cd(repo.path, &block)
       end
     end
 
-    private
-
     def git_update uri, repo
       if !repo.exists?
         update_and_log uri, repo, "Cloning #{uri} into #{repo.path}" do
@@ -24,14 +25,14 @@ module Babushka
     end
 
     def update_and_log uri, repo, message, &block
-      log_block message do
+      LogHelpers.log_block message do
         if !block.call
           # failed
         elsif !repo.behind?
-          log " at #{repo.current_head.colorize('yellow')},", :newline => false
+          LogHelpers.log " 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
+          LogHelpers.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

data/lib/babushka/helpers/log_helpers.rb

@@ -2,6 +2,15 @@
 
 module Babushka
   module LogHelpers
+    # Make these helpers directly callable, and private when included.
+    module_function
+
+    # Log +message+ to STDERR. This is a shortcut for
+    #   log(message, :as => :error)
+    def log_stderr message, opts = {}, &block
+      log message, opts.merge(:as => :stderr), &block
+    end
+
     # Log +message+ as an error. This is a shortcut for
     #   log(message, :as => :error)
     def log_error message, opts = {}, &block
@@ -14,11 +23,6 @@ module Babushka
       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.
     #
@@ -33,7 +37,7 @@ module Babushka
     def log_block message, opts = {}, &block
       log "#{message}...", :newline => false
       block.call.tap {|result|
-        log result ? ' done.' : ' failed', :as => (result ? nil : :error), :indentation => false
+        log result ? " #{opts[:success] || 'done'}." : " #{opts[:failure] || 'failed'}", :as => (result ? nil : :error), :indentation => false
       }
     end
 
@@ -56,6 +60,24 @@ module Babushka
       log message, opts.merge(:debug => !opts[:log]), &block
     end
 
+    def deprecated! date, opts = {}
+      callpoint = "#{caller[opts[:skip] || 1].sub(/\:in `.*$/, '')}: " unless opts[:callpoint] == false
+      opts[:method_name] ||= "##{caller[0].scan(/`(\w+)'$/).flatten.first}"
+      warning = "#{callpoint}#{opts[:method_name]} has been deprecated and will be removed on #{date}."
+      instead = " Use #{opts[:instead]} instead#{opts[:example] ? ", e.g.:" : '.'}" unless opts[:instead].nil?
+      log_warn "#{warning}#{instead}"
+      log opts[:example].strip unless opts[:example].nil?
+      log ''
+    end
+
+    def removed! opts = {}
+      opts[:method_name] ||= "##{caller[0].scan(/`(\w+)'$/).flatten.first}"
+      warning = "#{opts[:method_name]} has been removed after being deprecated."
+      instead = " Use #{opts[:instead]} instead#{opts[:example] ? ", e.g.:" : '.'}" unless opts[:instead].nil?
+      message = ["#{warning}#{instead}", opts[:example]].compact.join("\n")
+      raise NoMethodError.new(message)
+    end
+
     # Write +message+ to the log.
     #
     # By default, the log is written to STDOUT, and to ~/.babushka/logs/<dep_name>.
@@ -81,12 +103,14 @@ module Babushka
     # 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 Base.task.opt(:profile)
+        delta = Time.now - Base.start_time
+        Logging.print_log("%.4f ".colorize('grey') % delta, printable, opts[:as])
+      end
+      Logging.print_log(Logging.indentation, printable, opts[:as]) unless opts[:indentation] == false
       if block_given?
-        Logging.print_log "#{message} {\n".colorize('grey'), printable
+        Logging.print_log("#{message} {".colorize('grey') + "\n", printable, opts[:as])
         Logging.indent! if printable
         yield.tap {|result|
           Logging.undent! if printable
@@ -99,7 +123,7 @@ module Babushka
         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
+        Logging.print_log(message, printable, opts[:as])
         $stdout.flush
         nil
       end
@@ -126,6 +150,11 @@ module Babushka
       end
     end
 
+    def self.log_exception exception
+      log_error "#{exception.backtrace.first}: #{exception.message}"
+      debug exception.backtrace * "\n"
+    end
+
     def self.log_table headings, rows
       all_rows = rows.map {|row|
         row.map(&:to_s)
@@ -149,8 +178,14 @@ module Babushka
 
     private
 
-    def self.print_log message, printable
-      print message if printable
+    def self.print_log message, printable, as
+      if !printable
+        # Only written to the log file.
+      elsif [:error, :stderr].include?(as)
+        $stderr.print message
+      elsif !Base.task.opt(:silent)
+        $stdout.print message
+      end
       write_to_persistent_log message
     end
 
@@ -161,13 +196,16 @@ module Babushka
     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

data/lib/babushka/helpers/path_helpers.rb

@@ -1,16 +1,19 @@
 module Babushka
   module PathHelpers
+    # Make these helpers directly callable, and private when included.
+    module_function
+
     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?
+        ShellHelpers.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
+            LogHelpers.debug "in dir #{dir} (#{path})" do
               yield path
             end
           end
@@ -18,11 +21,6 @@ module Babushka
       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

data/lib/babushka/helpers/run_helpers.rb

@@ -5,85 +5,49 @@ module Babushka
     include PathHelpers
 
     def hostname
-      shell 'hostname -f'
+      removed! :instead => "#shell directly", :example => "shell('hostname -f')"
     end
 
     def rake cmd, &block
-      sudo "rake #{cmd} RAILS_ENV=#{var :app_env}", :as => var(:username), &block
+      removed! :instead => "#shell directly", :example => "shell({'RAILS_ENV' => env}, 'rake #{cmd}')"
     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
+      removed! :instead => "#shell directly", :example => "shell({'RAILS_ENV' => 'env'}, 'bundle exec #{cmd}')"
     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
-      }
+      removed! :instead => "Fancypath##{method_name}", :example => "path.p.#{method_name}"
     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
+      removed! :instead => 'Fancypath#grep', :example => "#{file.inspect}.p.grep(#{pattern.inspect})"
     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("")
+      removed! :instead => "sed via #shell", :example => "shell(\"sed -i'' -e 's/^#{Regexp.escape(line)}$/#{replacement}/' '#{filename}'\")"
     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
+      removed! :instead => "a template with #render_erb"
     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'
+      removed! :instead => "sed via #shell", :example => "shell(\"sed -i'' -e 's/^#{Regexp.escape(keyword)}\\s+#{Regexp.escape(from)}\\b/#{keyword} #{to}/' '#{file}'\")"
     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
+      removed! :instead => 'Fancypath#append', :example => "'#{file}'.p.append(#{text.inspect})"
     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}"
@@ -103,14 +67,13 @@ module Babushka
     end
 
     def yaml path
-      require 'yaml'
-      YAML.load_file path.p
+      removed! :instead => 'Fancypath#yaml', :example => "'#{path}'.p.yaml"
     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]
+      elsif !File.exists?(path)
         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|
@@ -132,14 +95,11 @@ module Babushka
     end
 
     def log_and_open message, url
-      log "#{message} Hit Enter to open the download page.", :newline => false
-      read_from_prompt ' '
-      shell "open #{url}"
+      removed! :instead => "a plain #log with the URL", :example => "log('Download here: http://website.org')"
     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}"
+      removed! :instead => "#shell directly", :example => "shell('mysql', '-u', username, :input => cmd.end_with(';'))"
     end
   end
 end

data/lib/babushka/helpers/shell_helpers.rb

@@ -2,6 +2,9 @@ module Babushka
   module ShellHelpers
     include LogHelpers
 
+    # Make these helpers directly callable, and private when included.
+    module_function
+
     # Run +cmd+.
     #
     # If the command succeeds (i.e. returns 0), its output will be returned
@@ -43,10 +46,10 @@ module Babushka
       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')
+        LogHelpers.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)
+        LogHelpers.log "$ #{e.cmd.join(' ')}", :closing_status => 'shell command failed' do
+          LogHelpers.log_error(e.stderr.empty? ? e.stdout : e.stderr)
         end
       end
     end
@@ -69,10 +72,6 @@ module Babushka
       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]
@@ -80,6 +79,8 @@ module Babushka
           else
             raise Errno::ENOENT, opts[:cd]
           end
+        elsif !opts[:cd].p.dir?
+          raise Errno::ENOTDIR, opts[:cd]
         end
       end
       shell_method = (opts[:as] || opts[:sudo]) ? :sudo : :shell_cmd
@@ -97,22 +98,16 @@ module Babushka
       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
+        shell "zsh -i -c '#{cmd}'", opts, &block
       else
-        shell %Q{bash -l -c "#{cmd.gsub('"', '\"')}"}, opts, &block
+        shell "bash -l -c '#{cmd}'", opts, &block
       end
     end
 
@@ -144,17 +139,16 @@ module Babushka
         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')
+      raw_as = opts[:as] || opts[:sudo] || 'root'
+      as = raw_as == true ? 'root' : raw_as
       cmd = cmd.last
 
       sudo_cmd = if current_username == as
         cmd # Don't sudo if we're already running as the specified user.
+      elsif opts[:su] || cmd[' |'] || cmd[' >']
+        "sudo su - #{as} -c \"#{cmd.gsub('"', '\"')}\""
       else
-        if opts[:su] || cmd[' |'] || cmd[' >']
-          "sudo su - #{as} -c \"#{cmd.gsub('"', '\"')}\""
-        else
-          "sudo -u #{as} #{cmd}"
-        end
+        "sudo -u #{as} #{cmd}"
       end
 
       shell [env, sudo_cmd], opts.discard(:as, :sudo, :su), &block
@@ -169,7 +163,7 @@ module Babushka
     #   which('babushka') #=> nil
     #
     # This is roughly equivalent to using `which` or `type` on the shell.
-    # However, because those commands' behaviour and ouptut vary across
+    # However, because those commands' behaviour and output vary across
     # platforms and shells, we instead use the logic in #cmd_dir.
     def which cmd_name
       matching_dir = cmd_dir(cmd_name)
@@ -210,13 +204,11 @@ module Babushka
     #   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
+      LogHelpers.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