require 'spec_helper' describe Applix do it 'cluster defaults shadow globals' do args = %w(-c=5 cluster cmd) Applix.main(args, a: :global, b: 2, :cluster => {a: :cluster, c: 3}) do handle(:cmd) { raise 'should not be called!' } cluster(:cluster) do handle(:cmd) do |*args, options| options.should == {:a => :cluster, :b => 2, :c => '5'} args end end end end it 'calls cluster prolog' do Applix.main(%w(foo a b)) do cluster(:foo) do prolog { |args, options| args.should == %w(a b) args.reverse! } handle(:a) { raise 'should not be called!' } handle(:b) { :b_was_called } end end.should == :b_was_called end it 'support :cluster for nesting' do args = %w(-a -b:2 foo bar p1 p2) Applix.main(args) do handle(:foo) do raise 'should not be called!' end cluster(:foo) do handle(:bar) do |*args, options| args.should == %w(p1 p2) options.should == {:a => true, :b => 2} args end end end.should == %w{p1 p2} end it 'can even cluster clusters' do args = %w(foo bar f p1 p2) Applix.main(args) do cluster(:foo) do cluster(:bar) do handle(:f) do |*args, options| args.should == %w(p1 p2) options.should == {} args end end end end.should == %w{p1 p2} end it 'prolog can even temper with arguments to modify the handle sequence' do Applix.main(['a', 'b']) do prolog { |args, options| args.should == ['a', 'b'] args.reverse! } handle(:a) { raise 'should not be called!' } handle(:b) { :b_was_called } end.should == :b_was_called end it 'prolog has read/write access to args and options' do Applix.main(['func']) do prolog { |args, options| args.should == ['func'] options[:prolog] = Time.now } handle(:func) { |*_, options| options[:prolog] } end.should_not == nil end it 'epilog has access to task handler results' do Applix.main(['func']) do # @epilog will NOT make it into the handle invocation epilog { |rc, *_| rc.should == [1, 2, 3] rc.reverse } handle(:func) { [1, 2, 3] } end.should == [3, 2, 1] end it 'runs before callback before handle calls' do Applix.main(['func']) do # @prolog will be available in handle invocations prolog { @prolog = :prolog } # @epilog will NOT make it into the handle invocation epilog { |rc, *_| @epilog = :epilog rc } handle(:func) { [@prolog, @epilog] } end.should == [:prolog, nil] end it 'runs epilog callback after handle' do last_action = nil Applix.main([:func]) do epilog { |rc, *_| # handle was already executed last_action.should == :handle last_action = :epilog } handle(:func) { # epilog block should not have been executed yet last_action.should == nil last_action = :handle } end last_action.should == :epilog end it 'supports :any as fallback on command lines without matching task' do Applix.main(%w(--opt1 foo param1 param2), {:opt2 => false}) do handle(:not_called) { raise "can't possible happen" } any do |*args, options| args.should == ["foo", "param1", "param2"] options.should == {:opt1 => true, :opt2 => false} end end end it 'any does not shadow existing tasks' do Applix.main(['--opt1', 'foo', "param1", "param2"], {:opt2 => false}) do handle(:foo) do |*args, options| args.should == ["param1", "param2"] options.should == {:opt1 => true, :opt2 => false} end any { raise "can't possible happen" } end end it 'supports :any when task does not depend on first arguments' do %w(bla fasel laber red).each do |name| Applix.main(['--opt1', name, "param1", "param2"], {:opt2 => false}) do any do |*args, options| args.should == [name, "param1", "param2"] options.should == {:opt1 => true, :opt2 => false} end end end end it 'should call actions by first argument names' do argv = ['func'] Applix.main(argv) do handle(:func) { :func_return } end.should == :func_return end it 'should pass arguments to function' do argv = ['func', 'p1', 'p2'] Applix.main(argv) do handle(:func) { |*args, options| args } end.should == %w{p1 p2} end it 'should pass emtpy options to function on default' do argv = %w(func) Applix.main(argv) do handle(:func) { |*_, options| options } end.should == {} end it 'should pass a processed options hash' do argv = %w(-a --bar func) Applix.main(argv) do handle(:func) { |*_, options| options } end.should == {:a => true, :bar => true} end it "should parse the old unit test..." do # -f becomes { :f => true } # --flag becomes { :flag => true } (ApplixHash.parse '-f').should == [:f, true] (ApplixHash.parse '--flag').should == [:flag, true] # --flag:false becomes { :flag => false } (ApplixHash.parse '--flag:false').should == [:flag, false] # --option=value becomes { :option => "value" } (ApplixHash.parse '--opt=val').should == [:opt, 'val'] # --int=1 becomes { :int => "1" } # --int:1 becomes { :int => 1 } # --float=2.3 becomes { :float => "2.3" } # --float:2.3 becomes { :float => 2.3 } # -f:1.234 becomes { :f => 1.234 } (Hash.from_argv ["--int=1"])[:int].should == "1" (Hash.from_argv ["--int:1"])[:int].should == 1 (Hash.from_argv ["--float=2.3"])[:float].should == "2.3" (Hash.from_argv ["--float:2.3"])[:float].should == 2.3 (Hash.from_argv ["-f:2.345"])[:f].should == 2.345 # --txt="foo bar" becomes { :txt => "foo bar" } # --txt:'"foo bar"' becomes { :txt => "foo bar" } # --txt:%w{foo bar} becomes { :txt => ["foo", "bar"] } (Hash.from_argv ['--txt="foo bar"'])[:txt].should == "foo bar" (Hash.from_argv [%q|--txt:'"foo bar"'|])[:txt].should == "foo bar" (Hash.from_argv [%q|--txt:'%w{foo bar}'|])[:txt].should == ["foo", "bar"] # --now:Time.now becomes { :now => Mon Jul 09 01:30:21 0200 2007 } #dt = Time.now - H.parse("--now:Time.now")[1] (t = (Hash.from_argv ["--now:Time.now"])[:now]).should_not == nil end end __END__ port this from unit to rspec... class HashFromArgvTest < Test::Unit::TestCase # XXX this is hacking the new Hash.from_argv interface into the old # dissect signature to make proper reuse of the existing unit tests def dissect(argv) h = Hash.from_argv(argv) [h[:arguments], h.delete_if { |k, _| k == :arguments }] end def test_applix_dissect_flags assert_equal [[], {:foo=>true}], dissect(%w{--foo}) end def test_applix_colon_option _, opts = dissect ["-a:%w{a b c}"] assert_equal({:a=>['a', 'b', 'c']}, opts) _, opts = dissect ["-b:(1..10)"] assert_equal({:b=>(1..10)}, opts) _, opts = dissect ["-c:Time.now"] assert opts[:c] < Time.now assert (Time.now - opts[:c]) < 0.01 end def test_applix_dissect_options _, opts = dissect %w{-v=3.15} assert_equal({:v=>"3.15"}, opts) _, opts = dissect %w{-v:3.15} assert_equal({:v=>3.15}, opts) av, opts = dissect %w{--een --twee=3 -v:3.15} assert_equal [], av assert_equal({:een => true, :twee => "3", :v => 3.15}, opts) end def test_applix_dissect_without_options #assert_equal [[], {}], dissect #assert_equal [ARGV, {}], dissect %w{een twee 3 3.15 foo-bar}.inject([]) do |memo, arg| memo << arg av, opts = dissect(memo) assert_equal memo, av assert_equal({}, opts) memo end end end