+
where [options] are:
EOM
end
def test_floating_point_formatting
@p.opt :arg, "desc", :type => :float, :short => "f"
opts = nil
assert_nothing_raised { opts = @p.parse %w(-f 1) }
assert_equal 1.0, opts[:arg]
assert_nothing_raised { opts = @p.parse %w(-f 1.0) }
assert_equal 1.0, opts[:arg]
assert_nothing_raised { opts = @p.parse %w(-f 0.1) }
assert_equal 0.1, opts[:arg]
assert_nothing_raised { opts = @p.parse %w(-f .1) }
assert_equal 0.1, opts[:arg]
assert_nothing_raised { opts = @p.parse %w(-f .99999999999999999999) }
assert_equal 1.0, opts[:arg]
assert_nothing_raised { opts = @p.parse %w(-f -1) }
assert_equal(-1.0, opts[:arg])
assert_nothing_raised { opts = @p.parse %w(-f -1.0) }
assert_equal(-1.0, opts[:arg])
assert_nothing_raised { opts = @p.parse %w(-f -0.1) }
assert_equal(-0.1, opts[:arg])
assert_nothing_raised { opts = @p.parse %w(-f -.1) }
assert_equal(-0.1, opts[:arg])
assert_raises(CommandlineError) { @p.parse %w(-f a) }
assert_raises(CommandlineError) { @p.parse %w(-f 1a) }
assert_raises(CommandlineError) { @p.parse %w(-f 1.a) }
assert_raises(CommandlineError) { @p.parse %w(-f a.1) }
assert_raises(CommandlineError) { @p.parse %w(-f 1.0.0) }
assert_raises(CommandlineError) { @p.parse %w(-f .) }
assert_raises(CommandlineError) { @p.parse %w(-f -.) }
end
def test_date_formatting
@p.opt :arg, "desc", :type => :date, :short => 'd'
opts = nil
assert_nothing_raised { opts = @p.parse(['-d', 'Jan 4, 2007']) }
assert_equal Date.civil(2007, 1, 4), opts[:arg]
begin
require 'chronic'
assert_nothing_raised { opts = @p.parse(['-d', 'today']) }
assert_equal Date.today, opts[:arg]
rescue LoadError
# chronic is not available
end
end
def test_short_options_cant_be_numeric
assert_raises(ArgumentError) { @p.opt :arg, "desc", :short => "-1" }
@p.opt :a1b, "desc"
@p.opt :a2b, "desc"
assert_not_equal "2", @p.specs[:a2b][:short]
end
def test_short_options_can_be_weird
assert_nothing_raised { @p.opt :arg1, "desc", :short => "#" }
assert_nothing_raised { @p.opt :arg2, "desc", :short => "." }
assert_raises(ArgumentError) { @p.opt :arg3, "desc", :short => "-" }
end
def test_options_cant_be_set_multiple_times_if_not_specified
@p.opt :arg, "desc", :short => "-x"
assert_nothing_raised { @p.parse %w(-x) }
assert_raises(CommandlineError) { @p.parse %w(-x -x) }
assert_raises(CommandlineError) { @p.parse %w(-xx) }
end
def test_options_can_be_set_multiple_times_if_specified
assert_nothing_raised do
@p.opt :arg, "desc", :short => "-x", :multi => true
end
assert_nothing_raised { @p.parse %w(-x) }
assert_nothing_raised { @p.parse %w(-x -x) }
assert_nothing_raised { @p.parse %w(-xx) }
end
def test_short_options_with_multiple_options
opts = nil
assert_nothing_raised do
@p.opt :xarg, "desc", :short => "-x", :type => String, :multi => true
end
assert_nothing_raised { opts = @p.parse %w(-x a -x b) }
assert_equal %w(a b), opts[:xarg]
assert_equal [], @p.leftovers
end
def short_options_with_multiple_options_does_not_affect_flags_type
opts = nil
assert_nothing_raised do
@p.opt :xarg, "desc", :short => "-x", :type => :flag, :multi => true
end
assert_nothing_raised { opts = @p.parse %w(-x a) }
assert_equal true, opts[:xarg]
assert_equal %w(a), @p.leftovers
assert_nothing_raised { opts = @p.parse %w(-x a -x b) }
assert_equal true, opts[:xarg]
assert_equal %w(a b), @p.leftovers
assert_nothing_raised { opts = @p.parse %w(-xx a -x b) }
assert_equal true, opts[:xarg]
assert_equal %w(a b), @p.leftovers
end
def test_short_options_with_multiple_arguments
opts = nil
@p.opt :xarg, "desc", :type => :ints
assert_nothing_raised { opts = @p.parse %w(-x 3 4 0) }
assert_equal [3, 4, 0], opts[:xarg]
assert_equal [], @p.leftovers
@p.opt :yarg, "desc", :type => :floats
assert_nothing_raised { opts = @p.parse %w(-y 3.14 4.21 0.66) }
assert_equal [3.14, 4.21, 0.66], opts[:yarg]
assert_equal [], @p.leftovers
@p.opt :zarg, "desc", :type => :strings
assert_nothing_raised { opts = @p.parse %w(-z a b c) }
assert_equal %w(a b c), opts[:zarg]
assert_equal [], @p.leftovers
end
def test_short_options_with_multiple_options_and_arguments
opts = nil
@p.opt :xarg, "desc", :type => :ints, :multi => true
assert_nothing_raised { opts = @p.parse %w(-x 3 4 5 -x 6 7) }
assert_equal [[3, 4, 5], [6, 7]], opts[:xarg]
assert_equal [], @p.leftovers
@p.opt :yarg, "desc", :type => :floats, :multi => true
assert_nothing_raised { opts = @p.parse %w(-y 3.14 4.21 5.66 -y 6.99 7.01) }
assert_equal [[3.14, 4.21, 5.66], [6.99, 7.01]], opts[:yarg]
assert_equal [], @p.leftovers
@p.opt :zarg, "desc", :type => :strings, :multi => true
assert_nothing_raised { opts = @p.parse %w(-z a b c -z d e) }
assert_equal [%w(a b c), %w(d e)], opts[:zarg]
assert_equal [], @p.leftovers
end
def test_combined_short_options_with_multiple_arguments
@p.opt :arg1, "desc", :short => "a"
@p.opt :arg2, "desc", :short => "b"
@p.opt :arg3, "desc", :short => "c", :type => :ints
@p.opt :arg4, "desc", :short => "d", :type => :floats
opts = nil
assert_nothing_raised { opts = @p.parse %w(-abc 4 6 9) }
assert_equal true, opts[:arg1]
assert_equal true, opts[:arg2]
assert_equal [4, 6, 9], opts[:arg3]
assert_nothing_raised { opts = @p.parse %w(-ac 4 6 9 -bd 3.14 2.41) }
assert_equal true, opts[:arg1]
assert_equal true, opts[:arg2]
assert_equal [4, 6, 9], opts[:arg3]
assert_equal [3.14, 2.41], opts[:arg4]
assert_raises(CommandlineError) { opts = @p.parse %w(-abcd 3.14 2.41) }
end
def test_long_options_with_multiple_options
@p.opt :xarg, "desc", :type => String, :multi => true
opts = nil
assert_nothing_raised { opts = @p.parse %w(--xarg=a --xarg=b) }
assert_equal %w(a b), opts[:xarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--xarg a --xarg b) }
assert_equal %w(a b), opts[:xarg]
assert_equal [], @p.leftovers
end
def test_long_options_with_multiple_arguments
opts = nil
@p.opt :xarg, "desc", :type => :ints
assert_nothing_raised { opts = @p.parse %w(--xarg 3 2 5) }
assert_equal [3, 2, 5], opts[:xarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--xarg=3) }
assert_equal [3], opts[:xarg]
assert_equal [], @p.leftovers
@p.opt :yarg, "desc", :type => :floats
assert_nothing_raised { opts = @p.parse %w(--yarg 3.14 2.41 5.66) }
assert_equal [3.14, 2.41, 5.66], opts[:yarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--yarg=3.14) }
assert_equal [3.14], opts[:yarg]
assert_equal [], @p.leftovers
@p.opt :zarg, "desc", :type => :strings
assert_nothing_raised { opts = @p.parse %w(--zarg a b c) }
assert_equal %w(a b c), opts[:zarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--zarg=a) }
assert_equal %w(a), opts[:zarg]
assert_equal [], @p.leftovers
end
def test_long_options_with_multiple_options_and_arguments
opts = nil
@p.opt :xarg, "desc", :type => :ints, :multi => true
assert_nothing_raised { opts = @p.parse %w(--xarg 3 2 5 --xarg 2 1) }
assert_equal [[3, 2, 5], [2, 1]], opts[:xarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--xarg=3 --xarg=2) }
assert_equal [[3], [2]], opts[:xarg]
assert_equal [], @p.leftovers
@p.opt :yarg, "desc", :type => :floats, :multi => true
assert_nothing_raised { opts = @p.parse %w(--yarg 3.14 2.72 5 --yarg 2.41 1.41) }
assert_equal [[3.14, 2.72, 5], [2.41, 1.41]], opts[:yarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--yarg=3.14 --yarg=2.41) }
assert_equal [[3.14], [2.41]], opts[:yarg]
assert_equal [], @p.leftovers
@p.opt :zarg, "desc", :type => :strings, :multi => true
assert_nothing_raised { opts = @p.parse %w(--zarg a b c --zarg d e) }
assert_equal [%w(a b c), %w(d e)], opts[:zarg]
assert_equal [], @p.leftovers
assert_nothing_raised { opts = @p.parse %w(--zarg=a --zarg=d) }
assert_equal [%w(a), %w(d)], opts[:zarg]
assert_equal [], @p.leftovers
end
def test_long_options_also_take_equals
@p.opt :arg, "desc", :long => "arg", :type => String, :default => "hello"
opts = nil
assert_nothing_raised { opts = @p.parse %w() }
assert_equal "hello", opts[:arg]
assert_nothing_raised { opts = @p.parse %w(--arg goat) }
assert_equal "goat", opts[:arg]
assert_nothing_raised { opts = @p.parse %w(--arg=goat) }
assert_equal "goat", opts[:arg]
## actually, this next one is valid. empty string for --arg, and goat as a
## leftover.
## assert_raises(CommandlineError) { opts = @p.parse %w(--arg= goat) }
end
def test_auto_generated_long_names_convert_underscores_to_hyphens
@p.opt :hello_there
assert_equal "hello-there", @p.specs[:hello_there][:long]
end
def test_arguments_passed_through_block
@goat = 3
boat = 4
Parser.new(@goat) do |goat|
boat = goat
end
assert_equal @goat, boat
end
def test_help_has_default_banner
@p = Parser.new
sio = StringIO.new "w"
@p.parse []
@p.educate sio
help = sio.string.split "\n"
assert help[0] =~ /options/i
assert_equal 2, help.length # options, then -h
@p = Parser.new
@p.version "my version"
sio = StringIO.new "w"
@p.parse []
@p.educate sio
help = sio.string.split "\n"
assert help[0] =~ /my version/i
assert_equal 4, help.length # version, options, -h, -v
@p = Parser.new
@p.banner "my own banner"
sio = StringIO.new "w"
@p.parse []
@p.educate sio
help = sio.string.split "\n"
assert help[0] =~ /my own banner/i
assert_equal 2, help.length # banner, -h
end
def test_help_preserves_positions
@p.opt :zzz, "zzz"
@p.opt :aaa, "aaa"
sio = StringIO.new "w"
@p.educate sio
help = sio.string.split "\n"
assert help[1] =~ /zzz/
assert help[2] =~ /aaa/
end
def test_version_and_help_short_args_can_be_overridden
@p.opt :verbose, "desc", :short => "-v"
@p.opt :hello, "desc", :short => "-h"
@p.version "version"
assert_nothing_raised { @p.parse(%w(-v)) }
assert_raises(VersionNeeded) { @p.parse(%w(--version)) }
assert_nothing_raised { @p.parse(%w(-h)) }
assert_raises(HelpNeeded) { @p.parse(%w(--help)) }
end
def test_version_and_help_long_args_can_be_overridden
@p.opt :asdf, "desc", :long => "help"
@p.opt :asdf2, "desc2", :long => "version"
assert_nothing_raised { @p.parse %w() }
assert_nothing_raised { @p.parse %w(--help) }
assert_nothing_raised { @p.parse %w(--version) }
assert_nothing_raised { @p.parse %w(-h) }
assert_nothing_raised { @p.parse %w(-v) }
end
def test_version_and_help_override_errors
@p.opt :asdf, "desc", :type => String
@p.version "version"
assert_nothing_raised { @p.parse %w(--asdf goat) }
assert_raises(CommandlineError) { @p.parse %w(--asdf) }
assert_raises(HelpNeeded) { @p.parse %w(--asdf --help) }
assert_raises(VersionNeeded) { @p.parse %w(--asdf --version) }
end
def test_conflicts
@p.opt :one
assert_raises(ArgumentError) { @p.conflicts :one, :two }
@p.opt :two
assert_nothing_raised { @p.conflicts :one, :two }
assert_nothing_raised { @p.parse %w(--one) }
assert_nothing_raised { @p.parse %w(--two) }
assert_raises(CommandlineError) { opts = @p.parse %w(--one --two) }
@p.opt :hello
@p.opt :yellow
@p.opt :mellow
@p.opt :jello
@p.conflicts :hello, :yellow, :mellow, :jello
assert_raises(CommandlineError) { opts = @p.parse %w(--hello --yellow --mellow --jello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--hello --mellow --jello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--hello --jello) }
assert_nothing_raised { opts = @p.parse %w(--hello) }
assert_nothing_raised { opts = @p.parse %w(--jello) }
assert_nothing_raised { opts = @p.parse %w(--yellow) }
assert_nothing_raised { opts = @p.parse %w(--mellow) }
assert_nothing_raised { opts = @p.parse %w(--mellow --one) }
assert_nothing_raised { opts = @p.parse %w(--mellow --two) }
assert_raises(CommandlineError) { opts = @p.parse %w(--mellow --two --jello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--one --mellow --two --jello) }
end
def test_conflict_error_messages
@p.opt :one
@p.opt "two"
@p.conflicts :one, "two"
begin
@p.parse %w(--one --two)
flunk "no error thrown"
rescue CommandlineError => e
assert_match(/--one/, e.message)
assert_match(/--two/, e.message)
end
end
def test_depends
@p.opt :one
assert_raises(ArgumentError) { @p.depends :one, :two }
@p.opt :two
assert_nothing_raised { @p.depends :one, :two }
assert_nothing_raised { opts = @p.parse %w(--one --two) }
assert_raises(CommandlineError) { @p.parse %w(--one) }
assert_raises(CommandlineError) { @p.parse %w(--two) }
@p.opt :hello
@p.opt :yellow
@p.opt :mellow
@p.opt :jello
@p.depends :hello, :yellow, :mellow, :jello
assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--hello --mellow --jello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--hello --jello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--hello) }
assert_raises(CommandlineError) { opts = @p.parse %w(--mellow) }
assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello --one --two) }
assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello --one --two a b c) }
assert_raises(CommandlineError) { opts = @p.parse %w(--mellow --two --jello --one) }
end
def test_depend_error_messages
@p.opt :one
@p.opt "two"
@p.depends :one, "two"
assert_nothing_raised { @p.parse %w(--one --two) }
begin
@p.parse %w(--one)
flunk "no error thrown"
rescue CommandlineError => e
assert_match(/--one/, e.message)
assert_match(/--two/, e.message)
end
begin
@p.parse %w(--two)
flunk "no error thrown"
rescue CommandlineError => e
assert_match(/--one/, e.message)
assert_match(/--two/, e.message)
end
end
## courtesy neill zero
def test_two_required_one_missing_accuses_correctly
@p.opt "arg1", "desc1", :required => true
@p.opt "arg2", "desc2", :required => true
begin
@p.parse(%w(--arg1))
flunk "should have failed on a missing req"
rescue CommandlineError => e
assert e.message =~ /arg2/, "didn't mention arg2 in the error msg: #{e.message}"
end
begin
@p.parse(%w(--arg2))
flunk "should have failed on a missing req"
rescue CommandlineError => e
assert e.message =~ /arg1/, "didn't mention arg1 in the error msg: #{e.message}"
end
assert_nothing_raised { @p.parse(%w(--arg1 --arg2)) }
end
def test_stopwords_mixed
@p.opt "arg1", :default => false
@p.opt "arg2", :default => false
@p.stop_on %w(happy sad)
opts = @p.parse %w(--arg1 happy --arg2)
assert_equal true, opts["arg1"]
assert_equal false, opts["arg2"]
## restart parsing
@p.leftovers.shift
opts = @p.parse @p.leftovers
assert_equal false, opts["arg1"]
assert_equal true, opts["arg2"]
end
def test_stopwords_no_stopwords
@p.opt "arg1", :default => false
@p.opt "arg2", :default => false
@p.stop_on %w(happy sad)
opts = @p.parse %w(--arg1 --arg2)
assert_equal true, opts["arg1"]
assert_equal true, opts["arg2"]
## restart parsing
@p.leftovers.shift
opts = @p.parse @p.leftovers
assert_equal false, opts["arg1"]
assert_equal false, opts["arg2"]
end
def test_stopwords_multiple_stopwords
@p.opt "arg1", :default => false
@p.opt "arg2", :default => false
@p.stop_on %w(happy sad)
opts = @p.parse %w(happy sad --arg1 --arg2)
assert_equal false, opts["arg1"]
assert_equal false, opts["arg2"]
## restart parsing
@p.leftovers.shift
opts = @p.parse @p.leftovers
assert_equal false, opts["arg1"]
assert_equal false, opts["arg2"]
## restart parsing again
@p.leftovers.shift
opts = @p.parse @p.leftovers
assert_equal true, opts["arg1"]
assert_equal true, opts["arg2"]
end
def test_stopwords_with_short_args
@p.opt :global_option, "This is a global option", :short => "-g"
@p.stop_on %w(sub-command-1 sub-command-2)
global_opts = @p.parse %w(-g sub-command-1 -c)
cmd = @p.leftovers.shift
@q = Parser.new
@q.opt :cmd_option, "This is an option only for the subcommand", :short => "-c"
cmd_opts = @q.parse @p.leftovers
assert_equal true, global_opts[:global_option]
assert_nil global_opts[:cmd_option]
assert_equal true, cmd_opts[:cmd_option]
assert_nil cmd_opts[:global_option]
assert_equal cmd, "sub-command-1"
assert_equal @q.leftovers, []
end
def assert_parses_correctly(parser, commandline, expected_opts,
expected_leftovers)
opts = parser.parse commandline
assert_equal expected_opts, opts
assert_equal expected_leftovers, parser.leftovers
end
def test_unknown_subcommand
@p.opt :global_flag, "Global flag", :short => "-g", :type => :flag
@p.opt :global_param, "Global parameter", :short => "-p", :default => 5
@p.stop_on_unknown
expected_opts = { :global_flag => true, :help => false, :global_param => 5, :global_flag_given => true }
expected_leftovers = [ "my_subcommand", "-c" ]
assert_parses_correctly @p, %w(--global-flag my_subcommand -c), \
expected_opts, expected_leftovers
assert_parses_correctly @p, %w(-g my_subcommand -c), \
expected_opts, expected_leftovers
expected_opts = { :global_flag => false, :help => false, :global_param => 5, :global_param_given => true }
expected_leftovers = [ "my_subcommand", "-c" ]
assert_parses_correctly @p, %w(-p 5 my_subcommand -c), \
expected_opts, expected_leftovers
assert_parses_correctly @p, %w(--global-param 5 my_subcommand -c), \
expected_opts, expected_leftovers
end
def test_alternate_args
args = %w(-a -b -c)
opts = ::Trollop.options(args) do
opt :alpher, "Ralph Alpher", :short => "-a"
opt :bethe, "Hans Bethe", :short => "-b"
opt :gamow, "George Gamow", :short => "-c"
end
physicists_with_humor = [:alpher, :bethe, :gamow]
physicists_with_humor.each do |physicist|
assert_equal true, opts[physicist]
end
end
def test_io_arg_type
@p.opt :arg, "desc", :type => :io
@p.opt :arg2, "desc", :type => IO
@p.opt :arg3, "desc", :default => $stdout
opts = nil
assert_nothing_raised { opts = @p.parse() }
assert_equal $stdout, opts[:arg3]
assert_nothing_raised { opts = @p.parse %w(--arg /dev/null) }
assert_kind_of File, opts[:arg]
assert_equal "/dev/null", opts[:arg].path
#TODO: move to mocks
#assert_nothing_raised { opts = @p.parse %w(--arg2 http://google.com/) }
#assert_kind_of StringIO, opts[:arg2]
assert_nothing_raised { opts = @p.parse %w(--arg3 stdin) }
assert_equal $stdin, opts[:arg3]
assert_raises(CommandlineError) { opts = @p.parse %w(--arg /fdasfasef/fessafef/asdfasdfa/fesasf) }
end
def test_openstruct_style_access
@p.opt "arg1", "desc", :type => :int
@p.opt :arg2, "desc", :type => :int
opts = @p.parse(%w(--arg1 3 --arg2 4))
assert_nothing_raised { opts.arg1 }
assert_nothing_raised { opts.arg2 }
assert_equal 3, opts.arg1
assert_equal 4, opts.arg2
end
def test_multi_args_autobox_defaults
@p.opt :arg1, "desc", :default => "hello", :multi => true
@p.opt :arg2, "desc", :default => ["hello"], :multi => true
opts = @p.parse
assert_equal ["hello"], opts[:arg1]
assert_equal ["hello"], opts[:arg2]
opts = @p.parse %w(--arg1 hello)
assert_equal ["hello"], opts[:arg1]
assert_equal ["hello"], opts[:arg2]
opts = @p.parse %w(--arg1 hello --arg1 there)
assert_equal ["hello", "there"], opts[:arg1]
end
def test_ambigious_multi_plus_array_default_resolved_as_specified_by_documentation
@p.opt :arg1, "desc", :default => ["potato"], :multi => true
@p.opt :arg2, "desc", :default => ["potato"], :multi => true, :type => :strings
@p.opt :arg3, "desc", :default => ["potato"]
@p.opt :arg4, "desc", :default => ["potato", "rhubarb"], :short => :none, :multi => true
## arg1 should be multi-occurring but not multi-valued
opts = @p.parse %w(--arg1 one two)
assert_equal ["one"], opts[:arg1]
assert_equal ["two"], @p.leftovers
opts = @p.parse %w(--arg1 one --arg1 two)
assert_equal ["one", "two"], opts[:arg1]
assert_equal [], @p.leftovers
## arg2 should be multi-valued and multi-occurring
opts = @p.parse %w(--arg2 one two)
assert_equal [["one", "two"]], opts[:arg2]
assert_equal [], @p.leftovers
## arg3 should be multi-valued but not multi-occurring
opts = @p.parse %w(--arg3 one two)
assert_equal ["one", "two"], opts[:arg3]
assert_equal [], @p.leftovers
## arg4 should be multi-valued but not multi-occurring
opts = @p.parse %w()
assert_equal ["potato", "rhubarb"], opts[:arg4]
end
def test_given_keys
@p.opt :arg1
@p.opt :arg2
opts = @p.parse %w(--arg1)
assert opts[:arg1_given]
assert !opts[:arg2_given]
opts = @p.parse %w(--arg2)
assert !opts[:arg1_given]
assert opts[:arg2_given]
opts = @p.parse []
assert !opts[:arg1_given]
assert !opts[:arg2_given]
opts = @p.parse %w(--arg1 --arg2)
assert opts[:arg1_given]
assert opts[:arg2_given]
end
def test_default_shorts_assigned_only_after_user_shorts
@p.opt :aab, "aaa" # should be assigned to -b
@p.opt :ccd, "bbb" # should be assigned to -d
@p.opt :user1, "user1", :short => 'a'
@p.opt :user2, "user2", :short => 'c'
opts = @p.parse %w(-a -b)
assert opts[:user1]
assert !opts[:user2]
assert opts[:aab]
assert !opts[:ccd]
opts = @p.parse %w(-c -d)
assert !opts[:user1]
assert opts[:user2]
assert !opts[:aab]
assert opts[:ccd]
end
def test_accepts_arguments_with_spaces
@p.opt :arg1, "arg", :type => String
@p.opt :arg2, "arg2", :type => String
opts = @p.parse ["--arg1", "hello there", "--arg2=hello there"]
assert_equal "hello there", opts[:arg1]
assert_equal "hello there", opts[:arg2]
assert_equal 0, @p.leftovers.size
end
def test_multi_args_default_to_empty_array
@p.opt :arg1, "arg", :multi => true
opts = @p.parse ""
assert_equal [], opts[:arg1]
end
end
end
end
================================================
FILE: vendor/gems/trollop/www/index.html
================================================
Trollop
Trollop
Current project news: see the blog.
Trollop is a commandline option parser for Ruby that gets out of your
way. One line of code per option is all you need to write. For that, you get
a nice automatically-generated help page (fit to your screen size!), robust
option parsing, command subcompletion, and sensible defaults for everything you
don't specify.
Reasons to use Trollop:
- It requires fewer lines of code than any other option out there.
- It doesn't require you to subclass some shit just to use a damn option parser.
- It's a single file. You don't even need to make it a dependency. Just throw it in
lib/.
- This gradient-free webpage. Fight the candy!
To install, you have three options:
- Trollop is a single file with no dependencies. You can just download it and throw it in your code directory.
- You can use rubygems and command your computer to
gem install trollop.
- You can download the tarball (why?) from the Trollop Rubyforge page.
To hack, command your computer to git clone git://gitorious.org/trollop/mainline.git, or see the Trollop Gitorious page.
To understand, read the examples below, the FAQ, and the API docs.
Examples
Simple
require 'trollop'
opts = Trollop::options do
opt :monkey, "Use monkey mode"
opt :goat, "Use goat mode", :default => true
opt :num_limbs, "Number of limbs", :default => 4
opt :num_thumbs, "Number of thumbs", :type => :int
end
p opts
- Trollop::options returns a hash of values. That's all the output you get.
- Underscores are converted to dashes. opt :hello_there corresponds to an option --hello-there.
- All options are taken to be boolean flags, defaulting to false, unless you specify a default or a type. The type will be inferred from the default if given, so no need to specify both.
- Short (one-character) option names are created automatically. You can set them manually with :short.
Medium
require 'trollop'
opts = Trollop::options do
version "test 1.2.3 (c) 2008 William Morgan"
banner <<-EOS
Test is an awesome program that does something very, very important.
Usage:
test [options] <filenames>+
where [options] are:
EOS
opt :ignore, "Ignore incorrect values"
opt :file, "Extra data filename to read in, with a very long option description like this one", :type => String
opt :volume, "Volume level", :default => 3.0
opt :iters, "Number of iterations", :default => 5
end
Trollop::die :volume, "must be non-negative" if opts[:volume] < 0
Trollop::die :file, "must exist" unless File.exist?(opts[:file]) if opts[:file]
- You can specify a version and some banner text for the help message. --help and --version are defined for you.
- Any special error-checking is done by you, on the option hash. You can call Trollop::die to die with a nice message.
Sub-commands, a la SVN and Git
require 'trollop'
SUB_COMMANDS = %w(delete copy)
global_opts = Trollop::options do
banner "magic file deleting and copying utility"
opt :dry_run, "Don't actually do anything", :short => "-n"
stop_on SUB_COMMANDS
end
cmd = ARGV.shift
cmd_opts = case cmd
when "delete"
Trollop::options do
opt :force, "Force deletion"
end
when "copy"
Trollop::options do
opt :double, "Copy twice for safety's sake"
end
else
Trollop::die "unknown subcommand #{cmd.inspect}"
end
puts "Global options: #{global_opts.inspect}"
puts "Subcommand: #{cmd.inspect}"
puts "Subcommand options: #{cmd_opts.inspect}"
puts "Remaining arguments: #{ARGV.inspect}"
Contributors
Trollop is brought to you by William Morgan and by:
- Tuomas Kareinen <tkareine at the gmail dot coms>
- Ohad Lutzky <ohad at the lutzky dot nets>
- Erik Ostrom <erik at the echographia dot coms>
================================================
FILE: vendor/gems/xml-simple/lib/xmlsimple.rb
================================================
# = XmlSimple
#
# Author:: Maik Schmidt
# Copyright:: Copyright (c) 2003-2009 Maik Schmidt
# License:: Distributes under the same terms as Ruby.
#
require 'rexml/document'
require 'stringio'
# Easy API to maintain XML (especially configuration files).
class XmlSimple
include REXML
@@VERSION = '1.0.12'
# A simple cache for XML documents that were already transformed
# by xml_in.
class Cache
# Creates and initializes a new Cache object.
def initialize
@mem_share_cache = {}
@mem_copy_cache = {}
end
# Saves a data structure into a file.
#
# data::
# Data structure to be saved.
# filename::
# Name of the file belonging to the data structure.
def save_storable(data, filename)
cache_file = get_cache_filename(filename)
File.open(cache_file, "w+") { |f| Marshal.dump(data, f) }
end
# Restores a data structure from a file. If restoring the data
# structure failed for any reason, nil will be returned.
#
# filename::
# Name of the file belonging to the data structure.
def restore_storable(filename)
cache_file = get_cache_filename(filename)
return nil unless File::exist?(cache_file)
return nil unless File::mtime(cache_file).to_i > File::mtime(filename).to_i
data = nil
File.open(cache_file) { |f| data = Marshal.load(f) }
data
end
# Saves a data structure in a shared memory cache.
#
# data::
# Data structure to be saved.
# filename::
# Name of the file belonging to the data structure.
def save_mem_share(data, filename)
@mem_share_cache[filename] = [Time::now.to_i, data]
end
# Restores a data structure from a shared memory cache. You
# should consider these elements as "read only". If restoring
# the data structure failed for any reason, nil will be
# returned.
#
# filename::
# Name of the file belonging to the data structure.
def restore_mem_share(filename)
get_from_memory_cache(filename, @mem_share_cache)
end
# Copies a data structure to a memory cache.
#
# data::
# Data structure to be copied.
# filename::
# Name of the file belonging to the data structure.
def save_mem_copy(data, filename)
@mem_share_cache[filename] = [Time::now.to_i, Marshal.dump(data)]
end
# Restores a data structure from a memory cache. If restoring
# the data structure failed for any reason, nil will be
# returned.
#
# filename::
# Name of the file belonging to the data structure.
def restore_mem_copy(filename)
data = get_from_memory_cache(filename, @mem_share_cache)
data = Marshal.load(data) unless data.nil?
data
end
private
# Returns the "cache filename" belonging to a filename, i.e.
# the extension '.xml' in the original filename will be replaced
# by '.stor'. If filename does not have this extension, '.stor'
# will be appended.
#
# filename::
# Filename to get "cache filename" for.
def get_cache_filename(filename)
filename.sub(/(\.xml)?$/, '.stor')
end
# Returns a cache entry from a memory cache belonging to a
# certain filename. If no entry could be found for any reason,
# nil will be returned.
#
# filename::
# Name of the file the cache entry belongs to.
# cache::
# Memory cache to get entry from.
def get_from_memory_cache(filename, cache)
return nil unless cache[filename]
return nil unless cache[filename][0] > File::mtime(filename).to_i
return cache[filename][1]
end
end
# Create a "global" cache.
@@cache = Cache.new
# Creates and intializes a new XmlSimple object.
#
# defaults::
# Default values for options.
def initialize(defaults = nil)
unless defaults.nil? || defaults.instance_of?(Hash)
raise ArgumentError, "Options have to be a Hash."
end
@default_options = normalize_option_names(defaults, (KNOWN_OPTIONS['in'] + KNOWN_OPTIONS['out']).uniq)
@options = Hash.new
@_var_values = nil
end
# Converts an XML document in the same way as the Perl module XML::Simple.
#
# string::
# XML source. Could be one of the following:
#
# - nil: Tries to load and parse '.xml'.
# - filename: Tries to load and parse filename.
# - IO object: Reads from object until EOF is detected and parses result.
# - XML string: Parses string.
#
# options::
# Options to be used.
def xml_in(string = nil, options = nil)
handle_options('in', options)
# If no XML string or filename was supplied look for scriptname.xml.
if string.nil?
string = File::basename($0).dup
string.sub!(/\.[^.]+$/, '')
string += '.xml'
directory = File::dirname($0)
@options['searchpath'].unshift(directory) unless directory.nil?
end
if string.instance_of?(String)
if string =~ /<.*?>/m
@doc = parse(string)
elsif string == '-'
@doc = parse($stdin.read)
else
filename = find_xml_file(string, @options['searchpath'])
if @options.has_key?('cache')
@options['cache'].each { |scheme|
case(scheme)
when 'storable'
content = @@cache.restore_storable(filename)
when 'mem_share'
content = @@cache.restore_mem_share(filename)
when 'mem_copy'
content = @@cache.restore_mem_copy(filename)
else
raise ArgumentError, "Unsupported caching scheme: <#{scheme}>."
end
return content if content
}
end
@doc = load_xml_file(filename)
end
elsif string.kind_of?(IO) || string.kind_of?(StringIO) || string.kind_of?(Zlib::GzipReader)
@doc = parse(string.read)
else
raise ArgumentError, "Could not parse object of type: <#{string.type}>."
end
result = collapse(@doc.root)
result = @options['keeproot'] ? merge({}, @doc.root.name, result) : result
put_into_cache(result, filename)
result
end
# This is the functional version of the instance method xml_in.
def XmlSimple.xml_in(string = nil, options = nil)
xml_simple = XmlSimple.new
xml_simple.xml_in(string, options)
end
# Converts a data structure into an XML document.
#
# ref::
# Reference to data structure to be converted into XML.
# options::
# Options to be used.
def xml_out(ref, options = nil)
handle_options('out', options)
if ref.instance_of?(Array)
ref = { @options['anonymoustag'] => ref }
end
if @options['keeproot']
keys = ref.keys
if keys.size == 1
ref = ref[keys[0]]
@options['rootname'] = keys[0]
end
elsif @options['rootname'] == ''
if ref.instance_of?(Hash)
refsave = ref
ref = {}
refsave.each { |key, value|
if !scalar(value)
ref[key] = value
else
ref[key] = [ value.to_s ]
end
}
end
end
@ancestors = []
xml = value_to_xml(ref, @options['rootname'], '')
@ancestors = nil
if @options['xmldeclaration']
xml = @options['xmldeclaration'] + "\n" + xml
end
if @options.has_key?('outputfile')
if @options['outputfile'].kind_of?(IO)
return @options['outputfile'].write(xml)
else
File.open(@options['outputfile'], "w") { |file| file.write(xml) }
end
end
xml
end
# This is the functional version of the instance method xml_out.
def XmlSimple.xml_out(hash, options = nil)
xml_simple = XmlSimple.new
xml_simple.xml_out(hash, options)
end
private
# Declare options that are valid for xml_in and xml_out.
KNOWN_OPTIONS = {
'in' => %w(
keyattr keeproot forcecontent contentkey noattr
searchpath forcearray suppressempty anonymoustag
cache grouptags normalisespace normalizespace
variables varattr keytosymbol attrprefix
),
'out' => %w(
keyattr keeproot contentkey noattr rootname
xmldeclaration outputfile noescape suppressempty
anonymoustag indent grouptags noindent attrprefix
)
}
# Define some reasonable defaults.
DEF_KEY_ATTRIBUTES = []
DEF_ROOT_NAME = 'opt'
DEF_CONTENT_KEY = 'content'
DEF_XML_DECLARATION = ""
DEF_ANONYMOUS_TAG = 'anon'
DEF_FORCE_ARRAY = true
DEF_INDENTATION = ' '
DEF_KEY_TO_SYMBOL = false
# Normalizes option names in a hash, i.e., turns all
# characters to lower case and removes all underscores.
# Additionally, this method checks, if an unknown option
# was used and raises an according exception.
#
# options::
# Hash to be normalized.
# known_options::
# List of known options.
def normalize_option_names(options, known_options)
return nil if options.nil?
result = Hash.new
options.each { |key, value|
lkey = key.downcase
lkey.gsub!(/_/, '')
if !known_options.member?(lkey)
raise ArgumentError, "Unrecognised option: #{lkey}."
end
result[lkey] = value
}
result
end
# Merges a set of options with the default options.
#
# direction::
# 'in': If options should be handled for xml_in.
# 'out': If options should be handled for xml_out.
# options::
# Options to be merged with the default options.
def handle_options(direction, options)
@options = options || Hash.new
raise ArgumentError, "Options must be a Hash!" unless @options.instance_of?(Hash)
unless KNOWN_OPTIONS.has_key?(direction)
raise ArgumentError, "Unknown direction: <#{direction}>."
end
known_options = KNOWN_OPTIONS[direction]
@options = normalize_option_names(@options, known_options)
unless @default_options.nil?
known_options.each { |option|
unless @options.has_key?(option)
if @default_options.has_key?(option)
@options[option] = @default_options[option]
end
end
}
end
unless @options.has_key?('noattr')
@options['noattr'] = false
end
if @options.has_key?('rootname')
@options['rootname'] = '' if @options['rootname'].nil?
else
@options['rootname'] = DEF_ROOT_NAME
end
if @options.has_key?('xmldeclaration') && @options['xmldeclaration'] == true
@options['xmldeclaration'] = DEF_XML_DECLARATION
end
@options['keytosymbol'] = DEF_KEY_TO_SYMBOL unless @options.has_key?('keytosymbol')
if @options.has_key?('contentkey')
if @options['contentkey'] =~ /^-(.*)$/
@options['contentkey'] = $1
@options['collapseagain'] = true
end
else
@options['contentkey'] = DEF_CONTENT_KEY
end
unless @options.has_key?('normalisespace')
@options['normalisespace'] = @options['normalizespace']
end
@options['normalisespace'] = 0 if @options['normalisespace'].nil?
if @options.has_key?('searchpath')
unless @options['searchpath'].instance_of?(Array)
@options['searchpath'] = [ @options['searchpath'] ]
end
else
@options['searchpath'] = []
end
if @options.has_key?('cache') && scalar(@options['cache'])
@options['cache'] = [ @options['cache'] ]
end
@options['anonymoustag'] = DEF_ANONYMOUS_TAG unless @options.has_key?('anonymoustag')
if !@options.has_key?('indent') || @options['indent'].nil?
@options['indent'] = DEF_INDENTATION
end
@options['indent'] = '' if @options.has_key?('noindent')
# Special cleanup for 'keyattr' which could be an array or
# a hash or left to default to array.
if @options.has_key?('keyattr')
if !scalar(@options['keyattr'])
# Convert keyattr => { elem => '+attr' }
# to keyattr => { elem => ['attr', '+'] }
if @options['keyattr'].instance_of?(Hash)
@options['keyattr'].each { |key, value|
if value =~ /^([-+])?(.*)$/
@options['keyattr'][key] = [$2, $1 ? $1 : '']
end
}
elsif !@options['keyattr'].instance_of?(Array)
raise ArgumentError, "'keyattr' must be String, Hash, or Array!"
end
else
@options['keyattr'] = [ @options['keyattr'] ]
end
else
@options['keyattr'] = DEF_KEY_ATTRIBUTES
end
if @options.has_key?('forcearray')
if @options['forcearray'].instance_of?(Regexp)
@options['forcearray'] = [ @options['forcearray'] ]
end
if @options['forcearray'].instance_of?(Array)
force_list = @options['forcearray']
unless force_list.empty?
@options['forcearray'] = {}
force_list.each { |tag|
if tag.instance_of?(Regexp)
unless @options['forcearray']['_regex'].instance_of?(Array)
@options['forcearray']['_regex'] = []
end
@options['forcearray']['_regex'] << tag
else
@options['forcearray'][tag] = true
end
}
else
@options['forcearray'] = false
end
else
@options['forcearray'] = @options['forcearray'] ? true : false
end
else
@options['forcearray'] = DEF_FORCE_ARRAY
end
if @options.has_key?('grouptags') && !@options['grouptags'].instance_of?(Hash)
raise ArgumentError, "Illegal value for 'GroupTags' option - expected a Hash."
end
if @options.has_key?('variables') && !@options['variables'].instance_of?(Hash)
raise ArgumentError, "Illegal value for 'Variables' option - expected a Hash."
end
if @options.has_key?('variables')
@_var_values = @options['variables']
elsif @options.has_key?('varattr')
@_var_values = {}
end
end
# Actually converts an XML document element into a data structure.
#
# element::
# The document element to be collapsed.
def collapse(element)
result = @options['noattr'] ? {} : get_attributes(element)
if @options['normalisespace'] == 2
result.each { |k, v| result[k] = normalise_space(v) }
end
if element.has_elements?
element.each_element { |child|
value = collapse(child)
if empty(value) && (element.attributes.empty? || @options['noattr'])
next if @options.has_key?('suppressempty') && @options['suppressempty'] == true
end
result = merge(result, child.name, value)
}
if has_mixed_content?(element)
# normalisespace?
content = element.texts.map { |x| x.to_s }
content = content[0] if content.size == 1
result[@options['contentkey']] = content
end
elsif element.has_text? # i.e. it has only text.
return collapse_text_node(result, element)
end
# Turn Arrays into Hashes if key fields present.
count = fold_arrays(result)
# Disintermediate grouped tags.
if @options.has_key?('grouptags')
result.each { |key, value|
next unless (value.instance_of?(Hash) && (value.size == 1))
child_key, child_value = value.to_a[0]
if @options['grouptags'][key] == child_key
result[key] = child_value
end
}
end
# Fold Hashes containing a single anonymous Array up into just the Array.
if count == 1
anonymoustag = @options['anonymoustag']
if result.has_key?(anonymoustag) && result[anonymoustag].instance_of?(Array)
return result[anonymoustag]
end
end
if result.empty? && @options.has_key?('suppressempty')
return @options['suppressempty'] == '' ? '' : nil
end
result
end
# Collapses a text node and merges it with an existing Hash, if
# possible.
# Thanks to Curtis Schofield for reporting a subtle bug.
#
# hash::
# Hash to merge text node value with, if possible.
# element::
# Text node to be collapsed.
def collapse_text_node(hash, element)
value = node_to_text(element)
if empty(value) && !element.has_attributes?
return {}
end
if element.has_attributes? && !@options['noattr']
return merge(hash, @options['contentkey'], value)
else
if @options['forcecontent']
return merge(hash, @options['contentkey'], value)
else
return value
end
end
end
# Folds all arrays in a Hash.
#
# hash::
# Hash to be folded.
def fold_arrays(hash)
fold_amount = 0
keyattr = @options['keyattr']
if (keyattr.instance_of?(Array) || keyattr.instance_of?(Hash))
hash.each { |key, value|
if value.instance_of?(Array)
if keyattr.instance_of?(Array)
hash[key] = fold_array(value)
else
hash[key] = fold_array_by_name(key, value)
end
fold_amount += 1
end
}
end
fold_amount
end
# Folds an Array to a Hash, if possible. Folding happens
# according to the content of keyattr, which has to be
# an array.
#
# array::
# Array to be folded.
def fold_array(array)
hash = Hash.new
array.each { |x|
return array unless x.instance_of?(Hash)
key_matched = false
@options['keyattr'].each { |key|
if x.has_key?(key)
key_matched = true
value = x[key]
return array if value.instance_of?(Hash) || value.instance_of?(Array)
value = normalise_space(value) if @options['normalisespace'] == 1
x.delete(key)
hash[value] = x
break
end
}
return array unless key_matched
}
hash = collapse_content(hash) if @options['collapseagain']
hash
end
# Folds an Array to a Hash, if possible. Folding happens
# according to the content of keyattr, which has to be
# a Hash.
#
# name::
# Name of the attribute to be folded upon.
# array::
# Array to be folded.
def fold_array_by_name(name, array)
return array unless @options['keyattr'].has_key?(name)
key, flag = @options['keyattr'][name]
hash = Hash.new
array.each { |x|
if x.instance_of?(Hash) && x.has_key?(key)
value = x[key]
return array if value.instance_of?(Hash) || value.instance_of?(Array)
value = normalise_space(value) if @options['normalisespace'] == 1
hash[value] = x
hash[value]["-#{key}"] = hash[value][key] if flag == '-'
hash[value].delete(key) unless flag == '+'
else
$stderr.puts("Warning: <#{name}> element has no '#{key}' attribute.")
return array
end
}
hash = collapse_content(hash) if @options['collapseagain']
hash
end
# Tries to collapse a Hash even more ;-)
#
# hash::
# Hash to be collapsed again.
def collapse_content(hash)
content_key = @options['contentkey']
hash.each_value { |value|
return hash unless value.instance_of?(Hash) && value.size == 1 && value.has_key?(content_key)
hash.each_key { |key| hash[key] = hash[key][content_key] }
}
hash
end
# Adds a new key/value pair to an existing Hash. If the key to be added
# does already exist and the existing value associated with key is not
# an Array, it will be converted into an Array. Then the new value is
# appended to that Array.
#
# hash::
# Hash to add key/value pair to.
# key::
# Key to be added.
# value::
# Value to be associated with key.
def merge(hash, key, value)
if value.instance_of?(String)
value = normalise_space(value) if @options['normalisespace'] == 2
# do variable substitutions
unless @_var_values.nil? || @_var_values.empty?
value.gsub!(/\$\{(\w+)\}/) { |x| get_var($1) }
end
# look for variable definitions
if @options.has_key?('varattr')
varattr = @options['varattr']
if hash.has_key?(varattr)
set_var(hash[varattr], value)
end
end
end
#patch for converting keys to symbols
if @options.has_key?('keytosymbol')
if @options['keytosymbol'] == true
key = key.to_s.downcase.to_sym
end
end
if hash.has_key?(key)
if hash[key].instance_of?(Array)
hash[key] << value
else
hash[key] = [ hash[key], value ]
end
elsif value.instance_of?(Array) # Handle anonymous arrays.
hash[key] = [ value ]
else
if force_array?(key)
hash[key] = [ value ]
else
hash[key] = value
end
end
hash
end
# Checks, if the 'forcearray' option has to be used for
# a certain key.
def force_array?(key)
return false if key == @options['contentkey']
return true if @options['forcearray'] == true
forcearray = @options['forcearray']
if forcearray.instance_of?(Hash)
return true if forcearray.has_key?(key)
return false unless forcearray.has_key?('_regex')
forcearray['_regex'].each { |x| return true if key =~ x }
end
return false
end
# Converts the attributes array of a document node into a Hash.
# Returns an empty Hash, if node has no attributes.
#
# node::
# Document node to extract attributes from.
def get_attributes(node)
attributes = {}
if @options['attrprefix']
node.attributes.each { |n,v| attributes["@" + n] = v }
else
node.attributes.each { |n,v| attributes[n] = v }
end
attributes
end
# Determines, if a document element has mixed content.
#
# element::
# Document element to be checked.
def has_mixed_content?(element)
if element.has_text? && element.has_elements?
return true if element.texts.join('') !~ /^\s*$/s
end
false
end
# Called when a variable definition is encountered in the XML.
# A variable definition looks like
# value
# where attrname matches the varattr setting.
def set_var(name, value)
@_var_values[name] = value
end
# Called during variable substitution to get the value for the
# named variable.
def get_var(name)
if @_var_values.has_key?(name)
return @_var_values[name]
else
return "${#{name}}"
end
end
# Recurses through a data structure building up and returning an
# XML representation of that structure as a string.
#
# ref::
# Reference to the data structure to be encoded.
# name::
# The XML tag name to be used for this item.
# indent::
# A string of spaces for use as the current indent level.
def value_to_xml(ref, name, indent)
named = !name.nil? && name != ''
nl = @options.has_key?('noindent') ? '' : "\n"
if !scalar(ref)
if @ancestors.member?(ref)
raise ArgumentError, "Circular data structures not supported!"
end
@ancestors << ref
else
if named
return [indent, '<', name, '>', @options['noescape'] ? ref.to_s : escape_value(ref.to_s), '', nl].join('')
else
return ref.to_s + nl
end
end
# Unfold hash to array if possible.
if ref.instance_of?(Hash) && !ref.empty? && !@options['keyattr'].empty? && indent != ''
ref = hash_to_array(name, ref)
end
result = []
if ref.instance_of?(Hash)
# Reintermediate grouped values if applicable.
if @options.has_key?('grouptags')
ref.each { |key, value|
if @options['grouptags'].has_key?(key)
ref[key] = { @options['grouptags'][key] => value }
end
}
end
nested = []
text_content = nil
if named
result << indent << '<' << name
end
if !ref.empty?
ref.each { |key, value|
next if !key.nil? && key[0, 1] == '-'
if value.nil?
unless @options.has_key?('suppressempty') && @options['suppressempty'].nil?
raise ArgumentError, "Use of uninitialized value!"
end
value = {}
end
# Check for the '@' attribute prefix to allow separation of attributes and elements
if @options['noattr'] ||
(@options['attrprefix'] && !(key =~ /^@(.*)/)) ||
!scalar(value)
nested << value_to_xml(value, key, indent + @options['indent'])
else
value = value.to_s
value = escape_value(value) unless @options['noescape']
if key == @options['contentkey']
text_content = value
else
result << ' ' << ($1||key) << '="' << value << '"'
end
end
}
else
text_content = ''
end
if !nested.empty? || !text_content.nil?
if named
result << '>'
if !text_content.nil?
result << text_content
nested[0].sub!(/^\s+/, '') if !nested.empty?
else
result << nl
end
if !nested.empty?
result << nested << indent
end
result << '' << nl
else
result << nested
end
else
result << ' />' << nl
end
elsif ref.instance_of?(Array)
ref.each { |value|
if scalar(value)
result << indent << '<' << name << '>'
result << (@options['noescape'] ? value.to_s : escape_value(value.to_s))
result << '' << nl
elsif value.instance_of?(Hash)
result << value_to_xml(value, name, indent)
else
result << indent << '<' << name << '>' << nl
result << value_to_xml(value, @options['anonymoustag'], indent + @options['indent'])
result << indent << '' << nl
end
}
else
# Probably, this is obsolete.
raise ArgumentError, "Can't encode a value of type: #{ref.type}."
end
@ancestors.pop if !scalar(ref)
result.join('')
end
# Checks, if a certain value is a "scalar" value. Whatever
# that will be in Ruby ... ;-)
#
# value::
# Value to be checked.
def scalar(value)
return false if value.instance_of?(Hash) || value.instance_of?(Array)
return true
end
# Attempts to unfold a hash of hashes into an array of hashes. Returns
# a reference to th array on success or the original hash, if unfolding
# is not possible.
#
# parent::
#
# hashref::
# Reference to the hash to be unfolded.
def hash_to_array(parent, hashref)
arrayref = []
hashref.each { |key, value|
return hashref unless value.instance_of?(Hash)
if @options['keyattr'].instance_of?(Hash)
return hashref unless @options['keyattr'].has_key?(parent)
arrayref << { @options['keyattr'][parent][0] => key }.update(value)
else
arrayref << { @options['keyattr'][0] => key }.update(value)
end
}
arrayref
end
# Replaces XML markup characters by their external entities.
#
# data::
# The string to be escaped.
def escape_value(data)
Text::normalize(data)
end
# Removes leading and trailing whitespace and sequences of
# whitespaces from a string.
#
# text::
# String to be normalised.
def normalise_space(text)
text.strip.gsub(/\s\s+/, ' ')
end
# Checks, if an object is nil, an empty String or an empty Hash.
# Thanks to Norbert Gawor for a bugfix.
#
# value::
# Value to be checked for emptyness.
def empty(value)
case value
when Hash
return value.empty?
when String
return value !~ /\S/m
else
return value.nil?
end
end
# Converts a document node into a String.
# If the node could not be converted into a String
# for any reason, default will be returned.
#
# node::
# Document node to be converted.
# default::
# Value to be returned, if node could not be converted.
def node_to_text(node, default = nil)
if node.instance_of?(REXML::Element)
node.texts.map { |t| t.value }.join('')
elsif node.instance_of?(REXML::Attribute)
node.value.nil? ? default : node.value.strip
elsif node.instance_of?(REXML::Text)
node.value.strip
else
default
end
end
# Parses an XML string and returns the according document.
#
# xml_string::
# XML string to be parsed.
#
# The following exception may be raised:
#
# REXML::ParseException::
# If the specified file is not wellformed.
def parse(xml_string)
Document.new(xml_string)
end
# Searches in a list of paths for a certain file. Returns
# the full path to the file, if it could be found. Otherwise,
# an exception will be raised.
#
# filename::
# Name of the file to search for.
# searchpath::
# List of paths to search in.
def find_xml_file(file, searchpath)
filename = File::basename(file)
if filename != file
return file if File::file?(file)
else
searchpath.each { |path|
full_path = File::join(path, filename)
return full_path if File::file?(full_path)
}
end
if searchpath.empty?
return file if File::file?(file)
raise ArgumentError, "File does not exist: #{file}."
end
raise ArgumentError, "Could not find <#{filename}> in <#{searchpath.join(':')}>"
end
# Loads and parses an XML configuration file.
#
# filename::
# Name of the configuration file to be loaded.
#
# The following exceptions may be raised:
#
# Errno::ENOENT::
# If the specified file does not exist.
# REXML::ParseException::
# If the specified file is not wellformed.
def load_xml_file(filename)
parse(IO::read(filename))
end
# Caches the data belonging to a certain file.
#
# data::
# Data to be cached.
# filename::
# Name of file the data was read from.
def put_into_cache(data, filename)
if @options.has_key?('cache')
@options['cache'].each { |scheme|
case(scheme)
when 'storable'
@@cache.save_storable(data, filename)
when 'mem_share'
@@cache.save_mem_share(data, filename)
when 'mem_copy'
@@cache.save_mem_copy(data, filename)
else
raise ArgumentError, "Unsupported caching scheme: <#{scheme}>."
end
}
end
end
end
# vim:sw=2
## Try it out
cd `gem env gemdir`/gems/jashmenn-git-style-binaries-0.1.4/test/fixtures
./wordpress -h
./wordpress help post
## Goal
Lets use the imaginary `wordpress` gem. Let's say we have three different
actions we want to specify:
* categories
* list
* post
Each command has its own binary in a directory structure like this:
bin/
|-- wordpress
|-- wordpress-categories
|-- wordpress-list
`-- wordpress-post
The goal is to be able to call commands in this manner:
wordpress -h # gives help summary of all commands
wordpress-list -h # gives long help of wordpress-list
wordpress list -h # ditto
echo "about me" | wordpress-post --title="new post" # posts a new post with that title
## Example code
Our `bin/wordpress` binary is called the *primary* . Our primary only needs to contain the following line:
#!/usr/bin/env ruby
require 'git-style-binary/command'
`git-style-binary` will automatically make this command the primary.
The `bin/wordpress-post` binary could contain the following:
#!/usr/bin/env ruby
require 'git-style-binary/command'
GitStyleBinary.command do
short_desc "create a blog post"
banner <<-EOS
Usage: #{command.full_name} #{all_options_string} {content|STDIN}
Posts content to a wordpress blog
EOS
opt :blog, "short name of the blog to use", :default => 'default'
opt :category, "tag/category. specify multiple times for multiple categories", :type => String, :multi => true
opt :title, "title for the post", :required => true, :type => String
opt :type, "type of the content [html|xhtml|text]", :default => 'html', :type => String
run do |command|
command.die :type, "type must be one of [html|xhtml|text]" unless command.opts[:type] =~ /^(x?html|text)$/i
puts "Subcommand name: #{command.name.inspect}"
puts "Options: #{command.opts.inspect}"
puts "Remaining arguments: #{command.argv.inspect}"
end
end
And so on with the other binaries.
## Running the binaries
Now if we run `wordpress -h` we get the following output:
NAME
wordpress
VERSION
0.0.1 (c) 2009 Nate Murray - local
SYNOPSIS
wordpress [--version] [--test-primary] [--help] [--verbose] COMMAND [ARGS]
SUBCOMMANDS
wordpress-categories
do something with categories
wordpress-help
get help for a specific command
wordpress-list
list blog postings
wordpress-post
create a blog post
See 'wordpress help COMMAND' for more information on a specific command.
OPTIONS
-v, --verbose
verbose
-t, --test-primary=