pablo 1.0.3

data/test/test_parsers.rb

@@ -0,0 +1,470 @@
+###### 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 TestParsers < Test::Unit::TestCase
+
+    # ------------------ always ----------------
+
+    def test_always
+        p = Pablo.new
+        worked = false
+
+        p.always do
+            worked = true
+        end
+
+        p.parse []
+        assert worked
+    end
+
+    # ------------------ command ----------------
+
+    def test_command_consume_all
+        p = Pablo.new
+        p.command :foo, :consume_all => false
+        p.command :bar, :consume_all => false
+
+        p.parse ['foo', 'bar']
+        assert p.commands[:foo]
+        assert p.commands[:bar]
+    end
+
+    def test_single_command
+        worked = false
+        p = Pablo.new
+
+        p.command :foo do |args, pablo|
+            assert_equal 1, args.length
+            assert_equal 'bar', args[0]
+            worked = true
+        end
+
+        p.parse %w{foo bar}
+        assert worked
+    end
+
+    def test_commands
+        worked = false
+        p = Pablo.new
+
+        p.command :foo do |args, pablo|
+            assert_equal 1, args.length
+            assert_equal 'bar', args[0]
+            worked = true
+        end
+
+        p.command :bar do
+            flunk 'two top-level commands called'
+        end
+
+        p.parse %w{foo bar}
+        assert worked
+    end
+
+    # ------------------ option -----------------
+
+    def test_option_negates
+        p = Pablo.new
+        p.option :nocolor, :negates => :color
+        p.option :dontshow, :negates => :show
+        p.option :foo
+        p.option :nofoo, :negates => :foo
+
+        p.parse ['--nocolor', '--dontshow', '--foo']
+
+        assert_equal false, p.options[:color]
+        assert_equal false, p.options[:show]
+        assert_equal true, p.options[:foo]
+    end
+
+    def test_option
+        worked = []
+        p = Pablo.new
+
+        p.option :foo do |args, pablo|
+            assert_equal 2, args.length
+            worked << :command
+        end
+
+        p.command :bar do |args, pablo|
+            assert_equal 1, args.length
+            worked << :option
+        end
+
+        p.parse %w{--foo bar baz}
+        assert_equal [:command, :option], worked
+    end
+
+    def test_options
+        worked = []
+        p = Pablo.new
+
+        p.option :goo do |args, pablo|
+            assert_equal 0, args.length
+            worked << :goo
+        end
+
+        p.option :foo do |args, pablo|
+            assert_equal 2, args.length
+            worked << :foo
+        end
+
+        p.command :bar do |args, pablo|
+            assert_equal 1, args.length
+            worked << :bar
+        end
+
+        p.parse %w{--foo bar baz --goo}
+        assert_equal [:goo, :foo, :bar], worked
+    end
+
+    # ------------------ token ------------------
+
+    def test_token
+        worked = []
+        p = Pablo.new
+
+        p.token do |args, pablo|
+            assert_equal 2, args.length
+            worked << :nil
+        end
+
+        p.token 'foo' do |args, pablo|
+            assert_equal 2, args.length
+            worked << :string
+        end
+
+        p.token(/^bar$/) do |args, pablo|
+            assert_equal 1, args.length
+            worked << :rex
+        end
+
+        p.token 'bar', 1 do |args, pablo|
+            assert_equal 1, args.length
+            worked << :pos
+        end
+
+        p.token 'bar', 0 do
+            flunk 'p.token called although specified on position 0'
+        end
+
+        p.command :bar do |args, pablo|
+            assert_equal 0, args.length
+            worked << :sym
+        end
+
+        p.parse %w{foo bar}
+        assert_equal [:nil, :string, :rex, :pos, :sym], worked
+    end
+
+    # ------------------ mixed ------------------
+
+    def test_parser_caches
+        p = Pablo.new
+        p.option :foo
+        p.option :bar
+        p.parse %w{--foo --bar}
+        assert p.options[:foo]
+        assert p.options[:bar]
+
+        p = Pablo.new
+        p.command :foo
+        p.command :bar
+        p.parse %w{foo bar}
+        assert p.commands[:foo]
+        assert_nil p.commands[:bar]
+
+        p = Pablo.new
+        p.option :foo
+        p.option :bar
+        p.parse %w{--foo --bar}
+        assert p.options[:foo]
+        assert p.options[:bar]
+    end
+
+    def test_register
+        p = Pablo.new
+        p.desc "foo"
+        p.longdesc "foo"
+        p.command :foo
+
+        p.desc "bar"
+        p.longdesc "bar"
+        p.option :bar
+
+        p.desc "goo"
+        p.longdesc "goo"
+        p.token :goo
+
+        p.parse ['foo', '--bar', 'goo']
+        assert_equal 3, p.registered.length
+        assert_equal [:foo], p.registered[0].names
+        assert_equal [:bar], p.registered[1].names
+        assert_equal [:goo], p.registered[2].names
+    end
+
+    def test_multiple_names
+        [%w{foo}, %w{bar}].each do |arr|
+            worked = false
+    
+            p = Pablo.new
+            p.command :foo, :bar do
+                worked = true
+            end
+
+            p.parse arr
+            assert worked
+        end
+
+        [%w{--foo}, %w{--nobar}].each do |arr|
+            worked = false
+    
+            p = Pablo.new
+            p.option :foo, :nobar, :negates => :bar do
+                worked = true
+            end
+
+            p.parse arr
+            assert worked
+        end
+
+        [%w{foo}, %w{bar}].each do |arr|
+            worked = false
+    
+            p = Pablo.new
+            p.token :foo, :bar do
+                worked = true
+            end
+
+            p.parse arr
+            assert worked
+        end
+    end
+
+    def test_consume_opt
+        [1, /bar/, %w{foo bar}, 'bar'].each do |c|
+            p = Pablo.new
+            p.option :foo, :consume => c
+            p.parse %w{--foo bar}
+            assert_equal 'bar', p.options[:foo]
+
+            p = Pablo.new
+            p.token :foo, :consume => c
+            p.parse %w{bar}
+            assert_equal "bar", p.tokens[:foo]
+
+            p = Pablo.new
+            p.command :foo, :consume => c
+            p.parse %w{foo bar}
+            assert_equal "bar", p.commands[:foo]
+        end
+
+        p = Pablo.new
+        p.option :foo, :consume => 2
+        p.parse %w{--foo bar baz}
+        assert_equal %w{bar baz}, p.options[:foo]
+
+        p = Pablo.new
+        p.token :foo, :consume => 2
+        p.parse %w{foo bar baz}
+        assert_equal %w{foo bar}, p.tokens[:foo]
+
+        p = Pablo.new
+        p.command :foo, :consume => 2
+        p.parse %w{foo bar baz}
+        assert_equal %w{bar baz}, p.commands[:foo]
+    end
+
+    def test_defaults
+        p = Pablo.new
+        p.token :color, /asdf/, :default => :bar
+        p.option :nocolor, :default => :bar, :negates => :color
+        p.command :color, :default => :bar
+
+        p.token :gogo, :default => :bar do
+            p.tokens[:gogo] = :goo
+        end
+
+        p.option :gogo, :default => :bar do
+            p.options[:gogo] = :goo
+        end
+
+        p.command :gogo, :default => :bar do
+            p.commands[:gogo] = :goo
+        end
+
+        p.parse ['gogo', '--gogo']
+        assert_equal :bar, p.tokens[:color]
+        assert_equal :bar, p.options[:nocolor]
+        assert_equal :bar, p.commands[:color]
+        assert_equal :goo, p.commands[:gogo]
+        assert_equal :goo, p.options[:gogo]
+        assert_equal :goo, p.tokens[:gogo]
+    end
+
+    def test_subparsers
+        p = Pablo.new
+        p.command :foo do
+            p.command :bar
+        end
+
+        p.parse %w{foo bar}
+        assert p.commands[:foo]
+        assert p.commands[:bar]
+
+        p = Pablo.new
+        p.option :foo do
+            p.option :bar
+        end
+
+        p.parse %w{--foo -bar}
+        assert p.options[:foo]
+        assert p.options[:bar]
+
+        p = Pablo.new
+        p.token :foo do
+            p.token :bar
+        end
+
+        p.parse %w{foo bar}
+        assert p.tokens[:foo]
+        assert p.tokens[:bar]
+
+        p = Pablo.new
+        p.command :foo do
+            p.command :bar
+        end
+
+        p.parse %w{bar}
+        assert_nil p.commands[:foo]
+        assert_nil p.commands[:bar]
+
+        p = Pablo.new
+        p.option :foo do
+            p.option :bar
+        end
+
+        p.parse %w{bar}
+        assert_nil p.options[:foo]
+        assert_nil p.options[:bar]
+
+        p = Pablo.new
+        p.token :foo, /foo/ do
+            p.token :bar
+        end
+
+        p.parse %w{bar}
+        assert_nil p.tokens[:foo]
+        assert_nil p.tokens[:bar]
+    end
+
+    def test_consume_and_block
+        @worked = []
+        p = Pablo.new
+        p.command :foo, :consume_all => false, :consume => 1 do
+            @worked << :command
+        end
+
+        p.option :bar, :consume => 1 do
+            @worked << :option
+        end
+
+        p.token(:goo, /goo/, :consume => 1) do
+            @worked << :token
+        end
+
+        p.parse %w{foo good --bar bad goo}
+        assert_equal 'good', p.commands[:foo]
+        assert_equal 'bad', p.options[:bar]
+        assert_equal 'goo', p.tokens[:goo]
+        assert_equal [:command, :option, :token], @worked
+    end
+
+    def test_file_functions
+        p = Pablo.new
+        p.token :foo, :directory?
+        p.token :bar, :file?
+        p.token :baz, :exists?
+
+        p.parse [Dir.pwd]
+        assert p.tokens[:foo]
+        assert !p.tokens[:bar]
+        assert p.tokens[:baz]
+
+        p = Pablo.new
+        p.token :foo, :directory?
+        p.token :bar, :file?
+        p.token :baz, :exist?
+
+        p.parse [__FILE__]
+        assert !p.tokens[:foo]
+        assert p.tokens[:bar]
+        assert p.tokens[:baz]
+
+        p = Pablo.new
+        p.token :baz, :exist?
+
+        p.parse [__FILE__ + 'nanana']
+        assert !p.tokens[:baz]
+    end
+
+    def test_position
+        p = Pablo.new
+        p.token :foo, /foo/, 0
+        p.token :bar, /bar/, 0
+
+        p.parse %w{foo bar}
+        assert p.tokens[:foo]
+        assert_nil p.tokens[:bar]
+
+        p = Pablo.new
+        p.token :foo, /foo/, :position => 0
+        p.token :bar, /bar/, :position => 0
+
+        p.parse %w{foo bar}
+        assert p.tokens[:foo]
+        assert_nil p.tokens[:bar]
+
+        p = Pablo.new
+        p.token :foo, /foo/, 0..2
+        p.token :bar, /bar/, 0..2
+
+        p.parse %w{foo foo foo bar}
+        assert p.tokens[:foo]
+        assert_nil p.tokens[:bar]
+
+        p = Pablo.new
+        p.token :foo, /foo/, :position => 0..2
+        p.token :bar, /bar/, :position => 0..2
+
+        p.parse %w{foo foo foo bar}
+        assert p.tokens[:foo]
+        assert_nil p.tokens[:bar]
+    end
+
+end
+