tap_dance 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmRkZjkyMDQ0NWQ0NGE1MmNjMDRhYTBhY2EwMDQ5ZmUyMDMxNDk2MA==
+  data.tar.gz: !binary |-
+    YzM1YTQzODBjYTk4OTFiZmRmMjE2ODAzODcwM2U2MTdhNWFlMmUxZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NDg0NGJhZjE0OTA3ZTYyN2E1NzFkOTA3NWE2YjNiOGVlNTY1YmRlZmIxOGIw
+    ZmFmMTNmZDU0NTdjYjY3MjdmMzI5YjcxNjdkMWMzZWNkYjY0M2VkMzlkODQx
+    N2NkZGQzYzRhMzQ5MjJkZDU4NWJiYTE5OWExNmVkMWRjMjEyZjA=
+  data.tar.gz: !binary |-
+    NWJhMTcwNWNlMjU0ODc0ZDYwMWMwZWRiNDQ5MDJjYzAwZGMyYjUzNzZhYzRj
+    MDA4MDUyZWNmMzRhNzNjMTNhMDhmZmI3NDczYjEzZjU5NmNiNjJjNmYyMjlm
+    ZTZkZTA1MDAwYzVjMzQyMDNmNmIyOGRmMDI4MDFkYzZlNDU4YWQ=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tap_dance.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^bin/(.+)$})         { |m| [ "spec/bin/#{m[1]}_spec.rb" ] }
+  watch(%r{^lib/(.+)\.rb$})     { |m| [ "spec" ] }
+  # "spec/lib/#{m[1]}_spec.rb"
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jonathan Martin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+[![Gem Version](https://badge.fury.io/rb/tap_dance.png)](http://badge.fury.io/rb/tap_dance)
+[![Dependency Status](https://gemnasium.com/nybblr/tap_dance.png)](https://gemnasium.com/nybblr/tap_dance)
+[![Code Climate](https://codeclimate.com/github/nybblr/tap_dance.png)](https://codeclimate.com/github/nybblr/tap_dance)
+
+Tap Dance: Homebrew meets Bundler
+===============================
+
+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. Tap Dance aims to do the same for system binaries by alleviating such issues as:
+- "What did I `brew install` to make my vim plugins work?"
+- "With what extra arguments did I run my python installation?"
+- "Did I install that item in `brew list` for a reason I don't remember, or is it an automatically installed dependency?"
+- "Ugh, I just want to pull my latest dotfiles and have everything work."
+
+Installation
+------------
+
+The "best" way to install tap dance is by including it in your system-wide Gemfile (e.g. a Gemfile in your dotfiles).
+
+Add this line to your Gemfile:
+
+    gem 'tap_dance'
+
+And then execute:
+
+    $ bundle
+
+If you don't version-control your dots (which you should), install it yourself as:
+
+    $ gem install tap_dance
+
+Usage
+-----
+
+TODO: Write usage instructions here
+
+What's up with the name?
+------------------------
+
+Because declaring system and project deps with an awesome ruby gem makes me want to dance. Although I actually prefer swing and waltz.
+
+Features
+--------
+
+Limit by:
+- matching computer name
+- environment variable
+- shell script
+- if installed
+
+Groups
+
+Credit where due!
+-----------------
+
+Huge thanks to Yehuda Katz for his awesome work on Bundler. I shamelessly stole a lot of the feature ideas and Gemfile evaluation magic from it. Oh, and obviously since the gem is built around Homebrew, a big thanks to Max and the community around brew: it has redefined my machine setup workflow.
+
+Contributing
+------------
+
+I love contributions: give me a hand by including an in-depth description of the problem fixed or feature implemented, with usage information if applicable.
+
+Most importantly, please include tests: if the request fixes a bug, include one or more failing tests which cover the issue. For new features, try to cover the basic functionalities, making sure the tests can pass on any properly configured OSX workstation.
+
+**Steps to contribution awesomeness:**
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Although you could just make your commits on the master branch, it's easier to inspect merge histories with actual feature branches. It also makes the bounds of your contribution obvious. Did I mention it looks better in `git log --oneline --graph`

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/dance

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# Add lib, ext to load path
+root = File.expand_path '../..', __FILE__
+[:lib, :ext].each do |dir|
+  path = File.join root, dir.to_s
+  $:.unshift(path) unless $:.include?(path)
+end
+
+require 'rubygems'
+require 'thor'
+
+require "tap_dance"
+
+TapDance::CLI.start

data/examples/01_brewfile.rb

@@ -0,0 +1,7 @@
+tap :dev, "nybblr/dev"
+# tap :dart, "dartsim/dart" do
+#   brew "dartsim"
+# end
+
+brew "sack", :tap => :dev
+brew "vim", :flags => { :with => [:ruby, :perl, :python] }

data/ext/array.rb

@@ -0,0 +1,18 @@
+class Array
+  # Simple implementation of hash
+  # squash for Hash#squash. See the
+  # Hash notes for more explanation.
+  #
+  # For Array, we simply call squash
+  # on each item.
+
+  def squash(separator=" ")
+    map do |m|
+      if m.respond_to? :squash
+        m.squash(separator)
+      else
+        m.to_s
+      end
+    end.flatten
+  end
+end

data/ext/hash.rb

@@ -0,0 +1,42 @@
+class Hash
+  # Converts a deeply nested hash
+  # of stringish keys and values
+  # to an array of flattened branches
+  #
+  # For example, consider:
+  #
+  #   hash = {
+  #     :with => {
+  #       :b => [1, 2]
+  #     },
+  #     :without => "c"
+  #   }
+  #
+  #   hash.squash("_") =>
+  #     [
+  #       "with_b_1",
+  #       "with_b_2",
+  #       "without_c"
+  #     ]
+  #
+  # This is useful for readable hash options, like:
+  #
+  #   magic :with => [ "Jack", "Giant" => { :in => "sky", :on => [ "ground", "harp" ] } ]
+
+  def squash(separator=" ")
+    inject([]) do |memo, (k, v)|
+      key = if k.respond_to?(:squash) then k.squash else [ k.to_s ] end
+      val = if v.respond_to?(:squash) then v.squash else [ v.to_s ] end
+
+      # Loop over all combos
+      for sk in key do
+        for sv in val do
+          memo << (sk + separator + sv)
+        end
+      end
+
+      memo
+    end
+
+  end
+end

data/lib/tap_dance/brew.rb

@@ -0,0 +1,109 @@
+require 'tap_dance/ui'
+require 'tap_dance/brew_cli'
+
+module TapDance
+  class Brew
+    attr_accessor :name
+    attr_accessor :tap
+
+    def initialize(name, opts={})
+      @opts  = opts.dup
+      @name  = name.to_s
+      @tap   = @opts[:tap]
+      @flags = @opts[:flags]
+      @flags ||= []
+
+      # Get actual tap object
+      unless @tap.nil?
+        case @tap
+        when String, Symbol
+          @tap = @opts[:definition].tap_named @tap.to_s
+        when TapDance::Tap
+          # Good to go!
+        end
+        @opts[:tap] = @tap
+      end
+
+    end
+
+    def install
+      if brewable?
+        # Do magic here
+        BrewCLI.install canonical, @flags
+      else
+        TapDance.ui.error "No available formula for \"#{canonical}\""
+      end
+    end
+
+    def upgrade
+      if installed?
+        # Do magic here
+        BrewCLI.upgrade canonical, @flags
+      else
+        TapDance.ui.error "You haven't installed \"#{canonical}\""
+      end
+    end
+
+    def canonical
+      unless @tap.nil?
+        "#{@tap.url}/#{@name}"
+      else
+        @name
+      end
+    end
+
+    # Does the formula exist?
+    def brewable?
+      BrewCLI.formula_info(canonical).okay?
+    end
+
+    def formula_version
+      res = BrewCLI.formula_info(canonical)
+      return nil unless res.okay?
+
+      res.out.split($/).first.match(/#{name}: stable ([^\s,]+)/)[1]
+    end
+
+    def formula_versions
+      # Takes a long time to get; cache return
+      if @formula_versions.nil?
+        @formula_versions = BrewCLI.formula_versions(canonical).
+          out.chomp.split($/).map do |v|
+          s = v.split(/\s+/)
+          version = s[0]
+          commit  = s[3]
+          path    = s[4]
+          [ version, commit, path ]
+        end
+      else
+        return @formula_versions
+      end
+    end
+
+    def installed_versions
+      # Would love to use StringScanner...but we don't need to!
+      versions = BrewCLI.list_versions(canonical).out.strip.split(/\s+/)
+      unless versions.empty?
+        return versions[1..-1]
+      else
+        return []
+      end
+    end
+
+    # Is a version installed?
+    def installed?
+      !installed_versions.empty?
+    end
+
+    def latest_version
+      # Works unless the versions have
+      # strings in them, like alpha/beta
+      installed_versions.sort.last if installed?
+    end
+
+    def to_s
+      return canonical
+    end
+
+  end
+end

data/lib/tap_dance/brew_cli.rb

@@ -0,0 +1,99 @@
+require 'tap_dance'
+require 'tap_dance/shell_result'
+
+# Load in extensions
+require 'hash'
+require 'array'
+
+module TapDance
+  module BrewCLI
+    class << self
+      # One offing terminal commands makes it easy to stub.
+      attr_accessor :dry_run
+      attr_writer :prefix
+
+      def prefix
+        @prefix ||= exec("--prefix").strip
+      end
+
+      def update
+        exec "update", true
+      end
+
+      def install(name, flags="")
+        exec "install #{name} #{flag_string flags}", true
+      end
+
+      def upgrade(name, flags="")
+        exec "upgrade #{name} #{flag_string flags}", true
+      end
+
+      def list_versions(name)
+        exec "list --versions #{name}"
+      end
+
+      def formula_info(name)
+        exec "info #{name}"
+      end
+
+      def formula_versions(name)
+        exec "versions #{name}"
+      end
+
+      def tap(url)
+        exec "tap #{url}", true
+      end
+
+      def untap(url)
+        exec "untap #{url}", true
+      end
+
+      def tap_list
+        exec "tap"
+      end
+
+    private
+
+      # Private because we want
+      # all brew commands wrapped
+      # for testing.
+      def exec(cmd, volatile=false)
+        # If a command is volatile (causes system changes),
+        # we want to offer a dry-run option for testing
+        # and the CLI.
+        cmd.strip!
+
+        if volatile and @dry_run
+          TapDance.ui.warn "Would run: brew #{cmd}"
+          return nil
+        else
+          ShellResult.of "brew #{cmd}"
+        end
+      end
+
+      # Sanitize flags with standard unix
+      # conventions and generate a string
+      def flag_string(flags)
+        case flags
+        when String
+          return flags
+        else
+          return flags.squash("-").map {|m|
+            case m
+            when /^--/
+              m
+            when /^-[^\-]/
+              m
+            else
+              if m =~ /^.[ =]/
+                "-#{m}"
+              else
+                "--#{m}"
+              end
+            end
+          }.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/tap_dance/cli.rb

@@ -0,0 +1,83 @@
+require 'tap_dance'
+require 'tap_dance/brew'
+require 'tap_dance/tap'
+require 'tap_dance/dsl'
+
+require 'thor'
+
+module TapDance
+  class CLI < Thor
+    package_name "TapDance"
+    default_task "install"
+
+    class_option "verbose",
+      :type => :boolean,
+      :banner => "Enable verbose output mode",
+      :aliases => "-v"
+    class_option "brewfile",
+      :type => :string,
+      :banner => "Specify an alternate path to a Brewfile",
+      :aliases => "-B"
+    class_option "dry-run",
+      :type => :boolean,
+      :banner => "Print out what volatile commands would be run"
+
+    attr_accessor :brewfile
+    attr_accessor :definition
+
+    def initialize(*args, &block)
+      super(*args, &block)
+
+      # Activate shell output
+      TapDance.ui = UI::Shell.new(options)
+      TapDance.ui.level = "debug" if options["verbose"]
+
+      # Make sure homebrew is installed
+      unless command?(:brew)
+        TapDance.ui.error "You haven't installed homebrew, or it isn't in your path."
+        exit 1
+      end
+
+      @definition = nil
+
+      # Activate dry-run mode
+      TapDance::BrewCLI.dry_run = options["dry-run"] if options["dry-run"]
+
+      # Find brewfile
+      @brewfile = options["brewfile"]
+      @brewfile ||= "./Brewfile"
+      @brewfile = File.expand_path @brewfile
+
+      TapDance.ui.info "Brewing from #{@brewfile}"
+
+      unless File.exist? @brewfile
+        TapDance.ui.error "Nothing to brew! No Brewfile found."
+      else
+        TapDance.ui.info "Running `brew update` for good measure."
+        BrewCLI.update
+      end
+    end
+
+    desc "install", "install all the brews in your Brewfile"
+    def install
+      return unless File.exist? @brewfile
+      @definition = TapDance::DSL.evaluate @brewfile
+      @definition.execute
+    end
+
+    desc "update", "update all the brews in your Brewfile"
+    def update(name=nil)
+      return unless File.exist? @brewfile
+      @definition = TapDance::DSL.evaluate @brewfile
+      @definition.execute true
+    end
+
+  private
+
+    # Note: susceptible to code injection!
+    def command?(name)
+      system "which #{name.to_s} > /dev/null 2>&1"
+    end
+
+  end
+end

data/lib/tap_dance/definition.rb

@@ -0,0 +1,47 @@
+require 'tap_dance/brew'
+require 'tap_dance/tap'
+require 'tap_dance/ui'
+require 'tap_dance'
+
+module TapDance
+  class Definition
+    attr_accessor :taps
+    attr_accessor :brews
+
+    def initialize(taps=[], brews=[])
+      @taps = taps
+      @brews = brews
+    end
+
+    def tap(name, url, opts={})
+      @taps << Tap.new(name, url, opts.merge(:definition => self))
+      @taps.last
+    end
+
+    def brew(name, opts={})
+      @brews << Brew.new(name, opts.merge(:definition => self))
+      @brews.last
+    end
+
+    def tap_named(name)
+      @taps.find { |t| t.name.to_s == name.to_s }
+    end
+
+    def execute(upgrade=false)
+      for tap in @taps do
+        TapDance.ui.confirm "Tapping \"#{tap}\""
+        TapDance.ui.detail tap.entap
+      end
+
+      for brew in @brews do
+        unless upgrade
+          TapDance.ui.confirm "Installing \"#{brew}\""
+          TapDance.ui.detail brew.install
+        else
+          TapDance.ui.confirm "Upgrading \"#{brew}\""
+          TapDance.ui.detail brew.upgrade
+        end
+      end
+    end
+  end
+end

data/lib/tap_dance/dsl.rb

@@ -0,0 +1,55 @@
+require 'tap_dance/definition'
+require 'tap_dance/brew'
+require 'tap_dance/tap'
+require 'tap_dance/ui'
+
+class BrewfileError < RuntimeError; end
+module TapDance
+  class DSL
+    attr_reader :definition
+
+    def self.evaluate(brewfile, lockfile=nil, unlock=nil)
+      builder = new
+      builder.eval_brewfile(brewfile)
+      builder.definition
+    end
+
+    def initialize
+      @groups = [] # Arg/filter groups
+      @tap   = nil # Current tap scope
+
+      @definition = Definition.new
+    end
+
+    def eval_brewfile(brewfile, contents = nil)
+      contents ||= File.read File.expand_path(brewfile.to_s)
+      instance_eval contents, brewfile.to_s, 1
+    rescue SyntaxError => e
+      bt = e.message.split("\n")[1..-1]
+      raise BrewfileError, ["Brewfile syntax error:", *bt].join("\n")
+    rescue ScriptError, RegexpError, NameError, ArgumentError => e
+      e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
+      TapDance.ui.warn e.backtrace.join("\n       ")
+      raise BrewfileError, "There was an error in your Brewfile," \
+        " and TapDance cannot continue."
+    end
+
+    ### DSL commands
+    def tap(name, url, opts={})
+      # Can't nest taps; doesn't make sense
+      raise BrewfileError, "You cannot nest taps!" unless @tap.nil?
+      old_tap = @tap
+
+      @tap = @definition.tap name, url, opts
+
+      yield if block_given?
+
+      @tap = old_tap
+    end
+
+    def brew(name, opts={})
+      @definition.brew name, { :tap => @tap }.merge(opts)
+    end
+
+  end
+end

data/lib/tap_dance/shell_result.rb

@@ -0,0 +1,61 @@
+require 'open3'
+
+module TapDance
+  class ShellResult
+    attr_reader :out
+    attr_reader :err
+    attr_reader :status
+
+    def self.of(cmd)
+      out, err, sts = Open3.capture3 cmd
+      new out, err, sts.exitstatus
+    end
+
+    def initialize(out, err=nil, status=0)
+      @out    = out.to_s
+      @err    = err.to_s
+      @status = status
+    end
+
+    def okay?
+      !error?
+    end
+
+    def error?
+      @status != 0 || erred(@out) || erred(@err)
+    end
+
+    def stdout?
+      @out.strip != ""
+    end
+
+    def stderr?
+      @err.strip != ""
+    end
+
+    def to_s
+      if @out.strip == "" then @err else @out end
+    end
+
+    ### We likes, but disable for refactoring
+    # def method_missing(method, *args, &block)
+    #   # Let people treat it like a string
+    #   if String.new.respond_to? method
+    #     to_s.send(method, *args, &block)
+    #   else
+    #     super
+    #   end
+    # end
+
+    # def respond_to_missing?(method, include_private = false)
+    #   String.new.respond_to?(method) || super
+    # end
+
+  private
+
+    def erred(string)
+      string[0..4] == 'Error'
+    end
+
+  end
+end