cri 1.0.1 → 2.0a1

data/test/test_command_dsl.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+class Cri::CommandDSLTestCase < Cri::TestCase
+
+  def test_create_command
+    # Define
+    dsl = Cri::CommandDSL.new
+    dsl.instance_eval do
+      name        'moo'
+      usage       'dunno whatever'
+      summary     'does stuff'
+      description 'This command does a lot of stuff.'
+
+      option    :a, :aaa, 'opt a', :argument => :optional
+      required  :b, :bbb, 'opt b'
+      optional  :c, :ccc, 'opt c'
+      flag      :d, :ddd, 'opt d'
+      forbidden :e, :eee, 'opt e'
+
+      run do |opts, args|
+        $did_it_work = :probably
+      end
+    end
+    command = dsl.command
+
+    # Run
+    $did_it_work = :sadly_not
+    command.run(%w( -a x -b y -c -d -e ))
+    assert_equal :probably, $did_it_work
+
+    # Check
+    assert_equal 'moo', command.name
+    assert_equal 'dunno whatever', command.usage
+    assert_equal 'does stuff', command.short_desc
+    assert_equal 'This command does a lot of stuff.', command.long_desc
+
+    # Check options
+    expected_option_definitions = Set.new([
+      { :short => 'a', :long => 'aaa', :desc => 'opt a', :argument => :optional,  :block => nil },
+      { :short => 'b', :long => 'bbb', :desc => 'opt b', :argument => :required,  :block => nil },
+      { :short => 'c', :long => 'ccc', :desc => 'opt c', :argument => :optional,  :block => nil },
+      { :short => 'd', :long => 'ddd', :desc => 'opt d', :argument => :forbidden, :block => nil },
+      { :short => 'e', :long => 'eee', :desc => 'opt e', :argument => :forbidden, :block => nil }
+      ])
+    actual_option_definitions = Set.new(command.option_definitions)
+    assert_equal expected_option_definitions, actual_option_definitions
+  end
+
+  def test_subcommand
+    # Define
+    dsl = Cri::CommandDSL.new
+    dsl.instance_eval do
+      name 'super'
+      subcommand do
+        name 'sub'
+      end
+    end
+    command = dsl.command
+
+    # Check
+    assert_equal 'super', command.name
+    assert_equal 1,       command.subcommands.size
+    assert_equal 'sub',   command.subcommands.to_a[0].name
+  end
+
+end

data/test/test_core_ext.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+class Cri::CoreExtTestCase < Cri::TestCase
+
+  def test_string_to_paragraphs
+    original = "Lorem ipsum dolor sit amet,\nconsectetur adipisicing.\n\n" +
+               "Sed do eiusmod\ntempor incididunt ut labore."
+
+    expected = [ "Lorem ipsum dolor sit amet, consectetur adipisicing.",
+                 "Sed do eiusmod tempor incididunt ut labore." ]
+
+    actual = original.to_paragraphs
+    assert_equal expected, actual
+  end
+
+  def test_string_wrap_and_indent_without_indent
+    original = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " +
+               "sed do eiusmod tempor incididunt ut labore et dolore " + 
+               "magna aliqua."
+
+    expected = "Lorem ipsum dolor sit amet, consectetur\n" +
+               "adipisicing elit, sed do eiusmod tempor\n" +
+               "incididunt ut labore et dolore magna\n" +
+               "aliqua."
+
+    actual = original.wrap_and_indent(40, 0)
+    assert_equal expected, actual
+  end
+
+  def test_string_wrap_and_indent_with_indent
+    original = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " +
+               "sed do eiusmod tempor incididunt ut labore et dolore " + 
+               "magna aliqua."
+
+    expected = "    Lorem ipsum dolor sit amet,\n" +
+               "    consectetur adipisicing elit, sed\n" +
+               "    do eiusmod tempor incididunt ut\n" +
+               "    labore et dolore magna aliqua."
+
+    actual = original.wrap_and_indent(36, 4)
+    assert_equal expected, actual
+  end
+
+  def test_string_wrap_and_indent_with_multiple_lines
+    original = "Lorem ipsum dolor sit\namet, consectetur adipisicing elit, " +
+               "sed do\neiusmod tempor incididunt ut\nlabore et dolore " + 
+               "magna\naliqua."
+
+    expected = "    Lorem ipsum dolor sit amet,\n" +
+               "    consectetur adipisicing elit, sed\n" +
+               "    do eiusmod tempor incididunt ut\n" +
+               "    labore et dolore magna aliqua."
+
+    actual = original.wrap_and_indent(36, 4)
+    assert_equal expected, actual
+  end
+
+end

data/test/test_option_parser.rb

@@ -0,0 +1,281 @@
+# encoding: utf-8
+
+class Cri::OptionParserTestCase < Cri::TestCase
+
+  def test_parse_without_options
+    input       = %w( foo bar baz )
+    definitions = []
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({},                      result[:options])
+    assert_equal([ 'foo', 'bar', 'baz' ], result[:arguments])
+  end
+
+  def test_parse_with_invalid_option
+    input       = %w( foo -x )
+    definitions = []
+
+    result = nil
+
+    assert_raises(Cri::OptionParser::IllegalOptionError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+  def test_parse_without_options
+    input       = %w( foo )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :forbidden }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(!result[:options][:aaa])
+  end
+
+  def test_parse_with_long_valueless_option
+    input       = %w( foo --aaa bar )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :forbidden }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert_equal([ 'foo', 'bar' ], result[:arguments])
+  end
+
+  def test_parse_with_long_valueful_option
+    input       = %w( foo --aaa xxx bar )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :required }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({ :aaa => 'xxx' },  result[:options])
+    assert_equal([ 'foo', 'bar' ], result[:arguments])
+  end
+
+  def test_parse_with_long_valueful_equalsign_option
+    input       = %w( foo --aaa=xxx bar )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :required }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({ :aaa => 'xxx' },  result[:options])
+    assert_equal([ 'foo', 'bar' ], result[:arguments])
+  end
+
+  def test_parse_with_long_valueful_option_with_missing_value
+    input       = %w( foo --aaa )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :required }
+    ]
+
+    result = nil
+
+    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+  def test_parse_with_two_long_valueful_options
+    input       = %w( foo --all --port 2 )
+    definitions = [
+      { :long => 'all',  :short => 'a', :argument => :required  },
+      { :long => 'port', :short => 'p', :argument => :required }
+    ]
+
+    result = nil
+
+    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+  def test_parse_with_long_valueless_option_with_optional_value
+    input       = %w( foo --aaa )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :optional }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert_equal([ 'foo' ], result[:arguments])
+  end
+
+  def test_parse_with_long_valueful_option_with_optional_value
+    input       = %w( foo --aaa xxx )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :optional }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({ :aaa => 'xxx' },  result[:options])
+    assert_equal([ 'foo' ], result[:arguments])
+  end
+
+  def test_parse_with_long_valueless_option_with_optional_value_and_more_options
+    input       = %w( foo --aaa -b -c )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :optional  },
+      { :long => 'bbb', :short => 'b', :argument => :forbidden },
+      { :long => 'ccc', :short => 'c', :argument => :forbidden }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert(result[:options][:bbb])
+    assert(result[:options][:ccc])
+    assert_equal([ 'foo' ], result[:arguments])
+  end
+
+  def test_parse_with_short_valueless_options
+    input       = %w( foo -a bar )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :forbidden }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert_equal([ 'foo', 'bar' ], result[:arguments])
+  end
+
+  def test_parse_with_short_valueful_option_with_missing_value
+    input       = %w( foo -a )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :required }
+    ]
+
+    result = nil
+
+    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+  def test_parse_with_short_combined_valueless_options
+    input       = %w( foo -abc bar )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      { :long => 'bbb', :short => 'b', :argument => :forbidden },
+      { :long => 'ccc', :short => 'c', :argument => :forbidden }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert(result[:options][:bbb])
+    assert(result[:options][:ccc])
+    assert_equal([ 'foo', 'bar' ], result[:arguments])
+  end
+
+  def test_parse_with_short_combined_valueful_options_with_missing_value
+    input       = %w( foo -abc bar )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :required  },
+      { :long => 'bbb', :short => 'b', :argument => :forbidden },
+      { :long => 'ccc', :short => 'c', :argument => :forbidden }
+    ]
+
+    result = nil
+
+    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+  def test_parse_with_two_short_valueful_options
+    input       = %w( foo -a -p 2 )
+    definitions = [
+      { :long => 'all',  :short => 'a', :argument => :required  },
+      { :long => 'port', :short => 'p', :argument => :required }
+    ]
+
+    result = nil
+
+    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+  def test_parse_with_short_valueless_option_with_optional_value
+    input       = %w( foo -a )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :optional }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert_equal([ 'foo' ], result[:arguments])
+  end
+
+  def test_parse_with_short_valueful_option_with_optional_value
+    input       = %w( foo -a xxx )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :optional }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({ :aaa => 'xxx' },  result[:options])
+    assert_equal([ 'foo' ], result[:arguments])
+  end
+
+  def test_parse_with_short_valueless_option_with_optional_value_and_more_options
+    input       = %w( foo -a -b -c )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :optional  },
+      { :long => 'bbb', :short => 'b', :argument => :forbidden },
+      { :long => 'ccc', :short => 'c', :argument => :forbidden }
+    ]
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert(result[:options][:aaa])
+    assert(result[:options][:bbb])
+    assert(result[:options][:ccc])
+    assert_equal([ 'foo' ], result[:arguments])
+  end
+
+  def test_parse_with_single_hyphen
+    input       = %w( foo - bar )
+    definitions = []
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({},                    result[:options])
+    assert_equal([ 'foo', '-', 'bar' ], result[:arguments])
+  end
+
+  def test_parse_with_end_marker
+    input       = %w( foo bar -- -x --yyy -abc )
+    definitions = []
+
+    result = Cri::OptionParser.parse(input, definitions)
+
+    assert_equal({},                                      result[:options])
+    assert_equal([ 'foo', 'bar', '-x', '--yyy', '-abc' ], result[:arguments])
+  end
+
+  def test_parse_with_end_marker_between_option_key_and_value
+    input       = %w( foo --aaa -- zzz )
+    definitions = [
+      { :long => 'aaa', :short => 'a', :argument => :required }
+    ]
+
+    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+      result = Cri::OptionParser.parse(input, definitions)
+    end
+  end
+
+end

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: cri
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  prerelease: 3
+  version: 2.0a1
 platform: ruby
 authors: 
 - Denis Defreyne
@@ -9,11 +10,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-02 00:00:00 +01:00
-default_executable: 
+date: 2011-06-19 00:00:00 Z
 dependencies: []
 
-description: Cri is a library for building easy-to-use commandline tools.
+description: Cri allows building easy-to-use commandline interfaces with support for subcommands.
 email: denis.defreyne@stoneship.org
 executables: []
 
@@ -22,47 +22,57 @@ extensions: []
 extra_rdoc_files: 
 - ChangeLog
 - LICENSE
-- README
+- README.md
+- NEWS.md
 files: 
 - ChangeLog
 - LICENSE
-- NEWS
-- README
+- NEWS.md
 - Rakefile
-- VERSION
-- lib/cri.rb
-- lib/cri/base.rb
+- README.md
 - lib/cri/command.rb
-- lib/cri/core_ext.rb
+- lib/cri/command_dsl.rb
+- lib/cri/commands/basic_help.rb
+- lib/cri/commands/basic_root.rb
 - lib/cri/core_ext/string.rb
+- lib/cri/core_ext.rb
 - lib/cri/option_parser.rb
-has_rdoc: true
-homepage: 
+- lib/cri.rb
+- test/helper.rb
+- test/test_base.rb
+- test/test_command.rb
+- test/test_command_dsl.rb
+- test/test_core_ext.rb
+- test/test_option_parser.rb
+- cri.gemspec
+- .gemtest
+homepage: http://stoneship.org/software/cri/
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --charset=UTF-8
+- --main
+- README.md
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: Cri is a library for building easy-to-use commandline tools.
+summary: a library for building easy-to-use commandline tools
 test_files: []