cli-mastermind 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a20b74d9d0e99c2d10a5f9c834be1ece3ffbecf8b5f978882c5fa165b7289316
+  data.tar.gz: af0406ca768e182e8243348a958adebac42f7640b6d497d2e990c0871d7aaee7
+SHA512:
+  metadata.gz: 7bba8a6c1e62ebf4adcd69075982396f4121422866f20f387396442c9e6f3607d67b09bab11bad462a093e137416359ff8ab14b39ff32bcf3d95be26262241fc
+  data.tar.gz: 0e713288d9930e8d7b7a1a872d120264d9b2a6e51792a5d37ac5d1cc7d32a619085d9cc9ca235ecbae85fd18c68a617eeb1e08659ece7273beabef6abc285141

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.masterplan

@@ -0,0 +1,6 @@
+#-*- ruby -*-
+at_project_root
+
+has_plan_files
+
+configure(:gemspec) { Gem::Specification.load('cli-mastermind.gemspec') }

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+#ruby=ruby-2.5.1
+#ruby-gemset=cli-mastermind
+
+# Specify your gem's dependencies in cli-mastermind.gemspec
+gemspec
+
+gem 'pry'
+gem 'pry-byebug'

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    cli-mastermind (0.0.1)
+      cli-ui (~> 1.2, >= 1.2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (10.0.2)
+    cli-ui (1.2.1)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  cli-mastermind!
+  pry
+  pry-byebug
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Chris Hall
+
+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,164 @@
+# Mastermind
+
+Mastermind is a CLI toolkit.  It's purpose is to help build, configure, and run
+command line tools.
+
+Mastermind is designed for flexibility, extensibility, and minimal dependencies.
+
+## Flexibility
+
+Mastermind is written in Ruby and, therefore, provides first-class citizenship
+to that language and uses Ruby's syntax and semantics in its primary configuration
+files.
+
+Mastermind looks for and executes `.masterplan` files recursively up the file tree
+until it reaches the root of your project, if defined, or your home directory,
+if it's not.  Additionally, it always looks for and attempts to load a `.masterplan`
+file in your home directory, if one exists.
+
+In this way, configuration for your tools can live where it makes the most sense
+for it to live with as much or as little duplication as you deem necessary.
+
+See [Writing Masterplans](#writing-masterplans) for more on their structure and semantics.
+
+Mastermind makes up for the lack of language flexibility in its configuration
+with full flexibility in its planfiles.  Which brings us to...
+
+## Extensibility
+
+Mastermind is designed from the outset to provide means of extending its planfile
+formats through custom `Loader`s.  In fact, Mastermind's own `PlanfileLoader` is
+the first of such loaders.  You can specify your own file extensions and provide
+your own loaders as needed.
+
+As long as the objects returned by your loader quack like a `Plan`, Mastermind
+won't fuss at them.  After all, you can't take over the world if your busy mucking
+about in the details!
+
+## Minimal Dependencies
+
+Mastermind only has one dependency, Shopify's excelent [cli-ui project][cli-ui].
+It doesn't require that you load it in your Gemfile or do anything in particular.
+All you need to be able to do is run its executable and Mastermind does the rest.
+
+## Usage
+
+### The `mastermind` Executable
+
+Mastermind's own help is pretty straightforward:
+
+    Usage: mastermind [--help, -h] [--plans[ PATTERN], --tasks[ PATTERN], -T [PATTERN], -P [PATTERN] [PLAN[, PLAN[, ...]]] -- [PLAN ARGUMENTS]
+        -h, --help                       Display this help
+        -P, -T, --plans [PATTERN],       Display plans.  Optional pattern is used to filter the returned plans.
+            --tasks
+
+Any arguments specified after `--` are passed as-is down to the executed plan.
+You can then process those arguments however you like or ignore them completely!
+
+Unlike Rake and other, similar, tools that allow you to run multiple tasks in
+parallel, Mastermind is designed to run only one task at a time.  Specifying
+multiple plans on the command line is how you walk down the tree to a specific
+plan.
+
+### Writing Masterplans
+
+`.masterplan` files use a minimal DSL to configure Mastermind and load planfiles.
+Some of these commands have sensible defaults designed to keep configuration to
+a minimum.
+
+#### Masterplan DSL
+
+##### `project_root [directory]`
+
+Specifies the root of your project.  Must be specified to prevent Mastermind
+from scanning more of your filesystem than it needs to.  The easiest way to
+do this is to just specify it in a `.masterplan` file in the actual root of
+your project.
+
+Aliased as `at_project_root`.  The argument defaults to the directory of the
+current `.masterplan`.
+
+##### `plan_files [directory]`
+
+Specifies that plan files exist in the given directory.  Mastermind will search
+this directory for any files that end in a supported extension and mark them
+for loading.  By default, Mastermind only supports files with a `.plan` extension.
+
+Aliased as `has_plan_files`. The argument defaults to a `plans` directory in
+the same directory as the current `.masterplan`.
+
+##### `plan_file filename[, filename[, ...]]`
+
+Instructs Mastermind to load the planfiles located at the given filenames.
+
+##### `configure attribute [value] [&block]`
+
+Used to set arbitrary configuration options.  When a configuration option is
+set in multiple `.masterplan` files, the "closest" one to your invocation wins.
+In other words, since Mastermind reads `.masterplan` files starting in your
+current directory and working it's way "up" the hierarchy, the first `.masterplan`
+that specifies a configuration option "wins".
+
+When provided a block, the value is computed the first time the option is called
+for.  The block runs in the context of the `Configuration` object built up by
+all the loaded `.masterplan` files, so it has access to all previously set
+configuration options.
+
+The block is only executed once.  After that, the value is cached so that it
+doesn't need to be recomputed.
+
+If both a block and a value are given, the block is ignored and only the value
+is stored.
+
+##### `see_also filename`
+
+Instructs Mastermind to also load the configuration specified in `filename`.
+This file does _not_ have to be named `.masterplan` but _does_ have to conform
+to the syntax outlined here.
+
+### Writing Planfiles
+
+By default, planfiles use a very simple DSL that will feel familiar to anyone
+that's ever used Rake.  The biggest difference between Rake (and similar tools)
+and Mastermind is that Mastermind has no support for dependent tasks or parallel
+tasks.  If your workflow requires either of those things, Mastermind is probably
+not the tool you want to use.  Or, rather, not the _only_ tool you want to use.
+
+#### Planfile DSL
+
+##### `plot name &block`
+
+Creates a Plan that contains children with the given `name`.  This is similar
+to the `namespace` command in a Rakefile.  The Plans created inside the block
+are added as children of this Plan.
+
+##### `description text`
+
+Provides a description for the next Plan created.  Plans created with `plot`
+can also have descriptions.
+
+##### `plan name &block`
+
+Creates a Plan with the given name and sets the given block as its action.
+This block is passed the arguments from the command line and is run as a Plan.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can
+also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+Mastermind uses itself to run tests and build new versions.  Run `bin/rspec` to
+run tests.  To install this gem onto your local machine, run `exe/mastermind gem install`
+To release a new version, update the version number in `version.rb`, and then run
+`exe/mastermind gem release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/chall8908/cli-mastermind.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+[cli-ui]: https://github.com/shopify/cli-ui

data/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cli/mastermind"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+require 'pry-byebug'
+Pry.start

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cli-mastermind.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cli/mastermind/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cli-mastermind"
+  spec.version       = CLI::Mastermind.gem_version
+  spec.authors       = ["Chris Hall"]
+  spec.email         = ["chall8908@gmail.com"]
+
+  spec.summary       = "Mastermind is a library for constructing command line toolboxes."
+  spec.description   = <<-DESC
+                         Take over the world from your command line!
+                         With mastermind, you can quickly build and generate
+                         command line toolkits without having to custom build
+                         everything for every project.
+                       DESC
+  spec.homepage      = "https://github.com/chall8908/cli-mastermind"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "cli-ui", "~> 1.2", ">= 1.2.1"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/exe/mastermind

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'cli/mastermind'
+
+CLI::Mastermind.execute(ARGV)

data/lib/cli/mastermind/arg_parse.rb

@@ -0,0 +1,79 @@
+require 'optparse'
+
+module CLI::Mastermind
+  class ArgParse
+    # When set, used to display available plans
+    attr_reader :pattern
+
+    # Used by mastermind to lookup plans
+    # attr_reader :mastermind_arguments
+
+    # Passed as-is into plans
+    attr_reader :plan_arguments
+
+    def initialize(arguments=ARGV)
+      @initial_arguments = arguments
+      @ask = true
+      @display_ui = true
+
+      parse_arguments
+    end
+
+    def display_plans?
+      !@pattern.nil?
+    end
+
+    def has_additional_plan_names?
+      @mastermind_arguments.any?
+    end
+
+    def get_next_plan_name
+      @mastermind_arguments.shift
+    end
+
+    def display_ui?
+      @display_ui
+    end
+
+    def ask?
+      @ask
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner = 'Usage: mastermind [--help, -h] [--plans[ PATTERN], --tasks[ PATTERN], -T [PATTERN], -P [PATTERN] [PLAN[, PLAN[, ...]]] -- [PLAN ARGUMENTS]'
+
+        opt.on('--help', '-h', 'Display this help') do
+          puts opt
+          exit
+        end
+
+        opt.on('-A', '--no-ask', "Don't ask before executing a plan") do
+          @ask = false
+        end
+
+        opt.on('-U', '--no-fancy-ui', "Don't display the fancy UI") do
+          @display_ui = false
+        end
+
+        # TODO: Finish plan display
+        # opt.on('--plans [PATTERN]', '--tasks [PATTERN]', '-P [PATTERN]', '-T [PATTERN]',
+        #        [:text],
+        #        'Display plans.  Optional pattern is used to filter the returned plans.') do |pattern|
+        #   @pattern = RegExp.new(pattern || '*')
+        # end
+      end
+    end
+
+    private
+
+    def parse_arguments
+      @mastermind_arguments = @initial_arguments.take_while { |arg| arg != '--' }
+      @plan_arguments = @initial_arguments[(@mastermind_arguments.size + 1)..-1]
+
+      unless @mastermind_arguments.empty?
+        @mastermind_arguments = parser.parse *@mastermind_arguments
+      end
+    end
+  end
+end

data/lib/cli/mastermind/configuration.rb

@@ -0,0 +1,142 @@
+require 'set'
+
+module CLI
+  module Mastermind
+    ##
+    # Main configuration object.  Walks up the file tree looking for masterplans
+    # and loading them into to build a the configuration used by the CLI.
+    #
+    # Masterplans are loaded such that configuration specified closest to the
+    # point of invocation override configuration from farther masterplans.
+    # This allows you to add folder specific configuration while still falling
+    # back to more and more general configuration options.
+    #
+    # A global masterplan located at $HOME/.masterplan (or equivalent) is loaded
+    # _last_.  You can use this to specify plans you want accessible everywhere
+    # or global configuration that should apply everywhere (unless overridden by
+    # more specific masterplans).
+    class Configuration
+      # Filename of masterplan files
+      PLANFILE = '.masterplan'
+
+      # Path to the top-level masterplan
+      MASTER_PLAN = File.join(Dir.home, PLANFILE)
+
+      attr_reader :plans
+
+      # Adds an arbitrary attribute given by +attribute+ to the configuration class
+      def self.add_attribute(attribute)
+        return if self.method_defined? attribute
+
+        self.define_method "#{attribute}=" do |new_value=nil,&block|
+          self.instance_variable_set("@#{attribute}", new_value||block)  if self.instance_variable_get("@#{attribute}").nil?
+        end
+
+        self.define_method attribute do
+          value = self.instance_variable_get("@#{attribute}")
+          return value unless value.respond_to?(:call)
+
+          # Cache the value returned by the block so we're not doing potentially
+          # expensive operations mutliple times.
+          self.instance_variable_set("@#{attribute}", self.instance_eval(&value))
+        end
+      end
+
+      # Specifies the directory that is the root of your project.
+      # This directory is where Mastermind will stop looking for more
+      # masterplans, so it's important that it be set.
+      add_attribute :project_root
+
+      def initialize
+        @loaded_masterplans = Set.new
+        @plan_files = Set.new
+
+        lookup_and_load_masterplans
+        load_masterplan MASTER_PLAN
+      end
+
+      # Adds a set of filenames for plans into the set of +@plan_files+
+      def add_plans(planfiles)
+        @plan_files.merge(planfiles)
+      end
+
+      # Loads all plan files added using +add_plans+
+      # @see Plan.load
+      def load_plans
+        @plans ||= @plan_files.reduce({}) do |hash, file|
+          plans = Plan.load file
+          plans.each { |plan| hash[plan.name] = plan }
+          hash
+        end
+      end
+
+      # Loads a masterplan using the DSL, if it exists and hasn't been loaded already
+      def load_masterplan filename
+        if File.exists? filename and !@loaded_masterplans.include? filename
+          @loaded_masterplans << filename
+          DSL.new(self, filename)
+        end
+      end
+
+      private
+
+      # Walks up the file tree looking for masterplans.
+      def lookup_and_load_masterplans
+        load_masterplan File.join(Dir.pwd, PLANFILE)
+
+        # Walk up the tree until we reach the project root, the home directory, or
+        # the root directory
+        unless [project_root, Dir.home, '/'].include? Dir.pwd
+          Dir.chdir('..') { lookup_and_load_masterplans }
+        end
+      end
+
+      class DSL
+        def initialize(config, filename)
+          @config = config
+          @filename = filename
+          instance_eval(File.read(filename), filename, 0) if File.exists? filename
+        end
+
+        # Specifies that another masterplan should also be loaded when loading
+        # this masterplan.  NOTE: This _immediately_ loads the other masterplan.
+        def see_also(filename)
+          @config.load_masterplan(filename)
+        end
+
+        # With no arguments, specifies that the current directory containing this
+        # masterplan is at the root of your project.  Otherwise, specifies the root
+        # of the project.
+        def project_root(root = File.dirname(@filename))
+          @config.project_root = root
+        end
+        alias_method :at_project_root, :project_root
+
+        # With no arguments, specifies that plans exist in a /plans/ directory
+        # under the directory the masterplan is in.
+        def plan_files(directory = File.join(File.dirname(@filename), 'plans'))
+          @config.add_plans(Dir.glob(File.join(directory, '**', "*{#{supported_extensions}}")))
+        end
+        alias_method :has_plan_files, :plan_files
+
+        # Specifies that a specific plan file exists at the given +filename+.
+        def plan_file(*files)
+          @config.add_plans(files)
+        end
+
+        # Add arbitrary configuration attributes to the configuration object.
+        # Use this to add plan specific configuration options.
+        def configure(attribute, value=nil, &block)
+          Configuration.add_attribute(attribute)
+          @config.public_send "#{attribute}=", value, &block
+        end
+
+        private
+
+        def supported_extensions
+          Loader.supported_extensions.join(',')
+        end
+      end
+    end
+  end
+end

data/lib/cli/mastermind/errors.rb

@@ -0,0 +1,12 @@
+module CLI
+  module Mastermind
+    class Error < StandardError
+    end
+
+    class UnsupportedFileTypeError < Error
+      def initialize(extension)
+        super "Unsupported file type: #{extension}"
+      end
+    end
+  end
+end

data/lib/cli/mastermind/interface.rb

@@ -0,0 +1,74 @@
+module CLI::Mastermind::Interface
+  def enable_ui
+    CLI::UI::StdoutRouter.enable
+  end
+
+  def ui_enabled?
+    CLI::UI::StdoutRouter.enabled?
+  end
+
+  def spinner(title)
+    return yield unless ui_enabled?
+
+    yield_value = nil
+
+    group = CLI::UI::SpinGroup.new
+    group.add(title) do |spinner|
+      catch(:success) do
+        msg = catch(:fail) do
+          yield_value = yield spinner
+          throw :success
+        end
+
+        puts msg
+        CLI::UI::Spinner::TASK_FAILED
+      end
+    end
+
+    group.wait
+
+    yield_value
+  end
+
+  def frame(title)
+    return yield unless ui_enabled?
+    CLI::UI::Frame.open(title) { yield }
+  end
+
+  def ask(question, default: nil)
+    CLI::UI.ask(question, default: default)
+  end
+
+  def confirm(question)
+    CLI::UI.confirm(question)
+  end
+
+  def select(question, options:, default: options.first, **opts)
+    default_value = nil
+    options = case options
+              when Array
+                default_value = default
+
+                o = options - [default]
+                o.zip(o).to_h
+              when Hash
+                # Handle the "default" default.  Otherwise, we expect the
+                # default to be a key in the options hash
+                default = default.first if default.is_a? Array
+                default_value = options[default]
+                options.dup.tap { |o| o.delete(default) }
+              end
+
+    CLI::UI::Prompt.ask(question, **opts) do |handler|
+      handler.option(titleize(default.to_s)) { default_value }
+
+      options.each do |(text, value)|
+        handler.option(titleize(text.to_s)) { value }
+      end
+    end
+  end
+
+  def titleize(string)
+    string.gsub(/[-_-]/, ' ').split(' ').map(&:capitalize).join(' ')
+  end
+end

data/lib/cli/mastermind/loader/planfile_loader.rb

@@ -0,0 +1,48 @@
+module CLI::Mastermind
+  class Loader
+    class PlanfileLoader < Loader
+      @loadable_extensions = %w[ .plan ].freeze
+
+      def self.load(filename)
+        DSL.new(filename).plans
+      end
+
+      private
+
+      class DSL
+        attr_reader :plans
+
+        def initialize(filename=nil, &block)
+          @plans = []
+
+          if block_given?
+            instance_eval(&block)
+          elsif File.exists? filename
+            instance_eval(File.read(filename), filename, 0)
+          else
+            raise 'Must provide valid path to a planfile or a block', Error
+          end
+        end
+
+        def plot(name, &block)
+          plan = Plan.new name, @description
+          @description = nil
+          @plans << plan
+          plan.add_children DSL.new(&block).plans
+        end
+        alias_method :namespace, :plot
+
+        def description(text)
+          @description = text
+        end
+        alias_method :desc, :description
+
+        def plan(name, &block)
+          @plans << Plan.new(name, @description, &block)
+          @description = nil
+        end
+        alias_method :task, :plan
+      end
+    end
+  end
+end

data/lib/cli/mastermind/loader.rb

@@ -0,0 +1,34 @@
+module CLI::Mastermind
+  class Loader
+    class << self
+      attr_reader :loadable_extensions
+      @@loaders = []
+
+      def inherited(subclass)
+        @@loaders << subclass
+      end
+
+      def find_loader(extension)
+        loader = @@loaders.find { |l| l.can_load? extension }
+
+        raise UnsupportedFileTypeError.new(extension) unless loader
+
+        loader
+      end
+
+      def supported_extensions
+        @@loaders.flat_map { |l| l.loadable_extensions }
+      end
+
+      def can_load?(extension)
+        @loadable_extensions.include? extension
+      end
+
+      def load(filename)
+        raise NotImplementedError
+      end
+    end
+  end
+end
+
+require 'cli/mastermind/loader/planfile_loader'

data/lib/cli/mastermind/plan.rb

@@ -0,0 +1,64 @@
+require 'forwardable'
+
+module CLI
+  module Mastermind
+    class Plan
+      extend Forwardable
+      include Interface
+
+      # The name of the plan.  Used to specify the plan from the command line
+      # or from the interactive menu
+      attr_reader :name
+
+      # Displayed in the non-interactive list of available plans
+      attr_reader :description
+
+      # Used in the interactive plan selector to display child plans
+      attr_reader :children
+
+      # Loads a particular plan from the filesystem.
+      # @see Loader
+      def self.load(filename)
+        ext = File.extname(filename)
+        loader = Loader.find_loader(ext)
+        loader.load(filename)
+      end
+
+      def initialize(name, description=nil, &block)
+        @name = name.to_s.freeze
+        @description = description.freeze
+        @block = block
+        @children = {}
+      end
+
+      # Get the child plan with the specified +name+
+      def get_child(name)
+        @children[name]
+      end
+      alias_method :[], :get_child
+      alias_method :dig, :get_child
+
+      def add_children(plans)
+        raise 'Cannot add child plans to a plan with an action', InvalidPlanError unless @block.nil?
+        plans.each { |plan| @children[plan.name] = plan }
+      end
+
+      def has_children?
+        @children.any?
+      end
+
+      def call(options=nil)
+        case @block.arity
+        when 1, -1 then instance_exec(options, &@block)
+        else            instance_exec(&@block)
+        end
+      end
+
+      private
+
+      # Delegate configuration to the top-level configuration object
+      def_delegator :'CLI::Mastermind', :configuration
+      alias_method :config, :configuration
+    end
+  end
+end

data/lib/cli/mastermind/version.rb

@@ -0,0 +1,17 @@
+module CLI
+  module Mastermind
+
+    def self.gem_version
+      Gem::Version.new VERSION::STRING
+    end
+
+    module VERSION
+      RELEASE = 0
+      MAJOR = 0
+      MINOR = 1
+      PATCH = nil
+
+      STRING = [RELEASE, MAJOR, MINOR, PATCH].compact.join('.').freeze
+    end
+  end
+end

data/lib/cli/mastermind.rb

@@ -0,0 +1,74 @@
+require 'cli/ui'
+require 'cli/mastermind/arg_parse'
+require 'cli/mastermind/configuration'
+require 'cli/mastermind/errors'
+require 'cli/mastermind/interface'
+require 'cli/mastermind/loader'
+require 'cli/mastermind/plan'
+require 'cli/mastermind/version'
+
+module CLI
+  module Mastermind
+    extend Interface
+
+    class << self
+      attr_reader :plans
+
+      def configuration
+        @config
+      end
+
+      def execute(cli_args=ARGV)
+        @arguments = ArgParse.new(cli_args)
+
+        enable_ui if @arguments.display_ui?
+
+        frame('Mastermind') do
+          @config = spinner('Loading configuration') { Configuration.new }
+          @plans = spinner('Loading plans') { @config.load_plans }
+          @plan_stack = []
+
+          @selected_plan = nil
+
+          while @arguments.has_additional_plan_names?
+            plan_name = @arguments.get_next_plan_name
+            @selected_plan = (@selected_plan || @plans)[plan_name]
+            @plan_stack << titleize(plan_name)
+
+            if @selected_plan.nil?
+              puts "No plan found at #{@plan_stack.join('/')}"
+              puts @arguments.parser
+              exit 1
+            end
+          end
+
+          # Prevent the prompt from exploading
+          if @selected_plan.nil? and @plans.count == 1
+            @selected_plan = @plans.values.first
+            @plan_stack << titleize(@selected_plan.name)
+          end
+
+          while @selected_plan.nil? or @selected_plan.has_children?
+            do_interactive_plan_selection
+            @plan_stack << titleize(@selected_plan.name)
+          end
+
+          if !@arguments.ask? or confirm("Execute plan #{@plan_stack.join('/')}?")
+            @selected_plan.call(@arguments.plan_arguments)
+          else
+            puts 'aborted!'
+          end
+        end
+      end
+
+      private
+
+      def do_interactive_plan_selection
+        options = @selected_plan&.children || @plans
+
+        @selected_plan = select("Select a plan under #{@plan_stack.join('/')}", options: options)
+      end
+
+    end
+  end
+end

data/plans/gem.plan

@@ -0,0 +1,39 @@
+#-*- ruby -*-
+plot :gem do
+  description 'Builds the mastermind gem'
+  # NOTE: The Gem::Package interface doesn't appear to be completely stable.
+  #       This may only work on version 2.7.7 of RubyGems, though other versions
+  #       seem to support passing only a spec as I'm doing here.
+  plan :build do
+    Dir.mkdir 'pkg' unless Dir.exists? 'pkg'
+
+    require 'rubygems/package'
+    spec = config.gemspec
+
+    Gem::Package.build(spec)
+
+    File.write(File.join('pkg', spec.file_name), File.read(spec.file_name), mode: ?w)
+    File.delete(spec.file_name)
+  end
+
+  description 'Install mastermind into the local system'
+  plan :install do
+    require 'rubygems/installer'
+    config.plans['gem']['build'].call
+
+    Gem::Installer.at(File.join('pkg', config.gemspec.file_name)).install
+  end
+
+  description 'Package and push a new release'
+  plan :release do
+    config.plans['gem']['build'].call
+    spec = config.gemspec
+
+    `git tag '#{spec.version}'`
+    `git push origin HEAD`
+    `git push --tags`
+
+    require 'rubygems/command_manager'
+    Gem::CommandManager.instance['push'].invoke File.join('pkg', spec.file_name)
+  end
+end

data/plans/sample.plan

@@ -0,0 +1,17 @@
+#-*- ruby -*-
+# aliased as `namespace` for a less fanciful, rake-like way of doing things
+plot :top_level do
+
+  # aliased as `desc` if you prefer brevity
+  description 'This is the description of the next plan defined'
+  # aliased as `task`, for a less fanciful, rake-like way of doing things
+  plan :child_plan do |arguments|
+    puts 'EXECUTING'
+    puts arguments
+  end
+
+  description 'This is another plan under the top_level plan'
+  plan :second_child do
+    # more tasks
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: cli-mastermind
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Hall
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cli-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2
+                           Take over the world from your command line!
+                           With mastermind, you can quickly build and generate
+                           command line toolkits without having to custom build
+                           everything for every project.
+email:
+- chall8908@gmail.com
+executables:
+- mastermind
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".masterplan"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/rspec
+- bin/setup
+- cli-mastermind.gemspec
+- exe/mastermind
+- lib/cli/mastermind.rb
+- lib/cli/mastermind/arg_parse.rb
+- lib/cli/mastermind/configuration.rb
+- lib/cli/mastermind/errors.rb
+- lib/cli/mastermind/interface.rb
+- lib/cli/mastermind/loader.rb
+- lib/cli/mastermind/loader/planfile_loader.rb
+- lib/cli/mastermind/plan.rb
+- lib/cli/mastermind/version.rb
+- plans/gem.plan
+- plans/sample.plan
+homepage: https://github.com/chall8908/cli-mastermind
+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.7.7
+signing_key: 
+specification_version: 4
+summary: Mastermind is a library for constructing command line toolboxes.
+test_files: []