hobo-inviqa 0.0.2

data/lib/hobo/cli.rb

@@ -0,0 +1,185 @@
+module Hobo
+
+  class Halt < Error
+  end
+
+  class Cli
+    attr_accessor :slop, :help_formatter
+
+    def initialize opts = {}
+      @opts = opts
+      @slop = opts[:slop] || Slop.new
+      @help_formatter = opts[:help] || Hobo::HelpFormatter.new(@slop)
+      @help_opts = {}
+    end
+
+    def start argv = ARGV
+      load_hobofile
+
+      tasks = structure_tasks Hobo::Metadata.metadata.keys
+      args = fix_args_with_equals argv
+      define_global_opts @slop
+
+      begin
+        # Parse out global args first
+        @slop.parse! args
+        opts = @slop.to_hash
+        @help_opts[:all] = opts[:all]
+        Hobo.ui.interactive = !(opts[:'non-interactive'] == true)
+
+        @slop.add_callback :empty do
+          show_help
+        end
+
+        # Necessary to make command level help work
+        args.push "--help" if @slop.help?
+
+        @help_formatter.command_map = define_tasks(tasks, @slop)
+
+        remaining = @slop.parse! args
+        raise Hobo::InvalidCommandOrOpt.new remaining.join(" "), self if remaining.size > 0
+
+        show_help if @slop.help?
+      rescue Halt
+        # NOP
+      end
+
+      return 0
+    end
+
+    def show_help(opts = {})
+      Hobo.ui.info @help_formatter.help(@help_opts.merge(opts))
+      halt
+    end
+
+    private
+
+    def load_hobofile
+      if Hobo.in_project? && File.exists?(Hobo.hobofile_path)
+        load Hobo.hobofile_path
+      end
+    end
+
+    def define_global_opts slop
+      slop.on '--debug', 'Enable debugging'
+      slop.on '-a', '--all', 'Show hidden commands'
+      slop.on '-h', '--help', 'Display help'
+      slop.on '--non-interactive', 'Run non-interactively. Defaults will be automaticall used where possible.'
+
+      slop.on '-v', '--version', 'Print version information' do
+        Hobo.ui.info "Hobo version #{Hobo::VERSION}"
+        halt
+      end
+    end
+
+    def halt
+      raise Halt.new
+    end
+
+    def define_tasks structured_list, scope, stack = [], map = {}
+      structured_list.each do |k, v|
+        name = (stack + [k]).join(':')
+        new_stack = stack + [k]
+        map[name] = if v.size == 0
+          define_command(name, scope, new_stack)
+        else
+          define_namespace(name, scope, new_stack, v, map)
+        end
+      end
+      return map
+    end
+
+    # Map rake namespace to a Slop command
+    def define_namespace name, scope, stack, subtasks, map
+      metadata = Hobo::Metadata.metadata[name]
+      hobo = self
+      new_scope = nil
+
+      scope.instance_eval do
+        new_scope = command stack.last do
+
+          description metadata[:desc]
+          long_description metadata[:long_desc]
+          hidden metadata[:hidden]
+          project_only metadata[:project_only]
+
+          # NOP; run runs help anyway
+          on '-h', '--help', 'Display help' do end
+
+          run do |opts, args|
+            hobo.show_help(target: name)
+          end
+        end
+      end
+
+      define_tasks subtasks, new_scope, stack, map
+      return new_scope
+    end
+
+    # Map rake task to a Slop command
+    def define_command name, scope, stack
+      metadata = Hobo::Metadata.metadata[name]
+      hobo = self
+      new_scope = nil
+
+      scope.instance_eval do
+        new_scope = command stack.last do
+          task = Rake::Task[name]
+
+          description metadata[:desc]
+          long_description metadata[:long_desc]
+          arg_list task.arg_names
+          hidden metadata[:hidden]
+          project_only metadata[:project_only]
+
+          metadata[:opts].each do |opt|
+            on *opt
+          end if metadata[:opts]
+
+          on '-h', '--help', 'Display help' do
+            hobo.show_help(target: name)
+          end
+
+          run do |opts, args|
+            raise ::Hobo::ProjectOnlyError.new if opts.project_only && !Hobo.in_project?
+            task.opts = opts.to_hash
+            raise ::Hobo::MissingArgumentsError.new(name, args, hobo) if args && task.arg_names.length > args.length
+            task.invoke *args
+            args.pop(task.arg_names.size)
+            task.opts = nil
+          end
+        end
+      end
+
+      return new_scope
+    end
+
+    # Expand flat task list in to hierarchy (non-recursive)
+    def structure_tasks list
+      out = {}
+      list.each do |name|
+        ref = out
+        name = name.split(":")
+        name.each do |n|
+          ref[n] ||= {}
+          ref = ref[n]
+        end
+      end
+      out
+    end
+
+    # Slop badly handles assignment args passed as --arg=val
+    # This hack fixes that by making them --arg val
+    def fix_args_with_equals args
+      items = []
+      args.each do |item|
+        if item.match /^-.*\=/
+          item.split('=').each { |i| items.push i }
+        else
+          items.push item
+        end
+      end
+      return items
+    end
+  end
+end

data/lib/hobo/config/file.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+
+module Hobo
+  module Config
+    class File
+      def self.save(file, config)
+        dir = ::File.dirname file
+        FileUtils.mkdir_p dir unless ::File.exists? dir
+        ::File.open(file, 'w+') do |f|
+          f.puts config.to_yaml
+        end
+      end
+
+      def self.load(file)
+        config = ::File.exists?(file) ? YAML.load_file(file) : {}
+        raise "Invalid hobo configuration (#{file})" unless config
+        return config
+      end
+    end
+  end
+end

data/lib/hobo/error_handlers/debug.rb

@@ -0,0 +1,9 @@
+module Hobo
+  module ErrorHandlers
+    class Debug
+      def handle error
+        raise error
+      end
+    end
+  end
+end

data/lib/hobo/error_handlers/friendly.rb

@@ -0,0 +1,52 @@
+require 'tmpdir' # Needed for Dir.tmpdir
+
+module Hobo
+  module ErrorHandlers
+    class Friendly
+      def handle error
+        log_file = File.join(Dir.tmpdir, 'hobo_error.log')
+
+        # Not possible to match Interrupt class unless we use class name as string for some reason!
+        case error.class.to_s
+          when "Interrupt"
+            Hobo.ui.warning "\n\nCaught Interrupt. Aborting\n"
+            return 1
+          when "Hobo::ExternalCommandError"
+            FileUtils.cp error.output.path, log_file
+            Hobo.ui.error <<-ERROR
+
+  The following external command appears to have failed (exit status #{error.exit_code}):
+    #{error.command}
+
+  The output of the command has been logged to #{log_file}
+            ERROR
+            return 3
+          when "Hobo::InvalidCommandOrOpt"
+            Hobo.ui.error "\n#{error.message}"
+            Hobo.ui.info error.cli.help_formatter.help if error.cli
+            return 4
+          when "Hobo::MissingArgumentsError"
+            Hobo.ui.error "\n#{error.message}"
+            Hobo.ui.info error.cli.help_formatter.help(target: error.command) if error.cli
+            return 5
+          when "Hobo::UserError"
+            Hobo.ui.error "\n#{error.message}\n"
+            return 6
+          when "Hobo::ProjectOnlyError"
+            Hobo.ui.error "\nHobo requires you to be in a project directory for this command!\n"
+            return 7
+          else
+            File.write(log_file, "(#{error.class}) #{error.message}\n\n#{error.backtrace.join("\n")}")
+            Hobo.ui.error <<-ERROR
+
+  An unexpected error has occured:
+    #{error.message}
+
+  The backtrace has been logged to #{log_file}
+            ERROR
+            return 128
+        end
+      end
+    end
+  end
+end

data/lib/hobo/errors.rb

@@ -0,0 +1,60 @@
+module Hobo
+  class Error < StandardError
+  end
+
+  class RubyVersionError < Error
+    def initialize
+      super("Ruby 1.9+ is required to run hobo")
+    end
+  end
+
+  class MissingDependencies < Error
+    def initialize deps
+      deps.map! { |dep| " - #{dep}"}
+      super("Hobo requires the following commands to be available on your path:\n\n" + deps.join("\n"))
+    end
+  end
+
+  class InvalidCommandOrOpt < Error
+    attr_accessor :command, :cli
+    def initialize command, cli = nil
+      @command = command
+      @cli = cli
+      super("Invalid command or option specified: '#{command}'")
+    end
+  end
+
+  class MissingArgumentsError < Error
+    attr_accessor :command, :cli
+    def initialize command, args, cli = nil
+      @command = command
+      @args = args
+      @cli = cli
+      super("Not enough arguments for #{command}")
+    end
+  end
+
+  class ExternalCommandError < Error
+    attr_accessor :command, :exit_code, :output
+
+    def initialize command, exit_code, output
+      @command = command
+      @exit_code = exit_code
+      @output = output
+      super("'#{command}' returned exit code #{exit_code}")
+    end
+  end
+
+  class UserError < Error
+  end
+
+  class ProjectOnlyError < Error
+  end
+
+  class NonInteractiveError < Error
+    def initialize question
+      @question = question
+      super("A task requested input from user but hobo is in non-interactive mode")
+    end
+  end
+end

data/lib/hobo/help_formatter.rb

@@ -0,0 +1,111 @@
+module Hobo
+  class HelpFormatter
+    attr_accessor :command_map
+    ALIGN_PAD = 4
+
+    def initialize global
+      @global = global
+      @command_map = {}
+    end
+
+    def help opts = {}
+      target = opts[:target] || nil
+      output = [""]
+
+      command = @command_map[target]
+
+      if !command
+        command_opts = []
+        commands = commands_for(@global, opts)
+        command = @global
+      else
+        command_opts = options_for(command)
+        commands = commands_for(command, opts)
+      end
+
+      global_opts = options_for(@global)
+
+      align_to = longest([global_opts, command_opts, commands]) + ALIGN_PAD
+
+      if command != @global
+        description = [ command.long_description, command.description ].compact.first
+        output.push Hobo.ui.color("#{description}\n", :description) if description
+      end
+
+      output.push section("Usage", [usage(command, target)])
+      output.push section("Global options", global_opts, align_to)
+      output.push section("Command options", command_opts, align_to)
+      output.push section("Commands", commands, align_to)
+
+      return output.compact.join("\n")
+    end
+
+    private
+
+    def longest inputs
+      inputs.map do |input|
+        next unless input.is_a? Array
+        if input.size == 0
+          0
+        else
+          input.map(&:first).map(&:size).max
+        end
+      end.compact.max
+    end
+
+    def options_for source
+      heads  = source.options.reject(&:tail?)
+      tails  = (source.options - heads)
+
+      (heads + tails).map do |opt|
+        next if source != @global && opt.short == 'h'
+        line = padded(opt.short ? "-#{opt.short}," : "", 4)
+
+        if opt.long
+          value = opt.config[:argument] ? "#{opt.long.upcase}" : ""
+          value = "[#{value}]" if opt.accepts_optional_argument?
+          value = "=#{value}" unless value.empty?
+
+          line += "--#{opt.long}#{value}"
+        end
+
+        [Hobo.ui.color(line, :opt), opt.description]
+      end.compact
+    end
+
+    def commands_for source, opts = {}
+      source.commands.map do |name, command|
+        next if command.hidden && !opts[:all]
+        next unless command.hidden == false || command.description || opts[:all]
+        [Hobo.ui.color(name, :command), command.description]
+      end.compact
+    end
+
+    def usage source, command = nil
+      banner = source.banner
+      if banner.nil?
+        arg_list = (source.arg_list || []).map do |arg|
+          "<#{arg}>"
+        end
+
+        banner = "#{File.basename($0, '.*')}"
+        banner << " [command]" if source.commands.any? && command.nil?
+        banner << " #{command.split(':').join(' ')}" if command
+        banner << " #{arg_list.join(' ')}" if arg_list.size > 0
+        banner << " [options]"
+      end
+    end
+
+    def section title, contents, align_to = false
+      return nil if contents.empty?
+      output = Hobo.ui.color("#{title}:\n", :help_title)
+      output += contents.map do |line|
+        line.is_a?(String) ? "  #{line}" : "  #{padded(line[0], align_to)}#{line[1]}"
+      end.join("\n") + "\n"
+    end
+
+    def padded str, target
+      str + (' ' * (target - str.size))
+    end
+  end
+end

data/lib/hobo/helper/file_locator.rb

@@ -0,0 +1,39 @@
+require 'open3'
+
+module Hobo
+  module Helper
+    def locate(pattern, opts = {}, &block)
+      match = nil
+
+      Dir.chdir Hobo.project_path do
+        match = locate_git(pattern, false, &block)
+        match = locate_git(pattern, true, &block) if !match
+      end
+
+      return true if match
+
+      Hobo.ui.warning opts[:missing] if opts[:missing]
+      return false
+    end
+
+    private
+
+    def locate_git pattern, others, &block
+      args = [ 'git', 'ls-files', pattern ]
+      args.push '-o' if others
+      output = Hobo::Helper.shell *args, :capture => true
+      path = output.split("\n")[0]
+
+      unless path.nil?
+        path.strip!
+        Dir.chdir File.dirname(path) do
+          yield path
+        end
+
+        return true
+      end
+    end
+  end
+end
+
+include Hobo::Helper