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