hobo-inviqa 0.0.2

data/lib/hobo/tasks/tools.rb

@@ -0,0 +1,13 @@
+namespace :tools do
+  task :composer do
+    bin_file = File.join(Hobo.project_bin_path, "composer.phar")
+    unless File.exists?(bin_file)
+      Hobo.ui.success "Getting composer.phar"
+      FileUtils.mkdir_p File.dirname(bin_file)
+      Dir.chdir File.dirname(bin_file) do
+        shell "php", "-r", "eval('?>'.file_get_contents('https://getcomposer.org/installer'));", realtime: true, indent: 2
+      end
+      Hobo.ui.separator
+    end
+  end
+end

data/lib/hobo/tasks/vm.rb

@@ -0,0 +1,49 @@
+desc "VM related commands"
+project_only
+namespace :vm do
+  def vagrantfile &block
+    locate("*Vagrantfile", missing: "No Vagrantfile found") do
+      yield
+    end
+  end
+
+  desc "Start VM"
+  task :start => [ 'deps:gems', 'deps:chef', 'deps:composer', 'vm:up', 'vm:start' ]
+
+  desc "Stop VM"
+  task :stop do
+    vagrantfile do
+      Hobo.ui.title "Stopping VM"
+      bundle_shell "vagrant", "suspend", "--color", realtime: true, indent: 2
+      Hobo.ui.separator
+    end
+  end
+
+  desc "Rebuild VM"
+  task :rebuild => [ 'vm:destroy', 'vm:start' ]
+
+  desc "Destroy VM"
+  task :destroy do
+    vagrantfile do
+      Hobo.ui.title "Stopping VM"
+      bundle_shell "vagrant", "destroy", "--color", realtime: true, indent: 2
+      Hobo.ui.separator
+    end
+  end
+
+  task :up do
+    vagrantfile do
+      Hobo.ui.title "Starting vagrant VM"
+      bundle_shell "vagrant", "up", "--no-provision", "--color", realtime: true, indent: 2
+      Hobo.ui.separator
+    end
+  end
+
+  task :provision do
+     vagrantfile do
+      Hobo.ui.title "Provisioning VM"
+      bundle_shell "vagrant", "provision", "--color", realtime: true, indent: 2
+      Hobo.ui.separator
+    end
+  end
+end

data/lib/hobo/ui.rb

@@ -0,0 +1,96 @@
+require 'highline'
+
+module Hobo
+  class << self
+    attr_accessor :ui
+  end
+
+  class Ui
+    attr_accessor :interactive
+
+    def initialize out = $stdout, error = $stderr
+      colors = HighLine::ColorScheme.new do |cs|
+        cs[:debug] = [ ]
+        cs[:info]  = [ ]
+        cs[:warning]  = [ :yellow ]
+        cs[:error] = [ :red ]
+        cs[:success] = [ :green ]
+        cs[:opt] = [ :green ]
+        cs[:command] = [:green ]
+        cs[:special] = [ :blue ]
+        cs[:title]   = [ :green ]
+        cs[:help_title] = [ :yellow ]
+        cs[:description] = [ :bold ]
+      end
+
+      HighLine.color_scheme = colors
+
+      @out = ::HighLine.new $stdin, out
+      @error = ::HighLine.new $stdin, error
+    end
+
+    def color_scheme scheme = nil
+      HighLine.color_scheme = scheme if scheme
+      HighLine.color_scheme
+    end
+
+    def ask question, opts = {}
+      unless Hobo.ui.interactive
+        raise Hobo::NonInteractive.new(question) if opts[:default].nil?
+        return opts[:default]
+      end
+
+      question = "#{question} [#{opts[:default]}]" if opts[:default]
+      question += ": "
+      begin
+        answer = @out.ask(question) do |q|
+          q.validate = opts[:validate] if opts[:validate]
+          q.readline
+        end
+        answer.strip.empty? ? opts[:default] : answer.strip
+      rescue EOFError
+        Hobo.ui.info ""
+        ""
+      end
+    end
+
+    def separator
+      info ""
+    end
+
+    def color *args
+      @out.color *args
+    end
+
+    def debug message
+      say @out, message, :debug
+    end
+
+    def info message
+      say @out, message, :info
+    end
+
+    def warning message
+      say @error, message, :warning
+    end
+
+    def error message
+      say @error, message, :error
+    end
+
+    def success message
+      say @out, message, :success
+    end
+
+    def title message
+      say @out, message, :title
+    end
+
+    private
+
+    def say channel, message, color
+      return if message.nil?
+      channel.say(color ? channel.color(message, color) : message)
+    end
+  end
+end

data/lib/hobo/util.rb

@@ -0,0 +1,7 @@
+module Hobo
+  class << self
+    def in_project?
+      !Hobo.project_path.nil?
+    end
+  end
+end

data/lib/hobo/version.rb

@@ -0,0 +1,3 @@
+module Hobo
+  VERSION = '0.0.2'
+end

data/spec/hobo/cli_spec.rb

@@ -0,0 +1,135 @@
+require 'rake'
+
+require 'hobo/metadata'
+require 'hobo/patches/rake'
+require 'hobo/patches/slop'
+
+require 'hobo/errors'
+require 'hobo/cli'
+
+
+describe Hobo::Cli do
+  cli = nil
+  help = nil
+
+  before do
+    Rake::Task.tasks.each do |task|
+      task.clear
+    end
+    Hobo.ui = double(Hobo::Ui).as_null_object
+    help = double(Hobo::HelpFormatter).as_null_object
+    cli = Hobo::Cli.new help: help
+  end
+
+  describe "hobofile" do
+    it "should load the hobofile if present" do
+      cli.start []
+      Rake::Task["test:non-interactive"].should_not be nil
+    end
+  end
+
+  describe "command mapping" do
+    it "should set command map on help formatter" do
+      help.should_recieve('command_map=')
+      cli.start ["test", "subcommand"]
+    end
+  end
+
+  describe "metadata" do
+    it "should propagate description metadata" do
+      map = nil
+      allow(help).to receive("command_map=") { |i| map = i }
+      cli.start []
+      map["test:metadata"].description.should match "description"
+    end
+
+    it "should propagate long description metadata" do
+      map = nil
+      allow(help).to receive("command_map=") { |i| map = i }
+      cli.start []
+      map["test:metadata"].long_description.should match "long description"
+    end
+
+    it "should propagate arg list metadata" do
+      map = nil
+      allow(help).to receive("command_map=") { |i| map = i }
+      cli.start []
+      expect(map["test:metadata"].arg_list).to eq [ :arg ]
+    end
+
+    it "should propagate option metadata" do
+      map = nil
+      allow(help).to receive("command_map=") { |i| map = i }
+      cli.start []
+      map["test:metadata"].options.length.should be 2
+      expect(map["test:metadata"].options.map(&:short)).to eq [ 'o', 'h' ]
+      expect(map["test:metadata"].options.map(&:long)).to eq [ 'option', 'help' ]
+      expect(map["test:metadata"].options.map(&:description)).to eq [ 'Option description', 'Display help' ]
+    end
+
+    it "should propagate hidden metadata" do
+      map = nil
+      allow(help).to receive("command_map=") { |i| map = i }
+      cli.start []
+      map["test:metadata"].hidden.should be true
+    end
+  end
+
+  describe "global options" do
+    it "should set non-interactive mode in ui if --non-interactive" do
+      Hobo.ui.should_receive('interactive=').with(false)
+      cli.start(['--non-interactive'])
+    end
+  end
+
+  describe "invocation" do
+    it "should show help if no args or opts passed" do
+      help.should_receive(:help)
+      cli.start([])
+    end
+
+    it "should show help for --help" do
+      help.should_receive(:help)
+      cli.start ["--help"]
+    end
+
+    it "should execute a top level command" do
+      Hobo.ui.should_recieve(:info).with("top level")
+      cli.start ["top-level"]
+    end
+
+    it "should execute a subcommand" do
+      Hobo.ui.should_recieve(:info).with("Subcommand test")
+      cli.start ["test", "subcommand"]
+    end
+
+    it "should show help for a namespace" do
+      help.should_receive(:help).with(all: nil, target: "test")
+      cli.start ["test"]
+    end
+
+    it "should show command help for --help" do
+      help.should_receive(:help).with(all: nil, target: "test:subcommand")
+      cli.start ["test", "subcommand", "--help"]
+    end
+
+    it "should propagate --all option to help" do
+      help.should_receive(:help).with(all: true, target: "test")
+      cli.start ["test", "--all"]
+    end
+
+    it "should propagate command opts to command" do
+      Hobo.ui.should_receive(:info).with("1234")
+      cli.start ["test", "option-test", "--testing=1234"]
+    end
+
+    it "should propagate arguments to command" do
+      Hobo.ui.should_receive(:info).with("1234")
+      cli.start ["test", "argument-test", "1234"]
+    end
+
+    it "should raise an exception if not enough arguments were passed" do
+      expect { cli.start(["test", "metadata"]) }.to raise_error Hobo::MissingArgumentsError
+    end
+  end
+end

data/spec/hobo/config/file_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'hobo/paths'
+require 'hobo/config/file'
+
+describe Hobo::Config::File do
+  before do
+    Hobo.project_path = nil
+    FakeFS.activate!
+  end
+
+  after do
+    FakeFS::FileSystem.clear
+    FakeFS.deactivate!
+  end
+
+  def fake_config
+    {
+      :string => "string",
+      :integer => 0,
+      :boolean => true,
+      :hash => { :test => true },
+      :array => [ 1 ]
+    }
+  end
+
+  describe "save" do
+    it "should save config hash to specified file" do
+      Hobo::Config::File.save "test.yaml", fake_config
+      File.read("test.yaml").should match /string: string/
+    end
+  end
+
+  describe "load" do
+    it "should load config hash from file" do
+      Hobo::Config::File.save "test.yaml", fake_config
+      fake_config().should eq Hobo::Config::File.load("test.yaml")
+    end
+
+    it "should return empty hash if file does not exist" do
+      Hobo::Config::File.load("test.yaml").should eq({})
+    end
+
+    it "should raise error if file can't be parsed" do
+      File.write("test.yaml", "##Invalid yaml file")
+      expect { Hobo::Config::File.load("test.yaml") }.to raise_error(RuntimeError, "Invalid hobo configuration (test.yaml)")
+    end
+  end
+end

data/spec/hobo/error_handlers/debug_spec.rb

@@ -0,0 +1,10 @@
+require 'hobo/error_handlers/debug'
+
+describe Hobo::ErrorHandlers::Debug do
+  describe "handle" do
+    it "should re-raise the error" do
+      exception = Exception.new
+      expect { Hobo::ErrorHandlers::Debug.new.handle(exception) }.to raise_error exception
+    end
+  end
+end

data/spec/hobo/error_handlers/friendly_spec.rb

@@ -0,0 +1,81 @@
+require 'hobo/error_handlers/friendly'
+require 'hobo/ui'
+
+describe Hobo::ErrorHandlers::Friendly do
+  before do
+    Hobo.ui = double(Hobo::Ui.new).as_null_object
+    FakeFS.activate!
+    FileUtils.mkdir '/tmp'
+  end
+
+  after do
+    FakeFS::FileSystem.clear
+    FakeFS.deactivate!
+  end
+
+  describe "handle" do
+    it "should display specialized error for Interrupt" do
+      error = Interrupt.new
+      Hobo.ui.should_receive(:warning).with(/Caught Interrupt/)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+    end
+
+    it "should display specialized error for an external command error" do
+      File.write("temp_log", "command output")
+      output = Struct.new(:path).new
+      output.path = "temp_log"
+      error = Hobo::ExternalCommandError.new("command", 128, output)
+      Hobo.ui.should_receive(:error).with(/The following external command appears to have failed \(exit status 128\)/)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+    end
+
+    it "should write command output to /tmp/hobo_error.log for external command error" do
+      File.write("temp_log", "command output")
+      output = Struct.new(:path).new
+      output.path = "temp_log"
+      error = Hobo::ExternalCommandError.new("command", 128, output)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+      File.read(File.join(Dir.tmpdir, 'hobo_error.log')).should match "command output"
+    end
+
+    it "should display specialized error for invalid command or opt error" do
+      error = Hobo::InvalidCommandOrOpt.new("command")
+      Hobo.ui.should_receive(:error).with(/Invalid command or option specified: 'command'/)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+    end
+
+    it "should display specialized error for missing argument error" do
+      error = Hobo::MissingArgumentsError.new("command", ["arg1"])
+      Hobo.ui.should_receive(:error).with(/Not enough arguments for command/)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+    end
+
+    it "should display specialized error for user error" do
+      error = Hobo::UserError.new("user error")
+      Hobo.ui.should_receive(:error).with(/user error/)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+    end
+
+    it "should display generic error for other exception" do
+      error = nil
+      begin
+        raise Exception.new("general error")
+      rescue Exception => error
+      end
+
+      Hobo.ui.should_receive(:error).with(/An unexpected error has occured/)
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+    end
+
+    it "should write error backtrace to /tmp/hobo_error.log for other exception" do
+      error = nil
+      begin
+        raise Exception.new("general error")
+      rescue Exception => error
+      end
+
+      Hobo::ErrorHandlers::Friendly.new.handle(error)
+      File.read(File.join(Dir.tmpdir, 'hobo_error.log')).should match /\(Exception\) general error/
+    end
+  end
+end