rubycut-babushka 0.10.6

data/deps/templates/ppa.rb

@@ -0,0 +1,24 @@
+dep 'python-software-properties.managed' do
+  provides 'add-apt-repository'
+end
+
+meta :ppa do
+  accepts_value_for :adds
+  template {
+    requires 'python-software-properties.managed'
+    met? {
+      Dir.glob("/etc/apt/sources.list.d/*").any? {|f|
+        f.p.read[Regexp.new('https?://' + adds.gsub(':', '.*') + '/ubuntu ')]
+      }
+    }
+    before {
+      adds[/^\w+\:\w+/] or log_error("'#{adds}' doesn't look like 'ppa:something'.")
+    }
+    meet {
+      sudo "sudo add-apt-repository #{adds}"
+    }
+    after {
+      Babushka::Base.host.pkg_helper.update_pkg_lists "Updating apt lists to load #{adds}."
+    }
+  }
+end

data/deps/templates/src.rb

@@ -0,0 +1,42 @@
+meta :src do
+  accepts_list_for :source
+  accepts_list_for :extra_source
+  accepts_list_for :provides, :basename
+  accepts_value_for :prefix, '/usr/local'
+
+  accepts_block_for(:preconfigure) {
+    if './configure'.p.exists?
+      true # No preconfigure needed
+    elsif !'./configure.in'.p.exists? && !'./configure.ac'.p.exists?
+      true # Not pre-configurable
+    else
+      log_shell "autoconf", "autoconf"
+    end
+  }
+  accepts_block_for(:configure) { log_shell "configure", default_configure_command }
+  accepts_list_for :configure_env
+  accepts_list_for :configure_args
+
+  accepts_block_for(:build) { log_shell "build", "make" }
+  accepts_block_for(:install) { Babushka::SrcHelper.install_src! 'make install' }
+  accepts_block_for(:postinstall)
+
+  accepts_block_for(:process_source) {
+    call_task(:preconfigure) and
+    call_task(:configure) and
+    call_task(:build) and
+    call_task(:install) and
+    call_task(:postinstall)
+  }
+
+  def default_configure_command
+    "#{configure_env.map(&:to_s).join} ./configure --prefix=#{prefix} #{configure_args.map(&:to_s).join(' ')}"
+  end
+
+  template {
+    requires 'build tools', 'curl.managed'
+    prepare { setup_source_uris }
+    met? { in_path?(provides) }
+    meet { process_sources { call_task :process_source } }
+  }
+end

data/deps/templates/tmbundle.rb

@@ -0,0 +1,15 @@
+meta :tmbundle, :for => :osx do
+  accepts_value_for :source
+
+  def path
+    '~/Library/Application Support/TextMate/Bundles' / name
+  end
+
+  template {
+    requires 'benhoskings:TextMate.app'
+    met? { path.dir? }
+    before { shell "mkdir -p '#{path.parent}'" }
+    meet { git source, :to => path }
+    after { log_shell "Telling TextMate to reload bundles", %Q{osascript -e 'tell app "TextMate" to reload bundles'} }
+  }
+end

data/lib/babushka.rb

@@ -0,0 +1,28 @@
+module Babushka
+  VERSION        = '0.10.6'
+  WorkingPrefix  = '~/.babushka'
+  SourcePrefix   = '~/.babushka/sources'
+  BuildPrefix    = '~/.babushka/build'
+  DownloadPrefix = '~/.babushka/downloads'
+  LogPrefix      = '~/.babushka/logs'
+  VarsPrefix     = '~/.babushka/vars'
+  ReportPrefix   = '~/.babushka/runs'
+
+  module Path
+    def self.binary() File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__ end
+    def self.bin() File.dirname(binary) end
+    # this is not correct in gem version
+    def self.path() File.dirname(bin) end
+    def self.lib() File.join(path, 'lib') end
+    def self.run_from_path?() ENV['PATH'].split(':').include? File.dirname($0) end
+  end
+end
+
+# First, load the component lists.
+require File.join(Babushka::Path.path, 'lib', 'components')
+
+# Load external components that babushka depends on.
+Babushka::ExternalComponents.each {|c| require File.join(Babushka::Path.path, 'lib', c) }
+
+# Next, load babushka itself.
+Babushka::Components.each {|c| require File.join(Babushka::Path.path, 'lib/babushka', c) }

data/lib/babushka/accepts_block_for.rb

@@ -0,0 +1,72 @@
+module Babushka
+  module AcceptsBlockFor
+    def self.included base
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      def default_blocks
+        merged_default_blocks_for self
+      end
+      def merged_default_blocks_for klass
+        parent_values = klass == DepDefiner ? {} : merged_default_blocks_for(klass.superclass)
+        parent_values.merge(default_blocks_for(klass))
+      end
+      def default_blocks_for klass
+        (@@default_blocks ||= Hashish.hash)[klass]
+      end
+
+      def accepted_blocks
+        default_blocks.keys
+      end
+
+      def accepts_block_for method_name, &default_block
+        default_blocks_for(self)[method_name] = default_block
+        class_eval %Q{
+          def #{method_name} *args, &block
+            payload[#{method_name.inspect}] ||= {}
+            if block.nil?
+              block_for #{method_name.inspect}
+            else
+              store_block_for #{method_name.inspect}, args, block
+            end
+          end
+        }
+      end
+    end
+
+    def has_block? block_name
+      payload[block_name] ||= {}
+      !!specific_block_for(block_name)
+    end
+
+    def default_block_for block_name
+      differentiator = Base.host.differentiator_for payload[block_name].keys
+      L{
+        debug "#{block_name} not defined#{" for #{differentiator}" unless differentiator.nil?}."
+        true
+      }
+    end
+
+    def default_blocks
+      self.class.default_blocks
+    end
+
+    def store_block_for method_name, args, block
+      raise "#{method_name} only accepts args like :on => :linux (as well as a block arg)." unless args.empty? || args.first.is_a?(Hash)
+
+      payload[method_name] ||= {}
+      chosen_on = (args.first || {})[:on] || @current_platform || :all
+      payload[method_name][chosen_on] = block
+    end
+
+    def block_for method_name
+      specific_block_for(method_name) or default_block_for(method_name)
+    end
+
+    def specific_block_for method_name
+      payload[method_name][(Base.host.match_list & payload[method_name].keys).first] ||
+      default_blocks[method_name]
+    end
+  end
+end

data/lib/babushka/accepts_list_for.rb

@@ -0,0 +1,49 @@
+module Babushka
+  module AcceptsListFor
+    def self.included base
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      def accepts_list_for method_name, *args
+        opts = {:type => 'list'}.merge args.extract_options!
+        default = args.shift
+
+        file, line = caller.first.split(':', 2)
+        line = line.to_i
+
+        module_eval <<-LOL, file, line
+          def #{method_name} *args, &block
+            if !args.empty? && !block.nil?
+              raise ArgumentError, "You can supply arguments or a block, but not both."
+            elsif args.empty? && block.nil?
+              #{opts[:type]}_for #{method_name.inspect}, #{default.inspect}
+            else
+              store_#{opts[:type]}_for #{method_name.inspect}, block || [*args].flatten, #{opts[:choose_with].inspect}
+              self
+            end
+          end
+        LOL
+      end
+    end
+
+    def store_list_for method_name, data, choose_with
+      if data.respond_to? :call
+        store_list_for method_name, LambdaChooser.new(self, *chooser_choices, &data).choose(chooser, choose_with), choose_with
+      else
+        (payload[method_name] ||= []).concat(data || [])
+      end
+    end
+
+    def list_for method_name, default
+      if payload.has_key? method_name
+        payload[method_name].map {|i| i.respond_to?(:call) ? i.call : i }.compact
+      else
+        # Splatting on expressions instead of just a single token seems
+        # to break the result in rubinius. https://gist.github.com/1173301
+        values = default.is_a?(Symbol) ? send(default) : (default || [])
+        [*values]
+      end
+    end
+  end
+end

data/lib/babushka/accepts_value_for.rb

@@ -0,0 +1,24 @@
+module Babushka
+  module AcceptsValueFor
+    def self.included base
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      def accepts_value_for method_name, *args
+        opts = args.extract_options!
+        accepts_list_for method_name, *args.push(opts.merge(:type => 'value'))
+      end
+    end
+
+    def store_value_for method_name, data, choose_with
+      raise "Multiple values for #{method_name}" if data.respond_to?(:length) && data.length > 1
+      payload.delete(method_name) # otherwise new values would be #concat'ed and ignored.
+      store_list_for method_name, data, choose_with
+    end
+
+    def value_for method_name, default
+      list_for(method_name, default).first
+    end
+  end
+end

data/lib/babushka/base.rb

@@ -0,0 +1,78 @@
+module Babushka
+  class Base
+  class << self
+
+    # +task+ represents the overall job that is being run, and the parts that
+    # are external to running the corresponding dep tree itself - logging, and
+    # var loading and saving in particular.
+    def task
+      Task.instance
+    end
+
+    # +cmdline+ is an instance of +Cmdline::Parser+ that represents the arguments
+    # that were passed via the commandline. It handles parsing those arguments,
+    # and choosing the task to perform based on the 'verb' supplied - e.g. 'meet',
+    # 'list', etc.
+    def cmdline
+      @cmdline ||= Cmdline::Parser.for(ARGV)
+    end
+
+    # +host+ is an instance of Babushka::SystemProfile for the system the command
+    # was invoked on.
+    # If the current system isn't supported, SystemProfile.for_host will return
+    # +nil+, and Base.run will fail early. If the system is known but the
+    # flavour isn't (e.g. an unknown Linux variant), a generic SystemProfile
+    # will be used, which should work for most operations but will fail on deps
+    # that attempt to use the package manager, etc.
+    def host
+      @host ||= Babushka::SystemProfile.for_host
+    end
+
+    # +sources+ is an instance of Babushka::SourcePool, contains all the
+    # sources that babushka can currently load deps from. This means all the sources
+    # found in ~/.babushka/sources, plus the default sources:
+    #   - anonymous (no source file; i.e. deps defined in an +irb+ session,
+    #     or similar)
+    #   - core (the builtin deps that babushka uses to install itself)
+    #   - current dir (the contents of ./babushka-deps)
+    #   - personal (the contents of ~/.babushka/deps)
+    def sources
+      SourcePool.instance
+    end
+
+    def threads
+      @threads ||= []
+    end
+
+    def in_thread &block
+      threads.push Thread.new(&block)
+    end
+
+    # The top-level entry point for babushka runs invoked at the command line.
+    # When the `babushka` command is run, bin/babushka.rb first triggers a load
+    # via lib/babushka.rb, and then calls this method.
+    def run
+      cmdline.run
+    ensure
+      threads.each(&:join)
+    end
+
+    def exit_on_interrupt!
+      if $stdin.tty?
+        stty_save = `stty -g`.chomp
+        trap("INT") {
+          system "stty", stty_save
+          unless Base.task.callstack.empty?
+            puts "\n#{Logging.closing_log_message("#{Base.task.callstack.first.contextual_name} (cancelled)", false, :closing_status => true)}"
+          end
+          exit false
+        }
+      end
+    end
+
+    def program_name
+      @program_name ||= ENV['PATH'].split(':').include?(File.dirname($0)) ? File.basename($0) : $0
+    end
+  end
+  end
+end

data/lib/babushka/bug_reporter.rb

@@ -0,0 +1,55 @@
+module Babushka
+  class BugReporter
+    extend LogHelpers
+    extend ShellHelpers
+
+    # This method creates a bug report for +dep+, by reading the debug log and
+    # vars associated with it and posting them as a gist. If the github user is
+    # set in the git config, it's marked as from that user, otherwise it's
+    # anonymous.
+    def self.report dep
+      Prompt.confirm "I can file a bug report for that now, if you like.", :default => 'n', :otherwise => "OK, you're on your own :)" do
+        post_report dep,
+          (which('git') && shell('git config github.user')) || 'anonymous',
+          Base.task.var_path_for(dep).read,
+          Base.task.log_path_for(dep).read
+      end
+    end
+
+
+    private
+
+    # gist.github.com API example at http://gist.github.com/4277
+    def self.post_report dep, user, vars, log
+      require 'net/http'
+      require 'uri'
+
+      Net::HTTP.post_form(
+        URI.parse('http://gist.github.com/api/v1/xml/new'), {
+          "files[from]" => user,
+          "files[vars.yml]" => vars,
+          "files[#{dep.contextual_name}.log]" => log.decolorize
+        }
+      ).tap {|response|
+        report_report_result dep, response
+      }.is_a? Net::HTTPSuccess
+    end
+
+    def self.report_report_result dep, response
+      if response.is_a? Net::HTTPSuccess
+        gist_id = response.body.scan(/<repo>(\d+)<\/repo>/).flatten.first
+        if gist_id.nil?
+          log "Done, but the report's URL couldn't be parsed. Here's some info:"
+          log response.body
+        else
+          log "You can view the report at http://gist.github.com/#{gist_id} - thanks :)"
+        end
+      else
+        log "Deary me, the bug report couldn't be submitted! Would you mind emailing these two files:"
+        log '  ' + Base.task.var_path_for(dep)
+        log '  ' + Base.task.log_path_for(dep)
+        log "to ben@hoskings.net? Thanks."
+      end
+    end
+  end
+end

data/lib/babushka/cmdline.rb

@@ -0,0 +1,133 @@
+# coding: utf-8
+
+module Babushka
+  module Cmdline
+    extend LogHelpers
+
+    handle('global', "Options that are valid for any handler") {
+      opt '-v', '--version',     "Print the current version"
+      opt '-h', '--help',        "Show this information"
+      opt '-d', '--debug',       "Show more verbose logging, and realtime shell command output"
+      opt       '--[no-]color',
+                '--[no-]colour', "Disable color in the output"
+    }
+
+    handle('help', "Print usage information").run {|cmd|
+      Helpers.print_version :full => true
+      if cmd.argv.empty?
+        Helpers.print_usage
+        Helpers.print_handlers
+        Helpers.print_notes
+      elsif (handler = Handler.for(cmd.argv.first)).nil?
+        Helpers.log "#{cmd.argv.first.capitalize}? I have honestly never heard of that."
+      else
+        Helpers.log "\n#{handler.name} - #{handler.description}"
+        cmd.parse(&handler.opt_definer)
+        cmd.print_usage
+      end
+      Helpers.log "\n"
+      true
+    }
+
+    handle('version', "Print the current version").run {
+      Helpers.print_version
+      true
+    }
+
+    handle('list', "List the available deps") {
+      opt '-t', '--templates', "List templates instead of deps"
+    }.run {|cmd|
+      Base.sources.local_only {
+        Helpers.generate_list_for(cmd.opts[:templates] ? :templates : :deps, cmd.argv.first)
+      }
+    }
+
+    handle('meet', 'The main one: run a dep and all its dependencies.') {
+      opt '-n', '--dry-run',      "Discover the curent state without making any changes"
+      opt '-y', '--defaults',     "Assume the default value for all vars without prompting, where possible"
+      opt       '--show-args',    "Show the arguments being passed between deps as they're run"
+      opt       '--track-blocks', "Track deps' blocks in TextMate as they're run"
+    }.run {|cmd|
+      # TODO: spec var parsing
+      dep_names, vars = cmd.argv.partition {|arg| arg['='].nil? }
+      if !(bad_var = vars.detect {|var| var[/^\w+=/].nil? }).nil?
+        fail_with "'#{bad_var}' looks like a var but it doesn't make sense."
+      elsif dep_names.empty?
+        fail_with "Nothing to do."
+      elsif cmd.opts[:track_blocks] && !which('mate')
+        fail_with "The --track-blocks option requires TextMate, and the `mate` helper.\nOn a Mac, you can install them like so:\n  babushka benhoskings:textmate"
+      else
+        Base.task.process dep_names, vars.map {|i|
+          i.split('=', 2)
+        }.inject({}) {|hsh,i|
+          hsh[i.first] = i.last
+          hsh
+        }
+      end
+    }
+
+    handle('sources', "Manage dep sources") {
+      opt '-a', '--add NAME URI', "Add the source at URI as NAME"
+      opt '-u', '--update',       "Update all known sources"
+      opt '-l', '--list',         "List dep sources"
+    }.run {|cmd|
+      if cmd.opts.slice(:add, :update, :list).length != 1
+        fail_with "'sources' requires a single option."
+      elsif cmd.opts.has_key?(:add)
+        begin
+          Source.new(cmd.argv.first, :name => cmd.opts[:add]).add!
+        rescue SourceError => e
+          log_error e.message
+        end
+      elsif cmd.opts.has_key?(:update)
+        Base.sources.update!
+      elsif cmd.opts.has_key?(:list)
+        Base.sources.list!
+      end
+    }
+
+    handle('console', "Start an interactive (irb-based) babushka session").run {
+      exec "irb -r'#{Path.lib / 'babushka'}' --simple-prompt"
+    }
+
+    handle('search', "Search for deps in the community database").run {|cmd|
+      if cmd.argv.length != 1
+        fail_with "'search' requires a single argument."
+      else
+        require 'net/http'
+        require 'yaml'
+
+        search_term = cmd.argv.first
+        results = Helpers.search_results_for(search_term)
+
+        if results.empty?
+          log "Never seen a dep with '#{search_term}' in its name."
+        else
+          Helpers.print_search_results search_term, results
+          true
+        end
+      end
+    }
+
+    handle('edit', "Load the file containing the specified dep in $EDITOR").run {|cmd|
+      if cmd.argv.length != 1
+        fail_with "'edit' requires a single argument."
+      elsif (dep = Dep.find_or_suggest(cmd.argv.first)).nil?
+        fail_with "Can't find '#{cmd.argv.first}' to edit."
+      elsif dep.load_path.nil?
+        fail_with "Can't edit '#{dep.name}, since it wasn't loaded from a file."
+      else
+        file, line = dep.context.file_and_line
+        editor_var = ENV['BABUSHKA_EDITOR'] || ENV['VISUAL'] || ENV['EDITOR'] || which('mate') || which('vim') || which('vi')
+        case editor_var
+        when /^mate/
+          exec "mate -l#{line} '#{file}'"
+        when /^vim?/, /^nano/, /^pico/, /^emacs/
+          exec "#{editor_var} +#{line} '#{file}'"
+        else
+          exec "#{editor_var} '#{file}'"
+        end
+      end
+    }
+  end
+end