pablo 1.0.3

data/test/fixtures/load_yaml.yml

@@ -0,0 +1,37 @@
+--- 
+:program: program
+:version: version
+:license: license
+:desc: desc
+:longdesc: longdesc
+:usage: usage
+:expand: true
+:command_consumes_all: false
+:capabilities:
+  - capa
+  - bili
+  - ties
+:parsers:
+  - :command:
+      - :foo
+      - :foofoo
+    :consume_all: false
+    :longdesc: longdesc
+    :desc: desc
+    :usage: usage
+  - :option:
+      - :bar
+    :consume:
+      - one
+      - two
+  - :option:
+      - :nobar
+    :negates: :bar
+  - :token:
+      - :file?
+      - !ruby/regexp /goo/
+    :consume: 1
+    :default: moose
+  - :help_command: true
+    :desc: desc
+    :nothing: nothing

data/test/fixtures/output.yml

@@ -0,0 +1,13 @@
+--- 
+:help: " test 0.1\n\n   test [usage]\n\n Commands:\n   foo    \n   help     :  Displays this message.\n   bar    \n\n Options:\n   --bla  \n   --nobla\n\n Tokens:\n   blubb    :  Nothing.\n"
+:color_help: " $test 0.1$\n\n   +test+ _[usage]_\n\n %Commands:%\n   +foo    +\n   +help   +  :  Displays this message.\n   +bar    +\n\n %Options:%\n   +--bla  +\n   +--nobla+\n\n %Tokens:%\n   +blubb  +  :  Nothing.\n"
+:command_help: " test 0.1\n\n   help [<command>]\n\n Shows a simple help message for this program.\n If a command is given as well, a more detailed message about that\n particular command is shown (such as this one).\n"
+:help_expand: "\n   foobar\n\n"
+:unknown: "Sorry, but I don't know 'luugu'.\nTry running 'help' without parameters to get a list of all the commands, options etc.\n"
+:version: "test 0.1\n+woodle-doodle -foobar\n"
+:missing_argument: "Missing argument for 'foo'.\n"
+:missing_argument_2: "Missing argument 'bar' for 'foo'.\n"
+:wrong_argument: "Wrong argument 'bar' for 'foo'.\n"
+:wrong_argument_2: "Wrong argument 'bar' for 'foo'. Expected regular expression.\n"
+:ambiguity_command: "Ambiguous argument 'foo'. Could be any of:\n  * foobar\n  * foogoo\n"
+:colorize_text: "foo+bar+foo foo + bar + foo"

data/test/help_fixtures.rb

@@ -0,0 +1,47 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+require 'test/unit'
+require 'yaml'
+
+class Test::Unit::TestCase
+
+    def fixtures
+        self.class.instance_variable_get(:@fixtures)
+    end
+
+    class << self
+        def fixture file, format = :yml
+            @fixtures ||= Hash.new
+
+            open(File.join(File.dirname(__FILE__), 'fixtures', file.to_s + '.' + format.to_s)) { |f|
+                @fixtures[file] = 
+                    case format
+                    when :yml then YAML::load(f)
+                    else f.read()
+                    end
+            }
+        end
+    end
+end
+

data/test/test_arguments.rb

@@ -0,0 +1,56 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+require "test/unit"
+require "pablo"
+
+class TestArguments < Test::Unit::TestCase
+
+    def test_arguments_consume
+        p = Pablo.new
+
+        p.command :foo do |args, pablo|
+            assert_equal 1, args.length
+            args.consume 0
+            assert_equal 0, args.length
+        end
+
+        p.parse %w{foo bar}
+    end
+
+    def test_consume_all
+        p = Pablo.new
+
+        p.command :foo do |args, pablo|
+            assert !args.consumed?
+            assert_equal 2, args.length
+            args.consume_all
+            assert_equal 0, args.length
+            assert args.consumed?
+        end
+
+        p.parse %w{foo bar baz}
+    end
+
+end
+

data/test/test_expansion.rb

@@ -0,0 +1,62 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+require "test/unit"
+require "pablo"
+
+class TestExpansion < Test::Unit::TestCase
+
+    def test_expansion
+        p = Pablo.new :expand => true, :command_consumes_all => false
+
+        p.option :barbar
+        p.option :bazbaz
+        p.option :bazbass
+        p.command :foofoo
+
+        p.parse %w{foo --bar --baz}
+
+        assert p.commands[:foofoo]
+        assert p.options[:barbar]
+        assert_nil p.options[:bazbaz]
+        assert_nil p.options[:bazbass]
+    end
+
+    def test_ambiguity
+        worked = false
+        p = Pablo.new :expand => true
+
+        p.option :foobar
+        p.option :foogoo
+
+        p.ambiguity do |arg,names|
+            worked = true
+            assert_equal 'foo', arg
+            assert_equal ['foobar', 'foogoo'], names
+        end
+
+        p.parse %w{foo}
+    end
+
+end
+

data/test/test_output.rb

@@ -0,0 +1,202 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+require "test/unit"
+require "pablo"
+require File.join File.dirname(__FILE__), 'help_fixtures'
+
+class TestOutput < Test::Unit::TestCase
+
+    fixture :output
+    fixture :license, :txt
+
+    def setup
+        $stdout = $stderr = @io = StringIO.new
+    end
+
+    def teardown
+        $stdout = STDOUT
+        $stderr = STDERR
+    end
+
+    def test_help
+        p = Pablo.new :program => 'test', :version => '0.1', :usage => '[usage]'
+        p.command :foo
+        p.help_command
+        p.command :bar
+        p.option :bla
+        p.option :nobla, :negates => :bla
+        p.desc("Nothing.")
+        p.token :blubb
+
+        p.parse ['help']
+        assert_equal fixtures[:output][:help], @io.string
+    end
+
+    def test_command_help
+        p = Pablo.new :program => 'test', :version => '0.1', :usage => '[usage]'
+        p.command :foo
+        p.help_command
+        p.command :bar
+
+        p.parse ['help', 'help']
+        assert_equal fixtures[:output][:command_help], @io.string
+    end
+
+    def test_unknown_help
+        p = Pablo.new :program => 'test', :version => '0.1', :usage => '[usage]'
+        p.command :foo
+        p.help_command
+        p.command :bar
+
+        p.parse ['help', 'luugu']
+        assert_equal fixtures[:output][:unknown], @io.string
+    end
+
+    def test_version
+        p = Pablo.new :program => 'test', :version => '0.1', :usage => '[usage]',
+                :capabilities => %w{+woodle-doodle -foobar}
+        p.version_command
+
+        p.parse ['version']
+        assert_equal fixtures[:output][:version], @io.string
+    end
+
+    def test_license
+        p = Pablo.new :license => 'test/fixtures/license.txt'
+        p.license_command
+
+        p.parse ['license']
+        assert_equal fixtures[:license], @io.string
+    end
+
+    def test_colorize
+        p = Pablo.new :program => 'test', :version => '0.1', :usage => '[usage]'
+        p.colorizing do |str, type|
+            case type
+            when :em then "+#{str}+"
+            when :h1 then "$#{str}$"
+            when :h2 then "%#{str}%"
+            when :usage then "_#{str}_"
+            else str
+            end
+        end
+
+        p.command :foo
+        p.help_command
+        p.command :bar
+        p.option :bla
+        p.option :nobla, :negates => :bla
+        p.desc("Nothing.")
+        p.token :blubb
+
+        p.parse ['help']
+        assert_equal fixtures[:output][:color_help], @io.string
+
+        t = p.colorize("foo$bar$foo foo $ bar $ foo", :text)
+        assert_equal fixtures[:output][:colorize_text], t
+    end
+
+    def test_errors
+        p = Pablo.new
+        p.command :foo do
+            p.missing_argument
+        end
+
+        p.parse %w{foo}
+        assert_equal fixtures[:output][:missing_argument], @io.string
+        setup()
+
+        p = Pablo.new
+        p.command :foo do
+            p.missing_argument('bar')
+        end
+
+        p.parse %w{foo}
+        assert_equal fixtures[:output][:missing_argument_2], @io.string
+        setup()
+
+        p = Pablo.new
+        p.command :foo do
+            p.wrong_argument('bar')
+        end
+
+        p.parse %w{foo}
+        assert_equal fixtures[:output][:wrong_argument], @io.string
+        setup()
+
+        p = Pablo.new
+        p.command :foo do
+            p.wrong_argument('bar', 'regular expression')
+        end
+
+        p.parse %w{foo}
+        assert_equal fixtures[:output][:wrong_argument_2], @io.string
+    end
+
+    def test_help_expansion
+        catch :abort do
+            p = Pablo.new :expand => true
+
+            p.help_command
+            p.command :foobar
+
+            p.parse %w{help foo}
+        end
+
+        assert_equal fixtures[:output][:help_expand], @io.string
+    end
+
+    def test_help_command
+        [%w{help}, %w{help foo}].each do |arr|
+            worked = false
+
+            catch :abort do
+                p = Pablo.new
+
+                p.help_command do |args, pablo|
+                    # arr.length because 'help' is already consumed
+                    assert_equal arr.length, args.length
+                    worked = true
+                    throw :abort
+                end
+
+                p.parse arr
+            end
+
+            assert worked
+        end
+    end
+
+    def test_ambiguity_command
+        p = Pablo.new :expand => true
+        p.ambiguity_command
+        p.command :foobar
+        p.command :foogoo
+
+        p.parse %w{foo}
+        assert_equal fixtures[:output][:ambiguity_command], @io.string
+    end
+
+end
+

data/test/test_pablo.rb

@@ -0,0 +1,115 @@
+###### DON'T PANIC License 1.1 ###########
+#
+# Don't panic, this piece of software is
+# free, i.e. you can do with it whatever
+# you like, including, but not limited to:
+# 
+#   * using it
+#   * copying it
+#   * (re)distributing it
+#   * burning/burying/shredding it
+#   * eating it
+#   * using it to obtain world domination
+#   * and ignoring it
+# 
+# Under the sole condition that you
+# 
+#   * CONSIDER buying the author a strong
+#     brownian motion producer, say a nice
+#     hot cup of tea, should you ever meet
+#     him in person.
+#
+##########################################
+
+require "test/unit"
+require "pablo"
+require File.join File.dirname(__FILE__), 'help_fixtures'
+
+class TestPablo < Test::Unit::TestCase
+
+    fixture :load_yaml
+
+    def test_load_yaml
+        yml = fixtures[:load_yaml].to_yaml
+
+        p = Pablo.new
+
+        p.load_yaml yml
+
+        assert_equal({
+            :program => 'program',
+            :desc => 'desc',
+            :version => 'version',
+            :longdesc => 'longdesc',
+            :usage => 'usage',
+            :capabilities => %w{capa bili ties},
+            :command_consumes_all => false,
+            :expand => true,
+            :license => 'license'
+        }, p.instance_variable_get(:@opts))
+
+        reg = p.instance_variable_get(:@registered)
+
+        assert_equal 5, reg.length
+
+        assert_equal [:foo, :foofoo], reg[0].names
+        assert_equal 'desc', reg[0].desc
+        assert_equal 'longdesc', reg[0].longdesc
+        assert_equal 'usage', reg[0].usage
+        assert_equal({
+            :consume_all => false
+        }, reg[0].instance_variable_get(:@opts))
+
+        assert_equal [:bar], reg[1].names
+        assert_equal({
+            :consume => %w{one two}
+        }, reg[1].instance_variable_get(:@opts))
+
+        assert_equal [:nobar], reg[2].names
+        assert_equal({
+            :negates => :bar
+        }, reg[2].instance_variable_get(:@opts))
+
+        assert_equal [], reg[3].names
+        assert_equal [:file?, /goo/], reg[3].instance_variable_get(:@verify)
+        assert_equal({
+            :default => 'moose',
+            :consume => 1,
+        }, reg[3].instance_variable_get(:@opts))
+
+        assert_equal [:help], reg[4].names
+        assert_equal 'desc', reg[4].desc
+        assert_equal({
+            :consume_all => false,
+            :nothing => 'nothing'
+        }, reg[4].instance_variable_get(:@opts))
+    end
+
+    def foo args, pablo
+        @worked << :token
+    end
+
+    def bar args, pablo
+        @worked << :option
+    end
+
+    def goo args, pablo
+        @worked << :command
+    end
+
+    def test_run_object
+        p = Pablo.new :run => self
+
+        @worked = []
+
+        p.token :foo
+        p.option :bar
+        p.command :goo
+
+        p.parse %w{foo --bar goo}
+
+        assert_equal [:token, :option, :command], @worked
+    end
+
+end
+