bindep 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: 158a70fba74e7159c2f9f1a2fec4ffacb7ce5ae9
+  data.tar.gz: 4742cd55e48e01349f82fe97f2ac570b04b94bbb
+SHA512:
+  metadata.gz: 6427680d083cf0373284f787e936120b8a6a4ed2d4525201f632434215258236dc197f1de43950f1c8ade05b834adcba7455c0b6e0c98e7cee2d9599d3d9462f
+  data.tar.gz: d5364eb79015a159342798713c3f723e2559f3eadfba392cbf326ad443ad2615d8356072a8edba6af15a23b3f2b15657f337f3308381efb4d961aa08c86a948f

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Bindepfile
+Gemfile.lock
+coverage
+test.rb
+.DS_Store
+tmp

data/.travis.yml

@@ -0,0 +1,10 @@
+---
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+
+script: bundle exec rspec

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,3 @@
+guard :rspec, cmd: "bundle exec rspec --color" do
+  watch(%r{(.+)\.rb$}){ "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Niko Dziemba, niko@dziemba.com
+
+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,139 @@
+# Bindep
+
+A simple way to manage binary dependencies for multiple platforms.
+
+[![Build Status](https://travis-ci.org/dziemba/bindep.svg?branch=master)](https://travis-ci.org/dziemba/bindep) [![Code Climate](https://codeclimate.com/github/dziemba/bindep.png)](https://codeclimate.com/github/dziemba/bindep)
+
+## Example 
+
+To install git and complile some less code:
+``` ruby
+
+require 'bindep'
+require 'bindep/library'
+
+# prompt user to install git if it is not available, do nothing otherwise
+Bindep.check 'git'
+
+# prompt to install less compiler if it is not available, 
+# then run it with given parameters
+css_code, stderr = Bindep.run :less, '-x -', less_code
+```
+
+## Installation
+
+Install the gem:
+
+``` shell
+gem install bindep
+```
+
+## Usage
+
+Load the gem:
+``` ruby
+require "bindep"  # core module
+require "bindep/library"  # predefined packages (optional)
+```
+
+Check if a package is available and prompt the user to install it otherwise:
+``` ruby
+Bindep.check 'git'
+```
+
+Run commands (`run` calls `check` automatically):
+``` ruby
+# syntax
+stdout, stderr, exitcode = Bindep.run :package, stdin, raise_on_error
+
+# no exception on failure
+css_code, stderr, exitcode = Bindep.run :less, '-x -', less_code, false
+css_code = '' unless exitcode.zero?
+
+# raise on failure
+begin
+  output, stderr = Bindep.run :git, 'status'
+  puts output
+rescue RuntimeError
+  puts 'Git failed!'
+end
+
+```
+
+Define new packages and check/install them:
+``` ruby
+Bindep.define(:npm) do |i|
+  i.command = "npm"
+  i.apt = [ "nodejs", "npm" ]
+  i.brew = "node"
+end
+
+Bindep.define(:lessc) do |i|
+  i.command = "lessc"        
+  i.npm = "lessc"
+  i.depends = [ :npm ] 
+end 
+
+Bindep.check :lessc
+```
+
+Combine `define` and `check`:
+``` ruby
+
+Bindep.check(:git) do |i|
+  i.command = "npm"
+  i.apt = "git-core"
+  i.brew = "git"
+  i.yum = "git-core"
+end
+```
+
+## Command Line Usage
+
+Create a `Bindepfile` in your project root using the same syntax:
+``` ruby
+check 'less'
+
+check(:git) do |i|
+  i.command = "npm"
+  i.apt = "git-core"
+  i.brew = "git"
+  i.yum = "git-core"
+end
+```
+
+and execute it by running `bindep` in your shell.
+
+
+## Configuration
+Add any of the following lines to your code before running any bindep commands.
+
+``` ruby
+# Abort if command is not found, do not try to install.
+Bindep.no_install = true
+
+# Do not ask user for confirmation before installing.
+Bindep.no_confirm_before_install = true
+
+# Do not output error messages and exit process but raise exceptions instead.
+Bindep.silent_exceptions = true
+```
+
+You can also set these in your `Bindepfile` by adding any of the following before the commands:
+``` ruby
+@no_install = true
+@no_confirm_before_install = true
+@silent_exceptions = true
+```
+
+## Contributing
+
+I really appreciate any input, either code or new library entries, so please:
+
+1. Fork it ( https://github.com/dziemba/bindep/fork )
+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 a new Pull Request
+
+

data/bin/bindep

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bindep'
+require 'bindep/library'
+
+if $1 == "--help"
+  puts "Usage: $0 [Bindepfile]"
+  exit 0
+end
+
+Bindep.load_file($1 || 'Bindepfile')

data/bindep.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "bindep/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "bindep"
+  spec.version       = Bindep::VERSION
+  spec.authors       = ["Niko Dziemba"]
+  spec.email         = ["niko@dziemba.com"]
+  spec.summary       = "A simple way to manage binary dependencies for multiple platforms."
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/dziemba/bindep"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "simplecov"
+end

data/lib/bindep.rb

@@ -0,0 +1,10 @@
+require "open3"
+
+require "bindep/version"
+require "bindep/error"
+require "bindep/helpers"
+require "bindep/os"
+require "bindep/core"
+require "bindep/item"
+require "bindep/context"
+

data/lib/bindep/context.rb

@@ -0,0 +1,91 @@
+module Bindep
+  class Context
+    attr_accessor :no_install, :no_confirm_before_install, :silent_exceptions
+
+    # Create a new Bindep context with its own options and item registry.
+    def initialize
+      @registry = {}
+
+      @no_install = false
+      @no_confirm_before_install = false
+      @silent_exceptions = false
+
+      unless Helpers.which_test
+        error "Command detection does not work on your system. Bindep cannot run on your system!"
+      end
+    end
+
+    # Define a new item.
+    def define(id, &block)
+      item = Item.new(id)
+      yield item
+
+      @registry[item.id] = item
+    end
+
+    # Check if a given item is installed, can also define item beforehand if block is given.
+    def check(id, force_install = false, &block)
+      item = block_given? ? define(id, &block) : get_item(id)
+
+      [ item.depends ].flatten.compact.each { |dep| check dep }
+      
+      install item if force_install || (item.local_command.nil? && !no_install)
+    end
+
+    # Runs the specified command with the given arguments.
+    def run(id, args = [], stdin = nil, raise_on_failure = true)
+      check id
+
+      cmd_string = "#{get_item(id).local_command} #{[ args ].flatten.join(" ")}".strip
+      Helpers.cmd cmd_string, stdin, raise_on_failure
+    end
+
+    # Gets an item from the registry.
+    def get_item(id)
+      @registry[id.to_sym] || raise(Error, "Cannot find item '#{id.to_sym}' in context!")
+    end
+
+    private
+    def pre_install(item)
+      if no_install
+        error "Cannot find command for '#{item.id}' and installation is deactivated. "\
+        "Please install manually."
+      end
+
+      if item.install_command.nil?
+        error "Cannot find installation instructions for '#{item.id}'. "\
+        "Please install manually."
+      end
+
+      unless no_confirm_before_install
+        puts "[Bindep] Command '#{item.id}' is not installed. "\
+        "Do you want to run the following command? (y/n)"
+      end
+
+      puts "[Bindep] $ #{item.install_command}\n"
+
+      unless no_confirm_before_install
+        error "Aborting." unless gets.downcase.strip == 'y'
+      end
+    end
+
+    def install(item)
+      pre_install item
+
+      Helpers.cmd_interactive item.install_command
+
+      unless item.local_command true
+        error "Installation for '#{item.id}' failed. Please install manually."
+      end
+    end
+
+    def error(message = nil)
+      exception = Error.new message
+
+      raise exception if silent_exceptions
+
+      puts exception.to_s
+      exit 1
+    end
+  end
+end

data/lib/bindep/core.rb

@@ -0,0 +1,16 @@
+module Bindep
+  # Get the global context instance, create a new one on first call.
+  def self.context
+    @context ||= Context.new
+  end
+
+  # Evaluate a Bindepfile in the global context.
+  def self.load_file(filename = 'Bindepfile')
+    context.instance_eval File.read(filename)
+  end
+
+  # Redirect all other method calls to the global context instance.
+  def self.method_missing(method, *args, &block)        
+    context.send method, *args, &block
+  end
+end

data/lib/bindep/error.rb

@@ -0,0 +1,7 @@
+module Bindep
+  class Error < RuntimeError
+    def to_s
+      "[Bindep] #{super.to_s}"
+    end
+  end
+end

data/lib/bindep/helpers.rb

@@ -0,0 +1,36 @@
+module Bindep
+  module Helpers
+    # Run a command, supply stdin and capture stdout and stderr.
+    def self.cmd(command, stdin = nil, raise_on_error = true)
+      stdout, stderr, status = Open3.capture3 command, stdin_data: stdin, binmode: true
+
+      if raise_on_error && (status.exitstatus != 0 || stderr =~ /error/i)
+        raise RuntimeError, "Command '#{command}' returned status #{status.exitstatus}"
+      end
+
+      [ stdout, stderr, status.exitstatus ]
+    end
+
+    # Run a command interactively, return exit status
+    def self.cmd_interactive(command, raise_on_error = true)
+      system command
+
+      if raise_on_error && !$?.exitstatus.zero?
+        raise RuntimeError, "Command '#{command}' returned status #{$?.exitstatus}"
+      end
+
+      $?.exitstatus
+    end
+
+    # Check if a shell command exists (using "which").
+    def self.command_exists?(cmd)
+      _, _, status = Helpers.cmd "which #{cmd.strip}", nil, false
+      status.zero?
+    end
+
+    # Check if "which" command is available and works correctly.
+    def self.which_test
+      command_exists?("which") && !command_exists?("foo_bar_command_does_not_exist")
+    end
+  end
+end

data/lib/bindep/item.rb

@@ -0,0 +1,35 @@
+module Bindep
+  class Item
+    attr_reader :id
+    attr_accessor :command, :apt, :yum, :brew, :npm, :rubygem, :install_command, :depends
+
+    def initialize(id)
+      @id = id.to_sym
+    end
+    
+    # Get the command for the current system. Return nil if command is not available.
+    def local_command(reset = false)
+      @local_command = nil if reset
+
+      @local_command ||= [ command ].flatten.compact.find do |cmd|
+        Helpers.command_exists? cmd
+      end
+    end
+
+    # Get the installation commands for the current system as a single string. 
+    # Return nil if there is no command that fits the current system.
+    def install_command
+      list = []
+      
+      list << OS.apt_install(apt) if apt && OS.apt?
+      list << OS.yum_install(yum) if yum && OS.yum?
+      list << OS.brew_install(brew) if brew && OS.brew?
+      list << OS.npm_install(npm) if npm && OS.npm?
+      list << OS.rubygem_install(rubygem) if rubygem && OS.rubygem?    
+      list << @install_command if @install_command
+
+      list.empty? ? nil : list.join("; ")
+    end
+  end
+end
+

data/lib/bindep/library.rb

@@ -0,0 +1,53 @@
+module Bindep
+
+  # Example, for testing.
+  define(:does_not_exist) do |i|
+    i.command = 'does_not_exist'
+  #  i.install_command = 'echo "This should install the command"'
+  end
+
+  define(:nmap) do |i|
+    i.command = 'nmap'
+    i.apt = 'nmap'
+    i.yum = 'nmap'
+    i.brew = 'nmap'
+  end
+
+  define(:git) do |i|
+    i.command = 'git'
+    i.apt = 'git-core'
+    i.yum = 'git-core'
+    i.brew = 'git'
+  end
+
+  define(:nodejs) do |i|
+    i.command = %w(nodejs node)
+    i.apt = %w(nodejs npm)
+    i.yum = %w(nodejs npm)
+    i.brew = 'node'
+  end
+
+  define(:npm) do |i|
+    i.command = 'npm'
+    i.depends = 'nodejs'
+  end
+
+  define(:less) do |i|
+    i.command = 'lessc'
+    i.npm = 'less'
+    i.depends = 'npm'
+  end
+
+  define(:uglifyjs) do |i|
+    i.command = 'uglifyjs'
+    i.npm = 'uglify-js'
+    i.depends = 'npm'
+  end
+
+  define(:jshint) do |i|
+    i.command = 'jshint'
+    i.npm = 'jshint'
+    i.depends = 'npm'
+  end
+
+end

data/lib/bindep/os.rb

@@ -0,0 +1,35 @@
+module Bindep
+  module OS
+    LIST = {
+      :brew => "brew install",  
+      :apt => "apt-get install -y",  
+      :yum => "yum install -y",  
+      :npm => "npm install -g",
+      :rubygem => "gem install",
+    }
+    @command_exists_cache = {}
+
+    class << self
+      LIST.each_pair do |method, install_cmd|
+        check_cmd = install_cmd.split(" ").first
+
+        # Create a "handler?" method which checks if the specified package handler is available.
+        define_method("#{method}?") do 
+          return @command_exists_cache[method] unless @command_exists_cache[method].nil?
+          @command_exists_cache[method] = Helpers.command_exists? check_cmd
+        end
+
+        # Create a "handler_install" method which returns the install string for the given handler.
+        define_method("#{method}_install") do |package| 
+          "#{sudo} #{install_cmd} #{package}".strip
+        end
+      end
+    end
+
+    private
+    def self.sudo
+      # homebrew does not need sudo for itself and other package managers
+      brew? ? "" : "sudo"
+    end
+  end
+end

data/lib/bindep/version.rb

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

data/spec/bindep/context_spec.rb

@@ -0,0 +1,195 @@
+require "spec_helper"
+
+describe Bindep::Context do
+  let (:context) { Bindep::Context.new }
+  let (:item) { context.define(:testitem) { } }
+
+  it "fails on init if which tests fails" do
+    expect(Bindep::Helpers).to receive(:which_test).once.and_return(false)
+
+    expect_any_instance_of(Bindep::Context).to receive(:error)
+    Bindep::Context.new
+  end
+
+  it "fails on getting invalid item" do
+    expect do
+      context.get_item(:invalid)
+    end.to raise_error Bindep::Error, "[Bindep] Cannot find item 'invalid' in context!"
+  end
+
+  it "can define and get a new item" do
+    item = context.define(:testid) do |i|
+      i.command = "cmd"
+    end   
+
+    expect(item).to be_a Bindep::Item
+    expect(item.id).to eq :testid
+    expect(item.command).to eq "cmd"
+
+    expect(context.get_item(:testid)).to eq item
+  end
+
+  context "checking" do
+    it "fails for an non-existing item and no block" do
+      expect do
+        context.check :testid
+      end.to raise_error Bindep::Error
+    end
+
+    it "work for an non-existing item and a defining block" do
+      expect(context).to receive(:install).once
+
+      context.check(:testid) do |i|
+        i.command = "testcmd"
+      end
+
+      expect(context.get_item(:testid).command).to eq "testcmd"
+    end
+
+    it "works for an existing installed item" do
+      context.define(:testid) { |i| i.command = "grep" }
+
+      context.check :testid
+    end
+
+    [ false, true ].each do |no_install|
+      context "with no_install #{no_install}" do
+        before :each do
+          context.no_install = no_install
+        end
+
+        it "works for an existing installed item with force install" do
+          item = context.define(:testid) { |i| i.command = "grep" }
+
+          expect(context).to receive(:install).with(item).once
+          context.check :testid, true
+        end
+
+        it "works for an existing but not installed item" do
+          item = context.define(:testid) { |i| i.command = "foo_bar_not_existing" }
+
+          expect(context).to receive(:install).with(item).exactly(no_install ? 0:1).times
+          context.check :testid
+        end
+      end
+    end
+
+    it "works with dependencies" do
+      dep1 = context.define(:dep1) {}
+      dep2 = context.define(:dep2) {}
+      dep3 = context.define(:dep3) { |i| i.depends = "dep2" }
+      item = context.define(:item) { |i| i.depends = [ "dep3", "dep1" ] }
+
+      [ dep2, dep3, dep1, item ].each do |i|
+        expect(context).to receive(:install).with(i).once
+      end
+
+      context.check :item
+    end
+  end
+
+  context "pre_install" do
+    it "aborts if no_install is set" do
+      context.no_install = true
+
+      expect(context).to receive(:error).with(/deactivated/).and_raise(Bindep::Error)
+
+      expect do
+        context.send :pre_install, item
+      end.to raise_error Bindep::Error
+    end
+
+    it "aborts if no install command is found" do
+      str = /Cannot find installation instructions/
+      expect(context).to receive(:error).with(str).and_raise(Bindep::Error)
+
+      expect do
+        context.send :pre_install, item
+      end.to raise_error Bindep::Error
+    end
+
+    it "outputs command and does nothing else if no_confirm_before_install is set" do
+      context.no_confirm_before_install = true
+
+      item.install_command = "my_install -b"
+
+      expect(context).to receive(:puts).with("[Bindep] $ my_install -b\n")
+
+      context.send :pre_install, item
+    end
+
+    it "asks for confirmation" do
+      item.install_command = "my_install -b"
+
+      expect(context).to receive(:puts).with(/'testitem' is not installed/)
+      expect(context).to receive(:puts).with("[Bindep] $ my_install -b\n")
+      expect(context).to receive(:gets).once.and_return("y\n")
+
+      context.send :pre_install, item
+    end
+
+    it "asks for confirmation and aborts if user wants" do
+      item.install_command = "my_install -b"
+
+      expect(context).to receive(:puts).twice
+      expect(context).to receive(:gets).once.and_return("bla\n")
+      expect(context).to receive(:error).with(/Aborting/)
+
+      context.send :pre_install, item
+    end
+  end
+
+  context "install" do
+    it "runs installation command (success)" do
+      item.install_command = "echo 1"
+      item.command = "cat"
+
+      expect(context).to receive(:pre_install).with(item)
+      expect(Bindep::Helpers).to receive(:system).with("echo 1")
+
+      context.send :install, item
+    end
+
+    it "runs installation command (fail)" do
+      item.install_command = "echo 1"
+
+      expect(context).to receive(:pre_install).with(item)
+      expect(Bindep::Helpers).to receive(:system).with("echo 1")
+      expect(context).to receive(:error).with(/Installation for 'testitem' failed/)
+
+      context.send :install, item
+    end
+  end
+
+  it "runs a command" do
+    item.command = "mycmd"
+
+    expect(item).to receive(:local_command).at_least(:once).and_return("mycmd")
+    expect(Bindep::Helpers).to receive(:cmd).with("mycmd --myparam mydoc", 'stdin', false)
+    expect(Bindep::Helpers).to receive(:cmd).with("mycmd", nil, true)
+    expect(Bindep::Helpers).to receive(:cmd).with("mycmd --myparam mydoc", nil, false)
+
+    context.run :testitem, [ "--myparam", "mydoc" ], 'stdin', false
+    context.run :testitem, "", nil, true
+    context.run :testitem, "--myparam mydoc", nil, false
+  end
+
+  context "error handler" do
+    it 'prints exception and exits' do
+      expect(context).to receive(:puts).with("[Bindep] My message").once
+
+      expect do
+        context.send :error, "My message"
+      end.to raise_error SystemExit
+    end
+
+    it 'prints raises exception if silent_exceptions is true' do
+      context.silent_exceptions = true
+
+      expect do
+        context.send :error, "My message"
+      end.to raise_error Bindep::Error, "[Bindep] My message"
+    end
+  end
+end
+

data/spec/bindep/core_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Bindep do
+  it "exposes a singleton context instance" do
+    context = Bindep.context
+
+    expect(context).to be_a Bindep::Context
+    expect(Bindep.context).to eq context
+  end
+
+  it "evaluates a Bindepfile" do
+    file = Tempfile.new('Bindep')
+    file.write "check 'test1'\ncheck 'test2'"
+    file.close
+
+    context = Bindep.context
+
+    expect(context).to receive(:check).with("test1")
+    expect(context).to receive(:check).with("test2")
+
+    Bindep.load_file file.path
+
+    file.unlink
+  end
+
+  it "sends all method calls to the singleton context instance" do
+    context = Bindep.context
+
+    expect(context).to receive(:define) do |arg, &blk| 
+      expect(blk.call).to eq :blocktest
+      expect(arg).to eq :test1
+    end
+
+    Bindep.define(:test1) { :blocktest }
+  end  
+end

data/spec/bindep/helpers_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Bindep::Helpers do
+  context '.cmd_interactive' do 
+    it 'works on success' do
+      expect(Bindep::Helpers.cmd_interactive 'true').to eq 0
+    end
+
+    it 'works on failure' do
+      expect(Bindep::Helpers.cmd_interactive 'false', false).to eq 1
+    end
+
+    it 'raises on failure' do
+      expect do
+        Bindep::Helpers.cmd_interactive 'false'
+      end.to raise_error RuntimeError, "Command 'false' returned status 1"
+    end
+  end
+
+  context '.cmd' do
+    it 'works on success' do
+      stdout, stderr, status = Bindep::Helpers.cmd 'cat', 'test'
+
+      expect(stdout).to eq 'test'
+      expect(stderr).to eq ''
+      expect(status).to eq 0
+    end
+
+    it 'works on failure' do
+      stdout, stderr, status = Bindep::Helpers.cmd 'false', nil, false
+      expect(status).to eq 1
+    end
+
+    it 'fails on failure' do
+      expect do
+        Bindep::Helpers.cmd 'false'
+      end.to raise_error RuntimeError, "Command 'false' returned status 1"
+    end
+  end
+  
+  it 'has .command_exists?' do
+    expect(Bindep::Helpers.command_exists? 'cat').to eq true
+    expect(Bindep::Helpers.command_exists? 'does_not_exists').to eq false
+  end
+
+  it 'has working which_test' do
+    expect(Bindep::Helpers.which_test).to eq true
+  end
+end
+

data/spec/bindep/item_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+
+describe Bindep::Item do
+  let (:item) { Bindep::Item.new :testid }
+
+  it "can create a valid item and has read and writable properties" do
+    item.command = "command"
+    item.apt = "apt"
+    item.brew = "brew"
+    item.depends = [ :dep1, :dep2 ]
+
+    expect(item.id).to eq :testid
+    expect(item.command).to eq "command"
+    expect(item.apt).to eq "apt"
+    expect(item.brew).to eq "brew"
+    expect(item.depends).to eq [ :dep1, :dep2 ]
+  end
+
+  it "can converts it to symbol" do
+    item = Bindep::Item.new "testid"
+
+    expect(item.id).to eq :testid
+  end
+
+  # tests in this context rely on sensible defaults (e.g. grep, cat are available, foo_bar_not_here is not)
+  context "command selection" do
+    it "works for empty command" do
+      item.command = nil
+
+      expect(item.local_command).to be_nil
+    end
+
+    it "does not change @command" do
+      item.command = [ "not_here", "cat" ]
+
+      item.local_command
+
+      expect(item.command).to eq [ "not_here", "cat" ]
+    end
+
+    it "works with a single correct command" do
+      item.command = "grep"
+
+      expect(item.local_command).to eq "grep"
+    end
+
+    it "works with a single wrong command" do
+      item.command = "foo_bar_not_here"
+
+      expect(item.local_command).to eq nil
+    end
+
+    it "works with a two correct commands" do
+      item.command = [ "grep", "cat" ]
+
+      expect(item.local_command).to eq "grep"
+    end
+
+    it "works with a one correct command at first position" do
+      item.command = [ "cat", "foo_bar_not_here" ]
+
+      expect(item.local_command).to eq "cat"
+    end
+
+    it "works with a one correct command at second position" do
+      item.command = [ "foo_bar_not_here", "cat", "foo_bar_not_here_two" ]
+
+      expect(item.local_command).to eq "cat"
+    end
+
+    it "does not run twice" do
+      item.command = [ "foo_bar_not_here", "cat" ]
+
+      expect(item.local_command).to eq "cat"
+      
+      item.command = "foo_bar_not_here"
+
+      expect(item.local_command).to eq "cat"
+      expect(item.command).to eq "foo_bar_not_here"
+    end
+
+    it "runs again if reset parameter is given" do
+      item.command = [ "foo_bar_not_here", "cat" ]
+
+      expect(item.local_command).to eq "cat"
+      
+      item.command = "grep"
+
+      expect(item.local_command(true)).to eq "grep"
+    end
+  end 
+
+  # cannot cover all tests (would be 2^n test cases, n = package handler count),
+  # so we choose a few general ones and edge cases
+  context "install commands" do
+    it "works for no packages given" do
+      expect(item.install_command).to be_nil
+    end
+
+    it "works for custom command given" do
+      cmd = "my_installer -fmgu my_package"
+      item.install_command = cmd
+
+      expect(item.install_command).to eq cmd
+    end
+
+    it "works all commands given and all available" do
+      Bindep::OS.instance_variable_set :@command_exists_cache, {
+        apt: true, npm: true, brew: true, yum: true, rubygem: true
+      }
+
+      item.apt = "p_apt"
+      item.npm = "p_npm"
+      item.yum = "p_yum"
+      item.brew = "p_brew"
+      item.rubygem = "p_gem"
+      item.install_command = "my package"
+      
+      results = [
+        Bindep::OS.apt_install("p_apt"),
+        Bindep::OS.yum_install("p_yum"),
+        Bindep::OS.brew_install("p_brew"),
+        Bindep::OS.npm_install("p_npm"),
+        Bindep::OS.rubygem_install("p_gem"),
+        "my package",
+      ]
+
+      expect(item.install_command).to eq results.join("; ")
+    end
+
+    it "works some commands given and some available" do
+      Bindep::OS.instance_variable_set :@command_exists_cache, {
+        apt: true, npm: true, brew: false, yum: true, rubygem: false
+      }
+
+      item.apt = "p_apt"
+      item.npm = nil
+      item.yum = "p_yum"
+      item.brew = "p_brew"
+      item.rubygem = "p_gem"
+      item.install_command = nil
+      
+      results = [
+        Bindep::OS.apt_install("p_apt"),
+        Bindep::OS.yum_install("p_yum"),
+      ]
+
+      expect(item.install_command).to eq results.join("; ")
+    end
+  end 
+end

data/spec/bindep/library_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Bindep Library' do
+ it 'loads the library file successfully' do
+   require 'bindep/library'
+ end  
+end

data/spec/bindep/os_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Bindep::OS do
+  HAVE_LIST = {
+    "brew?" => "brew",  
+    "apt?" => "apt-get",  
+    "yum?" => "yum",  
+    "npm?" => "npm",
+    "rubygem?" => "gem",
+  }
+
+  INSTALL_LIST = {
+    "brew_install" => "brew install pkg",  
+    "apt_install" => "apt-get install -y pkg",  
+    "yum_install" => "yum install -y pkg",  
+    "npm_install" => "npm install -g pkg",
+    "rubygem_install" => "gem install pkg",
+  }
+
+  before :each do
+    Bindep::OS.instance_variable_set(:@command_exists_cache, {})
+  end
+
+  HAVE_LIST.each_pair do |method, command|
+    it "has a #{method} method which caches result" do
+      expect(Bindep::Helpers).to receive(:command_exists?).with(command).once.and_return(false)
+
+      2.times { Bindep::OS.send method.to_sym }
+    end
+  end
+
+  [ true, false ].each do |sudo|
+    sudo_string = sudo ? "sudo" : ""
+
+    INSTALL_LIST.each_pair do |method, command|
+      it "has a corrent #{method} method with sudo #{sudo}" do
+        expect(Bindep::OS).to receive(:sudo).and_return(sudo_string)
+
+        expect(Bindep::OS.send(method.to_sym, "pkg")).to eq "#{sudo_string} #{command}".strip
+      end
+    end
+  end
+
+  it "requires sudo if no brew is available (e.g. not on mac os)" do
+    expect(Bindep::OS).to receive(:brew?).and_return(false)
+
+    expect(Bindep::OS.sudo).to eq "sudo"
+  end
+
+  it "requires no sudo if brew is available" do
+    expect(Bindep::OS).to receive(:brew?).and_return(true)
+
+    expect(Bindep::OS.sudo).to eq ""
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "simplecov"
+
+SimpleCov.coverage_dir "coverage"
+SimpleCov.start
+
+require 'tempfile'
+
+require "bindep"

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: bindep
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Niko Dziemba
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple way to manage binary dependencies for multiple platforms.
+email:
+- niko@dziemba.com
+executables:
+- bindep
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- bin/bindep
+- bindep.gemspec
+- lib/bindep.rb
+- lib/bindep/context.rb
+- lib/bindep/core.rb
+- lib/bindep/error.rb
+- lib/bindep/helpers.rb
+- lib/bindep/item.rb
+- lib/bindep/library.rb
+- lib/bindep/os.rb
+- lib/bindep/version.rb
+- spec/bindep/context_spec.rb
+- spec/bindep/core_spec.rb
+- spec/bindep/helpers_spec.rb
+- spec/bindep/item_spec.rb
+- spec/bindep/library_spec.rb
+- spec/bindep/os_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dziemba/bindep
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple way to manage binary dependencies for multiple platforms.
+test_files:
+- spec/bindep/context_spec.rb
+- spec/bindep/core_spec.rb
+- spec/bindep/helpers_spec.rb
+- spec/bindep/item_spec.rb
+- spec/bindep/library_spec.rb
+- spec/bindep/os_spec.rb
+- spec/spec_helper.rb