rubycut-babushka 0.10.8 → 0.15.6.1

data/lib/babushka/task.rb

@@ -5,20 +5,23 @@ module Babushka
     include PathHelpers
     include ShellHelpers
 
-    attr_reader :opts, :vars, :persistent_log
+    attr_reader :opts, :vars, :caches, :persistent_log
     attr_accessor :reportable
 
     def initialize
-      @vars = Vars.new
       @opts = Base.cmdline.opts.dup
       @running = false
+      @caching = false
     end
 
-    def process dep_names, with_vars = {}
+    def process dep_names, with_vars
       raise "A task is already running." if running?
+      @vars = Vars.new
       @running = true
       Base.in_thread { RunReporter.post_reports }
       dep_names.all? {|dep_name| process_dep dep_name, with_vars }
+    rescue SourceLoadError => e
+      Babushka::Logging.log_exception(e)
     ensure
       @running = false
     end
@@ -27,22 +30,41 @@ module Babushka
       Dep.find_or_suggest dep_name do |dep|
         log_dep(dep) {
           load_run_info_for dep, with_vars
-          dep.with(task_args_for(dep, with_vars)).process(:top_level => true).tap {|result|
+          dep.with(task_args_for(dep, with_vars)).process.tap {|result|
             save_run_info_for dep, result
           }
         }.tap {|result|
-          log "You can view #{opt(:debug) ? 'the' : 'a more detailed'} log at '#{log_path_for(dep)}'." unless result
+          log_stderr "You can view #{opt(:debug) ? 'the' : 'a more detailed'} log at '#{log_path_for(dep)}'." unless result
           RunReporter.queue dep, result, reportable
           BugReporter.report dep if reportable
         }
       end
     end
 
+    def cache &block
+      was_caching, @caching, @caches = @caching, true, {}
+      block.call
+    ensure
+      @caching = was_caching
+    end
+
+    def cached key, opts = {}, &block
+      if !@caching
+        block.call
+      elsif @caches.has_key?(key)
+        @caches[key].tap {|value|
+          opts[:hit].call(value) if opts.has_key?(:hit)
+        }
+      else
+        @caches[key] = block.call
+      end
+    end
+
     def task_info dep, result
       {
-        :version => VERSION,
+        :version => Base.ref,
         :run_at => Time.now,
-        :system_info => Base.host.description,
+        :system_info => Babushka.host.description,
         :dep_name => dep.name,
         :source_uri => dep.dep_source.uri,
         :result => result
@@ -88,8 +110,14 @@ module Babushka
       log_path_for(dep).open('w') {|f|
         f.sync = true
         @persistent_log = f
-        yield.tap { @persistent_log = nil }
+
+        # Note the current babushka & ruby versions at the top of the log.
+        LogHelpers.debug(Base.runtime_info)
+
+        yield
       }
+    ensure
+      @persistent_log = nil
     end
 
     def log_prefix

data/lib/babushka/{meta_dep_context.rb → templated_dep_context.rb}

@@ -1,5 +1,5 @@
 module Babushka
-  class MetaDepContext < DepContext
+  class TemplatedDepContext < DepContext
 
     def self.template &block
       @template = block unless block.nil?

data/lib/babushka/vars.rb

@@ -5,10 +5,51 @@ module Babushka
     attr_reader :vars, :saved_vars
 
     module Helpers
-      def set(key, value) Base.task.vars.set(key, value) end
-      def merge(key, value) Base.task.vars.merge(key, value) end
-      def var(name, opts = {}) Base.task.vars.var(name, opts) end
-      def define_var(name, opts = {}) Base.task.vars.define_var(name, opts) end
+      def set(key, value)
+        deprecated! '2012-12-12', :instead => 'an argument for a dep parameter', :example => "requires 'some dep'.with(:#{key} => '#{value}')"
+        Base.task.vars.set(key, value)
+      end
+
+      def merge(key, value)
+        deprecated! '2012-12-12', :instead => 'an argument for a dep parameter', :example => "requires 'some dep'.with(:#{key} => '#{value}')"
+        Base.task.vars.merge(key, value)
+      end
+
+      def var(name, opts = {})
+        print_var_deprecation_for('#var', name, opts)
+        Base.task.vars.var(name, opts)
+      end
+
+      def define_var(name, opts = {})
+        print_var_deprecation_for('#define_var', name, opts)
+        Base.task.vars.define_var(name, opts)
+      end
+
+      def print_var_deprecation_for method_name, var_name, opts
+        option_names_map = {
+          :default => :default,
+          :message => :ask,
+          :choices => :choose,
+          :choice_descriptions => :choose
+        }
+        param_opts = opts.slice(*option_names_map.keys).keys.map {|key|
+          opt_value = opts[key].respond_to?(:call) ? '...' : opts[key].inspect
+          "#{option_names_map[key]}(#{opt_value})"
+        }
+        example = if param_opts.empty?
+          "dep 'blah', :#{name} do ... end"
+        else
+          "
+dep 'blah', :#{var_name} do
+  #{[var_name].concat(param_opts).join('.')}
+end"
+        end
+        deprecated! '2012-12-12',
+          :skip => 2,
+          :method_name => method_name,
+          :instead => 'a dep parameter',
+          :example => example
+      end
     end
 
     def initialize
@@ -19,6 +60,7 @@ module Babushka
     def set key, value
       vars[key.to_s][:value] = value
     end
+
     def merge key, value
       set key, ((vars[key.to_s] || {})[:value] || {}).merge(value)
     end

data/lib/babushka/version_of.rb

@@ -1,28 +1,40 @@
 module Babushka
+
+  def VersionOf first, *rest
+    # Convert the arguments into a VersionOf. If a single string argument is
+    # passed, try splitting it on space to separate name and version. Otherwise,
+    # pass the arguments as-is, splatting if required.
+    if rest.any?
+      Babushka::VersionOf.new(*[first].concat(rest))
+    elsif first.is_a?(String)
+      name, version = first.split(' ', 2)
+      if version && VersionStr.parseable_version?(version)
+        Babushka::VersionOf.new(name, version)
+      else
+        Babushka::VersionOf.new(first)
+      end
+    elsif first.is_a?(Array)
+      Babushka::VersionOf.new(*first)
+    else
+      Babushka::VersionOf.new(first)
+    end
+  end
+
+  module_function :VersionOf
+
   class VersionOf
     module Helpers
-      module_function
-
       def VersionOf first, *rest
-        # Convert the arguments into a VersionOf. If a single string argument is
-        # passed, try splitting it on space to separate name and version. Otherwise,
-        # pass the arguments as-is, splatting if required.
-        if rest.any?
-          Babushka::VersionOf.new(*[first].concat(rest))
-        elsif first.is_a?(String)
-          Babushka::VersionOf.new(*first.split(' ', 2))
-        elsif first.is_a?(Array)
-          Babushka::VersionOf.new(*first)
-        else
-          Babushka::VersionOf.new(first)
-        end
+        # TODO: decide on the form for this and deprecate the others.
+        Babushka.VersionOf(first, *rest)
       end
+      module_function :VersionOf
     end
 
     attr_accessor :name, :version
 
     def initialize name, version = nil
-      @name = name.respond_to?(:name) ? name.name : name
+      @name = name.is_a?(VersionOf) ? name.name : name
       @version = if version.nil?
         name.version if name.respond_to?(:version)
       elsif version.is_a? VersionStr
@@ -54,8 +66,14 @@ module Babushka
       end
     end
 
-    def to_s joinery = '-'
-      [name, version].compact * joinery
+    def to_s
+      # == joins with a dash to produce versions like 'rack-1.4.1'; anything
+      # else joins with space like 'rack >= 1.4'.
+      [name, version].compact * (exact? ? '-' : ' ')
+    end
+
+    def exact?
+      !version.nil? && version.operator == '=='
     end
 
     def inspect

data/lib/babushka/version_str.rb

@@ -8,13 +8,8 @@ module Babushka
     attr_reader :pieces, :operator, :version
     GemVersionOperators = %w[= == != > < >= <= ~>].freeze
 
-    def <=> other
-      other = other.to_version unless other.is_a? VersionStr
-      max_length = [pieces.length, other.pieces.length].max
-      (0...max_length).to_a.pick {|index|
-        result = compare_pieces pieces[index], other.pieces[index]
-        result unless result == 0
-      } || 0
+    def self.parseable_version? str
+      !str.nil? && !str[/\d|HEAD/].nil?
     end
 
     def initialize str
@@ -22,7 +17,7 @@ module Babushka
 
       if !(@operator.nil? || GemVersionOperators.include?(@operator))
         raise InvalidVersionOperator, "VersionStr.new('#{str}'): invalid operator '#{@operator}'."
-      elsif @version.nil?
+      elsif !self.class.parseable_version?(@version)
         raise InvalidVersionStr, "VersionStr.new('#{str}'): couldn't parse a version number."
       else
         @pieces = @version.strip.scan(/\d+|[a-zA-Z]+|\w+/).map {|piece|
@@ -36,6 +31,15 @@ module Babushka
       @operator == '==' ? @version : "#{@operator} #{@version}"
     end
 
+    def <=> other
+      other = other.to_version unless other.is_a? VersionStr
+      max_length = [pieces.length, other.pieces.length].max
+      (0...max_length).to_a.pick {|index|
+        result = compare_pieces pieces[index], other.pieces[index]
+        result unless result == 0
+      } || 0
+    end
+
     define_method "!=" do |other|
       !(self == other)
     end

data/lib/components.rb

@@ -4,6 +4,7 @@ module Babushka
   ExternalComponents = %w[
     fancypath/fancypath
     inkan/inkan
+    levenshtein/levenshtein
   ]
 
   Components = %w[
@@ -13,7 +14,6 @@ module Babushka
     core_patches/hash
     core_patches/hashish
     core_patches/integer
-    core_patches/io
     core_patches/numeric
     core_patches/bytes
     core_patches/object
@@ -25,13 +25,13 @@ module Babushka
     helpers/shell_helpers
     helpers/path_helpers
     helpers/run_helpers
-    helpers/suggest_helpers
     helpers/git_helpers
     helpers/uri_helpers
     popen
     shell
     git_repo
     resource
+    asset
     prompt
     lambda_chooser
     ip
@@ -41,24 +41,25 @@ module Babushka
     accepts_value_for
     accepts_block_for
     colorizer
-    levenshtein
     cmdline/parser
     cmdline/handler
     cmdline/helpers
     cmdline
     base
     renderable
+    current_ruby
     system_definitions
     system_profile
+    system_detector
+    system_matcher
     run_reporter
     bug_reporter
     pkg_helper
-    pkg_helpers/base_helper
+    pkg_helpers/unknown_pkg_helper
     pkg_helpers/apt_helper
     pkg_helpers/yum_helper
     pkg_helpers/brew_helper
     pkg_helpers/gem_helper
-    pkg_helpers/macports_helper
     pkg_helpers/src_helper
     pkg_helpers/pip_helper
     pkg_helpers/binpkgsrc_helper
@@ -73,10 +74,10 @@ module Babushka
     source_pool
     vars
     parameter
-    dep_runner
+    path_checker
     dep_definer
     dep_context
-    meta_dep
-    meta_dep_context
+    dep_template
+    templated_dep_context
   ]
 end

data/lib/fancypath/fancypath.rb

@@ -3,20 +3,21 @@ require 'pathname'
 class Fancypath < Pathname
   module Helpers
     require 'etc'
+
     def to_fancypath
       Fancypath.new to_tilde_expanded_path
     end
+
     def to_expanded_fancypath
       Fancypath.new File.expand_path(to_tilde_expanded_path)
     end
+    alias :p :to_expanded_fancypath
+
     def to_tilde_expanded_path
       sub(/^\~\/|^\~$/) {|_| Etc.getpwuid(Process.euid).dir.end_with('/') }
     end
-    alias :p :to_expanded_fancypath
   end
 
-  # methods are chainable and do what you think they do
-
   alias_method :to_str, :to_s unless method_defined? :to_str
 
   alias_method :dir, :dirname
@@ -31,6 +32,17 @@ class Fancypath < Pathname
   alias_method :exists?, :exist?
   alias_method :rename_to, :rename
 
+
+  # About this Fancypath object.
+
+  def inspect
+    super.sub('Pathname','Fancypath')
+  end
+
+  def to_fancypath
+    self
+  end
+
   def == other
     if other.is_a? String
       to_s == other
@@ -43,51 +55,45 @@ class Fancypath < Pathname
     to_s.length
   end
 
-  def join(path)
-    path_str = path.to_s
-    super(path_str[0..0] == '/' ? path_str[1..-1] : path_str).p
-  end
 
-  alias_method :/, :join
+  # Querying the path.
 
-  # This method returns true if the path is writable (i.e. and already
-  # exists), or if the current user would be able to create it (i.e. if
-  # its closest existing parent is writable).
-  def hypothetically_writable?
-    writable? || (!exists? && !root? && parent.hypothetically_writable?)
+  def empty?
+    directory? ? children.size == 0 : self.size == 0
   end
 
-  # make file
-  def touch
-    `touch '#{self}'`
-    self
+  def owner
+    Etc.getpwuid(File.stat(to_s).uid).name
   end
 
-  def create_dir
-    mkpath unless exist?
-    self
+  def group
+    Etc.getgrgid(File.stat(to_s).gid).name
   end
 
-  alias_method :create, :create_dir
-
-  def copy(dest)
-    `cp -pPR '#{self}' '#{dest}'`
-    self
+  # True if the path is writable (and already exists), or createable by the
+  # current user (i.e. if its closest existing parent is writable).
+  def hypothetically_writable?
+    writable? || (!exists? && !root? && parent.hypothetically_writable?)
   end
 
-  alias_method :cp, :copy
 
-  # file or dir
-  def remove
-    directory? ? rmtree : delete if exist?
-    self
+  # Path traversal & manipulation.
+
+  def join(path)
+    path_str = path.to_s
+    super(path_str[0..0] == '/' ? path_str[1..-1] : path_str).p
   end
-  alias_method :rm, :remove
+  alias_method :/, :join
 
-  def read
-    super.chomp if exists?
+  def parent
+    super.p
   end
 
+  def children
+    super.reject { |c| c.basename.to_s =~ /^\./ }
+  end
+  alias_method :all_children, :children
+
   def readlink
     if !symlink?
       self
@@ -97,29 +103,13 @@ class Fancypath < Pathname
     end
   end
 
-  def mkdir
-    `mkdir -p '#{self}'`
-    self
-  end
-
-  def glob expr = nil, flags = File::FNM_CASEFOLD, &block
-    Dir.glob((expr.nil? ? self : (self / expr)).to_s, flags, &block)
-  end
 
-  def write(contents, mode='wb')
-    dirname.create
-    open(mode) { |f| f.write contents }
-    self
-  end
+  # Querying the file the path refers to.
 
-  def append(contents)
-    write(contents,'a+')
-    self
-  end
+  alias_method :read!, :read
 
-  def move(dest)
-    self.rename(dest)
-    dest.p
+  def read
+    super if exists?
   end
 
   def tail(bytes)
@@ -130,34 +120,27 @@ class Fancypath < Pathname
     end
   end
 
-  alias_method :mv, :move
-
-  def set_extension(ext)
-    "#{without_extension}.#{ext}".p
+  def yaml
+    require 'yaml'
+    YAML.load_file self
   end
 
-  alias_method :change_extension, :set_extension
-
-  def without_extension
-    to_s[/^ (.+?) (\. ([^\.]+))? $/x, 1].p
-  end
 
-  def has_extension?(ext)
-    !!(self.to_s =~ /\.#{ext}$/)
-  end
+  # Querying the tree below the dir the path refers to.
 
-  def parent
-    super.p
+  def grep *args
+    if exists?
+      matches = read.split("\n").grep(*args)
+      matches unless matches.empty?
+    end
   end
 
-  alias_method :all_children, :children
-
-  def children
-    super.reject { |c| c.basename.to_s =~ /^\./ }
+  def glob expr = nil, flags = File::FNM_CASEFOLD, &block
+    Dir.glob((expr.nil? ? self : (self / expr)).to_s, flags, &block)
   end
 
-  # only takes sym atm
   def select(*args)
+    Babushka::LogHelpers.deprecated! '2012-10-23', :instead => 'Fancypath#glob', :example => "#{to_s.inspect}.p.glob(#{args.first.inspect})"
     return args.map { |arg| select(arg) }.flatten.uniq if args.size > 1
 
     case arg = args.first
@@ -169,24 +152,67 @@ class Fancypath < Pathname
       Dir["#{self}/#{arg}"].map { |p| self.class.new(p) }
     end
   end
-  
-  def empty?
-    directory? ? children.size == 0 : self.size == 0
+
+
+  # Filename manupulation.
+
+  def set_extension(ext)
+    "#{without_extension}.#{ext}".p
   end
-  
-  def owner
-    Etc.getpwuid(File.stat(to_s).uid).name
+  alias_method :change_extension, :set_extension
+
+  def without_extension
+    to_s[/^ (.+?) (\. ([^\.]+))? $/x, 1].p
   end
 
-  def group
-    Etc.getgrgid(File.stat(to_s).gid).name
+  def has_extension?(ext)
+    !!(self.to_s =~ /\.#{ext}$/)
   end
 
-  def inspect
-    super.sub('Pathname','Fancypath')
+
+  # Changing the file or dir the path refers to.
+
+  def touch
+    `touch '#{self}'`
+    self
   end
 
-  def to_fancypath
+  def create_dir
+    mkpath unless exist?
+    self
+  end
+  alias_method :create, :create_dir
+  alias_method :mkdir, :create_dir
+
+  def copy(dest)
+    `cp -pPR '#{self}' '#{dest}'`
+    self
+  end
+  alias_method :cp, :copy
+
+  def move(dest)
+    self.rename(dest)
+    dest.p
+  end
+  alias_method :mv, :move
+
+  def remove
+    directory? ? rmtree : delete if exist?
+    self
+  end
+  alias_method :rm, :remove
+
+
+  # Changing the contents of the file the path refers to.
+
+  def write(contents, mode='wb')
+    dirname.create
+    open(mode) { |f| f.write contents }
+    self
+  end
+
+  def append(contents)
+    write(contents,'a+')
     self
   end