Ame
Ame provides a simple command-line interface API for Ruby. It can be used
to provide both simple interfaces like that of rm
and complex ones like
that of git
. It uses Ruby’s own classes, methods, and argument lists to
provide an interface that is both simple to use from the command-line side
and from the Ruby side. The provided command-line interface is flexible and
follows commond standards for command-line processing.
Usage
Let’s begin by looking at two examples, one where we mimic the POSIX
command-line interface to the rm
command. Looking at the entry in the
standard, rm
takes the following options:
- -f
-
Do not prompt for confirmation.
- -i
-
Prompt for confirmation.
- -R
-
Remove file hierarchies.
- -r
-
Equivalent to -r.
It also takes the following arguments:
- FILE
-
A pathname or directory entry to be removed.
And actually allows one or more of these FILE arguments to be given.
We also note that the rm
command is described as a command to “remove
directory entries”.
Let’s turn this specification into one using Ame’s API. We begin by adding a flag for each of the options listed above:
class Rm < Ame::Root
flag 'f', '', false, 'Do not prompt for confirmation'
flag 'i', '', nil, 'Prompt for confirmation' do |options|
options['f'] = false
end
flag 'R', '', false, 'Remove file hierarchies'
flag 'r', '', nil, 'Equivalent to -R' do |options|
options['r'] = true
end
A flag is a boolean option that doesn’t take an argument. Each flag gets a short and long name, where an empty name means that there’s no corresponding short or long name for the flag, a default value (true, false, or nil), and a description of what the flag does. Each flag can also optionally take a block that can do further processing. In this case we use this block to modify the Hash that maps option names to their values passed to the block to set other flags’ values than the ones that the block is associated with. As these flags (‘i’ and ‘r’) aren’t themselves of interest, their default values have been set to nil, which means that they won’t be included in the Hash that maps option names to their values when passed to the method.
There are quite a few other kinds of options besides flags that can be defined using Ame, but flags are all that are required for this example. We’ll get to the other kinds in later examples.
Next we add a “splus” argument.
splus 'FILE', String, 'File to remove'
A splus argument is like a Ruby “splat”, that is, an Array argument at the
end of the argument list to a method preceded by a star, except that a
splus requires at least one argument. A splus argument gets a name for the
argument (FILE
), the type of argument it represents (String), and a
description.
Then we add a description of the command (method) itself:
description 'Remove directory entries'
Descriptions will be used in help output to assist the user in using the command.
Finally, we add the Ruby method that’ll implement the command (all preceding code included here for completeness):
class Rm < Ame::Root
version '1.0.0'
flag 'f', '', false, 'Do not prompt for confirmation'
flag 'i', '', nil, 'Prompt for confirmation' do |options|
options['f'] = false
end
flag 'R', '', false, 'Remove file hierarchies'
flag 'r', '', nil, 'Equivalent to -R' do |options|
options['r'] = true
end
splus 'FILE', String, 'File to remove'
description 'Remove directory entries'
def rm(files, options = {})
require 'fileutils'
FileUtils.send options['R'] ? :rm_r : :rm,
[first] + rest, :force => options['f']
end
end
Actually, another bit of code was also added, namely
version '1.0.0'
This sets the version String of the command. This information is used
when the command is invoked with the “--version
” flag. This flag is
automatically added, so you don’t need to add it yourself. Another flag,
“--help
”, is also added automatically. When given, this flag’ll make Ame
output usage information of the command.
To actually run the command, all you need to do is invoke
Rm.process
This’ll invoke the command using the command-line arguments stored in
ARGV
, but you can also specify other ones if you want to:
Rm.process 'rm', %w[-r /tmp/*]
The first argument to #process is the name of the method to invoke, which
defaults to File.basename($0)
, and the second argument is an Array of
Strings that should be processed as command-line arguments passed to the
command.
If you’d store the complete Rm
class defined above in a file called rm
and add #! /usr/bin/ruby -w
at the beginning and Rm.process
at the end,
you’d have a fully functional rm
command (after making it executable).
Let’s see it in action:
% rm --help
Usage: rm [OPTIONS]... FILE...
Remove directory entries
Arguments:
FILE... File to remove
Options:
-R Remove file hierarchies
-f Do not prompt for confirmation
--help Display help for this method
-i Prompt for confirmation
-r Equivalent to -R
--version Display version information
% rm --version
rm 1.0.0
Some commands are more complex than rm
. For example, git
has a rather
complex command-line interface. We won’t mimic it all here, but let’s
introduce the rest of the Ame API using a fake git
clone as an example.
Git
uses sub-commands to achieve most things. Implementing sub-commands
with Ame is done using a “dispatch”. We’ll discuss dispatches in more
detail later, but suffice it to say that a dispatch delegates processing to
a child class that’ll handle the sub-command in question. We begin by
defining our main git
command using a class called Git
under the
Git::CLI
namespace:
module Git end
class Git::CLI < Ame::Root
version '1.0.0'
class Git < Ame::Class
description 'The stupid content tracker'
def initialize; end
We’re setting things up to use the Git
class as a dispatch in the
Git::CLI
class. The description on the initialize
method will be used
as a description of the git
dispatch command itself.
Next, let’s add the format-patch
sub-command:
description 'Prepare patches for e-mail submission'
flag ?n, 'numbered', false, 'Name output in [PATCH n/m] format'
flag ?N, 'no-numbered', nil,
'Name output in [PATCH] format' do |options|
options['numbered'] = false
end
toggle ?s, 'signoff', false,
'Add Signed-off-by: line to the commit message'
switch '', 'thread', 'STYLE', nil,
Ame::Types::Enumeration[:shallow, :deep],
'Controls addition of In-Reply-To and References headers'
flag '', 'no-thread', nil,
'Disables addition of In-Reply-To and Reference headers' do |options, _|
options.delete 'thread'
end
option '', 'start-number', 'N', 1,
'Start numbering the patches at N instead of 1'
multioption '', 'to', 'ADDRESS', String,
'Add a To: header to the email headers'
optional 'SINCE', 'N/A', 'Generate patches for commits after SINCE'
def format_patch(since = '', options = {})
p since, options
end
We’re using quite a few new Ame commands here. Let’s look at each in turn:
toggle ?s, 'signoff', false,
'Add Signed-off-by: line to the commit message'
A “toggle” is a flag that also has an inverse. Beyond the flags ‘s’ and “signoff”, the toggle also defines “no-signoff”, which will set “signoff” to false. This is useful if you want to support configuration files that set “signoff”’s default to true, but still allow it to be overridden on the command line.
When using the short form of a toggle (and flag and switch), multiple ones
may be juxtaposed after the initial one. For example, “-sn
” is
equivalent to “-s -n
” to “git format-patch›”.
switch '', 'thread', 'STYLE', nil,
Ame::Types::Enumeration[:shallow, :deep],
'Controls addition of In-Reply-To and References headers'
A “switch” is an option that takes an optional argument. This allows you
to have separate defaults for when the switch isn’t present on the command
line and for when it’s given without an argument. The third argument to a
switch is the name of the argument. We’re also introducing a new concept
here in Ame::Types::Enumeration
. An enumeration allows you to limit the
allowed input to a set of Symbols. An enumeration also has a default value
in the first item to its constructor (which is aliased as .[]
). In this
case, the “thread” switch defaults to nil, but, when given, will default to
:shallow
if no argument is given. If an argument is given it must be
either “shallow” or “deep”. A switch isn’t required to take an enumeration
as its argument default and can take any kind of default value for its
argument that Ame knows how to handle. We’ll look at this in more detail
later, but know that the type of the default value will be used to inform
Ame how to parse a command-line argument into a Ruby value.
An argument to a switch must be given, in this case, as “--thread=deep
”
on the command line.
option '', 'start-number', 'N', 1,
'Start numbering the patches at N instead of 1'
An “option” is an option that takes an argument. The argument must always
be present and may be given, in this case, as “--start-number=2
” or
“--start-number 2
” on the command line. For a short-form option,
anything that follows the option is seen as an argument, so assuming that
“start-number” also had a short name of ‘S’, “-S2
” would be equivalent to
“-S 2
”, which would be equivalent to “--start-number 2
”. Note that
“-snS2
” would still work as expected.
multioption '', 'to', 'ADDRESS', String,
'Add a To: header to the email headers'
A “multioption” is an option that takes an argument and may be repeated any number of times. Each argument will be added to an Array stored in the Hash that maps option names to their values. Instead of taking a default argument, it takes a type for the argument (String, in this case). Again, types are used to inform Ame how to parse command-line arguments into Ruby values.
optional 'SINCE', 'N/A', 'Generate patches for commits after SINCE'
An “optional” argument is an argument that isn’t required. If it’s not
present on the command line it’ll get its default value (the String
'N/A'
, in this case).
We’ve now covered all kinds of options and one new kind of argument. There are three more types of argument (one that we’ve already seen and two new) that we’ll look into now: “argument”, “splat”, and “splus”.
description 'Annotate file lines with commit information'
argument 'FILE', String, 'File to annotate'
def annotate(file)
p file
end
An “argument” is an argument that’s required. If it’s not present on the command line, an error will be raised (and by default reported to the terminal). As it’s required, it doesn’t take a default, but rather a type.
description 'Add file contents to the index'
splat 'PATHSPEC', String, 'Files to add content from'
def add(paths)
p paths
end
A “splat” is an argument that’s not required, but may be given any number of times. The type of a splat is the type of one argument and the type of a splat as a whole is an Array of values of that type.
description 'Display gitattributes information'
splus 'PATHNAME', String, 'Files to list attributes of'
def check_attr(paths)
p paths
end
A “splus” is an argument that’s required, but may also be given any number of times. The type of a splus is the type of one argument and the type of a splus as a whole is an Array of values of that type.
Now that we’ve seen all kinds of options and arguments, let’s look on an additional tool at our disposal, the dispatch.
class Remote < Ame::Class
description 'Manage set of remote repositories'
def initialize; end
description 'Shows a list of existing remotes'
flag 'v', 'verbose', false, 'Show remote URL after name'
def list(options = {})
p options
end
description 'Adds a remote named NAME for the repository at URL'
argument 'name', String, 'Name of the remote to add'
argument 'url', String, 'URL to the repository of the remote to add'
def add(name, url)
p name, url
end
end
Here we’re defining a child class to Git::CLI::Git called “Remote” that doesn’t introduce anything new. Then we set up the dispatch:
dispatch Remote, :default => 'list'
This adds a method called “remote” to Git::CLI::Git that will dispatch
processing of the command line to an instance of the Remote class when
“git remote
” is seen on the command line. The “remote” method expects an
argument that’ll be used to decide what sub-command to execute. Here we’ve
specified that in the absence of such an argument, the “list” method should
be invoked.
We add the same kind of dispatch to Git under Git::CLI:
dispatch Git
and then we’re done. Here’s all the previous code in its entirety:
module Git end
class Git::CLI < Ame::Root
version '1.0.0'
class Git < Ame::Class
description 'The stupid content tracker'
def initialize; end
description 'Prepare patches for e-mail submission'
flag ?n, 'numbered', false, 'Name output in [PATCH n/m] format'
flag ?N, 'no-numbered', nil,
'Name output in [PATCH] format' do |options|
options['numbered'] = false
end
toggle ?s, 'signoff', false,
'Add Signed-off-by: line to the commit message'
switch '', 'thread', 'STYLE', nil,
Ame::Types::Enumeration[:shallow, :deep],
'Controls addition of In-Reply-To and References headers'
flag '', 'no-thread', nil,
'Disables addition of In-Reply-To and Reference headers' do |options, _|
options.delete 'thread'
end
option '', 'start-number', 'N', 1,
'Start numbering the patches at N instead of 1'
multioption '', 'to', 'ADDRESS', String,
'Add a To: header to the email headers'
optional 'SINCE', 'N/A', 'Generate patches for commits after SINCE'
def format_patch(since = '', options = {})
p since, options
end
description 'Annotate file lines with commit information'
argument 'FILE', String, 'File to annotate'
def annotate(file)
p file
end
description 'Add file contents to the index'
splat 'PATHSPEC', String, 'Files to add content from'
def add(paths)
p paths
end
description 'Display gitattributes information'
splus 'PATHNAME', String, 'Files to list attributes of'
def check_attr(paths)
p paths
end
class Remote < Ame::Class
description 'Manage set of remote repositories'
def initialize; end
description 'Shows a list of existing remotes'
flag 'v', 'verbose', false, 'Show remote URL after name'
def list(options = {})
p options
end
description 'Adds a remote named NAME for the repository at URL'
argument 'name', String, 'Name of the remote to add'
argument 'url', String, 'URL to the repository of the remote to add'
def add(name, url)
p name, url
end
end
dispatch Remote, :default => 'list'
end
dispatch Git
end
If we put this code in a file called “git” and add #! /usr/bin/ruby -w
at
the beginning and Git::CLI.process
at the end, you’ll have a very
incomplete git command-line interface on your hands. Let’s look at what
some of its --help
output looks like:
% git --help
Usage: git [OPTIONS]... METHOD [ARGUMENTS]...
The stupid content tracker
Arguments:
METHOD Method to run
[ARGUMENTS]... Arguments to pass to METHOD
Options:
--help Display help for this method
--version Display version information
Methods:
add Add file contents to the index
annotate Annotate file lines with commit information
check-attr Display gitattributes information
format-patch Prepare patches for e-mail submission
remote Manage set of remote repositories
% git format-patch --help
Usage: git format-patch [OPTIONS]... [SINCE]
Prepare patches for e-mail submission
Arguments:
[SINCE=N/A] Generate patches for commits after SINCE
Options:
-N, --no-numbered Name output in [PATCH] format
--help Display help for this method
-n, --numbered Name output in [PATCH n/m] format
--no-thread Disables addition of In-Reply-To and Reference headers
-s, --signoff Add Signed-off-by: line to the commit message
--start-number=N Start numbering the patches at N instead of 1
--thread[=STYLE] Controls addition of In-Reply-To and References headers
--to=ADDRESS* Add a To: header to the email headers
% git remote --help
Usage: git remote [OPTIONS]... [METHOD] [ARGUMENTS]...
Manage set of remote repositories
Arguments:
[METHOD=list] Method to run
[ARGUMENTS]... Arguments to pass to METHOD
Options:
--help Display help for this method
Methods:
add Adds a remote named NAME for the repository at URL
list Shows a list of existing remotes
API
The previous section gave an introduction to the whole user API in an informal and introductory way. For an indepth reference to the user API, see the user API documentation.
If you want to extend the API or use it in some way other than as a command-line-interface writer, see the developer API documentation.
Financing
Currently, most of my time is spent at my day job and in my rather busy private life. Please motivate me to spend time on this piece of software by donating some of your money to this project. Yeah, I realize that requesting money to develop software is a bit, well, capitalistic of me. But please realize that I live in a capitalistic society and I need money to have other people give me the things that I need to continue living under the rules of said society. So, if you feel that this piece of software has helped you out enough to warrant a reward, please PayPal a donation to now@disu.se. Thanks! Your support won’t go unnoticed!
Reporting Bugs
Please report any bugs that you encounter to the issue tracker.
Licensing
Ame is free software: you may redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 3 or later, as published by the Free Software Foundation.