rubycut-babushka 0.10.8 → 0.15.6.1

data/deps/os_x.rb

@@ -1,33 +0,0 @@
-dep 'xcode tools', :template => 'external' do
-  expects 'gcc', 'g++', 'autoconf', 'make', 'ld'
-  otherwise {
-    log_and_open "Install Xcode, and then run Babushka again.", "http://developer.apple.com/technology/xcode.html"
-  }
-end
-
-dep 'xcode commandline tools', :template => 'installer' do
-  # These pkgs consist of the packages inside the Xcode installer that contain the
-  # commandline tools and compiler toolchain. They're not a custom build - they're
-  # unmodified from the original Xcode install; just a subset (i.e. excluding the
-  # packages for things like Interface Builder and Xcode.app).
-  #
-  # See http://github.com/kennethreitz/osx-gcc-installer for more info.
-  source {
-    on :lion,         'https://github.com/downloads/kennethreitz/osx-gcc-installer/GCC-10.7-v2.pkg'
-    on :snow_leopard, 'https://github.com/downloads/kennethreitz/osx-gcc-installer/GCC-10.6.pkg'
-  }
-  provides %w[cc gcc c++ g++ llvm-gcc llvm-g++ clang] # compilers
-  provides %w[ld libtool] # linkety link
-  provides %w[make automake autoconf] # configure and build tools
-  provides %w[cpp m4 nasm yacc bison] # misc - the preprocessor, assembler, grammar stuff
-end
-
-dep 'llvm in path', :for => :snow_leopard do
-  requires 'xcode tools'
-  met? { which 'llvm-gcc-4.2' }
-  meet {
-    cd('/usr/local/bin') {|path|
-      shell "ln -s /Developer/usr/llvm-gcc-4.2/bin/llvm* .", :sudo => !path.writable?
-    }
-  }
-end

data/deps/templates/ppa.rb

@@ -1,24 +0,0 @@
-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/lib/babushka/core_patches/io.rb

@@ -1,8 +0,0 @@
-class IO
-  # Return true iff reading from this IO object would return data immediately,
-  # and not block while waiting for data.
-  def ready_for_read?
-    result = IO.select([self], [], [], 0)
-    result && (result.first.first == self)
-  end
-end

data/lib/babushka/dep_runner.rb

@@ -1,85 +0,0 @@
-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/helpers/suggest_helpers.rb

@@ -1,16 +0,0 @@
-module Babushka
-  module SuggestHelpers
-    def suggest_value_for typo, choices
-      if (possible_matches = choices.similar_to typo.to_s).empty?
-        nil # nothing to suggest
-      elsif possible_matches.length == 1
-        Prompt.confirm "#{"Did you mean".colorize('grey')} '#{possible_matches.first}'#{"?".colorize('grey')}" do
-          possible_matches.first
-        end or false
-      else
-        log "Similar: #{possible_matches.map {|d| "'#{d}'" }.join(', ')}"
-        Prompt.get_value("Did you mean any of those".colorize('grey'), :default => possible_matches.first)
-      end
-    end
-  end
-end

data/lib/babushka/pkg_helpers/base_helper.rb

@@ -1,19 +0,0 @@
-module Babushka
-  class BaseHelper < PkgHelper
-  class << self
-    def pkg_type; :unknown end
-    def manager_key; :unknown end
-    def manager_dep; nil end
-
-    private
-
-    def _install! pkgs, opts
-      raise DepDefiner::UnmeetableDep, "I don't know how to use the package manager on this system."
-    end
-
-    def _has? pkg
-      raise DepDefiner::UnmeetableDep, "I don't know how to use the package manager on this system."
-    end
-  end
-  end
-end

data/lib/babushka/pkg_helpers/macports_helper.rb

@@ -1,22 +0,0 @@
-module Babushka
-  class MacportsHelper < PkgHelper
-  class << self
-    def existing_packages
-      Dir.glob(prefix / "var/macports/software/*").map {|i| File.basename i }
-    end
-    def pkg_type; :port end
-    def pkg_cmd; 'port' end
-    def manager_key; :macports end
-
-    def _install! pkgs, opts
-      log_shell "Fetching #{pkgs.join(', ')}", "#{pkg_cmd} fetch #{pkgs.join(' ')}", :sudo => should_sudo?
-      super
-    end
-
-    private
-    def _has? pkg
-      existing_packages.include? pkg.name.split(/\s+/, 2).first
-    end
-  end
-  end
-end

data/spec/babushka/dep_definer_support.rb

@@ -1,36 +0,0 @@
-class TestDepContext < DepContext
-  def chooser
-    :osx # hardcode this for testing
-  end
-end
-class TestTemplate
-  def self.contextual_name; name end
-  def self.context_class; TestDepContext end
-end
-class FakeOSXSystemProfile < OSXSystemProfile
-  def version; '10.6.7' end
-  def get_version_info; '' end
-  def total_memory; 16_000_000_000 end
-end
-
-def setup_test_lambdas
-  @lambda_hello = L{ "hello world!" }
-end
-
-def test_accepts_block_for_response accepter_name, lambda, value, opts = {}
-  TestDepContext.accepts_block_for accepter_name
-  dep 'accepts_block_for' do
-    send accepter_name, opts, &lambda
-  end
-  on = opts[:on].nil? ? :all : Base.host.system
-  Dep('accepts_block_for').context.payload[accepter_name][on].should == value
-end
-
-def make_test_deps
-  dep 'test build tools' do
-    requires {
-      on :osx, 'xcode tools'
-      on :linux, 'build-essential', 'autoconf'
-    }
-  end
-end

data/spec/babushka/meta_dep_definer_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'dep_definer_support'
-
-describe "declaration" do
-  before {
-    @meta = meta 'test'
-  }
-  it "should work" do
-    L{ meta 'count_test' }.should change(Base.sources.anonymous.templates, :count).by(1)
-  end
-  it "should set the name" do
-    @meta.name.should == 'test'
-  end
-  it "should downcase the name" do
-    meta("Case_Test").name.should == 'case_test'
-  end
-  it "should set the source" do
-    @meta.source.should == Base.sources.anonymous
-  end
-  it "should define a dep context" do
-    @meta.context_class.should be_an_instance_of(Class)
-    @meta.context_class.ancestors.should include(Babushka::DepContext)
-  end
-  it "should define template on the context" do
-    @meta.context_class.source_template.should == @meta
-  end
-  it "should not define a dep helper" do
-    Object.new.should_not respond_to('test')
-  end
-  it "should not be marked as suffixed" do
-    @meta.opts[:suffix].should be_false
-  end
-  after { Base.sources.anonymous.templates.clear! }
-end
-
-describe "using" do
-  describe "invalid templates" do
-    it "should not define deps as options" do
-      L{
-        dep('something undefined', :template => 'undefined').should be_nil
-      }.should raise_error(TemplateNotFound, "There is no template named 'undefined' to define 'something undefined' against.")
-    end
-    it "should define deps as options" do
-      dep('something.undefined').should be_an_instance_of(Dep)
-    end
-  end
-
-  describe "without template" do
-    before {
-      @meta = meta('templateless_test') {}
-    }
-    it "should define deps based on the template" do
-      dep('templateless dep.templateless_test').template.should == @meta
-    end
-    after { Base.sources.anonymous.templates.clear! }
-  end
-
-  describe "with template" do
-    before {
-      @meta = meta 'template_test' do
-        def a_helper_method
-          'hello from the helper!'
-        end
-        template {
-          def a_helper
-            'hello from the helper in the template!'
-          end
-          met? {
-            'this dep is met.'
-          }
-        }
-      end
-    }
-    it "should define the helper on the context class" do
-      @meta.context_class.respond_to?(:a_helper).should be_false
-      @meta.context_class.new(nil).respond_to?(:a_helper).should be_false
-      dep('dep1.template_test').context.respond_to?(:a_helper).should be_true
-    end
-    it "should correctly define the helper method" do
-      dep('dep2.template_test').context.a_helper_method.should == 'hello from the helper!'
-    end
-    it "should correctly define the helper" do
-      dep('dep2.template_test').context.a_helper.should == 'hello from the helper in the template!'
-    end
-    it "should correctly define the met? block" do
-      dep('dep3.template_test').send(:process_task, :met?).should == 'this dep is met.'
-    end
-    it "should override the template correctly" do
-      dep('dep4.template_test') {
-        met? { 'overridden met? block.' }
-      }.send(:process_task, :met?).should == 'overridden met? block.'
-    end
-    after { Base.sources.anonymous.templates.clear! }
-  end
-
-  describe "acceptors" do
-    before {
-      @meta = meta 'acceptor_test' do
-        accepts_list_for :list_test
-        accepts_block_for :block_test
-        template {
-          met? {
-            list_test == ['valid']
-          }
-          meet {
-            block_test.call
-          }
-        }
-      end
-    }
-    it "should handle accepts_list_for" do
-      dep('unmet accepts_list_for.acceptor_test') { list_test 'invalid' }.met?.should be_false
-      dep('met accepts_list_for.acceptor_test') { list_test 'valid' }.met?.should be_true
-    end
-    it "should handle accepts_block_for" do
-      block_called = false
-      dep('accepts_block_for.acceptor_test') {
-        list_test 'invalid'
-        block_test {
-          block_called = true
-        }
-      }.meet
-      block_called.should be_true
-    end
-    after { Base.sources.anonymous.templates.clear! }
-  end
-end

data/spec/babushka/meta_dep_wrapper_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe "name checks" do
-  it "should not allow blank names" do
-    L{ meta(nil) }.should raise_error(ArgumentError, "You can't define a template with a blank name.")
-    L{ meta('') }.should raise_error(ArgumentError, "You can't define a template with a blank name.")
-  end
-  it "should not allow reserved names" do
-    L{ meta(:base) }.should raise_error(ArgumentError, "You can't use 'base' for a template name, because it's reserved.")
-  end
-  it "should allow valid names" do
-    L{ meta(:a) }.should_not raise_error
-    L{ meta('b') }.should_not raise_error
-    L{ meta('valid') }.should_not raise_error
-  end
-  it "should not allow spaces and numbers" do
-    L{ meta('meta dep 2') }.should raise_error(ArgumentError, "You can't use 'meta dep 2' for a template name - it can only contain [a-z0-9_].")
-  end
-  it "should not allow invalid characters" do
-    L{ meta("meta\ndep") }.should raise_error(ArgumentError, "You can't use 'meta\ndep' for a template name - it can only contain [a-z0-9_].")
-  end
-  it "should not allow names that don't start with a letter" do
-    L{ meta('3d_dep') }.should raise_error(ArgumentError, "You can't use '3d_dep' for a template name - it must start with a letter.")
-  end
-  describe "duplicate declaration" do
-    before { meta 'duplicate' }
-    it "should be prevented" do
-      L{ meta(:duplicate) }.should raise_error(ArgumentError, "A template called 'duplicate' has already been defined.")
-    end
-    after { Base.sources.anonymous.templates.clear! }
-  end
-end

data/spec/babushka/resource_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-
-def archive_path
-  __FILE__.p.parent.parent / 'archives'
-end
-
-describe Resource do
-  it "should detect file types" do
-    Resource.type(archive_path / 'archive.zip').should == :zip
-    Resource.type(archive_path / 'archive.tgz').should == :gzip
-  end
-  it "should first attempt to detect type using file extension" do
-    Resource.type(archive_path / 'really_a_gzip.zip').should == :zip
-  end
-  it "should attempt to detect type via when there is no extension" do
-    Resource.type(archive_path / 'zip_without_extension').should == :zip
-  end
-  it "should detect supported archive types" do
-    Resource.for(archive_path / 'archive.tgz').should be_supported
-    Resource.for(archive_path / 'archive.tbz2').should be_supported
-  end
-  it "should raise an error on unsupported types" do
-    L{
-      Resource.for(archive_path / 'invalid_archive')
-    }.should raise_error("Don't know how to extract invalid_archive.")
-  end
-  it "should set the name" do
-    Resource.for(archive_path / 'archive.tar').name.should == 'archive'
-    Resource.for(archive_path / 'archive.tar.gz').name.should == 'archive'
-  end
-  it "should generate the proper command to extract the archive" do
-    {
-      'tar' => "tar -xf '#{archive_path / 'archive.tar'}'",
-      'tgz' => "tar -zxf '#{archive_path / 'archive.tgz'}'",
-      'tbz2' => "tar -jxf '#{archive_path / 'archive.tbz2'}'",
-      'zip' => "unzip -o '#{archive_path / 'archive.zip'}'"
-    }.each_pair {|ext,command|
-      Resource.for(archive_path / "archive.#{ext}").extract_command.should == command
-    }
-  end
-  it "should yield in the extracted dir" do
-    Resource.for(archive_path / "archive.tar").extract {
-      Dir.pwd.should == (tmp_prefix / 'archives/archive')
-    }
-  end
-  it "should yield in the nested dir if there is one" do
-    Resource.for(archive_path / "nested_archive.tar").extract {
-      Dir.pwd.should == (tmp_prefix / 'archives/nested_archive/nested archive')
-    }
-  end
-  it "should find a standard content dir as a nested dir" do
-    Resource.for(archive_path / "test-0.3.1.tgz").extract {
-      Dir.pwd.should == (tmp_prefix / 'archives/test-0.3.1/test-0.3.1')
-      Dir.glob('*').should == ['content.txt']
-    }
-  end
-  it "shouldn't descend into some dirs" do
-    Resource.for(archive_path / "Blah.app.zip").extract {
-      Dir.pwd.should == (tmp_prefix / 'archives/Blah.app')
-      Dir.glob('**/*').should == ['Blah.app', 'Blah.app/content.txt']
-    }
-  end
-end
-
-describe Resource, '#content_subdir' do
-  before {
-    @resource = Resource.new('test.zip')
-  }
-
-  context "when there is just a single file inside the archive" do
-    before {
-      Dir.stub!(:glob).and_return(['a dir'])
-      File.should_receive(:directory?).with('a dir').and_return(false)
-    }
-    it "should choose it, whatever it's called" do
-      @resource.content_subdir.should be_nil
-    end
-  end
-  context "when there is just a single non-descendable dir inside the archive" do
-    before {
-      Dir.stub!(:glob).and_return(['a dir.app'])
-      File.should_receive(:directory?).with('a dir.app').and_return(true)
-    }
-    it "should choose it, whatever it's called" do
-      @resource.content_subdir.should be_nil
-    end
-  end
-  context "when there is just a single dir inside the archive" do
-    before {
-      Dir.stub!(:glob).and_return(['a dir'])
-      File.should_receive(:directory?).with('a dir').and_return(true)
-    }
-    it "should choose it, whatever it's called" do
-      @resource.content_subdir.should == 'a dir'
-    end
-  end
-  context "when there is more than one dir" do
-    context "and none are named after the archive" do
-      before {
-        Dir.stub!(:glob).and_return(['contents', 'another'])
-      }
-      it "should return nil (so the original extraction dir is used)" do
-        @resource.content_subdir.should be_nil
-      end
-    end
-    context "and one is named after the archive" do
-      before {
-        Dir.stub!(:glob).and_return(['contents', 'test'])
-      }
-      it "should choose the directory named after the archive" do
-        @resource.content_subdir.should == 'test'
-      end
-    end
-  end
-  context "when there are non-descendable dirs" do
-    context "and none are named after the archive" do
-      before {
-        Dir.stub!(:glob).and_return(['contents', 'LaunchBar.app', 'RSpec.tmbundle'])
-      }
-      it "should not choose the non-descendable dir" do
-        @resource.content_subdir.should be_nil
-      end
-    end
-    context "and one is named after the archive" do
-      before {
-        Dir.stub!(:glob).and_return(['contents', 'test.app'])
-      }
-      it "should not choose the non-descendable dir" do
-        @resource.content_subdir.should be_nil
-      end
-    end
-    context "one is named after the archive, and a descendable dir is present too" do
-      before {
-        Dir.stub!(:glob).and_return(['contents', 'test.app', 'test'])
-      }
-      it "should choose the descendable dir" do
-        @resource.content_subdir.should == 'test'
-      end
-    end
-  end
-end