rubycut-babushka 0.10.6

data/lib/babushka/dep_context.rb

@@ -0,0 +1,18 @@
+module Babushka
+  class DepContext < DepDefiner
+    include DepRunner
+
+    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?
+
+    accepts_block_for :prepare
+    accepts_block_for :before
+    accepts_block_for :meet
+    accepts_block_for :after
+  end
+end

data/lib/babushka/dep_definer.rb

@@ -0,0 +1,115 @@
+module Babushka
+  class DepDefiner
+    include LogHelpers
+    extend LogHelpers
+    include ShellHelpers
+    extend ShellHelpers
+    include PathHelpers
+    extend PathHelpers
+    include RunHelpers
+    extend RunHelpers
+
+    include Prompt::Helpers
+    extend Prompt::Helpers
+    include VersionOf::Helpers
+    extend VersionOf::Helpers
+
+    include AcceptsListFor
+    include AcceptsValueFor
+    include AcceptsBlockFor
+
+    attr_reader :dependency, :payload, :block
+
+    def name; dependency.name end
+    def basename; dependency.basename end
+    def load_path; dependency.load_path end
+
+    include Vars::Helpers
+    extend Vars::Helpers
+
+    def initialize dep, &block
+      @dependency = dep
+      @payload = {}
+      @block = block
+    end
+
+    def define!
+      define_params!
+
+      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)
+      end
+    end
+
+    def result message, opts = {}
+      opts[:result].tap {
+        dependency.result_message = message
+      }
+    end
+
+    def met message
+      result message, :result => true
+    end
+
+    def unmet message
+      result message, :result => false
+    end
+
+    def unmeetable message
+      raise Babushka::UnmeetableDep, message
+    end
+
+    def file_and_line
+      get_file_and_line_for(block)
+    end
+
+    def file_and_line_for block_name
+      get_file_and_line_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
+    end
+
+    private
+
+    def define_params!
+      dependency.params.each {|param|
+        if respond_to?(param)
+          raise DepParameterError, "You can't use #{param.inspect} as a parameter (on '#{dependency.name}'), because that's already a method on #{method(param).owner}."
+        else
+          metaclass.send :define_method, param do
+            dependency.args[param] ||= Parameter.new(param)
+          end
+        end
+      }
+    end
+
+    def pkg_manager
+      BaseHelper
+    end
+
+    def on platform, &blk
+      if [*chooser].include? platform
+        @current_platform = platform
+        blk.call.tap {
+          @current_platform = nil
+        }
+      end
+    end
+
+    def chooser
+      Base.host.match_list
+    end
+
+    def chooser_choices
+      SystemDefinitions.all_tokens
+    end
+
+    def self.source_template
+      Dep.base_template
+    end
+
+  end
+end

data/lib/babushka/dep_pool.rb

@@ -0,0 +1,49 @@
+module Babushka
+  class DepPool
+
+    def initialize source
+      clear!
+      @source = source
+    end
+
+    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
+        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
+    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)
+      @pool[item.name] = item
+    end
+
+  end
+end

data/lib/babushka/dep_runner.rb

@@ -0,0 +1,85 @@
+module Babushka
+  module DepRunner
+    include GitHelpers
+    include UriHelpers
+
+    private
+
+    # TODO: solve cmd/app and string/version handling better.
+    def in_path? provided_list
+      apps, command_names = [*provided_list].partition {|i| i.to_s[/\.app\/?$/] }
+      commands = command_names.versions
+      apps_in_path?(apps) and cmds_in_path?(commands) and matching_versions?(commands)
+    end
+
+    def apps_in_path? apps
+      present, missing = [*apps].partition {|app_name| app_dir(app_name) }
+
+      missing.empty?.tap {|result|
+        if result
+          log "#{present.map {|i| "'#{i}'" }.to_list} #{present.length == 1 ? 'is' : 'are'} present." unless present.empty?
+        else
+          log "#{missing.map {|i| "'#{i}'" }.to_list} #{missing.length == 1 ? 'is' : 'are'}n't present anywhere in $PATH."
+        end
+      }
+    end
+
+    def cmds_in_path? commands
+      dir_hash = [*commands].group_by {|cmd| cmd_dir(cmd.name) }
+
+      if dir_hash.keys.compact.length > 1
+        unmeetable "The commands for '#{name}' run from more than one place.\n" +
+          dir_hash.values.map {|cmds|
+            cmd_location_str_for cmds
+          }.to_list(:oxford => true, :conj => 'but').end_with('.')
+      else
+        cmds = dir_hash.values.first
+        dir_hash[nil].blank?.tap {|result|
+          if result
+            log cmd_location_str_for(cmds).end_with('.') unless cmds.blank?
+          else
+            log "#{dir_hash[nil].map {|i| "'#{i}'" }.to_list} #{dir_hash[nil].length == 1 ? 'is' : 'are'} missing."
+          end
+        }
+      end
+    end
+
+    def matching_versions? commands
+      versions = commands.select {|cmd|
+        !cmd.version.nil?
+      }.inject({}) {|hsh,cmd|
+        hsh[cmd] = (shell("#{cmd.name} --version") || '').split(/[\s\-]/).detect {|piece|
+          begin
+            cmd.matches? piece.to_version
+          rescue VersionStrError
+            false
+          end
+        }
+        log "#{cmd.name} is #{hsh[cmd]}, which is#{"n't" unless hsh[cmd]} #{cmd.version}.", :as => (:ok if hsh[cmd])
+        hsh
+      }
+      versions.values.all?
+    end
+
+    def app_dir app_name
+      prefix.find {|app_path|
+        (app_path.to_s / app_name).glob.select {|entry|
+          (entry / 'Contents/MacOS').exists?
+        }.first
+      }
+    end
+
+    def cmd_location_str_for cmds
+      "#{cmds.map {|i| "'#{i.name}'" }.to_list(:conj => '&')} run#{'s' if cmds.length == 1} from #{cmd_dir(cmds.first.name)}"
+    end
+
+    def call_task task_name
+      if (task_block = send(task_name)).nil?
+        true
+      else
+        instance_eval(&task_block)
+      end
+    end
+
+  end
+end

data/lib/babushka/dsl.rb

@@ -0,0 +1,26 @@
+module Babushka
+  module DSL
+    # 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.
+    # If no dep matching +spec+ is found, nil is returned.
+    def Dep spec, opts = {}
+      Base.sources.dep_for spec, opts
+    end
+
+    # Define and return a dep named +name+, and whose implementation is found
+    # in +block+. This is the usual top-level entry point of the babushka
+    # DSL (along with +meta+); templated or not, this is how deps are
+    # defined.
+    def dep name, *params, &block
+      Base.sources.current_load_source.deps.add_dep name, params, block
+    end
+
+    # Define and return a meta dep named +name+, and whose implementation is
+    # found in +block+. This method, along with +dep, together are the
+    # top level of babushka's DSL.
+    def meta name, opts = {}, &block
+      Base.sources.current_load_source.templates.add_template name, opts, block
+    end
+  end
+end

data/lib/babushka/git_repo.rb

@@ -0,0 +1,185 @@
+module Babushka
+  class GitRepoError < StandardError
+  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"
+  #
+  # For practical example how to use GitRepo class, see Ben Hoskings {https://github.com/benhoskings/babushka-deps/blob/master/push.rb push dep}
+  #
+  # Methods for checking repositrory state:
+  #
+  # * {#clean?}
+  # * {#dirty?}
+  # * {#include?} ref
+  # * {#ahead?}
+  # * {#behind?}
+  # * {#rebasing?}
+  # * {#applying?}
+  # * {#merging?}
+  # * {#bisecting?}
+  # * {#rebase_merging?}
+  # * {#rebasing_interactively?}
+  #
+  # Methods for repository operations:
+  # 
+  # * {#clone!}
+  # * {#branch!}
+  # * {#track!}
+  # * {#checkout!}
+  # * {#reset_hard!} refspec
+  
+  class GitRepo
+    include ShellHelpers
+    extend ShellHelpers
+
+    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
+    end
+
+    def path
+      @path ||= @raw_path.p
+    end
+
+    def root
+      @root ||= self.class.repo_for(path)
+    end
+
+    def git_dir
+      root / '.git'
+    end
+
+    def exists?
+      !root.nil? && root.exists?
+    end
+    # executes shell command setting current directory to repository root
+    #
+    def repo_shell cmd, opts = {}, &block
+      if !exists?
+        raise GitRepoError, "There is no repo at #{@path}."
+      else
+        shell cmd, opts.merge(:cd => root), &block
+      end
+    end
+
+    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
+
+    def dirty?
+      !clean?
+    end
+
+    def include? ref
+      repo_shell("git rev-list -n 1 '#{ref}'")
+    end
+
+    def ahead?
+      !remote_branch_exists? ||
+      !repo_shell("git rev-list origin/#{current_branch}..").split("\n").empty?
+    end
+
+    def behind?
+      remote_branch_exists? &&
+      !repo_shell("git rev-list ..origin/#{current_branch}").split("\n").empty?
+    end
+
+    def rebasing?
+      %w[rebase rebase-apply ../.dotest].any? {|d|
+        (git_dir / d).exists?
+      } or rebase_merging? or rebasing_interactively?
+    end
+
+    def applying?
+      %w[rebase rebase-apply ../.dotest].any? {|d|
+        (git_dir / d / 'applying').exists?
+      }
+    end
+
+    def merging?
+      (git_dir / 'MERGE_HEAD').exists? or rebase_merging?
+    end
+
+    def bisecting?
+      (git_dir / 'BISECT_LOG').exists?
+    end
+
+    def rebase_merging?
+      %w[rebase-merge .dotest-merge].any? {|d|
+        (git_dir / d).exists?
+      }
+    end
+
+    def rebasing_interactively?
+      %w[rebase-merge .dotest-merge].any? {|d|
+        (git_dir / d / 'interactive').exists?
+      }
+    end
+
+    def branches
+      repo_shell('git branch').split("\n").map {|l| l.sub(/^[* ]+/, '') }
+    end
+
+    def current_branch
+      repo_shell("cat .git/HEAD").strip.sub(/^.*refs\/heads\//, '')
+    end
+
+    def current_head
+      repo_shell("git rev-parse --short HEAD")
+    end
+
+    def current_full_head
+      repo_shell("git rev-parse HEAD")
+    end
+
+    def remote_branch_exists?
+      repo_shell('git branch -a').split("\n").map(&:strip).detect {|b|
+        b[/^(remotes\/)?origin\/#{current_branch}$/]
+      }
+    end
+
+    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|
+        shell.ok? || raise(GitRepoError, "Couldn't clone to #{path}: #{error_message_for shell.stderr}")
+      }
+    end
+
+    def branch! branch
+      repo_shell("git branch '#{branch}'")
+    end
+
+    def track! branch
+      repo_shell("git checkout -t '#{branch}'")
+    end
+
+    def checkout! branch
+      repo_shell("git checkout '#{branch}'")
+    end
+
+    def reset_hard! refspec = 'HEAD'
+      repo_shell("git reset --hard #{refspec}")
+    end
+
+    def inspect
+      "#<GitRepo:#{root} : #{current_branch}@#{current_head}#{' (dirty)' if dirty?}>"
+    end
+
+    private
+
+    def error_message_for git_error
+      git_error.sub(/^fatal\: /, '').sub(/\n.*$/m, '').end_with('.')
+    end
+  end
+end