rubycut-babushka 0.10.8 → 0.15.6.1

data/lib/babushka/dep_context.rb

@@ -1,11 +1,10 @@
 module Babushka
   class DepContext < DepDefiner
-    include DepRunner
+    include GitHelpers
+    include UriHelpers
 
-    accepts_list_for :desc
     accepts_list_for :requires
     accepts_list_for :requires_when_unmet
-    accepts_value_for :run_in
 
     accepts_block_for :setup
     accepts_block_for :met?
@@ -14,5 +13,11 @@ module Babushka
     accepts_block_for :before
     accepts_block_for :meet
     accepts_block_for :after
+
+    private
+
+    def in_path? provided_list
+      PathChecker.in_path? provided_list
+    end
   end
 end

data/lib/babushka/dep_definer.rb

@@ -31,15 +31,27 @@ module Babushka
       @dependency = dep
       @payload = {}
       @block = block
+      @loaded, @failed = false, false
+      @current_platform = nil
     end
 
-    def define!
-      define_params!
+    def loaded?; @loaded end
+    def failed?; @failed end
 
-      unless block.nil?
-        raise "Dep block arguments aren't supported anymore. Instead, specify parameter names as symbols after the dep name. More details here: http://github.com/benhoskings/babushka/commit/40054c2" if block.arity > 0
-        instance_eval(&block)
+    def define!
+      unless loaded? || failed?
+        define_elements!
+        @loaded, @failed = true, false
       end
+      self
+    rescue StandardError => e
+      @loaded, @failed = false, true
+      raise e
+    end
+
+    def invoke task_name
+      define! unless loaded?
+      instance_eval(&send(task_name)) unless failed?
     end
 
     def result message, opts = {}
@@ -49,31 +61,45 @@ module Babushka
     end
 
     def met message
-      result message, :result => true
+      removed! :instead => "a truthy return value from met?{} (maybe using #log_ok)"
     end
 
     def unmet message
-      result message, :result => false
+      removed! :instead => "a falsey return value from met?{} (maybe using #log)"
     end
 
     def unmeetable message
+      removed! :instead => "#unmeetable!"
+    end
+
+    def unmeetable! message
       raise Babushka::UnmeetableDep, message
     end
 
-    def file_and_line
-      get_file_and_line_for(block)
+    def source_location
+      get_source_location_for(block)
     end
 
-    def file_and_line_for block_name
-      get_file_and_line_for send(block_name) if has_block? block_name
+    def source_location_for block_name
+      get_source_location_for send(block_name) if has_block? block_name
     end
 
-    def get_file_and_line_for blk
-      blk.inspect.scan(/\#\<Proc\:0x[0-9a-f]+\@([^:]+):(\d+)>/).flatten
+    def get_source_location_for blk
+      if blk.respond_to?(:source_location) # Not present on cruby-1.8.
+        blk.source_location
+      else
+        blk.inspect.scan(/\#\<Proc\:0x[0-9a-f]+\@([^:]+):(\d+)>/).flatten
+      end
     end
 
     private
 
+    def define_elements!
+      debug "(defining #{dependency.name} against #{dependency.template.contextual_name})"
+      define_params!
+      instance_eval(&block) unless block.nil?
+    end
+
     def define_params!
       dependency.params.each {|param|
         if respond_to?(param)
@@ -87,7 +113,11 @@ module Babushka
     end
 
     def pkg_manager
-      BaseHelper
+      UnknownPkgHelper
+    end
+
+    def current_platform
+      @current_platform
     end
 
     def on platform, &blk
@@ -100,7 +130,7 @@ module Babushka
     end
 
     def chooser
-      Base.host.match_list
+      Babushka.host.match_list
     end
 
     def chooser_choices

data/lib/babushka/dep_pool.rb

@@ -9,36 +9,33 @@ module Babushka
     def count
       @pool.length
     end
-    
+
     def names
       @pool.keys
     end
+
     def items
       @pool.values
     end
+
     def for spec
       spec.respond_to?(:name) ? @pool[spec.name] : @pool[spec]
     end
 
     def add_dep name, params, block
-      if self.for name
-        self.for name
-      else
+      self.for(name) || begin
         opts = params.extract_options!
         Dep.new name, @source, params, opts, block
       end
     end
 
     def add_template name, in_opts, block
-      MetaDep.for name, @source, in_opts, &block
+      DepTemplate.for name, @source, in_opts, &block
     end
 
     def clear!
       @pool = {}
     end
-    def uncache!
-      items.each {|i| i.send :uncache! }
-    end
 
     def register item
       raise "Already registered '#{item.name}'." if @pool.has_key?(item.name)

data/lib/babushka/{meta_dep.rb → dep_template.rb}

@@ -1,5 +1,24 @@
 module Babushka
-  class MetaDep
+  # A BaseTemplate is just a blank, passthrough template -- all it does is
+  # return DepContext as the context against which standard (i.e. untemplated)
+  # deps are defined.
+  class BaseTemplate
+    def self.contextual_name; name end
+    def self.suffixed?; false end
+    def self.context_class; DepContext end
+  end
+
+  # This class represents a template against which deps can be defined. The
+  # resulting deps are structured just like regular ones, except for the context
+  # against which they were defined.
+  #
+  # Standard deps are defined against DepContext, which makes just the basic dep
+  # DSL available, i.e. requires/met?/meet, etc. Templated deps are defined against
+  # a subclass of TemplatedDepContext as built by +build_context+.
+  #
+  # This means that when a templated dep is defined, the context will be a superset
+  # of that of a standard dep -- the normal stuff, plus whatever the template adds.
+  class DepTemplate
     include LogHelpers
 
     INVALID_NAMES = %w[base]
@@ -54,7 +73,7 @@ module Babushka
     end
 
     def build_context block
-      Class.new(MetaDepContext, &block).tap {|context|
+      Class.new(TemplatedDepContext, &block).tap {|context|
         shadow = self
         context.metaclass.send :define_method, :source_template do
           shadow

data/lib/babushka/dsl.rb

@@ -1,5 +1,8 @@
 module Babushka
   module DSL
+    # Make these helpers directly callable, and private when included.
+    module_function
+
     # Use +spec+ to look up a dep. Because +spec+ might include a source
     # prefix, the dep this method returns could be from any of the currently
     # known sources.

data/lib/babushka/git_repo.rb

@@ -3,67 +3,74 @@ module Babushka
   end
   class GitRepoExists < GitRepoError
   end
-  # This class is used for manipulating git repositories (see {#initialize} how to start). Mostly it provides shortcuts to most often used git commands.
-  # @example Example of usage:
-  #   @repo ||= Babushka::GitRepo.new('.')
-  #   @repo.clone "https://github.com/benhoskings/babushka"
-  #   @repo.checkout! "devel"
+
+  # Provides some wrapper methods for interacting concisely with a git
+  # repository.
+  #
+  # The repo is accessed by shelling out to `git` via the {repo_shell}
+  # method, which makes sure the repo exists and that the commands are run
+  # in the right place. Hence, GitRepo doesn't depend on your current
+  # working directory.
+  #
+  # Most of the methods return a boolean and are used to discover things
+  # about the repository, like whether it's {clean?} or {dirty?}, currently
+  # {merging?} or {rebasing?}, and whether it's {ahead?} or {behind?} the
+  # default remote.
   #
-  # For practical example how to use GitRepo class, see Ben Hoskings {https://github.com/benhoskings/babushka-deps/blob/master/push.rb push dep}
+  # Some return a piece of data, like {current_head} and {current_branch}.
   #
-  # Methods for checking repositrory state:
+  # There are also some methods that make simple changes to the repository,
+  # like {checkout!} and {reset_hard!}.
   #
-  # * {#clean?}
-  # * {#dirty?}
-  # * {#include?} ref
-  # * {#ahead?}
-  # * {#behind?}
-  # * {#rebasing?}
-  # * {#applying?}
-  # * {#merging?}
-  # * {#bisecting?}
-  # * {#rebase_merging?}
-  # * {#rebasing_interactively?}
+  # To perform other operations on the repository like committing or
+  # rebasing, check out grit. This class is just a little `git` wrapper.
   #
-  # Methods for repository operations:
-  # 
-  # * {#clone!}
-  # * {#branch!}
-  # * {#track!}
-  # * {#checkout!}
-  # * {#reset_hard!} refspec
-  
   class GitRepo
     include ShellHelpers
     extend ShellHelpers
 
+    attr_reader :path
+
+    # The full path to the root of the repo {path} is within, if it is within
+    # one somewhere; otherwise nil.
     def self.repo_for path
-      maybe = shell("git rev-parse --git-dir", :cd => path) if path.p.dir?
-      maybe == '.git' ? path.p : maybe / '..' unless maybe.nil?
-    end
-    # @example Initialize repo in current dir
-    #   @repo ||= Babushka::GitRepo.new('.')
-    def initialize path
-      @raw_path = path
+      maybe = shell?("git rev-parse --git-dir", :cd => path) if path.p.dir?
+
+      if maybe == '.git'
+        path.p
+      elsif !maybe.nil?
+        maybe / '..'
+      end
     end
 
-    def path
-      @path ||= @raw_path.p
+    def initialize path
+      @path = path.p
     end
 
+    # This repo's top-level directory.
     def root
       @root ||= self.class.repo_for(path)
     end
 
+    # This repo's +.git+ directory, where git stores its objects and other repo data.
     def git_dir
       root / '.git'
     end
 
+    # True if +root+ points to an existing git repo.
+    #
+    # The repo doesn't always have to exist. For example, you can pass a
+    # nonexistent path when you initialize a GitRepo, and then call {clone!}
+    # on it.
     def exists?
       !root.nil? && root.exists?
     end
-    # executes shell command setting current directory to repository root
+
+    # Run +cmd+ on the shell, changing to this repo's {root}. If the repo
+    # doesn't exist, a GitRepoError is raised.
     #
+    # A GitRepo with a nonexistent {root} is valid - it will only fail if
+    # an operation that requires an existing repo is attempted.
     def repo_shell cmd, opts = {}, &block
       if !exists?
         raise GitRepoError, "There is no repo at #{@path}."
@@ -72,45 +79,75 @@ module Babushka
       end
     end
 
+    def repo_shell? cmd, opts = {}
+      if !exists?
+        raise GitRepoError, "There is no repo at #{@path}."
+      else
+        shell? cmd, opts.merge(:cd => root)
+      end
+    end
+
+
+    # True if the repo is clean, i.e. when the content in its index and working
+    # copy match the commit that HEAD refers to.
     def clean?
       repo_shell("git status") # Sometimes git caches invalid index info; this clears it.
       repo_shell("git diff-index --name-status HEAD", &:stdout).blank?
     end
 
+    # The inverse of {clean?} -- true if the content in the repo's index or
+    # working copy differs from the commit HEAD refers to.
     def dirty?
       !clean?
     end
 
+    # True if the commit referenced by +ref+ is present somewhere in this repo.
+    #
+    # Note that the ref being present doesn't mean that it's a parent of +HEAD+,
+    # just that it currently resolves to a commit.
     def include? ref
       repo_shell("git rev-list -n 1 '#{ref}'")
     end
 
+    # True if there are any commits in the current branch's history that
+    # aren't also present on the corresponding remote branch, or if the
+    # remote doesn't exist.
     def ahead?
       !remote_branch_exists? ||
-      !repo_shell("git rev-list origin/#{current_branch}..").split("\n").empty?
+      !repo_shell("git rev-list #{current_remote_branch}..").split("\n").empty?
     end
 
+    # True if there are any commits in the current branch's corresponding remote
+    # branch that aren't also present locally, if the remote branch exists.
     def behind?
       remote_branch_exists? &&
-      !repo_shell("git rev-list ..origin/#{current_branch}").split("\n").empty?
+      !repo_shell("git rev-list ..#{current_remote_branch}").split("\n").empty?
     end
 
+    # True if the repo is partway through a rebase of some kind. This could be
+    # because one of the commits conflicted when it was replayed, or that the
+    # rebase is interactive and is awaiting another command.
     def rebasing?
       %w[rebase rebase-apply ../.dotest].any? {|d|
         (git_dir / d).exists?
       } or rebase_merging? or rebasing_interactively?
     end
 
+    # True if a patch is partway through being applied -- perhaps because applying
+    # it caused conflicts that are yet to be resolved.
     def applying?
       %w[rebase rebase-apply ../.dotest].any? {|d|
         (git_dir / d / 'applying').exists?
       }
     end
 
+    # True if a merge is in progress -- perhaps because it produced conflicts that
+    # are yet to be resolved.
     def merging?
       (git_dir / 'MERGE_HEAD').exists? or rebase_merging?
     end
 
+    # True if a bisect is currently in progress.
     def bisecting?
       (git_dir / 'BISECT_LOG').exists?
     end
@@ -127,28 +164,70 @@ module Babushka
       }
     end
 
+
+
+    # An array of the names of all the local branches in this repo.
     def branches
-      repo_shell('git branch').split("\n").map {|l| l.sub(/^[* ]+/, '') }
+      names = repo_shell('git branch').split("\n").map {|l| l.sub(/^[* ]+/, '') }
+      names - ['(no branch)']
     end
 
+    def all_branches
+      names = repo_shell('git branch -a').split("\n").map {|l| l.sub(/^[* ]+/, '') }
+      (names - ['(no branch)']).reject {|i|
+        i['/origin/HEAD ->']
+      }.map {|i|
+        i.sub(/^remotes\//, '')
+      }
+    end
+
+    # The name of the branch that's currently checked out, if any. If there
+    # is no current branch (i.e. if the HEAD is detached), the HEAD's SHA is
+    # returned instead.
     def current_branch
       repo_shell("cat .git/HEAD").strip.sub(/^.*refs\/heads\//, '')
     end
 
+    # The namespaced name of the remote branch that the current local branch
+    # is tracking, or on origin if the branch isn't tracking an explicit
+    # remote branch.
+    def current_remote_branch
+      branch = current_branch
+      "#{remote_for(branch)}/#{branch}"
+    end
+
+    # The short SHA of the repo's current HEAD. This is usually 7 characters,
+    # but is longer when extra characters are required to disambiguate it.
     def current_head
       repo_shell("git rev-parse --short HEAD")
     end
 
+    # The full 40 character SHA of the current HEAD.
     def current_full_head
       repo_shell("git rev-parse HEAD")
     end
 
+    # The short SHA of the commit that +ref+ currently refers to.
+    def resolve ref
+      repo_shell?("git rev-parse --short #{ref}")
+    end
+
+    # The remote assigned to branch in the git config, or 'origin' if none
+    # is set. This is the remote that git pushes to and fetches from for this
+    # branch by default, and the branch that comparisons like #ahead? and
+    # #behind? are made against.
+    def remote_for branch
+      repo_shell?("git config branch.#{branch}.remote") || 'origin'
+    end
+
+    # True if origin contains a branch of the same name as the current local
+    # branch.
     def remote_branch_exists?
-      repo_shell('git branch -a').split("\n").map(&:strip).detect {|b|
-        b[/^(remotes\/)?origin\/#{current_branch}$/]
-      }
+      repo_shell?("git rev-parse refs/remotes/#{current_remote_branch}")
     end
 
+    # Clone the remote at +from+ to this GitRepo's path. The path must be
+    # nonexistent; an error is raised if the local repo already exists.
     def clone! from
       raise GitRepoExists, "Can't clone #{from} to existing path #{path}." if exists?
       shell("git clone '#{from}' '#{path.basename}'", :cd => path.parent, :create => true) {|shell|
@@ -156,20 +235,35 @@ module Babushka
       }
     end
 
-    def branch! branch
-      repo_shell("git branch '#{branch}'")
+    # Create a new local branch called +branch+ with +ref+ (defaulting to
+    # HEAD) as its tip.
+    def branch! branch, ref = 'HEAD'
+      repo_shell("git branch '#{branch}' '#{ref}'")
     end
 
+    # Create a new local tracking branch for +branch+, which should be specified
+    # as remote/branch. For example, if "origin/next" is passed, a local 'next'
+    # branch will be created to track origin's 'next' branch.
     def track! branch
-      repo_shell("git checkout -t '#{branch}'")
+      repo_shell("git checkout -t '#{branch}' -b '#{branch.sub(/^.*\//, '')}'")
+    end
+
+    # Check out the supplied ref, detaching the HEAD if the named ref
+    # isn't a branch.
+    def checkout! ref
+      repo_shell("git checkout '#{ref}'")
     end
 
-    def checkout! branch
-      repo_shell("git checkout '#{branch}'")
+    # Check out the supplied ref, detaching the HEAD. If the ref is a branch
+    # or tag, HEAD will reference the commit at the tip of the ref.
+    def detach! ref = 'HEAD'
+      repo_shell("git checkout '#{resolve(ref)}'")
     end
 
-    def reset_hard! refspec = 'HEAD'
-      repo_shell("git reset --hard #{refspec}")
+    # Reset the repo to the given ref, discarding changes in the index and
+    # working copy.
+    def reset_hard! ref = 'HEAD'
+      repo_shell("git reset --hard '#{ref}'")
     end
 
     def inspect