bosonson 0.304.1

data/test/manager_test.rb

@@ -0,0 +1,114 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Manager" do
+  describe ".after_load" do
+    def load_library(hash)
+      new_attributes = {:name=>hash[:name], :commands=>[], :created_dependencies=>[], :loaded=>true}
+      [:module, :commands].each {|e| new_attributes[e] = hash.delete(e) if hash[e] }
+      Manager.expects(:rescue_load_action).returns(Library.new(new_attributes))
+      Manager.load([hash[:name]])
+    end
+
+    before { reset_boson }
+
+    it "loads basic library" do
+      load_library :name=>'blah'
+      library_loaded? 'blah'
+    end
+
+    it "loads library with commands" do
+      load_library :name=>'blah', :commands=>['frylock','meatwad']
+      library_loaded? 'blah'
+      command_exists?('frylock')
+      command_exists?('meatwad')
+    end
+
+    it "prints error for library with SyntaxError" do
+      Manager.expects(:loader_create).raises(SyntaxError)
+      capture_stderr {
+        Manager.load 'blah'
+      }.should =~ /Unable to load library blah. Reason: SyntaxError/
+    end
+
+    it "prints error for library with LoadError" do
+      Manager.expects(:loader_create).raises(LoadError)
+      capture_stderr {
+        Manager.load 'blah'
+      }.should =~ /Unable to load library blah. Reason: LoadError/
+    end
+
+    describe "command aliases" do
+      before { eval %[module ::Aquateen; def frylock; end; end] }
+      after { Object.send(:remove_const, "Aquateen") }
+
+      it "created with command specific config" do
+        with_config(:command_aliases=>{'frylock'=>'fr'}) do
+          Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+          load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+          library_loaded? 'aquateen'
+        end
+      end
+
+      it "created with config command_aliases" do
+        with_config(:command_aliases=>{"frylock"=>"fr"}) do
+          Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+          load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+          library_loaded? 'aquateen'
+        end
+      end
+
+      it "not created and warns for commands with no module" do
+        with_config(:command_aliases=>{'frylock'=>'fr'}) do
+          capture_stderr {
+            load_library(:name=>'aquateen', :commands=>['frylock'])
+          }.should =~ /No aliases/
+          library_loaded? 'aquateen'
+          Aquateen.method_defined?(:fr).should == false
+        end
+      end
+    end
+
+    it "merges with existing created library" do
+      create_library('blah')
+      load_library :name=>'blah'
+      library_loaded? 'blah'
+      Boson.libraries.size.should == 1
+    end
+  end
+
+  describe "option commands without args" do
+    before_all {
+      reset_boson
+      @library = Library.new(:name=>'blah', :commands=>['foo', 'bar'])
+      Boson.libraries << @library
+      @foo = Command.new(:name=>'foo', :lib=>'blah', :options=>{:fool=>:string}, :args=>'*')
+      Boson.commands << @foo
+      Boson.commands << Command.new(:name=>'bar', :lib=>'blah', :options=>{:bah=>:string})
+    }
+
+    it "are deleted" do
+      Scientist.expects(:redefine_command).with(anything, @foo)
+      Manager.redefine_commands(@library, @library.commands)
+    end
+
+    it "are deleted and printed when verbose" do
+      Scientist.expects(:redefine_command).with(anything, @foo)
+      @library.instance_eval("@options = {:verbose=>true}")
+      capture_stdout { Manager.redefine_commands(@library, @library.commands) } =~ /options.*blah/
+    end
+  end
+
+  describe ".loaded?" do
+    before { reset_libraries }
+
+    it "returns false when library isn't loaded" do
+      create_library('blah')
+      Manager.loaded?('blah').should == false
+    end
+
+    it "returns true when library is loaded" do
+      create_library('blah', :loaded=>true)
+      Manager.loaded?('blah').should == true
+    end
+  end
+end

data/test/method_inspector_test.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "MethodInspector" do
+  it "non commands module can't set anything" do
+    eval "module Blah; end"
+    MethodInspector.current_module = Blah
+    Inspector.enable
+    Blah.module_eval("desc 'test'; def test; end; options :a=>1; def test2; end")
+    Inspector.disable
+    MethodInspector.store[:desc].empty?.should == true
+    MethodInspector.store[:options].empty?.should == true
+  end
+
+  it "handles anonymous classes" do
+    MethodInspector.mod_store = {}
+    Inspector.enable
+    Class.new.module_eval "def blah; end"
+    Inspector.disable
+    MethodInspector.store.should == nil
+  end
+
+  describe "commands module with" do
+    def parse(string)
+      Inspector.enable
+      ::Boson::Commands::Zzz.module_eval(string)
+      Inspector.disable
+      MethodInspector.store
+    end
+
+    before_all { eval "module ::Boson::Commands::Zzz; end" }
+    before { MethodInspector.mod_store.delete(::Boson::Commands::Zzz) }
+
+    it "desc sets descriptions" do
+      parsed = parse "desc 'test'; def m1; end; desc 'one'; desc 'more'; def m2; end"
+      parsed[:desc].should == {"m1"=>"test", "m2"=>"more"}
+    end
+
+    it "options sets options" do
+      parse("options :z=>'b'; def zee; end")[:options].should == {"zee"=>{:z=>'b'}}
+    end
+
+    it "option sets options" do
+      parse("option :z, 'b'; option :y, :boolean; def zee; end")[:options].should ==
+        {"zee"=>{:z=>'b', :y=>:boolean}}
+    end
+
+    it "option(s) sets options" do
+      parse("options :z=>'b'; option :y, :string; def zee; end")[:options].should ==
+        {"zee"=>{:z=>'b', :y=>:string}}
+    end
+
+    it "option(s) option overrides options" do
+      parse("options :z=>'b'; option :z, :string; def zee; end")[:options].should ==
+        {"zee"=>{:z=>:string}}
+    end
+
+    it "render_options sets render_options" do
+      parse("render_options :z=>true; def zee; end")[:render_options].should == {"zee"=>{:z=>true}}
+    end
+
+    it "config sets config" do
+      parse("config :z=>true; def zee; end")[:config].should == {"zee"=>{:z=>true}}
+    end
+
+    it "not all method attributes set causes method_locations to be set" do
+      MethodInspector.stubs(:find_method_locations).returns(["/some/path", 10])
+      parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; " +
+        "option :b, :boolean; render_options :a=>1; config :a=>1; desc 'z'; options :a=>1; def az; end"
+      parsed[:method_locations].key?('yo').should == true
+      parsed[:method_locations].key?('yep').should == true
+      parsed[:method_locations].key?('az').should == false
+    end
+
+    it "no find_method_locations doesn't set method_locations" do
+      MethodInspector.stubs(:find_method_locations).returns(nil)
+      parse("def bluh; end")[:method_locations].key?('bluh').should == false
+    end
+
+    it "options calls scrape_with_eval" do
+      ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
+      parse("desc 'desc'; options :some=>:opts; def doy(arg1); end")[:args]['doy'].should == [['arg1']]
+    end
+
+    it "options in file calls scrape_with_eval" do
+      MethodInspector.expects(:inspector_in_file?).returns(true)
+      ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
+      parse("desc 'desc'; def doz(arg1); end")[:args]['doz'].should == [['arg1']]
+    end
+  end
+end

data/test/option_parser_test.rb

@@ -0,0 +1,367 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "OptionParser" do
+  def create(opts)
+    @opt = OptionParser.new(opts)
+  end
+
+  def opt; @opt; end
+  
+  def parse(*args)
+    @non_opts = []
+    opt.parse(args.flatten)
+  end
+
+  describe "IndifferentAccessHash" do
+    before {
+      @hash = IndifferentAccessHash.new 'foo' => 'bar', 'baz' => 'bee'
+    }
+    it "can access values indifferently" do
+      @hash['foo'].should == 'bar'
+      @hash[:foo].should  == 'bar'
+      @hash.values_at(:foo, :baz).should == ['bar', 'bee']
+    end
+
+    it "can be initialized with either strings or symbols and be equal" do
+      hash2 = IndifferentAccessHash.new :foo=>'bar', :baz=>'bee'
+      @hash.should == hash2
+    end
+
+    it "returns keys as symbols by default" do
+      @hash.should == {:foo=>'bar', :baz=>'bee'}
+    end
+
+    it "can set values indifferently" do
+      @hash['foo'] = 'duh'
+      @hash[:foo].should == 'duh'
+      @hash[:baz] = 'wasp'
+      @hash['baz'].should == 'wasp'
+    end
+  end
+
+  describe "naming" do
+    it "automatically aliases long options with their first letter" do
+      create "--foo" => true
+      parse("-f")["foo"].should == true
+    end
+
+    it "automatically aliases two options with same first letters by aliasing alphabetical first with lowercase and second with uppercase" do
+      create :verbose=>:boolean, :vertical=>:string, :verz=>:boolean
+      parse('-v', '-V','2').should == {:verbose=>true, :vertical=>'2'}
+    end
+    
+    it "doesn't auto-alias options that have multiple names given" do
+      create ["--foo", "--bar"] => :boolean
+      parse("-f")["foo"].should == nil
+    end
+
+    it "allows aliases to be symbols or strings" do
+      create [:foo, :bar, 'baz'] =>:string
+      parse("--foo", "12")[:foo].should == "12"
+      parse("--bar", "12")[:foo].should == "12"
+      parse("--baz", "12")[:foo].should == "12"
+    end
+    
+    it "allows multiple aliases for a given opt" do
+      create ["--foo", "--bar", "--baz"] => :string
+      parse("--foo", "12")["foo"].should == "12"
+      parse("--bar", "12")["foo"].should == "12"
+      parse("--baz", "12")["foo"].should == "12"
+    end
+    
+    it "allows custom short names" do
+      create "-f" => :string
+      parse("-f", "12").should == {:f => "12"}
+    end
+
+    it "allows capital short names" do
+      create :A => :boolean
+      parse("-A")[:A].should == true
+    end
+
+    it "allows capital short aliases" do
+      create [:awesome, :A] => :string
+      parse("--awesome", "bar")[:awesome].should == 'bar'
+      parse("-A", "bar")[:awesome].should == 'bar'
+    end
+
+    it "allows custom short aliases" do
+      create ["--bar", "-f"] => :string
+      parse("-f", "12").should == {:bar => "12"}
+    end
+    
+    it "allows humanized opt name" do
+      create 'foo' => :string, :bar => :string
+      parse("-f", "1", "-b", "2").should == {:foo => "1", :bar => "2"}
+    end
+
+    it "allows humanized symbol opt name" do
+      create :foo=>:string
+      parse('-f','1').should == {:foo=>'1'}
+    end
+
+    it "doesn't allow alias to override another option" do
+      create :foo=>:string, [:bar, :foo]=>:boolean
+      parse("--foo", "boo")[:foo].should == 'boo'
+    end
+
+    it "doesn't recognize long opt format for a opt that is originally short" do
+      create 'f' => :string
+      parse("-f", "1").should == {:f => "1"}
+      parse("--f", "1").should == {}
+    end
+    
+    it "accepts --[no-]opt variant for booleans, setting false for value" do
+      create "--foo" => :boolean
+      parse("--no-foo")["foo"].should == false
+      parse("--no-f")["foo"].should == false
+      parse("--foo")["foo"].should == true
+    end
+
+    it "accepts --[no-]opt variant for single letter booleans" do
+      create :e=>true
+      parse("--no-e")[:e].should == false
+    end
+
+    it "will prefer 'no-opt' variant over inverting 'opt' if explicitly set" do
+      create "--no-foo" => true
+      parse("--no-foo")["no-foo"].should == true
+    end
+    
+  end
+
+  describe "option values can be set with" do
+    it "a opt=<value> assignment" do
+      create :foo => :string
+      parse("--foo=12")["foo"].should == "12"
+      parse("-f=12")["foo"].should == "12"
+      parse("--foo=bar=baz")["foo"].should == "bar=baz"
+      parse("--foo=sentence with spaces")["foo"].should == "sentence with spaces"
+    end
+  
+    it "a -nXY assignment" do
+      create "--num" => :numeric
+      parse("-n12")["num"].should == 12
+    end
+  
+    it "conjoined short options" do
+      create "--foo" => true, "--bar" => true, "--app" => true
+      opts = parse "-fba"
+      opts["foo"].should == true
+      opts["bar"].should == true
+      opts["app"].should == true
+    end
+  
+    it "conjoined short options with argument" do
+      create "--foo" => true, "--bar" => true, "--app" => :numeric
+      opts = parse "-fba", "12"
+      opts["foo"].should == true
+      opts["bar"].should == true
+      opts["app"].should == 12
+    end
+  end
+
+  describe "parse" do
+    it "extracts non-option arguments" do
+      create "--foo" => :string, "--bar" => true
+      parse("foo", "bar", "--baz", "--foo", "12", "--bar", "-T", "bang").should == {
+        :foo => "12", :bar => true
+      }
+      opt.leading_non_opts.should == ["foo", "bar", "--baz"]
+      opt.trailing_non_opts.should == ["-T", "bang"]
+      opt.non_opts.should == ["foo", "bar", "--baz", "-T", "bang"]
+    end
+
+    it "stopped by --" do
+      create :foo=>:boolean, :dude=>:boolean
+      parse("foo", "bar", "--", "-f").should == {}
+      opt.leading_non_opts.should == %w{foo bar}
+      opt.trailing_non_opts.should == %w{-- -f}
+    end
+
+    describe "with parse flag" do
+      it ":delete_invalid_opts deletes and warns of invalid options" do
+        create(:foo=>:boolean)
+        capture_stderr {
+          opt.parse(%w{-f -d ok}, :delete_invalid_opts=>true)
+        }.should =~ /Deleted invalid option '-d'/
+        opt.non_opts.should == ['ok']
+      end
+
+      it ":delete_invalid_opts deletes until - or --" do
+        create(:foo=>:boolean, :bar=>:boolean)
+        %w{- --}.each do |stop_char|
+          capture_stderr {
+            opt.parse(%w{ok -b -d} << stop_char << '-f', :delete_invalid_opts=>true)
+          }.should =~ /'-d'/
+          opt.non_opts.should == %w{ok -d} << stop_char << '-f'
+        end
+      end
+
+      it ":opts_before_args only allows options before args" do
+        create(:foo=>:boolean)
+        opt.parse(%w{ok -f}, :opts_before_args=>true).should == {}
+        opt.parse(%w{-f ok}, :opts_before_args=>true).should == {:foo=>true}
+      end
+    end
+
+    describe "with no arguments" do
+      it "and no options returns an empty hash" do
+        create({})
+        parse.should == {}
+      end
+
+      it "and several options returns an empty hash" do
+        create "--foo" => :boolean, "--bar" => :string
+        parse.should == {}
+      end
+    end
+  end
+
+  describe "option hashes" do
+    it "make hash keys available as symbols as well" do
+      create "--foo" => :string
+      parse("--foo", "12")[:foo].should == "12"
+    end
+
+    it "don't set nonexistant options" do
+      create "--foo" => :boolean
+      parse("--foo")["bar"].should == nil
+      opts = parse
+      opts["foo"].should == nil
+    end
+  end
+
+  describe ":required option attribute" do
+    before_all {
+      create "--foo" => {:type=>:string, :required=>true}, :bar => {:type=>:hash, :required=>true}
+    }
+
+    it "raises an error if string option isn't given" do
+      assert_error(OptionParser::Error, 'no value.*required.*foo') { parse("--bar", "str:ok") }
+    end
+
+    it "raises an error if non-string option isn't given" do
+      assert_error(OptionParser::Error, 'no value.*required.*bar') { parse("--foo", "yup") }
+    end
+
+    it "raises no error when given arguments" do
+      parse("--foo", "yup", "--bar","ok:dude").should == {:foo=>'yup', :bar=>{'ok'=>'dude'}}
+    end
+  end
+
+  describe ":bool_default option attribute" do
+    before_all {
+      create :foo=>{:type=>:string, :bool_default=>'whoop'}, :bar=>{:type=>:array, :bool_default=>'1'},
+        :verbose=>:boolean, :yep=>{:type=>:string, :bool_default=>true}
+    }
+
+    it "sets default boolean" do
+      parse('--foo', '--bar', '1')[:foo].should == 'whoop'
+      parse('--foo', 'ok', 'dokay')[:foo].should == 'whoop'
+    end
+
+    it "sets options normally" do
+      parse('--foo=boo', '--bar=har').should == {:foo=>'boo', :bar=>['har']}
+    end
+
+    it "sets default boolean for array" do
+      parse("--bar", '--foo', '2')[:bar].should == ['1']
+    end
+
+    it "sets default boolean for non-string value" do
+      parse('--yep', '--foo=2')[:yep].should == true
+    end
+
+    it "default booleans can be joined with boolean options" do
+      parse('-fbv').should == {:verbose=>true, :bar=>['1'], :foo=>'whoop'}
+    end
+  end
+
+  describe "option with attributes" do
+    it "can get type from :type" do
+      create :foo=>{:type=>:numeric}
+      parse("-f", '3')[:foo].should == 3
+    end
+
+    it "can get type and default from :default" do
+      create :foo=>{:default=>[]}
+      parse("-f", "1")[:foo].should == ['1']
+      parse[:foo].should == []
+    end
+
+    it "assumes :boolean type if no type found" do
+      create :foo=>{:some=>'params'}
+      parse('-f')[:foo].should == true
+    end
+  end
+  
+  def usage
+    opt.formatted_usage.split(" ").sort
+  end
+
+  describe "#formatted_usage" do
+    it "outputs string args with sample values" do
+      create "--repo" => :string, "--branch" => "bugfix", "-n" => 6
+      usage.should == %w([--branch=bugfix] [--repo=REPO] [-n=6])
+    end
+    
+    it "outputs numeric args with 'N' as sample value" do
+      create "--iter" => :numeric
+      usage.should == ["[--iter=N]"]
+    end
+
+    it "outputs array args with sample value" do
+      create "--libs" => :array
+      usage.should == ["[--libs=A,B,C]"]
+    end
+
+    it "outputs hash args with sample value" do
+      create '--paths' => :hash
+      usage.should == ["[--paths=A:B,C:D]"]
+    end
+  end
+
+  describe "user defined option class" do
+    before_all {
+      ::FooBoo = Struct.new(:name)
+      module Options::FooBoo
+        def create_foo_boo(value)
+          ::FooBoo.new(value)
+        end
+        def validate_foo_boo(value); end
+      end
+      ::OptionParser.send :include, Options::FooBoo
+      create :a=>:foo_boo, :b=>::FooBoo.new('blah'), :c=>:blah_blah,
+        :d=>{:type=>:foo_boo, :type=>::FooBoo.new('bling')}
+    }
+
+    it "created from symbol" do
+      (obj = parse('-a', 'whoop')[:a]).class.should == ::FooBoo
+      obj.name.should == 'whoop'
+    end
+
+    it "created from default" do
+      (obj = parse[:b]).class.should == ::FooBoo
+      obj.name.should == 'blah'
+    end
+
+    it "created from type attribute" do
+      (obj = parse('-d', 'whoop')[:d]).class.should == ::FooBoo
+      obj.name.should == 'whoop'
+    end
+
+    it "has its validation called" do
+      opt.expects(:validate_foo_boo)
+      parse("-a", 'blah')
+    end
+
+    it "has default usage" do
+      usage[0].should == "[-a=:foo_boo]"
+    end
+
+    it "when nonexistant raises error" do
+      assert_error(OptionParser::Error, "invalid.*:blah_blah") { parse("-c", 'ok') }
+    end
+  end
+end