boxen 2.9.0 → 3.0.0.beta1

data/boxen.gemspec

@@ -1,30 +1,30 @@
 # -*- encoding: utf-8 -*-
 
+$:.unshift File.expand_path("../lib", __FILE__)
+require "boxen/version"
+
 Gem::Specification.new do |gem|
   gem.name          = "boxen"
-  gem.version       = "2.9.0"
-  # Thanks go out to the previous maintainers John Barnette, Will
-  # Farrington, David Goodlad and Mike McQuaid for getting this project
-  # to where it is today.
-  gem.authors       = ["Jacob Bednarz"]
-  gem.email         = ["jacob.bednarz@gmail.com"]
+  gem.version       = Boxen::VERSION
+  gem.authors       = ["John Barnette", "Will Farrington", "David Goodlad"]
+  gem.email         = ["jbarnette@github.com", "wfarr@github.com", "dgoodlad@github.com"]
   gem.description   = "Manage Mac development boxes with love (and Puppet)."
   gem.summary       = "You know, for laptops and stuff."
   gem.homepage      = "https://github.com/boxen/boxen"
-  gem.license       = 'MIT'
 
-  gem.files         = `git ls-files`.split $/
-  gem.test_files    = gem.files.grep /^test/
+  gem.files         = `git ls-files`.split( $/)
+  gem.test_files    = gem.files.grep(/^test/)
+  gem.executables   = gem.files.grep(/^bin/).map { |bin| File.basename(bin) }
   gem.require_paths = ["lib"]
 
   gem.add_dependency "ansi",             "~> 1.4"
   gem.add_dependency "hiera",            "~> 1.0"
-  gem.add_dependency "highline",         "~> 1.6.0"
+  gem.add_dependency "highline",         "~> 1.6"
   gem.add_dependency "json_pure",        [">= 1.7.7", "< 2.0"]
   gem.add_dependency "librarian-puppet", "~> 1.0.0"
   gem.add_dependency "octokit",          "~> 2.7", ">= 2.7.1"
-  gem.add_dependency "puppet",           "~> 3.7"
+  gem.add_dependency "puppet",           "~> 3.0"
 
-  gem.add_development_dependency "minitest", "4.4.0" # pinned for mocha
+  gem.add_development_dependency "minitest", "~> 5.0" # pinned for mocha
   gem.add_development_dependency "mocha",    "~> 0.13"
 end

data/lib/boxen/check.rb

@@ -1,20 +1,11 @@
-require "ansi"
+require "boxen/util/logging"
 
 module Boxen
 
   # The superclass for preflight and postflight sanity checks.
 
   class Check
-
-    # A collection of preflight instances for `config`. An instance is
-    # created for every constant under `self` that's also a
-    # subclass of `self`.
-
-    def self.checks(config)
-      constants.map { |n| const_get n }.
-        select { |c| c < self }.
-        map { |c| c.new config }
-    end
+    include Boxen::Util::Logging
 
     # Search `dir` and load all Ruby files under it.
 
@@ -22,16 +13,12 @@ module Boxen
       Dir["#{dir}/*.rb"].sort.each { |f| load f }
     end
 
-    # Check each instance against `config`.
-
-    def self.run(config)
-      checks(config).each { |check| check.run unless check.ok? }
-    end
-
     attr_reader :config
+    attr_reader :command
 
-    def initialize(config)
-      @config = config
+    def initialize(config, command)
+      @config  = config
+      @command = command
     end
 
     # Is everything good to go? Implemented by subclasses.
@@ -46,27 +33,9 @@ module Boxen
       raise "Subclasses must implement this method."
     end
 
-    # A fancier `abort` and `warn`. This will probably really annoy
-    # someone at some point because it's overriding a Kernel method,
-    # but it's limited to checks.
-
-    def abort(message, *extras)
-      extras << { :color => :red }
-      warn message, *extras
-      exit 1
-    end
-
-    def warn(message, *extras)
-      options = Hash === extras.last ? extras.pop : {}
-      color   = options[:color] || :yellow
-
-      $stderr.puts ANSI.send(color) { "--> #{message}" }
-
-      unless extras.empty?
-        extras.each { |line| $stderr.puts "    #{line}" }
-      end
 
-      $stderr.puts
+    def debug?
+      @config.debug?
     end
   end
 end

data/lib/boxen/cli.rb

@@ -1,61 +1,35 @@
+require "boxen/command"
 require "boxen/config"
-require "boxen/flags"
-require "boxen/postflight"
-require "boxen/preflight"
-require "boxen/runner"
-require "boxen/util"
+require "boxen/util/logging"
 
 module Boxen
   class CLI
-    attr_reader :config
-    attr_reader :flags
-    attr_reader :runner
-
-    def initialize(config, flags)
-      @config = config
-      @flags  = flags
-      @runner = Boxen::Runner.new(@config, @flags)
-    end
-
-    def run
-      if flags.help?
-        puts flags
-        exit
-      end
+    include Boxen::Util::Logging
 
-      runner.run
+    def self.run(*args)
+      new.run(*args)
     end
 
-    # Run Boxen by wiring together the command-line flags, config,
-    # preflights, Puppet execution, and postflights. Returns Puppet's
-    # exit code.
-
-    def self.run(*args)
-      config = Boxen::Config.load
-      flags  = Boxen::Flags.new args
+    def initialize
+    end
 
-      # Apply command-line flags to the config in case we're changing or
-      # overriding anything.
-      flags.apply config
+    def run(*args)
+      cmd, *cmd_args = args.flatten
 
-      if flags.run?
-        # Run the preflight checks.
-        Boxen::Preflight.run config
+      with_friendly_errors do
+        config = Boxen::Config.load
+        status = Boxen::Command.invoke cmd, config, *cmd_args
 
-        # Save the config for Puppet (and next time).
-        Boxen::Config.save config
+        status.code
       end
+    end
 
-      # Make the magic happen.
-      status = Boxen::CLI.new(config, flags).run
-
-      if flags.run?
-        # Run the postflight checks.
-        Boxen::Postflight.run config if status.success?
-      end
+    private
 
-      # Return Puppet's exit status.
-      return status.code
+    def with_friendly_errors(&block)
+      yield
+    rescue => e
+      abort "#{e.class.name}: #{e.message}"
     end
   end
 end

data/lib/boxen/command.rb

@@ -0,0 +1,142 @@
+require "boxen/command_status"
+
+# Pulled in so the others don't have to
+require "boxen/preflight"
+require "boxen/postflight"
+require "boxen/util/logging"
+
+class Boxen::Command
+  include Boxen::Util::Logging
+
+  class UnknownCommandError < StandardError; end
+  class CommandNotRunError < StandardError; end
+
+  attr_reader :config
+
+  def self.help
+    raise "You should define this"
+  end
+
+  def self.detailed_help
+    raise "You should definitely define this"
+  end
+
+  def self.preflight(*klasses)
+    preflights.replace preflights | klasses.flatten
+  end
+
+  def self.preflights
+    @preflights ||= []
+  end
+
+  def self.postflight(*klasses)
+    postflights.replace postflights | klasses.flatten
+  end
+
+  def self.postflights
+    @postflights ||= []
+  end
+
+  def self.all
+    @commands
+  end
+
+  def self.register(name, klass, *aliases)
+    unless defined?(@commands)
+      @commands = {}
+    end
+    unless defined?(@aliases)
+      @aliases = {}
+    end
+
+    @commands[name] = klass
+    aliases.each { |a| @aliases[a] = name }
+  end
+
+  def self.reset!
+    @commands = {}
+  end
+
+  def self.invoke(name, *args)
+    if @commands && name && @commands.has_key?(name.to_sym)
+      @commands[name.to_sym].new(*args).invoke
+    elsif @aliases && name && @aliases.has_key?(name.to_sym)
+      invoke(@aliases[name.to_sym], *args)
+    else
+      raise UnknownCommandError,
+        "could not find `#{name.inspect.to_s}` in the list of registered commands"
+    end
+  end
+
+  def initialize(config, *args)
+    @config = config
+    @args   = args
+  end
+
+  def invoke
+    if preflights?
+      @cmd_status = self.run
+
+      postflights
+
+      @cmd_status
+    end
+  end
+
+  def run
+    raise "So your command #{self.class.name} hasn't defined a run method, so we dunno what to do. Sorry."
+  end
+
+  def preflights?
+    if self.class.preflights.any?
+      info "Performing preflight checks"
+    end
+
+    self.class.preflights.all? do |p|
+
+      debug "Performing preflight check: #{p.name}"
+
+      p = p.new(@config, self)
+      status = p.ok?
+
+      if status
+        debug "Passed preflight check: #{p.class.name}"
+      else
+        p.run
+      end
+
+      status
+    end
+  end
+
+  def postflights
+    if self.class.postflights.any?
+      info "Performing postflight checks"
+    end
+
+    self.class.postflights.each do |p|
+      p = p.new(@config, self)
+      p.run unless p.ok?
+    end
+  end
+
+  def debug?
+    @config.debug?
+  end
+
+  def success?
+    if @cmd_status
+      @cmd_status.success?
+    else
+      raise CommandNotRunError,
+        "the command hasn't been run, so we can't know if it was successful"
+    end
+  end
+end
+
+require "boxen/command/help"
+require "boxen/command/version"
+require "boxen/command/run"
+require "boxen/command/preflight"
+require "boxen/command/project"
+require "boxen/command/service"

data/lib/boxen/command/help.rb

@@ -0,0 +1,40 @@
+require "boxen/command"
+
+class Boxen::Command::Help < Boxen::Command
+  def self.help
+    "Displays help, obviously"
+  end
+
+  def self.detailed_help
+    <<-EOS
+
+    boxen help [<command>]
+
+        With no arguments, displays short help information for all commands.
+
+        Given a command name as an argument, displays detailed help about that command.
+
+EOS
+  end
+
+  def run
+    if @args.any?
+      puts Boxen::Command.all[@args.first.to_sym].detailed_help
+    else
+      Boxen::Command.all.each do |name, _|
+        display_help_for_command name
+      end
+    end
+
+    Boxen::CommandStatus.new(0)
+  end
+
+  def display_help_for_command(name)
+    # only shows top-level commands, not subcommands
+    unless name =~ /:/
+      puts "    #{name.to_s.ljust(16)} #{Boxen::Command.all[name.to_sym].help}"
+    end
+  end
+end
+
+Boxen::Command.register :help, Boxen::Command::Help, :"--help"

data/lib/boxen/command/preflight.rb

@@ -0,0 +1,38 @@
+require "boxen/command"
+
+class Boxen::Command::Preflight < Boxen::Command
+  def self.help
+    "Run a single preflight and return whether or not it's ok."
+  end
+
+  def self.detailed_help
+    <<-EOS
+
+    boxen preflight <check>
+
+        Run preflight named <check> and return whether or not it's ok.
+
+EOS
+  end
+
+  def run
+    if defined?(preflight)
+      info "#{preflight.name}: #{preflight.new(@config).ok?.inspect}"
+      return Boxen::CommandStatus.new(0)
+    else
+      fail("Could not find a preflight named: #{preflight_name}")
+    end
+  rescue => e
+    fail("Command failed: #{e.message} #{e.backtrace}")
+  end
+
+  def preflight
+    Object.const_get(preflight_name)
+  end
+
+  def preflight_name
+    "Boxen::Preflight::#{ARGV[1].capitalize}"
+  end
+end
+
+Boxen::Command.register :preflight, Boxen::Command::Preflight

data/lib/boxen/command/project.rb

@@ -0,0 +1,49 @@
+require "boxen/command"
+#require "boxen/service"
+
+class Boxen::Command::Project < Boxen::Command
+  def self.detailed_help
+    <<-EOS
+
+    boxen project
+
+        Display all projects Boxen knows about.
+
+    boxen project:install <project1> [<project2> ...]
+
+        Install a Boxen-managed project.
+
+    NOTE: 'boxen project' is aliased to 'projects' for convenience
+
+EOS
+  end
+
+  def self.help
+    "Show and install Boxen-managed projects"
+  end
+
+  def run
+    @args = [] # we don't care about args here
+
+    puts "Boxen knows about the following projects:"
+    puts
+
+    projects.each do |project|
+      puts "    #{project.name}"
+    end
+
+    puts
+    puts "You can install any of them by running \"boxen project:install <project>\""
+    puts
+
+    Boxen::CommandStatus.new(0)
+  end
+
+  def projects
+    @projects ||= @config.projects
+  end
+end
+
+require "boxen/command/project/install"
+
+Boxen::Command.register :project,  Boxen::Command::Project, :projects