ggem 1.7.0 → 1.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 9bb7a69fa7315e7512e780ebe935557f2e4b2664
+  data.tar.gz: 8aadfede4196531dc4af409a5856805818065ba3
+SHA512: 
+  metadata.gz: 7f6fe5a9353e8dcc1fb53ab4f3d6115c0d0d53d64f5bd79e4fe47fc85368ba1256916a91d6877ff2f16e62aaa1d4b14038ab98169f4662c3995bcec8ef05421b
+  data.tar.gz: f9dd50efd68643021c9a6ea8780c9f3547c5355905917f54ac66c472bec450627fdb559c3ecc5ad75ad6d1d04604d5913eb5a12ae0a074f2ab6de2a3f1b8a7d6

data/README.md

@@ -1,25 +1,169 @@
 # GGem
 
-Consistantly generate a ruby gem project ready to test, build, and deploy.  Uses and emulates most of Bundler's gem building features.
+A gem utility CLI.
+
+```
+$ cd /my/projects
+$ ggem -h
+Usage: ggem [COMMAND] [options]
+
+Options:
+        --version
+        --help
+
+Commands:
+  generate (g) # Create a gem given a GEM-NAME
+$ ggem generate mygem
+created gem in /my/projects/mygem
+initialized gem git repo
+$ cd mygem/
+$ ggem -h
+Usage: ggem [COMMAND] [options]
+
+Options:
+        --version
+        --help
+
+Commands:
+  generate (g) # Create a gem given a GEM-NAME
+  build    (b) # Build mygem-0.0.1.gem into the pkg directory
+  install  (i) # Build and install mygem-0.0.1.gem into system gems
+  push     (p) # Push built mygem-0.0.1.gem to https://rubygems.org
+  tag      (t) # Tag v0.0.1 and push git commits/tags
+  release  (r) # Tag v0.0.1 and push built mygem-0.0.1.gem to https://rubygems.org
+```
 
 ## Usage
 
+### Generate
+
 ```
-$ ggem --help
-$ ggem my-gem
+$ ggem generate -h
+Usage: ggem generate [options] GEM-NAME
+
+Options:
+        --version
+        --help
+
+Description:
+  Create a gem given a GEM-NAME
+$ ggem generate mygem
 $ git commit -m "Gem created with ggem"
 ```
 
-GGem creates a folder and files for developing, testing, and releasing a gem.  It is safe to run on existing gem folders, adding/overwriting where necessary.
-
-## Features
+The `generate` command creates a folder and files for developing, testing, and releasing a gem.  It is safe to run on existing gem folders, adding/overwriting where necessary.
 
 * creates `lib` and gem files similar to `bundle gem` (as of Bundler 1.2.4)
 * creates `test` files
-* source control using Git
-* test using Assert
-* release using Bundler
 * adds `TODO` entries in files where user input is needed
+* source control using [Git](https://git-scm.com/)
+* test using [Assert](https://github.com/redding/assert)
+
+You can also call this command using the `g` alias: `ggem g -h`.
+
+### Build
+
+```
+$ ggem build -h
+Usage: ggem build [options]
+
+Options:
+        --version
+        --help
+
+Description:
+  Build mygem-0.0.1.gem into the pkg directory
+```
+
+The `build` command creates a .gem file and copies it into the `pkg/` directory.  You can also call this command using the `b` alias: `ggem b -h`.
+
+### Install
+
+```
+$ ggem install -h
+Usage: ggem install [options]
+
+Options:
+        --version
+        --help
+
+Description:
+  Build and install mygem-0.0.1.gem into system gems
+```
+
+The `install` command first builds a .gem file and then installs it.  The command is the equivalent of running `ggem build && gem install pkg/mygem-0.0.1.gem`.  You can also call this command using the `i` alias: `ggem i -h`.
+
+### Push
+
+```
+Usage: ggem push [options]
+
+Options:
+        --version
+        --help
+
+Description:
+  Push built mygem-0.0.1.gem to https://rubygems.org
+```
+
+The `push` command first builds a .gem file and then pushes it to a gem host.  The command is the equivalent of running `ggem build && gem push pkg/mygem-0.0.1.gem --source https://rubygems.org`.  You can also call this command using the `p` alias: `ggem p -h`.
+
+#### Using a custom gem host
+
+To override the default `https://rubygems.org` push host, add a metadata entry to the .gemspec file:
+
+```ruby
+# ...
+gem.metadata['allowed_push_host'] = "https://gems.example.com"
+# ...
+```
+
+Now GGem will now use the allowed push host when pushing/releasing the gem.
+
+```
+$ ggem push -h
+Usage: ggem push [options]
+
+Options:
+        --version
+        --help
+
+Description:
+  Push built mygem-0.0.1.gem to https://gems.example.com
+```
+
+### Tag
+
+```
+$ ggem tag -h
+Usage: ggem tag [options]
+
+Options:
+        --version
+        --help
+
+Description:
+  Tag v0.0.1 and push git commits/tags
+```
+
+The `tag` command will tag the current git commit with the `version` data from the .gemspec file.  It then pushes any commits and tags.  The command is the equivalent of running `git tag -a -m "Version {version}" v{version} && git push && git push --tags`.  You can also call this command using the `t` alias: `ggem t -h`.
+
+### Release
+
+```
+$ ggem release -h
+Usage: ggem release [options]
+
+Options:
+        --version
+        --help
+
+Description:
+  Tag v0.0.1 and push built mygem-0.0.1.gem to https://rubygems.org
+  (macro for running `ggem tag && ggem push`)
+```
+
+As the help message says, this command is just a macro for running `ggem tag && ggem push`.  You can also call this command using the `r` alias: `ggem r -h`.
 
 ## Installation
 

data/bin/ggem

@@ -4,4 +4,4 @@
 #
 
 require 'ggem/cli'
-GGem::CLI.run *ARGV
+GGem::CLI.run ARGV

data/ggem.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version     = GGem::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.description = %q{"Juh Gem", baby! (a generator of gems this is)}
-  gem.summary     = %q{"Juh Gem", baby! (a generator of gems this is)}
+  gem.description = %q{"Juh Gem", baby! (a gem utility CLI)}
+  gem.summary     = %q{"Juh Gem", baby! (a gem utility CLI)}
   gem.homepage    = "http://github.com/redding/ggem"
   gem.license     = 'MIT'
 
@@ -18,6 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.15"])
+  gem.add_development_dependency("assert", ["~> 2.15.0"])
+
+  gem.add_dependency("much-plugin", ["~> 0.1.0"])
+  gem.add_dependency("scmd",        ["~> 3.0.1"])
 
 end

data/lib/ggem/cli.rb

@@ -1,106 +1,63 @@
-require 'ggem'
 require 'ggem/version'
+require 'ggem/cli/clirb'
+require 'ggem/cli/commands'
 
 module GGem
 
   class CLI
 
-    def self.run(*args)
-      self.new.run(*args)
+    COMMANDS = CommandSet.new{ |unknown| InvalidCommand.new(unknown) }.tap do |c|
+      c.add(GenerateCommand, 'generate', 'g')
+      c.add(BuildCommand,    'build',    'b')
+      c.add(InstallCommand,  'install',  'i')
+      c.add(PushCommand,     'push',     'p')
+      c.add(TagCommand,      'tag',      't')
+      c.add(ReleaseCommand,  'release',  'r')
     end
 
-    def initialize
-      @cli = CLIRB.new do
-        option 'debug', 'run in debug mode'
-      end
+    def self.run(args)
+      self.new.run(args)
     end
 
-    def run(*args)
-      begin
-        # parse manually in the case that parsing fails before the debug arg
-        debug_mode ||= args.include?('-d') || args.include?('--debug')
-        @cli.parse!(args)
-        raise CLIRB::Error, "please provide a gem name" if @cli.args.size < 1
+    def initialize(kernel = nil, stdout = nil, stderr = nil)
+      @kernel = kernel || Kernel
+      @stdout = stdout || $stdout
+      @stderr = stderr || $stderr
+    end
 
-        path = GGem::Gem.new(Dir.pwd, *args).save!.path
-        puts "created gem and initialized git repo in #{path}"
+    def run(args)
+      begin
+        cmd_name = args.shift
+        cmd = COMMANDS[cmd_name]
+        cmd.run(args)
       rescue CLIRB::HelpExit
-        puts help
+        @stdout.puts cmd.help
       rescue CLIRB::VersionExit
-        puts GGem::VERSION
-      rescue CLIRB::Error => exception
-        puts "#{exception.message}\n\n"
-        puts  debug_mode ? exception.backtrace.join("\n") : help
-        exit(1)
-      rescue Exception => exception
-        puts "#{exception.class}: #{exception.message}"
-        puts exception.backtrace.join("\n") if debug_mode
-        exit(1)
+        @stdout.puts GGem::VERSION
+      rescue CLIRB::Error, ArgumentError, InvalidCommandError => exception
+        display_debug(exception)
+        @stderr.puts "#{exception.message}\n\n"
+        @stdout.puts cmd.help
+        @kernel.exit 1
+      rescue CommandExitError
+        @kernel.exit 1
+      rescue StandardError => exception
+        @stderr.puts "#{exception.class}: #{exception.message}"
+        @stderr.puts exception.backtrace.join("\n")
+        @kernel.exit 1
       end
-      exit(0)
+      @kernel.exit 0
     end
 
-    def help
-      "Usage: ggem GEM-NAME\n\n"\
-      "Options:"\
-      "#{@cli}"
-    end
+    private
 
-  end
-
-  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
-    Error    = Class.new(RuntimeError);
-    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
-    attr_reader :argv, :args, :opts, :data
-
-    def initialize(&block)
-      @options = []; instance_eval(&block) if block
-      require 'optparse'
-      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
-        p.banner = ''; @options.each do |o|
-          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
-        end
-        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
-        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+    def display_debug(exception)
+      if ENV['DEBUG']
+        @stderr.puts "#{exception.class}: #{exception.message}"
+        @stderr.puts exception.backtrace.join("\n")
       end
     end
 
-    def option(*args); @options << Option.new(*args); end
-    def parse!(argv)
-      @args = (argv || []).dup.tap do |args_list|
-        begin; @parser.parse!(args_list)
-        rescue OptionParser::ParseError => err; raise Error, err.message; end
-      end; @data = @args + [@opts]
-    end
-    def to_s; @parser.to_s; end
-    def inspect
-      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
-    end
-
-    class Option
-      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
-
-      def initialize(name, *args)
-        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
-        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
-        @value, @klass = gvalinfo(settings[:value])
-        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
-          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
-        else
-          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
-        end
-      end
-
-      private
-
-      def parse_name_values(name, custom_abbrev)
-        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
-          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
-        ]
-      end
-      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
-      def gklass(k); k == Fixnum ? Integer : k; end
-    end
   end
 
 end

data/lib/ggem/cli/clirb.rb

@@ -0,0 +1,59 @@
+module GGem; end
+class GGem::CLI
+
+  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+    Error    = Class.new(RuntimeError);
+    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
+    attr_reader :argv, :args, :opts, :data
+
+    def initialize(&block)
+      @options = []; instance_eval(&block) if block
+      require 'optparse'
+      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
+        p.banner = ''; @options.each do |o|
+          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
+        end
+        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
+        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+      end
+    end
+
+    def option(*args); @options << Option.new(*args); end
+    def parse!(argv)
+      @args = (argv || []).dup.tap do |args_list|
+        begin; @parser.parse!(args_list)
+        rescue OptionParser::ParseError => err; raise Error, err.message; end
+      end; @data = @args + [@opts]
+    end
+    def to_s; @parser.to_s; end
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+    end
+
+    class Option
+      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
+
+      def initialize(name, *args)
+        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
+        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
+        @value, @klass = gvalinfo(settings[:value])
+        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
+          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
+        else
+          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+        end
+      end
+
+      private
+
+      def parse_name_values(name, custom_abbrev)
+        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
+        ]
+      end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
+      def gklass(k); k == Fixnum ? Integer : k; end
+    end
+  end
+
+end

data/lib/ggem/cli/commands.rb

@@ -0,0 +1,402 @@
+require 'ggem/cli/clirb'
+require 'much-plugin'
+
+module GGem; end
+class GGem::CLI
+
+  InvalidCommandError = Class.new(ArgumentError)
+  CommandExitError    = Class.new(RuntimeError)
+
+  class InvalidCommand
+
+    attr_reader :name, :clirb
+
+    def initialize(name)
+      @name  = name
+      @clirb = CLIRB.new
+    end
+
+    def new; self; end
+
+    def run(argv)
+      @clirb.parse!([@name, argv].flatten.compact)
+      raise CLIRB::HelpExit if @name.to_s.empty?
+      raise InvalidCommandError, "'#{self.name}' is not a command."
+    end
+
+    def help
+      "Usage: ggem [COMMAND] [options]\n\n" \
+      "Options: #{@clirb}\n" \
+      "Commands:\n" \
+      "#{COMMANDS.to_s.split("\n").map{ |l| "  #{l}" }.join("\n")}\n"
+    end
+
+  end
+
+  module ValidCommand
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      def initialize
+        @clirb  = CLIRB.new
+      end
+
+      def clirb; @clirb; end
+
+      def run(argv, stdout = nil, stderr = nil)
+        @clirb.parse!(argv)
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+      end
+
+      def summary
+        ''
+      end
+
+    end
+
+  end
+
+  module NotifyCmdCommand
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      private
+
+      def notify(success_msg, &cmd_block)
+        cmd(&cmd_block)
+        @stdout.puts success_msg
+      end
+
+      def cmd(&cmd_block)
+        cmd, status, output = cmd_block.call
+        if ENV['DEBUG']
+          @stdout.puts cmd
+          @stdout.puts output
+        end
+      end
+
+    end
+
+  end
+
+  module GitRepoCommand
+    include MuchPlugin
+
+    plugin_included do
+      include ValidCommand
+      include NotifyCmdCommand
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+      def initialize(*args)
+        super
+
+        require 'ggem/git_repo'
+        @repo = GGem::GitRepo.new(Dir.pwd)
+      end
+
+      private
+
+      def notify(*args, &block)
+        begin
+          super
+        rescue GGem::GitRepo::CmdError => exception
+          @stderr.puts exception.message
+          raise CommandExitError
+        end
+      end
+
+    end
+  end
+
+  class GenerateCommand
+    include GitRepoCommand
+
+    def run(argv, *args)
+      super
+
+      begin
+        require 'ggem/gem'
+        path = GGem::Gem.new(Dir.pwd, @clirb.args.first).save!.path
+        @stdout.puts "created gem in #{path}"
+      rescue GGem::Gem::NoNameError => exception
+        error = ArgumentError.new("GEM-NAME must be provided")
+        error.set_backtrace(exception.backtrace)
+        raise error
+      end
+
+      @repo = GGem::GitRepo.new(path)
+      notify("initialized gem git repo"){ @repo.run_init_cmd }
+    end
+
+    def summary
+      "Create a gem given a GEM-NAME"
+    end
+
+    def help
+      "Usage: ggem generate [options] GEM-NAME\n\n" \
+      "Options: #{@clirb}\n" \
+      "Description:\n" \
+      "  #{self.summary}"
+    end
+
+  end
+
+  module GemspecCommand
+    include MuchPlugin
+
+    plugin_included do
+      include ValidCommand
+      include NotifyCmdCommand
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+      def initialize(*args)
+        super
+
+        require 'ggem/gemspec'
+        begin
+          @spec = GGem::Gemspec.new(Dir.pwd)
+        rescue GGem::Gemspec::NotFoundError => exception
+          error = ArgumentError.new("There are no gemspecs at #{Dir.pwd}")
+          error.set_backtrace(exception.backtrace)
+          raise error
+        end
+      end
+
+      private
+
+      def notify(*args, &block)
+        begin
+          super
+        rescue GGem::Gemspec::CmdError => exception
+          @stderr.puts exception.message
+          raise CommandExitError
+        end
+      end
+
+    end
+  end
+
+  class BuildCommand
+    include GemspecCommand
+
+    def run(argv, *args)
+      super
+      notify("#{@spec.name} #{@spec.version} built to #{@spec.gem_file}") do
+        @spec.run_build_cmd
+      end
+    end
+
+    def summary
+      "Build #{@spec.gem_file_name} into the " \
+      "#{GGem::Gemspec::BUILD_TO_DIRNAME} directory"
+    end
+
+    def help
+      "Usage: ggem build [options]\n\n" \
+      "Options: #{@clirb}\n" \
+      "Description:\n" \
+      "  #{self.summary}"
+    end
+
+  end
+
+  class InstallCommand
+    include GemspecCommand
+
+    def initialize(*args)
+      super
+      @build_command = BuildCommand.new(*args)
+    end
+
+    def run(argv, *args)
+      super
+      @build_command.run(argv)
+      notify("#{@spec.name} #{@spec.version} installed to system gems") do
+        @spec.run_install_cmd
+      end
+    end
+
+    def summary
+      "Build and install #{@spec.gem_file_name} into system gems"
+    end
+
+    def help
+      "Usage: ggem install [options]\n\n" \
+      "Options: #{@clirb}\n" \
+      "Description:\n" \
+      "  #{self.summary}"
+    end
+
+  end
+
+  class PushCommand
+    include GemspecCommand
+
+    def initialize(*args)
+      super
+      @build_command = BuildCommand.new(*args)
+    end
+
+    def run(argv, *args)
+      super
+      @build_command.run(argv)
+
+      @stdout.puts "Pushing #{@spec.gem_file_name} to #{@spec.push_host}..."
+      notify("#{@spec.gem_file_name} received.") do
+        @spec.run_push_cmd
+      end
+    end
+
+    def summary
+      "Push built #{@spec.gem_file_name} to #{@spec.push_host}"
+    end
+
+    def help
+      "Usage: ggem push [options]\n\n" \
+      "Options: #{@clirb}\n" \
+      "Description:\n" \
+      "  #{self.summary}"
+    end
+
+  end
+
+  class TagCommand
+    include GitRepoCommand
+    include GemspecCommand
+
+    def run(argv, *args)
+      super
+
+      begin
+        cmd{ @repo.run_validate_clean_cmd }
+        cmd{ @repo.run_validate_committed_cmd }
+      rescue GGem::GitRepo::CmdError => err
+        @stderr.puts "There are files that need to be committed first."
+        raise CommandExitError
+      end
+
+      cmd{ @repo.run_add_version_tag_cmd(@spec.version, @spec.version_tag) }
+
+      @stdout.puts "Tagged #{@spec.version_tag}."
+
+      begin
+        cmd{ @repo.run_push_cmd }
+      rescue
+        cmd{ @repo.run_rm_tag_cmd(@spec.version_tag) }
+        raise
+      end
+
+      @stdout.puts "Pushed git commits and tags."
+    rescue GGem::GitRepo::CmdError => err
+      @stderr.puts err.message
+      raise CommandExitError
+    end
+
+    def summary
+      "Tag #{@spec.version_tag} and push git commits/tags"
+    end
+
+    def help
+      "Usage: ggem tag [options]\n\n" \
+      "Options: #{@clirb}\n" \
+      "Description:\n" \
+      "  #{self.summary}"
+    end
+
+  end
+
+  class ReleaseCommand
+    include GemspecCommand
+
+    def initialize(*args)
+      super
+      @tag_command  = TagCommand.new(*args)
+      @push_command = PushCommand.new(*args)
+    end
+
+    def run(argv, *args)
+      super
+      @tag_command.run(argv)
+      @push_command.run(argv)
+    end
+
+    def summary
+      "Tag #{@spec.version_tag} and push built #{@spec.gem_file_name} to " \
+      "#{@spec.push_host}"
+    end
+
+    def help
+      "Usage: ggem release [options]\n\n" \
+      "Options: #{@clirb}\n" \
+      "Description:\n" \
+      "  #{self.summary}\n" \
+      "  (macro for running `ggem tag && ggem push`)"
+    end
+
+  end
+
+  class CommandSet
+
+    def initialize(&unknown_cmd_block)
+      @lookup    = Hash.new{ |h,k| unknown_cmd_block.call(k) }
+      @names     = []
+      @aliases   = {}
+      @summaries = {}
+    end
+
+    def add(klass, name, *aliases)
+      begin
+        cmd = klass.new
+      rescue StandardError => err
+        # don't add any commands you can't init
+      else
+        ([name] + aliases).each{ |n| @lookup[n] = cmd }
+        @to_s = nil
+        @names << name
+        @aliases[name] = aliases.empty? ? '' : "(#{aliases.join(', ')})"
+        @summaries[name] = cmd.summary.to_s.empty? ? '' : "# #{cmd.summary}"
+      end
+    end
+
+    def remove(name)
+      @lookup.delete(name)
+      @names.delete(name)
+      @aliases.delete(name)
+      @to_s = nil
+    end
+
+    def [](name)
+      @lookup[name]
+    end
+
+    def size
+      @names.size
+    end
+
+    def to_s
+      max_name_size  = @names.map{ |n| n.size }.max || 0
+      max_alias_size = @aliases.values.map{ |v| v.size }.max || 0
+
+      @to_s ||= @names.map do |n|
+        "#{n.ljust(max_name_size)} #{@aliases[n].ljust(max_alias_size)} #{@summaries[n]}"
+      end.join("\n")
+    end
+
+  end
+
+end