belafonte 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a460418210e2ac70ea041d21767a9e07d66a2a59
+  data.tar.gz: 93cdbe5d558f4ad27929bcee53f9d3d4772a6a5a
+SHA512:
+  metadata.gz: 9b4299b8461f277f49c286e15a0d161e84bf4028733b58e50359773b3ac0c1e2b3c9096d0763354de1ab400976f4d7385467085ac73be8725d464f0f27ef3855
+  data.tar.gz: b4b6256af663d2a3574ee1a7ece14e35af67832d0269078fe3c8cf1b61db7410baff18af87f9152d194480b6f81b532f20d412f4e63cbdabe399b9267bcaa157

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dennis Walters
+
+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,158 @@
+# Belafonte #
+
+This library is all about making command-line applications. It's a lot like GLI, methadone, Main, and the other options. This is just my take.
+
+My goals in this:
+
+* Make a system that suits my tastes
+* Avoid magic
+* Make apps easier to test (specifically with aruba in-process)
+
+## Installation ##
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'belafonte'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install belafonte
+
+## Usage ##
+
+```ruby
+require 'belafonte'
+
+class MyApp < Belafonte::App
+
+  # Every Belafonte application must have a title.
+  title "myapp"
+  summary "A short description"
+  description <<-DESCRIPTION
+  This is a much longer description of the app, command, or what have you.
+  DESCRIPTION
+
+  # Switches are boolean flags that can be passed on the command line.
+  # At least one short or long flag is required, but you can pass multiple
+  # flags (without hyphens) for each if you like.
+
+  switch :switch_name,              # name the switch
+    short: 's',                     # short flags for the switch (array for 2+)
+    long: 'switch',                 # long flag for the switch (array for 2+)
+    description: 'This is a switch' # describe the switch (default '')
+
+  # Options are flags that take an argument. The basic setup for this is the
+  # same as that for switches, but with the additional requirement of a display
+  # name for the option's argument.
+
+  option :option_name,                # name the option
+    short: 'o',                       # short flags (array for 2+)
+    long: 'option',                   # long flags (array for 2+)
+    description: 'This is an option', # describe the option (default: '')
+    argument: 'option name'           # display name (required)
+
+  # Args are actual arguments to the command. These require a name, and by
+  # default are expected 1 time. You can specify any number of explicit
+  # occurrences that are greater-than 0, and you can also make them unlimited,
+  # but you're not allowed to add any further args after adding an unlimited
+  # arg.
+
+  arg :argument_name,
+    times: 1
+
+  arg :unlimited_argument,
+    times: :unlimited
+
+  # The `handle` method that you define for your app is the hook that Belafonte
+  # uses to run your code. If you don't define this, your app won't actually
+  # do much of anything.
+
+  def handle
+
+    # Do something if the :switch_name switch is active
+
+    if switch_active(:switch_name)
+      stdout.puts "Switch is active!"
+    else
+      stdout.puts "Switch is not active :/"
+    end
+
+    # Do something based on the options that came in
+    stdout.puts "We got this option: #{option[:option]}"
+
+    # Do something with the first argument we defined
+    stdout.puts arg[:argument_name].first
+
+    # Do something with the unlimited argument we defined
+    arg[:unlimited_argument].each do |unlimited|
+      stdout.puts "unlimited == '#{unlimited}'"
+    end
+  end
+end
+
+# Actually run the application. In addition to ARGV, the following .new args
+# are defaulted:
+#
+# * stdin (default: STDIN)
+# * stdout (default: STDOUT)
+# * stderr (default: STDERR)
+# * kernel (default: Kernel)
+#
+# Unfortunately, order matters, and you can't specify (say) kernel without
+# first specifying the items that come before it.
+#
+# In a more perfect world, your executable file is basically just a require to
+# pull in your app, then this line.
+
+exit MyApp.new(ARGV).execute!
+```
+
+## Upcoming Features ##
+
+So as to allow for "command suite" utilities, I'm planning to allow for the mounting of one application into another, a-la Rack, Sinatra, Grape, etc.
+
+The API for this is unstable, and I need to figure out some business logic, but it should look something like this:
+
+```ruby
+require 'belafonte'
+
+class InnerApp < Belafonte::App
+  title "inner"
+
+  def handle
+    stdout.puts "This is the inner app"
+  end
+end
+
+class OuterApp < Belafonte::App
+  title "outer"
+
+  mount InnerApp
+
+  def handle
+    stdout.puts "This is the outer app"
+  end
+end
+
+exit OuterApp.new(ARGV).execute!
+```
+
+## Development ##
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing ##
+
+1. Fork it ( https://github.com/[my-github-username]/belafonte/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/belafonte.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'belafonte/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "belafonte"
+  spec.version       = Belafonte::VERSION
+  spec.authors       = ["Dennis Walters"]
+  spec.email         = ["dwalters@engineyard.com"]
+
+  spec.summary       = %q{Jump in the command line!}
+  spec.homepage      = "https://github.com/ess/belafonte"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|examples|bin|.gitignore|.rspec|.ruby-gemset|.ruby-version|.travis.yml|Gemfile|Rakefile)/?}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "toady"
+end

data/lib/belafonte/app.rb

@@ -0,0 +1,86 @@
+require 'optparse'
+require 'belafonte/dsl'
+require 'belafonte/errors'
+require 'belafonte/help'
+
+module Belafonte
+  # An application container
+  class App
+    include Belafonte::DSL
+
+    attr_reader :argv, :stdin, :stdout, :stderr, :kernel
+
+    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel, parent = nil)
+      @argv = argv
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @kernel = kernel
+      @parent = parent
+    end
+
+    def execute!
+      (@parser = Parser.new(
+        switches: configured_switches,
+        options: configured_options,
+        commands: configured_subcommands,
+        arguments: configured_args,
+        argv: @argv
+      )).parsed.tap do |parsed|
+        @switches = parsed[:switches]
+        @options = parsed[:options]
+        @arguments = parsed[:args]
+        activate_help! if parsed[:help]
+      end
+
+      @command = arg(:command).shift if arg(:command)
+
+      unless dispatch || show_help || run_handle
+        stderr.puts "No handler for the provided command line"
+        return 1
+      end
+
+      0
+    end
+
+    private
+    def parent
+      @parent
+    end
+
+    def subcommand_instance(command)
+      command_class = configured_subcommands.
+        find {|subcommand| subcommand.info(:title) == command}
+
+      return nil unless command_class
+
+      command_class.new(arg(:command), stdin, stdout, stderr, kernel, self)
+    end
+
+    def dispatch
+      return false if @command.nil?
+      handler = subcommand_instance(@command)
+
+      unless handler
+        activate_help!
+        return false
+      end
+
+      handler.activate_help! if help_active?
+      handler.execute!
+      true
+    end
+
+    def show_help
+      return false unless help_active?
+      stdout.print Belafonte::Help.content_for(self)
+      true
+    end
+
+    def run_handle
+      return false unless respond_to?(:handle)
+      handle
+      true
+    end
+  end
+end

data/lib/belafonte/argument.rb

@@ -0,0 +1,48 @@
+require 'belafonte/errors'
+
+module Belafonte
+  # Represents a command line argument
+  class Argument
+    attr_reader :name, :times
+
+    def initialize(options = {})
+      @name = options[:name]
+      @times = options[:times]
+      normalize
+    end
+
+    def process(argv)
+      case times
+      when -1
+        argv
+      else
+        if argv.length < times
+          raise Belafonte::Errors::TooFewArguments.new("Not enough arguments were given")
+        end
+        argv.first(times)
+      end.clone
+    end
+
+    def unlimited?
+      @unlimited ||= false
+    end
+
+    private
+    def normalize
+      raise Belafonte::Errors::NoName.new("Arguments must be named") unless name
+
+      case times
+      when nil
+        @times = 1
+      when :unlimited
+        @times = -1
+        @unlimited = true
+      else
+        @times = times.to_i
+      end
+      
+      raise Belafonte::Errors::InvalidArgument.new("There must be at least one occurrence") unless times > 0 || unlimited?
+    end
+
+  end
+end

data/lib/belafonte/argument_processor.rb

@@ -0,0 +1,40 @@
+require 'belafonte/errors'
+
+module Belafonte
+  # Processes command line arguments
+  class ArgumentProcessor
+    def initialize(options = {})
+      @argv = options[:argv] || []
+      @arguments = options[:arguments] || []
+      process!
+    end
+
+    def processed
+      @processed ||= {}
+    end
+
+    private
+    def process!
+      argv = @argv.clone
+      arguments.each do |arg|
+        values = arg.process(argv)
+        processed[arg.name] = values
+        argv.shift(values.length)
+      end
+
+      validate_processed_args
+
+      if argv.length > 0
+        raise Belafonte::Errors::TooManyArguments.new("More args provided than I can handle")
+      end
+    end
+
+    def arguments
+      @arguments
+    end
+
+    def validate_processed_args
+      raise Belafonte::Errors::TooFewArguments.new("You didn't provide enough arguments") if processed.values.any? {|arg| arg.empty?}
+    end
+  end
+end

data/lib/belafonte/dsl/class_methods.rb

@@ -0,0 +1,75 @@
+require 'optparse'
+require 'belafonte/switch'
+require 'belafonte/option'
+require 'belafonte/argument'
+require 'belafonte/errors'
+
+module Belafonte
+  module DSL
+    # Class methods for defining apps
+    module ClassMethods
+      def meta
+        @meta ||= {}
+      end
+
+      def info(item)
+        meta[item]
+      end
+
+      def title(title)
+        meta[:title] = title
+      end
+
+      def summary(summary)
+        meta[:summary] = summary
+      end
+
+      def description(description)
+        meta[:description] = description
+      end
+
+      def switches
+        meta[:switches] ||= []
+      end
+
+      def switch(name, switch_options = {})
+        switches.push(Belafonte::Switch.new(switch_options.merge({name: name})))
+      end
+
+      def options
+        meta[:options] ||= []
+      end
+
+      def option(name, option_options = {})
+        options.push(Belafonte::Option.new(option_options.merge({name: name})))
+      end
+
+      def args
+        meta[:args] ||= []
+      end
+
+      def arg(name, arg_options = {})
+        args.last.tap do |arg|
+          if arg && arg.unlimited?
+            raise Belafonte::Errors::InvalidArgument.new("You may not add other arguments after an unlimited argument")
+          else
+            args.push(Belafonte::Argument.new(arg_options.merge({name: name})))
+          end
+        end
+      end
+
+      def subcommands
+        meta[:subcommands] ||= []
+      end
+
+      def mount(app)
+        unless args.any? {|arg| arg.name.to_sym == :command}
+          arg :command, times: :unlimited
+        end
+
+        raise Belafonte::Errors::CircularMount.new("An app cannot mount itself") if app == self
+        subcommands.push(app)
+      end
+    end
+  end
+end

data/lib/belafonte/dsl/instance_methods.rb

@@ -0,0 +1,98 @@
+require 'belafonte/parser'
+
+module Belafonte
+  module DSL
+    # Instance methods for apps
+    module InstanceMethods
+      def title
+        self.class.info(:title)
+      end
+
+      def summary
+        self.class.info(:summary)
+      end
+
+      def description
+        self.class.info(:description)
+      end
+
+      def configured_switches
+        self.class.switches
+      end
+
+      def configured_options
+        self.class.options
+      end
+
+      def configured_args
+        self.class.args
+      end
+
+      def configured_subcommands
+        self.class.subcommands
+      end
+
+      def switches
+        @switches ||= {}
+      end
+
+      def switch_active(switch)
+        switches[switch]
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def option(option)
+        options[option]
+      end
+
+      def args
+        @arguments ||= {}
+      end
+
+      def arg(arg)
+        args[arg]
+      end
+
+      def subcommands
+        @subcommands ||= []
+      end
+
+      def estate
+        @estate ||= {}
+      end
+
+      def bequeathed(name, value)
+        estate[name] ||= value
+      end
+      
+      def activate_help!
+        @help = true
+      end
+
+      private
+
+      def parser
+        @parser
+      end
+
+      #def short(option)
+        #"-#{option.to_s}"
+      #end
+
+      #def long(option)
+        #"-#{short(option)}"
+      #end
+
+      def help
+        @help ||= false
+      end
+
+      def help_active?
+        help
+      end
+    end
+  end
+end

data/lib/belafonte/dsl.rb

@@ -0,0 +1,14 @@
+require 'belafonte/dsl/instance_methods'
+require 'belafonte/dsl/class_methods'
+
+module Belafonte
+  # A DSL for making apps
+  module DSL
+    def self.included(klass)
+      klass.extend(Belafonte::DSL::ClassMethods)
+    end
+
+    include Belafonte::DSL::InstanceMethods
+    #include Belafonte::DSL::Mountin
+  end
+end

data/lib/belafonte/errors.rb

@@ -0,0 +1,25 @@
+module Belafonte
+  module Errors
+
+    # Raised when an app attempts to mount itself
+    CircularMount = Class.new(StandardError)
+    
+    # Raised when creation of an argument breaks the arg rules
+    InvalidArgument = Class.new(StandardError)
+    
+    # Raised when a name is required but not provided
+    NoName = Class.new(StandardError)
+    
+    # ArgumentNotNamed poop
+    ArgumentNotNamed = Class.new(StandardError)
+    
+    # TooFewArguments poop
+    TooFewArguments = Class.new(StandardError)
+    
+    # TooManyArguments poop
+    TooManyArguments = Class.new(StandardError)
+    
+    # UnknownCommand poop
+    UnknownCommand = Class.new(StandardError)
+  end
+end

data/lib/belafonte/flag.rb

@@ -0,0 +1,64 @@
+require 'belafonte/errors'
+
+module Belafonte
+  # Flag is the base class for switches and options
+  class Flag
+    # No flags were given
+    NoFlags = Class.new(StandardError)
+    # No name was given
+    NoName = Class.new(StandardError)
+
+    attr_reader :name, :short, :long, :description
+
+    def normalize_flag(flag)
+      flag.to_s.strip.gsub(/\s+/, '-')
+    end
+
+    def initialize(options = {})
+      options[:name].tap do |name|
+        unless options[:name]
+          raise Belafonte::Errors::NoName.new("Flag name cannot be blank")
+        end
+        @name = name.to_sym
+      end
+
+      @short = flag_array(options[:short])
+      @long = flag_array(options[:long])
+
+      if short.empty? && long.empty?
+        raise NoFlags.new("You must define at least one flag")
+      end
+
+      @description = options[:description] || ''
+    end
+
+    def to_opt_parse
+      [
+        short.map {|short_option| shortify(short_option)},
+        long.map {|long_option| longify(long_option)},
+        description
+      ].flatten
+    end
+
+    def variations
+      short + long
+    end
+    alias_method :flags, :variations
+
+    private
+    def shortify(option)
+      shortened = "-#{option.to_s}"
+    end
+
+    def longify(option)
+      "--#{option.to_s}"
+    end
+
+    def flag_array(items)
+      [items].
+        flatten.
+        map {|flag| normalize_flag(flag)}.
+        reject {|flag| flag == ''}
+    end
+  end
+end

data/lib/belafonte/help/app_extensions.rb

@@ -0,0 +1,72 @@
+module Belafonte
+  module Help
+    module AppExtensions
+      def root
+        if parent
+          parent.extend(AppExtensions)
+          parent.root
+        else
+          self
+        end
+      end
+
+      def root?
+        root == self
+      end
+
+      def executable
+        File.basename($0)
+      end
+
+      def display_title
+        root? ? executable : title
+      end
+
+      def display_description
+        description.to_s
+      end
+
+      def full_path
+        return signature unless parent
+        parent.extend(AppExtensions)
+        "#{parent.full_path} #{signature}"
+      end
+
+      def signature
+        cmd = display_title
+
+        cmd += " [#{cmd} options]" if has_flags?
+
+        if has_args?
+          cmd += " #{configured_args.map(&:name).map(&:to_s).join(' ')}"
+        end
+
+        if has_subcommands? && @command.nil?
+          cmd += " command"
+        end
+
+        cmd
+      end
+
+      def has_flags?
+        configured_switches.any? || configured_options.any?
+      end
+
+      def has_args?
+        configured_args.reject {|arg| arg.name.to_sym == :command}.any?
+      end
+
+      def has_subcommands?
+        configured_subcommands.any?
+      end
+
+      def sorted_flags
+        (configured_switches + configured_options).sort {|a,b| a.name <=> b.name}
+      end
+
+      def sorted_commands
+        configured_subcommands.sort {|a,b| a.name <=> b.name}
+      end
+    end
+  end
+end

data/lib/belafonte/help/command_extensions.rb

@@ -0,0 +1,13 @@
+module Belafonte
+  module Help
+    module CommandExtensions
+      def display_title
+        info(:title).to_s
+      end
+
+      def display_summary
+        info(:summary).to_s
+      end
+    end
+  end
+end

data/lib/belafonte/help/flag_extensions.rb

@@ -0,0 +1,17 @@
+module Belafonte
+  module Help
+    module FlagExtensions
+      def short_flags
+        short.map {|short_flag| shortify(short_flag)}
+      end
+
+      def long_flags
+        long.map {|long_flag| longify(long_flag)}
+      end
+
+      def signature
+        "#{(short_flags + long_flags).join(', ')} - #{description}"
+      end
+    end
+  end
+end

data/lib/belafonte/help/generator.rb

@@ -0,0 +1,60 @@
+require 'belafonte/wrapomatic'
+require 'belafonte/help/app_extensions'
+require 'belafonte/help/flag_extensions'
+require 'belafonte/help/command_extensions'
+
+module Belafonte
+  module Help
+    class Generator
+      def initialize(app)
+        @app = app
+        app.extend(AppExtensions)
+        @content = name_section + synopsis + options + commands
+      end
+
+      def content
+        @content
+      end
+
+      private
+      def app
+        @app
+      end
+
+      def name_section
+        "NAME\n#{Wrapomatic.new("#{app.display_title} - #{app.summary}").wrapped}\n"
+      end
+
+      def synopsis
+        synopsis = "\nSYNOPSIS\n#{Wrapomatic.new(app.full_path).wrapped}"
+        if app.description
+          synopsis += "\n\n#{Wrapomatic.wrap(app.display_description)}"
+        end
+        synopsis + "\n"
+      end
+
+      def options
+        return '' unless app.has_flags?
+        options = "\nOPTIONS\n"
+        app.sorted_flags.each do |flag|
+          flag.extend(FlagExtensions)
+          options += "#{Wrapomatic.new(flag.signature).wrapped}"
+        end
+
+        options + "\n"
+      end
+
+      def commands
+        return '' unless app.has_subcommands?
+        commands = "\nCOMMANDS\n"
+
+        app.sorted_commands.each do |command|
+          command.extend(CommandExtensions)
+          commands += "#{Wrapomatic.new("#{command.display_title} - #{command.display_summary}").wrapped}\n"
+        end
+
+        commands + "\n"
+      end
+    end
+  end
+end

data/lib/belafonte/help.rb

@@ -0,0 +1,11 @@
+require 'belafonte/help/generator'
+
+module Belafonte
+  # Generates the help for a given app
+  module Help
+
+    def self.content_for(app)
+      Generator.new(app).content
+    end
+  end
+end

data/lib/belafonte/helpers/tokens.rb

@@ -0,0 +1,10 @@
+module Belafonte
+  module Helpers
+    # deprecated tokenizer
+    module Tokens
+      def command_tokens
+        commands.keys
+      end
+    end
+  end
+end

data/lib/belafonte/option.rb

@@ -0,0 +1,26 @@
+require 'belafonte/flag'
+
+module Belafonte
+  # Flags that take arguments
+  class Option < Belafonte::Flag
+    # No argument given
+    NoArgument = Class.new(StandardError)
+
+    def initialize(options = {})
+      super(options)
+      options[:argument].tap do |arg|
+        raise NoArgument.new("Option requires an argument name") unless arg
+        @argument = arg.to_s.strip.upcase.gsub(/\s+/, '_')
+      end
+    end
+
+    private
+    def shortify(option)
+      "#{super(option)} #{@argument}"
+    end
+
+    def longify(option)
+      "#{super(option)}=#{@argument}"
+    end
+  end
+end

data/lib/belafonte/parser.rb

@@ -0,0 +1,108 @@
+require 'optparse'
+require 'belafonte/argument_processor'
+
+module Belafonte
+  # A service object that parses out argv
+  class Parser
+    def initialize(params = {})
+      @data = {
+        switches: params[:switches] || [],
+        options: params[:options] || [],
+        commands: params[:commands] || [],
+        arguments: params[:arguments] || [],
+        argv: params[:argv] || []
+      }
+      setup
+      parse
+    end
+
+    def parsed
+      @parsed ||= {
+        switches: {},
+        options: {},
+        args: {},
+      }
+    end
+
+    def help
+      parser.to_s
+    end
+
+    def parser
+      @parser ||= OptionParser.new
+    end
+
+    private
+
+    def setup
+      parsify_switches
+      parsify_options
+      add_help
+    end
+
+    def parsify_switches
+      switches.each do |switch|
+        parser.on(*(switch.to_opt_parse)) do
+          switch_results[switch.name] = true
+        end
+      end
+    end
+
+    def parsify_options
+      options.each do |option|
+        parser.on(*(option.to_opt_parse)) do |value|
+          option_results[option.name] = value
+        end
+      end
+    end
+
+    def add_help
+      parser.on_tail('-h', '--help', 'Shows this message') do
+        parsed[:help] = true
+      end
+    end
+
+    def parse
+      begin
+        parsed[:args] = ArgumentProcessor.new(
+          argv: parser.order(argv),
+          arguments: arguments
+        ).processed
+      rescue Errors::TooFewArguments, Errors::TooManyArguments
+        parsed[:help] = true
+      end
+    end
+
+    def switches
+      data[:switches]
+    end
+
+    def switch_results
+      parsed[:switches]
+    end
+
+    def option_results
+      parsed[:options]
+    end
+
+    def options
+      data[:options]
+    end
+
+    def commands
+      data[:commands]
+    end
+
+    def arguments
+      data[:arguments]
+    end
+
+    def argv
+      data[:argv]
+    end
+
+    def data
+      @data
+    end
+  end
+end

data/lib/belafonte/switch.rb

@@ -0,0 +1,7 @@
+require 'belafonte/flag'
+
+module Belafonte
+  # Boolean flags
+  class Switch < Belafonte::Flag
+  end
+end

data/lib/belafonte/version.rb

@@ -0,0 +1,3 @@
+module Belafonte
+  VERSION = "0.1.2"
+end

data/lib/belafonte/wrapomatic.rb

@@ -0,0 +1,58 @@
+module Belafonte
+  class Wrapomatic
+    attr_reader :text, :lines, :indents, :columns
+
+    def self.wrap(text, indents = 1, columns = 80)
+      new(text, indents, columns).wrapped
+    end
+
+    def initialize(text, indents = 1, columns = 80)
+      @text = text
+      @indents = indents
+      @columns = columns
+      @lines = []
+      indentomize
+    end
+
+    def refresh(text, indents = 1, columns = 80)
+      @text = text
+      @remainder = ''
+      @lines = []
+      indentomize
+    end
+
+    def wrapped
+      lines.join("\n")
+    end
+
+    private
+
+    def indentomize
+      begin
+        @lines.push(next_line)
+      end until next_line.nil?
+    end
+
+    def next_line
+      return nil if text.length == 0
+      offset + text_up_to(space_before_location(columns - offset.length - 1))
+    end
+
+    def space_before_location(start)
+      return start if start > text.length
+      text.rindex(/(\s|-)/, start) || start
+    end
+
+    def text_up_to(count)
+      text.slice!(0 .. count)
+    end
+
+    def indentation
+      '  '
+    end
+
+    def offset
+      indentation * indents
+    end
+  end
+end

data/lib/belafonte.rb

@@ -0,0 +1,6 @@
+require "belafonte/version"
+require 'belafonte/app'
+
+# An awesome system for making CLI apps
+module Belafonte
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: belafonte
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Dennis Walters
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: 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'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: toady
+  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: 
+email:
+- dwalters@engineyard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- belafonte.gemspec
+- lib/belafonte.rb
+- lib/belafonte/app.rb
+- lib/belafonte/argument.rb
+- lib/belafonte/argument_processor.rb
+- lib/belafonte/dsl.rb
+- lib/belafonte/dsl/class_methods.rb
+- lib/belafonte/dsl/instance_methods.rb
+- lib/belafonte/errors.rb
+- lib/belafonte/flag.rb
+- lib/belafonte/help.rb
+- lib/belafonte/help/app_extensions.rb
+- lib/belafonte/help/command_extensions.rb
+- lib/belafonte/help/flag_extensions.rb
+- lib/belafonte/help/generator.rb
+- lib/belafonte/helpers/tokens.rb
+- lib/belafonte/option.rb
+- lib/belafonte/parser.rb
+- lib/belafonte/switch.rb
+- lib/belafonte/version.rb
+- lib/belafonte/wrapomatic.rb
+homepage: https://github.com/ess/belafonte
+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.4.7
+signing_key: 
+specification_version: 4
+summary: Jump in the command line!
+test_files: []
+has_rdoc: