cmdparse 2.0.5 → 2.0.6

data/test/tc_commandhash.rb

@@ -0,0 +1,96 @@
+require 'minitest/autorun'
+require 'cmdparse'
+
+class CommandHashTest < Minitest::Test
+  def setup
+    @cmd = CmdParse::CommandHash.new
+  end
+
+  def test_basic
+    assert_equal 0, @cmd.size
+    assert_nil @cmd['import']
+    @cmd['import'] = 1
+    assert_equal 1, @cmd['import']
+    assert_equal 1, @cmd['i']
+    assert_equal 1, @cmd['im']
+    assert_equal 1, @cmd['imp']
+    assert_equal 1, @cmd['impo']
+    assert_equal 1, @cmd['impor']
+    assert_nil @cmd['importer']
+
+    @cmd['implode'] = 2
+    assert_equal 2, @cmd.size
+
+    assert_equal 1, @cmd['import']
+    assert_equal 2, @cmd['implode']
+    assert_nil @cmd['impart']
+
+    assert_nil @cmd['i']
+    assert_nil @cmd['im']
+    assert_nil @cmd['imp']
+    assert_equal 1, @cmd['impo']
+    assert_equal 1, @cmd['impor']
+    assert_equal 1, @cmd['import']
+    assert_equal 2, @cmd['implo']
+    assert_equal 2, @cmd['implod']
+    assert_equal 2, @cmd['implode']
+  end
+
+  def test_edge_cases
+    @cmd['import'] = 1
+    @cmd['important'] = 2
+
+    assert_equal 1, @cmd['import']
+    assert_equal 2, @cmd['important']
+    assert_nil @cmd['i']
+    assert_nil @cmd['im']
+    assert_nil @cmd['imp']
+    assert_nil @cmd['impo']
+    assert_nil @cmd['impor']
+    assert_equal 2, @cmd['importa']
+    assert_equal 2, @cmd['importan']
+
+    assert_nil @cmd['impart']
+  end
+
+  def test_integration
+    # define and setup the commands
+    cmd = CmdParse::CommandParser.new(handle_exceptions = false)
+    cmd.main_command.use_partial_commands( true )
+    Object.const_set(:ImportCommand, Class.new(CmdParse::Command) do
+      def initialize() super('import', false) end
+      def execute(args) raise 'import' end
+      def show_help() raise 'import' end
+    end)
+    Object.const_set(:ImpolodeCommand, Class.new(CmdParse::Command) do
+      def initialize() super('implode', false) end
+      def execute(args) raise 'implode' end
+      def show_help() raise 'implode' end
+    end)
+    cmd.add_command( ImportCommand.new )
+    cmd.add_command( ImpolodeCommand.new )
+
+    # simulate running the program
+    assert_raises(RuntimeError, 'import') {cmd.parse(['import'])}
+    assert_raises(RuntimeError, 'implode') {cmd.parse(['implode'])}
+    assert_raises(CmdParse::InvalidCommandError) {cmd.parse(['impart'])}
+
+    assert_raises(CmdParse::InvalidCommandError) {cmd.parse(['i'])}
+    assert_raises(CmdParse::InvalidCommandError) {cmd.parse(['im'])}
+    assert_raises(CmdParse::InvalidCommandError) {cmd.parse(['imp'])}
+    assert_raises(RuntimeError, 'import') {cmd.parse(['impo'])}
+    assert_raises(RuntimeError, 'import') {cmd.parse(['impor'])}
+    assert_raises(RuntimeError, 'implode') {cmd.parse(['impl'])}
+    assert_raises(RuntimeError, 'implode') {cmd.parse(['implo'])}
+    assert_raises(RuntimeError, 'implode') {cmd.parse(['implod'])}
+
+    # simulate the help command
+    cmd.add_command( CmdParse::HelpCommand.new )
+    assert_raises(RuntimeError, 'import') {cmd.parse(['help', 'import'])}
+    assert_raises(RuntimeError, 'implode') {cmd.parse(['help', 'implode'])}
+
+    cmd.main_command.use_partial_commands( false )
+    assert_raises(CmdParse::InvalidCommandError, 'import') {cmd.parse(['impo'])}
+    assert_raises(CmdParse::InvalidCommandError, 'implode') {cmd.parse(['impl'])}
+  end
+end

metadata

@@ -1,71 +1,67 @@
 --- !ruby/object:Gem::Specification
 name: cmdparse
 version: !ruby/object:Gem::Version
-  version: 2.0.5
-  prerelease: 
+  version: 2.0.6
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: cmdparse
 bindir: bin
 cert_chain: []
-date: 2012-06-09 00:00:00.000000000 Z
+date: 2014-04-05 00:00:00.000000000 Z
 dependencies: []
-description: ! "       cmdparse provides classes for parsing commands on the command
-  line; command line options\n       are parsed using optparse or any other option
-  parser implementation. Programs that use\n       such command line interfaces are,
-  for example, subversion's 'svn' or Rubygem's 'gem' program.\n"
+description: |2
+         cmdparse provides classes for parsing commands on the command line; command line options
+         are parsed using optparse or any other option parser implementation. Programs that use
+         such command line interfaces are, for example, subversion's 'svn' or Rubygem's 'gem' program.
 email: t_leitner@gmx.at
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - setup.rb
-- TODO
 - COPYING
 - COPYING.LESSER
-- README
+- README.md
 - Rakefile
 - net.rb
 - VERSION
-- lib/cmdparse/wrappers/optparse.rb
 - lib/cmdparse.rb
-- doc/plugin/extract.rb
-- doc/config.yaml
-- doc/src/features.page
-- doc/src/logo.png
-- doc/src/tutorial.page
-- doc/src/default.css
-- doc/src/index.page
-- doc/src/meta.info
-- doc/src/download.page
-- doc/src/default.template
-- doc/src/about.page
-homepage: http://cmdparse.rubyforge.org
-licenses: []
+- lib/cmdparse/wrappers/optparse.rb
+- doc/about.page
+- doc/default.css
+- doc/default.template
+- doc/download.page
+- doc/index.page
+- doc/logo.png
+- doc/tutorial.page
+- doc/virtual
+- test/tc_commandhash.rb
+homepage: http://cmdparse.gettalong.org
+licenses:
+- LGPLv3
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --line-numbers
-- -m
+- --main
 - CmdParse::CommandParser
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: cmdparse
-rubygems_version: 1.8.24
+rubyforge_project: 
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Advanced command line parser supporting commands
 test_files: []

data/README

@@ -1,55 +0,0 @@
-cmdparse - an advanced command line parser using optparse which has support for commands
-
-Copyright (C) 2004-2012 Thomas Leitner
-
-= Description
-
-Some new programs use a "command style" command line. Examples for such programs are the "svn"
-program from Subversion and the "gem" program from Rubygems. The standard Ruby distribution has no
-library to create programs that use such a command line interface.
-
-This library, cmdparse, can be used to create such a command line interface. Internally it uses
-optparse or any other option parser library to parse options and it provides a nice API for
-specifying commands.
-
-= License
-
-GNU LGPLv3 - see COPYING.LESSER for the LGPL and COPYING for the GPL
-
-= Dependencies
-
- none
-
-= Installation
-
-The preferred way of installing cmdparse is via RubyGems:
- $ gem install cmdparse
-
-If you do not have RubyGems installed, but Rake, you can use the following command:
- $ rake install
-
-If you have neither RubyGems nor Rake, use these commands:
- $ ruby setup.rb config
- $ ruby setup.rb setup
- $ ruby setup.rb install
-
-= Documentation
-
-You can build the documentation by invoking
- $ rake doc
-
-This builds the API and the additional documentation. The additional documentation needs webgen
->=0.3.5 (webgen.rubyforge.org) for building.
-
-
-= Example
-
-There is an example of how to use cmdparse in the +net.rb+ file.
-
-
-= Contact
-
-Author: Thomas Leitner
-* Web: http://cmdparse.rubyforge.org
-* e-Mail: t_leitner@gmx.at
-* GPG Key-Id: 0xD942E7F6

data/TODO

@@ -1,10 +0,0 @@
-* see mail from Markus Werner concerning class methods for defining methods as sub commands
-
----- DONE ----
-
-* define banner in a common way (like option parser), maybe use the one from option parser
-* raise NoCommandGivenError when no command was given
-* ability to specify default command (used when no command was given)
-* add order,order!,... methods to mimic optparse
-* optionally capture error messages and provide friendlier output
-* if command has subcommands, use order! method, if has arguments use permute! (=POSIXLY_CORRECT); same with getoptlong

data/doc/config.yaml

@@ -1,2 +0,0 @@
-PageHandler:
-  validator: xmllint

data/doc/plugin/extract.rb

@@ -1,29 +0,0 @@
-module CmdparsePlugins
-
-  class ExtractTag < Tags::DefaultTag
-
-    summary "Extracts lines from a file"
-    depends_on 'Tags'
-    add_param 'file', nil, 'the file from which to read the lines'
-    add_param 'lines', nil, 'the lines which should be read (Range)'
-    set_mandatory 'file'
-    set_mandatory 'lines'
-
-    def initialize
-      super
-      @processOutput = false
-      register_tag( 'extract' )
-    end
-
-    def process_tag( tag, node, refNode )
-      data = File.readlines( get_param( 'file' ) ).unshift( 'empty null line' )[get_param( 'lines' )]
-      out = '<table class="cmdparse-example"><tr>'
-      out << '<td><pre>' << get_param( 'lines' ).collect {|n| "#{n}<br />" }.to_s << '</pre></td>'
-      out << '<td><pre>' << data.collect {|line| "#{CGI::escapeHTML(line)}" }.to_s << '</pre></td>'
-      out << '</tr></table>'
-      out
-    end
-
-  end
-
-end

data/doc/src/download.page

@@ -1,34 +0,0 @@
----
-title: Download & Installation
-inMenu: true
-orderInfo: 4
----
-h2. Download
-
-The newest version of cmdparse can be downloaded from Rubyforge.
-
-Homepage: "cmdparse.rubyforge.org":http://cmdparse.rubyforge.org <br />
-Download: "rubyforge.org/frs/?group_id=396":http://rubyforge.org/frs/?group_id=396
-
-h2. Dependencies
-
-none
-
-h2. Installation
-
-The preferred way of installing cmdparse is via RubyGems:
-<pre>
- $ gem install cmdparse
-</pre>
-
-If you do not have RubyGems installed, but Rake, you can use the following command:
-<pre>
- $ rake install
-</pre>
-
-If you have neither RubyGems nor Rake, use these commands:
-<pre>
- $ ruby setup.rb config
- $ ruby setup.rb setup
- $ ruby setup.rb install
-</pre>

data/doc/src/features.page

@@ -1,11 +0,0 @@
----
-title: Features
-inMenu: true
-orderInfo: 3
----
-h2. Feature list
-
-* Commands can have subcommands
-* Default commands for showing help and the version of the program
-* Option parsing library of choice can be used (after writing wrapper), default is @optparse@
-* Easy to use

data/doc/src/index.page

@@ -1,80 +0,0 @@
----
-title: HomePage
-inMenu: true
-directoryName: cmdparse
-menuOrder: 1
----
-h2. Welcome
-
-... to the homepage of _*cmdparse*_, an advanced command line parser supporting commands.
-
-Have a look around the site!
-
-h2. News
-
-<b>2006-06-17 cmdparse 2.0.2 released!!!</b>
-
-Changes:
-
-* Included two patches from Assaph Mehr:
-  * partial command matching can now be used (see <a href="{relocatable: tutorial.page}">tutorial page</a>)
-  * now a banner for the help and version commands can be specified
-
-<b>2006-04-05 cmdparse 2.0.1 released!!!</b>
-
-Changes:
-
-* Just a bug fix release for those using cmdparse with Rubygems. By issuing the command
-  @require_gem 'cmdparse'@ the cmdparse library gets automagically loaded.
-* Minor documentation updates
-
-<b>2005-08-16 cmdparse 2.0.0 released!!!</b>
-
-This version is not compatible to previous versions of cmdparse as there have been major changes in
-the API. However, updating your code to use the new API is very easy!
-
-Changes:
-
-* Commands can now have subcommands which can have subcommands which can have subcommands...
-* No need to implement a whole new class for simple commands anymore
-* Default option parser library is @optparse@, however, any option parser library can be used after writing a small wrapper
-
-<b>2005-07-05 cmdparse 1.0.5 released!!!</b>
-
-Changes:
-
-* added possibility to parse global options, command and local options separately
-
-
-<b>2005-06-16 cmdparse 1.0.4 released!!!</b>
-
-Changes:
-
-* fix for older ruby versions
-* fixed bug where exception was not caught
-
-
-<b>2005-06-09 cmdparse 1.0.3 released!!!</b>
-
-Changes:
-
-* added optional graceful exception handling
-
-
-<b>2005-04-21 cmdparse 1.0.2 released!!!</b>
-
-Changes:
-
-* splitted parsing of the arguments and executing the command into two methods
-
-<b>2005-04-13 cmdparse 1.0.1 released!!!</b>
-
-Changes:
-
-* Improved HelpCommand: the global options -h and --help take an optional command name now
-* Possibility to define a default command which is used when no command was specified
-* A @NoCommandGivenError@ is thrown when no command on the CLI and no default command was specified
-
-h2. And so
-
-... have fun!

data/doc/src/meta.info

@@ -1,5 +0,0 @@
-api.html:
-    dest: rdoc/index.html
-    title: API Reference
-    orderInfo: 7
-    inMenu: true

data/doc/src/tutorial.page

@@ -1,177 +0,0 @@
----
-title: Tutorial
-inMenu: true
-orderInfo: 6
----
-h2. Quickstart
-
-Here are some short code fragments which show how to use cmdparse. A complete example app can be
-found later in the "tutorial section":#tutorial.
-
-Defining commands using classes:
-<pre>
-class TestCmd < CmdParse::Command
-  def initialize
-    super('test', true)
-    self.add_command(TestSubCmd.new)
-  end
-end
-
-class TestSubCmd < CmdParse::Command
-  def initialize
-    super('sub',false)
-  end
-
-  def execute (args)
-    puts "Hallo #{args}"
-  end
-end
-
-cmd = CmdParse::CommandParser.new( true )
-cmd.add_command(TestCmd.new)
-</pre>
-
-Defining command using the basic @CmdParse::Command@ class:
-<pre>
-cmd = CmdParse::CommandParser.new( true )
-testcmd = CmdParse::Command.new( 'test', true )
-testcmd.short_desc = "Short desc"
-cmd.add_command( testcmd )
-
-sub = CmdParse::Command.new( 'sub', false )
-sub.short_desc = "Add an IP address"
-sub.set_execution_block do |args|
-  puts "Hallo #{args}"
-end
-testcmd.add_command( sub )
-</pre>
-
-h2(#tutorial). Tutorial
-
-<b>The complete code for this example can be found in the file @net.rb@ of the @cmdparse@
-package!</b>
-
-This tutorial produces a small @net@ application which can add, delete and list IP adresses and show
-'network statistics'. The shown code fragments do not include the whole program. So, instead of
-writing all the code yourself, just look at the code fragments first and then use the include
-@net.rb@ file for running the program.
-
-h3. Require statements
-
-Create a new new file and write the necessary @require@ statements.
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 5..5}}</notextile>
-
-h3. The @CommandParser@ class
-
-Next we will define our basic @CommandParser@ by defining the name of the program, its version and
-the global options. The first boolean argument to the constructor of the @CommandParser@ class
-defines whether exceptions should be handled gracefully, i.e. by showing an appropriate error
-message and the help screen. The second boolean argument defines whether the top level commands
-should use partial command matching instead of full command matching. If partial command matching is
-used, then the shortest unambiguous part of a command name can be used instead of always specifing
-the full command name.
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 30..36}}</notextile>
-
-The options are defined using an option parser wrapper. Currently, the only option parser library
-supported is @optparse@ from the Ruby Standard Library. If you want to use another option parser
-library, you need to write a wrapper for it so that @cmdparse@ can use it.
-
-Now we only have to tell the program to use our newly defined class to process the command line
-arguments.
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 86..86}}</notextile>
-
-The @parse@ method of our @CommandParser@ instance parses the given array of options (or @ARGV@ if
-no argument is specified). All the command line options are parsed and the given command executed.
-
-The program can be executed now but won't be useful as we did not specify any commands.
-
-h3. Defining commands
-
-So, as we have defined our @CommandParser@ object, we need to add some commands to it. First, we
-will add two predefined commands, namely the @help@ and the @version@ command.
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 37..38}}</notextile>
-
-That was easy! Now you can execute the program and specify the commands @help@ or @version@.
-However, we want the program to do something "useful". Therefore we define a new command.
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 41..44}}</notextile>
-
-This command is defined by using the default @Command@ class. First an instance is created assigning
-a name to the command and defining whether this command takes subcommands and uses partial command
-matching. Next we add a short description so that the @help@ command can produce something useful.
-And at last, we add this command to our @CommandParser@ instance.
-
-We specified that our @ipaddr@ command takes subcommands. So we have to define them, too:
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 46..78}}</notextile>
-
-We add three subcommands to the @ipaddr@ command: @add@, @del@ and @list@.
-
-The @add@ command is similar to the @ipaddr@ command. However, as the @add@ command does not take
-other commands, we have to define an execution block.
-
-The @del@ command is similar to the @add@ command. As we want to be able to delete all IP addresses
-by issuing only one command, we add an option for this.
-
-By providing @true@ as second argument when we add the @list@ command to the @ipaddr@ command, we
-specifiy that this command should be the default command which gets invoked when no command name is
-specified on the command line. Only one command can be specified as default command!
-
-Till now we only used the basic @Command@ class to specify commands. However, new commands can also
-be created by subclassing the @Command@ class, as shown with this last command:
-
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 9..28}}</notextile>
-<notextile>{extract: {file: ../net.rb, lines: !ruby/range 39..39}}</notextile>
-
-h3. Running the program
-
-That's all! You can run the program now and have a look at the output which differs depending on
-which arguments you choose.
-
-So, a typical invocation of this program looks like this:
-
-<pre>
-  $ ruby net.rb --verbose ipaddr add 192.168.0.1 193.150.0.1
-</pre>
-
-* <notextile><tt>--verbose</tt></notextile> is a global option
-* @ipaddr@ is the first command name (which has no options)
-* @add@ is the second command name (which also has no options)
-* <tt>192.168.0.1 193.150.0.1</tt> are additional arguments
-
-You should notice that if you type
-<pre>
-  $ ruby net.rb
-</pre>
-
-you get an error because you did not specify any command.
-
-However, when you type
-<pre>
-  $ ruby net.rb ipaddr
-</pre>
-
-you do not get an error!
-
-Why? As the @ipaddr@ command takes subcommands there should be an additional command name (e.g.
-@list@) on the command line. However, as the @list@ command is the default command for @ipaddr@ you
-do not need to type it.
-
-*By the way:* You get the same output if you type
-<pre>
-  $ ruby net.rb ip
-</pre>
-
-Why? As partial command matching is used for the top level commands, the shortest unambiguous name
-for a command can be used. As there is no other command starting with @ip@ (or even with the letter
-@i@), it is sufficient to write the above to select the @ipaddr@ command.
-
-*Notice:* The options of a command which does not take subcommands do not need to be at the front;
-they can be anywhere, like this
-<pre>
-  $ ruby test.rb --verbose mycommand file1 file2 --recursive file3
-</pre>