tap_dance 0.0.1

data/lib/tap_dance/tap.rb

@@ -0,0 +1,36 @@
+require 'tap_dance/ui'
+require 'tap_dance/brew_cli'
+
+module TapDance
+  class Tap
+    attr_accessor :name
+    attr_accessor :url
+
+    def initialize(name, url, opts={})
+      @name = name.to_sym
+      @url  = url.to_s
+      @opts = opts
+    end
+
+    def entap
+      BrewCLI.tap(@url)
+    end
+
+    def untap
+      BrewCLI.untap(@url)
+    end
+
+    def tapped?
+      BrewCLI.tap_list.out.each_line { |t|
+        return true if @url == t.strip
+      }
+
+      return false
+    end
+
+    def to_s
+      "#{@name}:#{@url}"
+    end
+
+  end
+end

data/lib/tap_dance/ui.rb

@@ -0,0 +1,159 @@
+require 'rubygems/user_interaction'
+
+module TapDance
+  class UI
+    attr_reader :log
+
+    def warn(message, newline = nil)
+    end
+
+    def debug(message, newline = nil)
+    end
+
+    def trace(message, newline = nil)
+    end
+
+    def error(message, newline = nil)
+    end
+
+    def info(message, newline = nil)
+    end
+
+    def confirm(message, newline = nil)
+    end
+
+    def detail(message, newline = nil)
+    end
+
+    def debug?
+      false
+    end
+
+    def ask(message)
+    end
+
+    class Shell < UI
+      LEVELS = %w(silent error warn detail confirm info debug)
+
+      attr_writer :shell
+
+      def initialize(options = {})
+        if options["no-color"] || !STDOUT.tty?
+          Thor::Base.shell = Thor::Shell::Basic
+        end
+        @shell = Thor::Base.shell.new
+        @level = ENV['DEBUG'] ? "debug" : "info"
+      end
+
+      def info(msg, newline = nil)
+        tell_me(msg, nil, newline) if level("info")
+      end
+
+      def confirm(msg, newline = nil)
+        tell_me(msg, :green, newline) if level("confirm")
+      end
+
+      def detail(msg, newline = nil)
+        tell_me(msg, :cyan, newline) if level("detail")
+      end
+
+      def warn(msg, newline = nil)
+        tell_me(msg, :yellow, newline) if level("warn")
+      end
+
+      def error(msg, newline = nil)
+        tell_me(msg, :red, newline) if level("error")
+      end
+
+      def debug(msg, newline = nil)
+        tell_me(msg, nil, newline) if level("debug")
+      end
+
+      def debug?
+        # needs to be false instead of nil to be newline param to other methods
+        level("debug")
+      end
+
+      def quiet?
+        LEVELS.index(@level) <= LEVELS.index("warn")
+      end
+
+      def ask(msg)
+        @shell.ask(msg)
+      end
+
+      def level=(level)
+        raise ArgumentError unless LEVELS.include?(level.to_s)
+        @level = level
+      end
+
+      def level(name = nil)
+        name ? LEVELS.index(name) <= LEVELS.index(@level) : @level
+      end
+
+      def trace(e, newline = nil)
+        msg = ["#{e.class}: #{e.message}", *e.backtrace].join("\n")
+        if debug?
+          tell_me(msg, nil, newline)
+        elsif @trace
+          STDERR.puts "#{msg}#{newline}"
+        end
+      end
+
+      def silence
+        old_level, @level = @level, "silent"
+        yield
+      ensure
+        @level = old_level
+      end
+
+    private
+
+      def tell_me(msg, color = nil, newline = nil)
+        return if (msg.nil? || msg == "") && newline.nil?
+        msg = word_wrap(msg) if newline.is_a?(Hash) && newline[:wrap]
+        line = if newline.nil? then [] else [newline] end
+
+        if msg.is_a? ShellResult
+          unless msg.out.chomp == ""
+            @shell.say(msg.out.chomp, color, *line)
+            logger(msg.out.chomp, *line)
+          end
+
+          unless msg.err.chomp == ""
+            @shell.say(msg.err.chomp, :red)
+            logger(msg.err.chomp)
+          end
+        else
+          @shell.say(msg, color, *line)
+          logger(msg, *line)
+        end
+      end
+
+      def logger(message, newline=(message.to_s !~ /( |\t)$/))
+        @log ||= ""
+        @log << message
+        @log << $/ if newline
+      end
+
+      def word_wrap(text, line_width = @shell.terminal_width)
+        text.split("\n").collect do |line|
+          line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip : line
+        end * "\n"
+      end
+    end
+
+    class Logger < Shell
+
+    private
+
+      def tell_me(msg, color = nil, newline = nil)
+        if newline.nil?
+          logger(msg)
+        else
+          logger(msg, newline)
+        end
+      end
+    end
+  end
+end

data/lib/tap_dance/version.rb

@@ -0,0 +1,3 @@
+module TapDance
+  VERSION = "0.0.1"
+end

data/lib/tap_dance.rb

@@ -0,0 +1,21 @@
+require 'tap_dance/version'
+require 'tap_dance/cli'
+require 'tap_dance/ui'
+
+module TapDance
+  def self.respond_to?(method)
+    TapDance.instance_methods.include? method
+  end
+
+  def self.method_missing(method, *args, &block)
+    TapDance::CLI.new.send(method, *args, &block)
+  end
+
+  class << self
+    attr_writer :ui
+
+    def ui
+      @ui ||= UI.new
+    end
+  end
+end

data/spec/bin/dance_spec.rb

@@ -0,0 +1,24 @@
+cmd = "./bin/dance"
+
+describe "dancer" do
+  it "should output basic usage info" do
+    system(cmd).should be_true
+  end
+
+  it "should have an install task" do
+    system("#{cmd} install").should be_true
+  end
+
+  it "should have an update task" do
+    system("#{cmd} update").should be_true
+  end
+
+  it "should use the default Brewfile without args" do
+    `#{cmd}`.should include(File.join File.expand_path(Dir.pwd), "Brewfile")
+  end
+
+  it "should use the given Brewfile" do
+    brewfile = "lib/tap_dance/Brewfile"
+    `#{cmd} -B #{brewfile}`.should include(File.join File.expand_path(Dir.pwd), brewfile)
+  end
+end

data/spec/lib/brew_cli_spec.rb

@@ -0,0 +1,13 @@
+require 'tap_dance/brew_cli'
+require 'tap_dance/ui'
+require 'tap_dance'
+require 'thor'
+
+describe TapDance::BrewCLI do
+  it "should be able to do a dry-run on volatile actions" do
+    TapDance.ui = TapDance::UI::Logger.new
+    TapDance::BrewCLI.dry_run = true
+    TapDance::BrewCLI.install "git"
+    TapDance.ui.log.should include("Would run: brew install git")
+  end
+end

data/spec/lib/brew_spec.rb

@@ -0,0 +1,133 @@
+require 'tap_dance/brew'
+require 'tap_dance/tap'
+require 'tap_dance/brew_cli'
+require 'tap_dance/shell_result'
+
+describe TapDance::Brew do
+  it "should let me create a brew without options" do
+    brew = TapDance::Brew.new(:git)
+    brew.should_not be_nil
+  end
+
+  it "should let me create a brew with options" do
+    tap  = TapDance::Tap.new(:dev, "nybblr/dev")
+    brew = TapDance::Brew.new(:git, :tap => tap)
+    brew.should_not be_nil
+    brew.tap.should eql(tap)
+  end
+
+  it "should say git is a brewable formula" do
+    brew = TapDance::Brew.new(:git)
+    brew.brewable?.should be_true
+  end
+
+  it "should say asdfgh is not a brewable formula" do
+    brew = TapDance::Brew.new(:asdfgh)
+    brew.brewable?.should be_false
+  end
+
+  it "should be able to parse out correct installed versions" do
+    brew = TapDance::Brew.new(:git)
+    TapDance::BrewCLI.stub :list_versions => TapDance::ShellResult.new("git 1.8.2.1 1.8.2.2 2.0.0.alpha")
+
+    brew.installed_versions.should eql(%w[1.8.2.1 1.8.2.2 2.0.0.alpha])
+  end
+
+  it "should return nil if the brew isn't installed" do
+    brew = TapDance::Brew.new(:asdfgh)
+
+    brew.latest_version.should be_nil
+  end
+
+  it "should return the latest if the brew is installed" do
+    brew = TapDance::Brew.new(:asdfgh)
+    TapDance::BrewCLI.stub :list_versions => TapDance::ShellResult.new("git 1.8.2.1 1.8.2.2 2.0.0.alpha")
+
+    brew.latest_version.should eql("2.0.0.alpha")
+  end
+
+  it "should say a brew isn't installed when it isn't" do
+    brew = TapDance::Brew.new(:asdfgh)
+
+    brew.installed?.should be_false
+  end
+
+  it "should say a brew is installed when it is" do
+    brew = TapDance::Brew.new(:git)
+    TapDance::BrewCLI.stub :list_versions => TapDance::ShellResult.new("git 1.8.2.1 1.8.2.2 2.0.0.alpha")
+
+    brew.installed?.should be_true
+  end
+
+  it "should get any formula version if it exists" do
+    brew = TapDance::Brew.new(:git)
+
+    version = brew.formula_version
+    version.should_not be_nil
+    version.strip.should_not eql("")
+  end
+
+  it "should get the correct formula version when it exists" do
+    TapDance::BrewCLI.stub :formula_info => TapDance::ShellResult.new(<<-eos)
+git: stable 1.8.2.3, HEAD
+http://git-scm.com
+/usr/local/Cellar/git/1.8.2.1 (1289 files, 27M)
+  Built from source
+/usr/local/Cellar/git/1.8.2.2 (1290 files, 27M) *
+  Built from source
+https://github.com/mxcl/homebrew/commits/master/Library/Formula/git.rb
+==> Dependencies
+Optional: pcre, gettext
+==> Options
+--with-blk-sha1
+        Compile with the block-optimized SHA1 implementation
+--with-gettext
+        Build with gettext support
+--with-pcre
+        Build with pcre support
+--without-completions
+        Disable bash/zsh completions from "contrib" directory
+==> Caveats
+The OS X keychain credential helper has been installed to:
+  /usr/local/bin/git-credential-osxkeychain
+
+The 'contrib' directory has been installed to:
+  /usr/local/share/git-core/contrib
+
+Bash completion has been installed to:
+  /usr/local/etc/bash_completion.d
+
+zsh completion has been installed to:
+  /usr/local/share/zsh/site-functions"
+    eos
+
+    brew = TapDance::Brew.new(:git)
+    brew.formula_version.should eql("1.8.2.3")
+  end
+
+  it "should return nil when no formula version exists" do
+    brew = TapDance::Brew.new(:asdfgh)
+
+    brew.formula_version.should be_nil
+  end
+
+  it "should be able to fetch all formula versions" do
+    TapDance::BrewCLI.stub :formula_versions => TapDance::ShellResult.new(<<-eos, "Error", 1)
+1.8.3    git checkout 34ce866 /usr/local/Library/Formula/git.rb
+1.8.2.3  git checkout e33b2f0 /usr/local/Library/Formula/git.rb
+1.8.2.2  git checkout 015cd6e /usr/local/Library/Formula/git.rb
+1.8.2.1  git checkout fef0e87 /usr/local/Library/Formula/git.rb
+1.8.2    git checkout 583272d /usr/local/Library/Formula/git.rb
+
+    eos
+
+    brew = TapDance::Brew.new(:git)
+    brew.formula_versions.should eql([
+      %w[1.8.3   34ce866 /usr/local/Library/Formula/git.rb],
+      %w[1.8.2.3 e33b2f0 /usr/local/Library/Formula/git.rb],
+      %w[1.8.2.2 015cd6e /usr/local/Library/Formula/git.rb],
+      %w[1.8.2.1 fef0e87 /usr/local/Library/Formula/git.rb],
+      %w[1.8.2   583272d /usr/local/Library/Formula/git.rb],
+    ])
+  end
+end

data/spec/lib/cli_spec.rb

@@ -0,0 +1,23 @@
+require 'tap_dance/cli'
+
+describe TapDance::CLI do
+  it "outputs hello when installing" do
+    # TapDance::Dance.new.install.should eql("hello world!")
+    # TapDance::CLI.new.install
+  end
+
+  it "outputs goodbye when updating" do
+    # TapDance::Dance.new.update.should eql("goodbye world!")
+    # TapDance::CLI.new.update
+  end
+
+  it "should be able to install with Brewfile including flags" do
+    TapDance.ui = TapDance::UI::Shell.new
+    TapDance::BrewCLI.dry_run = true
+
+    cli = TapDance::CLI.new [], ["--brewfile", File.join(Dir.pwd, "examples/01_brewfile.rb")]
+    cli.install
+    # TapDance.ui.log.should include("Would run: brew install git")
+  end
+end
+

data/spec/lib/dsl_spec.rb

@@ -0,0 +1,7 @@
+require 'tap_dance/dsl'
+
+describe TapDance::DSL do
+  it "should run a simple Brewfile" do
+    TapDance::DSL.evaluate "examples/01_brewfile.rb"
+  end
+end

data/spec/lib/shell_result_spec.rb

@@ -0,0 +1,78 @@
+require 'tap_dance/shell_result'
+
+describe TapDance::ShellResult do
+  it "should report error if the result is failure" do
+    res = TapDance::ShellResult.new "Hello world!", "", 0
+
+    res.error?.should be_false
+    res.okay?.should  be_true
+  end
+
+  it "should report error even if nil is used" do
+    res = TapDance::ShellResult.new "Hello world!", nil, 0
+
+    res.error?.should be_false
+    res.okay?.should  be_true
+  end
+
+  it "should use exit status as ultimatum" do
+    res = TapDance::ShellResult.new "Hello world!", nil, 1
+
+    res.error?.should be_true
+    res.okay?.should  be_false
+
+    res = TapDance::ShellResult.new "Hello world!", "Something...", 1
+
+    res.error?.should be_true
+    res.okay?.should  be_false
+  end
+
+  it "should notice standard output or error prefixed with Error" do
+    res = TapDance::ShellResult.new "Error: something", nil, 0
+
+    res.error?.should be_true
+    res.okay?.should  be_false
+
+    res = TapDance::ShellResult.new "Hello world!", "Error: hello", 0
+
+    res.error?.should be_true
+    res.okay?.should  be_false
+  end
+
+  it "should report stdout and stderr if it is not blank" do
+    res = TapDance::ShellResult.new "Hello world!", "", 0
+
+    res.stdout?.should be_true
+    res.stderr?.should be_false
+
+    res = TapDance::ShellResult.new "Hello world!", "That's bad.", 0
+
+    res.stdout?.should be_true
+    res.stderr?.should be_true
+  end
+
+  it "should make a pretty string using stdout if available" do
+    res = TapDance::ShellResult.new "Hello world!", "", 0
+    res.to_s.should eql("Hello world!")
+
+    res = TapDance::ShellResult.new "Hello world!", "That's bad.", 0
+    res.to_s.should eql("Hello world!")
+
+    res = TapDance::ShellResult.new "", "That's bad.", 0
+    res.to_s.should eql("That's bad.")
+  end
+
+  it "should correctly get exit status of command" do
+    res = TapDance::ShellResult.of("echo hello && exit 1")
+    res.status.should eql(1)
+    res.out.chomp.should eql("hello")
+    res.err.chomp.should eql("")
+  end
+
+  it "should correctly get stderr when included" do
+    res = TapDance::ShellResult.of("echo hello >&2 && exit 0")
+    res.status.should eql(0)
+    res.out.chomp.should eql("")
+    res.err.chomp.should eql("hello")
+  end
+end

data/spec/lib/tap_spec.rb

@@ -0,0 +1,28 @@
+require 'tap_dance/tap'
+require 'tap_dance/brew'
+require 'tap_dance/brew_cli'
+require 'tap_dance/shell_result'
+
+describe TapDance::Tap do
+  it "should say it is tapped if it already is" do
+    tap = TapDance::Tap.new(:dev, "nybblr/dev")
+    TapDance::BrewCLI.stub :tab_list => <<-eos
+homebrew/dupes
+homebrew/science
+nybblr/dev
+samueljohn/python
+    eos
+
+    tap.tapped?.should be_true
+  end
+
+  it "should say it isn't tapped if it isn't" do
+    tap = TapDance::Tap.new(:dev, "nybblr/dev")
+    TapDance::BrewCLI.stub :tap_list => TapDance::ShellResult.new(<<-eos)
+homebrew/dupes
+homebrew/science
+    eos
+
+    tap.tapped?.should be_false
+  end
+end

data/spec/tap_dance_spec.rb

@@ -0,0 +1,9 @@
+require 'tap_dance'
+
+describe TapDance do
+  it "shouldn't mind aliasing to the module" do
+    # TapDance.install.should eql(TapDance::CLI.new.install)
+    # TapDance.update.should eql(TapDance::CLI.new.update)
+  end
+end
+

data/tap_dance.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tap_dance/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tap_dance"
+  spec.version       = TapDance::VERSION
+  spec.authors       = ["Jonathan Martin"]
+  spec.email         = ["me@nybblr.com"]
+  spec.description   = %q{Manage your OSX binaries on a per project and system basis. Powered by Homebrew, inspired by Bundler.}
+  spec.summary       = %q{Homebrew rocks, but managing system level dependencies can become a pain to track across multiple machines. Bundler was designed to make explicit declaration of Ruby dependencies consistent and painless. TapDance aims to do the same for system binaries.}
+  spec.homepage      = "https://github.com/nybblr/tap_dance"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "ext"]
+
+  spec.add_dependency "thor"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+end