thor 0.16.0 → 0.17.0

data/spec/parser/options_spec.rb

@@ -2,12 +2,12 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require 'thor/parser'
 
 describe Thor::Options do
-  def create(opts, defaults={})
+  def create(opts, defaults={}, stop_on_unknown=false)
     opts.each do |key, value|
       opts[key] = Thor::Option.parse(key, value) unless value.is_a?(Thor::Option)
     end
 
-    @opt = Thor::Options.new(opts, defaults)
+    @opt = Thor::Options.new(opts, defaults, stop_on_unknown)
   end
 
   def parse(*args)
@@ -18,38 +18,42 @@ describe Thor::Options do
     @opt.check_unknown!
   end
 
+  def remaining
+    @opt.remaining
+  end
+
   describe "#to_switches" do
     it "turns true values into a flag" do
-      Thor::Options.to_switches(:color => true).should == "--color"
+      expect(Thor::Options.to_switches(:color => true)).to eq("--color")
     end
 
     it "ignores nil" do
-      Thor::Options.to_switches(:color => nil).should == ""
+      expect(Thor::Options.to_switches(:color => nil)).to eq("")
     end
 
     it "ignores false" do
-      Thor::Options.to_switches(:color => false).should == ""
+      expect(Thor::Options.to_switches(:color => false)).to eq("")
     end
 
     it "writes --name value for anything else" do
-      Thor::Options.to_switches(:format => "specdoc").should == '--format "specdoc"'
+      expect(Thor::Options.to_switches(:format => "specdoc")).to eq('--format "specdoc"')
     end
 
     it "joins several values" do
       switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(' ').sort
-      switches.should == ['"bar"', "--color", "--foo"]
+      expect(switches).to eq(['"bar"', "--color", "--foo"])
     end
 
     it "accepts arrays" do
-      Thor::Options.to_switches(:count => [1,2,3]).should == "--count 1 2 3"
+      expect(Thor::Options.to_switches(:count => [1,2,3])).to eq("--count 1 2 3")
     end
 
     it "accepts hashes" do
-      Thor::Options.to_switches(:count => {:a => :b}).should == "--count a:b"
+      expect(Thor::Options.to_switches(:count => {:a => :b})).to eq("--count a:b")
     end
 
     it "accepts underscored options" do
-      Thor::Options.to_switches(:under_score_option => "foo bar").should == '--under_score_option "foo bar"'
+      expect(Thor::Options.to_switches(:under_score_option => "foo bar")).to eq('--under_score_option "foo bar"')
     end
 
   end
@@ -57,96 +61,126 @@ describe Thor::Options do
   describe "#parse" do
     it "allows multiple aliases for a given switch" do
       create ["--foo", "--bar", "--baz"] => :string
-      parse("--foo", "12")["foo"].should == "12"
-      parse("--bar", "12")["foo"].should == "12"
-      parse("--baz", "12")["foo"].should == "12"
+      expect(parse("--foo", "12")["foo"]).to eq("12")
+      expect(parse("--bar", "12")["foo"]).to eq("12")
+      expect(parse("--baz", "12")["foo"]).to eq("12")
     end
 
     it "allows custom short names" do
       create "-f" => :string
-      parse("-f", "12").should == {"f" => "12"}
+      expect(parse("-f", "12")).to eq({"f" => "12"})
     end
 
     it "allows custom short-name aliases" do
       create ["--bar", "-f"] => :string
-      parse("-f", "12").should == {"bar" => "12"}
+      expect(parse("-f", "12")).to eq({"bar" => "12"})
     end
 
     it "accepts conjoined short switches" do
       create ["--foo", "-f"] => true, ["--bar", "-b"] => true, ["--app", "-a"] => true
       opts = parse("-fba")
-      opts["foo"].should be_true
-      opts["bar"].should be_true
-      opts["app"].should be_true
+      expect(opts["foo"]).to be_true
+      expect(opts["bar"]).to be_true
+      expect(opts["app"]).to be_true
     end
 
     it "accepts conjoined short switches with input" do
       create ["--foo", "-f"] => true, ["--bar", "-b"] => true, ["--app", "-a"] => :required
       opts = parse "-fba", "12"
-      opts["foo"].should be_true
-      opts["bar"].should be_true
-      opts["app"].should == "12"
+      expect(opts["foo"]).to be_true
+      expect(opts["bar"]).to be_true
+      expect(opts["app"]).to eq("12")
     end
 
     it "returns the default value if none is provided" do
       create :foo => "baz", :bar => :required
-      parse("--bar", "boom")["foo"].should == "baz"
+      expect(parse("--bar", "boom")["foo"]).to eq("baz")
     end
 
     it "returns the default value from defaults hash to required arguments" do
       create Hash[:bar => :required], Hash[:bar => "baz"]
-      parse["bar"].should == "baz"
+      expect(parse["bar"]).to eq("baz")
     end
 
     it "gives higher priority to defaults given in the hash" do
       create Hash[:bar => true], Hash[:bar => false]
-      parse["bar"].should == false
+      expect(parse["bar"]).to eq(false)
     end
 
     it "raises an error for unknown switches" do
       create :foo => "baz", :bar => :required
       parse("--bar", "baz", "--baz", "unknown")
-      lambda { check_unknown! }.should raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
+      expect{ check_unknown! }.to raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
     end
 
     it "skips leading non-switches" do
       create(:foo => "baz")
 
-      parse("asdf", "--foo", "bar").should == {"foo" => "bar"}
+      expect(parse("asdf", "--foo", "bar")).to eq({"foo" => "bar"})
     end
 
     it "correctly recognizes things that look kind of like options, but aren't, as not options" do
       create(:foo => "baz")
-      parse("--asdf---asdf", "baz", "--foo", "--asdf---dsf--asdf").should == {"foo" => "--asdf---dsf--asdf"}
+      expect(parse("--asdf---asdf", "baz", "--foo", "--asdf---dsf--asdf")).to eq({"foo" => "--asdf---dsf--asdf"})
       check_unknown!
     end
 
     it "accepts underscores in commandline args hash for boolean" do
       create :foo_bar => :boolean
-      parse("--foo_bar")["foo_bar"].should == true
-      parse("--no_foo_bar")["foo_bar"].should == false
+      expect(parse("--foo_bar")["foo_bar"]).to eq(true)
+      expect(parse("--no_foo_bar")["foo_bar"]).to eq(false)
     end
 
     it "accepts underscores in commandline args hash for strings" do
       create :foo_bar => :string, :baz_foo => :string
-      parse("--foo_bar", "baz")["foo_bar"].should == "baz"
-      parse("--baz_foo", "foo bar")["baz_foo"].should == "foo bar"
+      expect(parse("--foo_bar", "baz")["foo_bar"]).to eq("baz")
+      expect(parse("--baz_foo", "foo bar")["baz_foo"]).to eq("foo bar")
+    end
+
+    it "interprets everything after -- as args instead of options" do
+      create(:foo => :string, :bar => :required)
+      expect(parse(%w[--bar abc moo -- --foo def -a])).to eq({"bar" => "abc"})
+      expect(remaining).to eq(%w[moo --foo def -a])
+    end
+
+    it "ignores -- when looking for single option values" do
+      create(:foo => :string, :bar => :required)
+      expect(parse(%w[--bar -- --foo def -a])).to eq({"bar" => "--foo"})
+      expect(remaining).to eq(%w[def -a])
+    end
+
+    it "ignores -- when looking for array option values" do
+      create(:foo => :array)
+      expect(parse(%w[--foo a b -- c d -e])).to eq({"foo" => %w[a b c d -e]})
+      expect(remaining).to eq([])
+    end
+
+    it "ignores -- when looking for hash option values" do
+      create(:foo => :hash)
+      expect(parse(%w[--foo a:b -- c:d -e])).to eq({"foo" => {'a' => 'b', 'c' => 'd'}})
+      expect(remaining).to eq(%w[-e])
+    end
+
+    it "ignores trailing --" do
+      create(:foo => :string)
+      expect(parse(%w[--foo --])).to eq({"foo" => nil})
+      expect(remaining).to eq([])
     end
 
     describe "with no input" do
       it "and no switches returns an empty hash" do
         create({})
-        parse.should == {}
+        expect(parse).to eq({})
       end
 
       it "and several switches returns an empty hash" do
         create "--foo" => :boolean, "--bar" => :string
-        parse.should == {}
+        expect(parse).to eq({})
       end
 
       it "and a required switch raises an error" do
         create "--foo" => :required
-        lambda { parse }.should raise_error(Thor::RequiredArgumentMissingError, "No value provided for required options '--foo'")
+        expect{ parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required options '--foo'")
       end
     end
 
@@ -156,21 +190,52 @@ describe Thor::Options do
       end
 
       it "raises an error if the required switch has no argument" do
-        lambda { parse("--foo") }.should raise_error(Thor::MalformattedArgumentError)
+        expect{ parse("--foo") }.to raise_error(Thor::MalformattedArgumentError)
       end
 
       it "raises an error if the required switch isn't given" do
-        lambda { parse("--bar") }.should raise_error(Thor::RequiredArgumentMissingError)
+        expect{ parse("--bar") }.to raise_error(Thor::RequiredArgumentMissingError)
       end
 
       it "raises an error if the required switch is set to nil" do
-        lambda { parse("--no-foo") }.should raise_error(Thor::RequiredArgumentMissingError)
+        expect{ parse("--no-foo") }.to raise_error(Thor::RequiredArgumentMissingError)
       end
 
       it "does not raises an error if the required option has a default value" do
         options = {:required => true, :type => :string, :default => "baz"}
         create :foo => Thor::Option.new("foo", options), :bar => :boolean
-        lambda { parse("--bar") }.should_not raise_error
+        expect{ parse("--bar") }.not_to raise_error
+      end
+    end
+
+    context "when stop_on_unknown is true" do
+      before do
+        create({:foo => :string, :verbose => :boolean}, {}, true)
+      end
+
+      it "stops parsing on first non-option" do
+        expect(parse(%w[foo --verbose])).to eq({})
+        expect(remaining).to eq(["foo", "--verbose"])
+      end
+
+      it "stops parsing on unknown option" do
+        expect(parse(%w[--bar --verbose])).to eq({})
+        expect(remaining).to eq(["--bar", "--verbose"])
+      end
+
+      it "still accepts options that are given before non-options" do
+        expect(parse(%w[--verbose foo])).to eq({"verbose" => true})
+        expect(remaining).to eq(["foo"])
+      end
+
+      it "still accepts options that require a value" do
+        expect(parse(%w[--foo bar baz])).to eq({"foo" => "bar"})
+        expect(remaining).to eq(["baz"])
+      end
+
+      it "still interprets everything after -- as args instead of options" do
+        expect(parse(%w[-- --verbose])).to eq({})
+        expect(remaining).to eq(["--verbose"])
       end
     end
 
@@ -180,43 +245,43 @@ describe Thor::Options do
       end
 
       it "accepts a switch <value> assignment" do
-        parse("--foo", "12")["foo"].should == "12"
+        expect(parse("--foo", "12")["foo"]).to eq("12")
       end
 
       it "accepts a switch=<value> assignment" do
-        parse("-f=12")["foo"].should == "12"
-        parse("--foo=12")["foo"].should == "12"
-        parse("--foo=bar=baz")["foo"].should == "bar=baz"
+        expect(parse("-f=12")["foo"]).to eq("12")
+        expect(parse("--foo=12")["foo"]).to eq("12")
+        expect(parse("--foo=bar=baz")["foo"]).to eq("bar=baz")
       end
 
       it "must accept underscores switch=value assignment" do
         create :foo_bar => :required
-        parse("--foo_bar=http://example.com/under_score/")["foo_bar"].should == "http://example.com/under_score/"
+        expect(parse("--foo_bar=http://example.com/under_score/")["foo_bar"]).to eq("http://example.com/under_score/")
       end
 
       it "accepts a --no-switch format" do
         create "--foo" => "bar"
-        parse("--no-foo")["foo"].should be_nil
+        expect(parse("--no-foo")["foo"]).to be_nil
       end
 
       it "does not consume an argument for --no-switch format" do
         create "--cheese" => :string
-        parse('burger', '--no-cheese', 'fries')["cheese"].should be_nil
+        expect(parse('burger', '--no-cheese', 'fries')["cheese"]).to be_nil
       end
 
       it "accepts a --switch format on non required types" do
         create "--foo" => :string
-        parse("--foo")["foo"].should == "foo"
+        expect(parse("--foo")["foo"]).to eq("foo")
       end
 
       it "accepts a --switch format on non required types with default values" do
         create "--baz" => :string, "--foo" => "bar"
-        parse("--baz", "bang", "--foo")["foo"].should == "bar"
+        expect(parse("--baz", "bang", "--foo")["foo"]).to eq("bar")
       end
 
       it "overwrites earlier values with later values" do
-        parse("--foo=bar", "--foo", "12")["foo"].should == "12"
-        parse("--foo", "12", "--foo", "13")["foo"].should == "13"
+        expect(parse("--foo=bar", "--foo", "12")["foo"]).to eq("12")
+        expect(parse("--foo", "12", "--foo", "13")["foo"]).to eq("13")
       end
     end
 
@@ -226,48 +291,48 @@ describe Thor::Options do
       end
 
       it "accepts --opt assignment" do
-        parse("--foo")["foo"].should == true
-        parse("--foo", "--bar")["foo"].should == true
+        expect(parse("--foo")["foo"]).to eq(true)
+        expect(parse("--foo", "--bar")["foo"]).to eq(true)
       end
 
       it "uses the default value if no switch is given" do
-        parse("")["foo"].should == false
+        expect(parse("")["foo"]).to eq(false)
       end
 
       it "accepts --opt=value assignment" do
-        parse("--foo=true")["foo"].should == true
-        parse("--foo=false")["foo"].should == false
+        expect(parse("--foo=true")["foo"]).to eq(true)
+        expect(parse("--foo=false")["foo"]).to eq(false)
       end
 
       it "accepts --[no-]opt variant, setting false for value" do
-        parse("--no-foo")["foo"].should == false
+        expect(parse("--no-foo")["foo"]).to eq(false)
       end
 
       it "accepts --[skip-]opt variant, setting false for value" do
-        parse("--skip-foo")["foo"].should == false
+        expect(parse("--skip-foo")["foo"]).to eq(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
+        expect(parse("--no-foo")["no-foo"]).to eq(true)
       end
 
       it "will prefer 'skip-opt' variant over inverting 'opt' if explicitly set" do
         create "--skip-foo" => true
-        parse("--skip-foo")["skip-foo"].should == true
+        expect(parse("--skip-foo")["skip-foo"]).to eq(true)
       end
 
       it "accepts inputs in the human name format" do
         create :foo_bar => :boolean
-        parse("--foo-bar")["foo_bar"].should == true
-        parse("--no-foo-bar")["foo_bar"].should == false
-        parse("--skip-foo-bar")["foo_bar"].should == false
+        expect(parse("--foo-bar")["foo_bar"]).to eq(true)
+        expect(parse("--no-foo-bar")["foo_bar"]).to eq(false)
+        expect(parse("--skip-foo-bar")["foo_bar"]).to eq(false)
       end
 
       it "doesn't eat the next part of the param" do
         create :foo => :boolean
-        parse("--foo", "bar").should == {"foo" => true}
-        @opt.remaining.should == ["bar"]
+        expect(parse("--foo", "bar")).to eq({"foo" => true})
+        expect(@opt.remaining).to eq(["bar"])
       end
     end
 
@@ -277,15 +342,15 @@ describe Thor::Options do
       end
 
       it "accepts a switch=<value> assignment" do
-        parse("--attributes=name:string", "age:integer")["attributes"].should == {"name" => "string", "age" => "integer"}
+        expect(parse("--attributes=name:string", "age:integer")["attributes"]).to eq({"name" => "string", "age" => "integer"})
       end
 
       it "accepts a switch <value> assignment" do
-        parse("--attributes", "name:string", "age:integer")["attributes"].should == {"name" => "string", "age" => "integer"}
+        expect(parse("--attributes", "name:string", "age:integer")["attributes"]).to eq({"name" => "string", "age" => "integer"})
       end
 
       it "must not mix values with other switches" do
-        parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"].should == {"name" => "string", "age" => "integer"}
+        expect(parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"]).to eq({"name" => "string", "age" => "integer"})
       end
     end
 
@@ -295,15 +360,15 @@ describe Thor::Options do
       end
 
       it "accepts a switch=<value> assignment" do
-        parse("--attributes=a", "b", "c")["attributes"].should == ["a", "b", "c"]
+        expect(parse("--attributes=a", "b", "c")["attributes"]).to eq(["a", "b", "c"])
       end
 
       it "accepts a switch <value> assignment" do
-        parse("--attributes", "a", "b", "c")["attributes"].should == ["a", "b", "c"]
+        expect(parse("--attributes", "a", "b", "c")["attributes"]).to eq(["a", "b", "c"])
       end
 
       it "must not mix values with other switches" do
-        parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"].should == ["a", "b", "c"]
+        expect(parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"]).to eq(["a", "b", "c"])
       end
     end
 
@@ -313,15 +378,15 @@ describe Thor::Options do
       end
 
       it "accepts a -nXY assignment" do
-        parse("-n12")["n"].should == 12
+        expect(parse("-n12")["n"]).to eq(12)
       end
 
       it "converts values to numeric types" do
-        parse("-n", "3", "-m", ".5").should == {"n" => 3, "m" => 0.5}
+        expect(parse("-n", "3", "-m", ".5")).to eq({"n" => 3, "m" => 0.5})
       end
 
       it "raises error when value isn't numeric" do
-        lambda { parse("-n", "foo") }.should raise_error(Thor::MalformattedArgumentError,
+        expect{ parse("-n", "foo") }.to raise_error(Thor::MalformattedArgumentError,
           "Expected numeric value for '-n'; got \"foo\"")
       end
     end

data/spec/rake_compat_spec.rb

@@ -32,41 +32,41 @@ end
 
 describe Thor::RakeCompat do
   it "sets the rakefile application" do
-    ["rake_compat_spec.rb", "Thorfile"].should include(Rake.application.rakefile)
+    expect(["rake_compat_spec.rb", "Thorfile"]).to include(Rake.application.rakefile)
   end
 
   it "adds rake tasks to thor classes too" do
     task = ThorTask.tasks["cool"]
-    task.should be
+    expect(task).to be
   end
 
   it "uses rake tasks descriptions on thor" do
-    ThorTask.tasks["cool"].description.should == "Say it's cool"
+    expect(ThorTask.tasks["cool"].description).to eq("Say it's cool")
   end
 
   it "gets usage from rake tasks name" do
-    ThorTask.tasks["cool"].usage.should == "cool"
+    expect(ThorTask.tasks["cool"].usage).to eq("cool")
   end
 
   it "uses non namespaced name as description if non is available" do
-    ThorTask::HiperMega.tasks["super"].description.should == "super"
+    expect(ThorTask::HiperMega.tasks["super"].description).to eq("super")
   end
 
   it "converts namespaces to classes" do
-    ThorTask.const_get(:HiperMega).should == ThorTask::HiperMega
+    expect(ThorTask.const_get(:HiperMega)).to eq(ThorTask::HiperMega)
   end
 
   it "does not add tasks from higher namespaces in lowers namespaces" do
-    ThorTask.tasks["super"].should_not be
+    expect(ThorTask.tasks["super"]).not_to be
   end
 
   it "invoking the thor task invokes the rake task" do
-    capture(:stdout) do
+    expect(capture(:stdout) {
       ThorTask.start ["cool"]
-    end.should == "COOL\n"
+    }).to eq("COOL\n")
 
-    capture(:stdout) do
+    expect(capture(:stdout) {
       ThorTask::HiperMega.start ["super"]
-    end.should == "HIPER MEGA SUPER\n"
+    }).to eq("HIPER MEGA SUPER\n")
   end
 end