thor 0.9.9 → 0.11.5

data/spec/parser/argument_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Argument do
+
+  def argument(name, type=:string, default=nil, required=nil)
+    @argument ||= Thor::Argument.new(name, nil, required || default.nil?, type, default)
+  end
+
+  describe "errors" do
+    it "raises an error if name is not supplied" do
+      lambda {
+        argument(nil)
+      }.must raise_error(ArgumentError, "Argument name can't be nil.")
+    end
+
+    it "raises an error if type is unknown" do
+      lambda {
+        argument(:task, :unknown)
+      }.must raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
+    end
+
+    it "raises an error if argument is required and have default values" do
+      lambda {
+        argument(:task, :string, "bar", true)
+      }.must raise_error(ArgumentError, "An argument cannot be required and have default value.")
+    end
+  end
+
+  describe "#usage" do
+    it "returns usage for string types" do
+      argument(:foo, :string).usage.must == "FOO"
+    end
+
+    it "returns usage for numeric types" do
+      argument(:foo, :numeric).usage.must == "N"
+    end
+
+    it "returns usage for array types" do
+      argument(:foo, :array).usage.must == "one two three"
+    end
+
+    it "returns usage for hash types" do
+      argument(:foo, :hash).usage.must == "key:value"
+    end
+  end
+end

data/spec/parser/arguments_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Arguments do
+  def create(opts={})
+    arguments = opts.map do |type, default|
+      Thor::Argument.new(type.to_s, nil, default.nil?, type, default)
+    end
+
+    arguments.sort!{ |a,b| b.name <=> a.name }
+    @opt = Thor::Arguments.new(arguments)
+  end
+
+  def parse(*args)
+    @opt.parse(args)
+  end
+
+  describe "#parse" do
+    it "parses arguments in the given order" do
+      create :string => nil, :numeric => nil
+      parse("name", "13")["string"].must == "name"
+      parse("name", "13")["numeric"].must == 13
+    end
+
+    it "accepts hashes" do
+      create :string => nil, :hash => nil
+      parse("product", "title:string", "age:integer")["string"].must == "product"
+      parse("product", "title:string", "age:integer")["hash"].must == { "title" => "string", "age" => "integer"}
+    end
+
+    it "accepts arrays" do
+      create :string => nil, :array => nil
+      parse("product", "title", "age")["string"].must == "product"
+      parse("product", "title", "age")["array"].must == %w(title age)
+    end
+
+    describe "with no inputs" do
+      it "and no arguments returns an empty hash" do
+        create
+        parse.must == {}
+      end
+
+      it "and required arguments raises an error" do
+        create :string => nil, :numeric => nil
+        lambda { parse }.must raise_error(Thor::RequiredArgumentMissingError, "no value provided for required arguments 'string', 'numeric'")
+      end
+
+      it "and default arguments returns default values" do
+        create :string => "name", :numeric => 13
+        parse.must == { "string" => "name", "numeric" => 13 }
+      end
+    end
+
+    it "returns the input if it's already parsed" do
+      create :string => nil, :hash => nil, :array => nil, :numeric => nil
+      parse("", 0, {}, []).must == { "string" => "", "numeric" => 0, "hash" => {}, "array" => [] }
+    end
+
+    it "returns the default value if none is provided" do
+      create :string => "foo", :numeric => 3.0
+      parse("bar").must == { "string" => "bar", "numeric" => 3.0 }
+    end
+  end
+end

data/spec/parser/option_spec.rb

@@ -0,0 +1,212 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Option do
+  def parse(key, value)
+    Thor::Option.parse(key, value)
+  end
+
+  def option(name, description=nil, required=false, type=nil, default=nil, banner=nil, group=nil, aliases=[])
+    @option ||= Thor::Option.new(name, description, required, type, default, banner, group, aliases)
+  end
+
+  describe "#parse" do
+
+    describe "with value as a symbol" do
+      describe "and symbol is a valid type" do
+        it "has type equals to the symbol" do
+          parse(:foo, :string).type.must == :string
+          parse(:foo, :numeric).type.must == :numeric
+        end
+
+        it "has not default value" do
+          parse(:foo, :string).default.must be_nil
+          parse(:foo, :numeric).default.must be_nil
+        end
+      end
+
+      describe "equals to :required" do
+        it "has type equals to :string" do
+          parse(:foo, :required).type.must == :string
+        end
+
+        it "has no default value" do
+          parse(:foo, :required).default.must be_nil
+        end
+      end
+
+      describe "equals to :optional" do
+        it "has type equals to :boolean" do
+          capture(:stderr){ parse(:foo, :optional).type.must == :boolean }
+        end
+
+        it "has no default value" do
+          capture(:stderr){ parse(:foo, :optional).default.must be_nil }
+        end
+      end
+
+      describe "and symbol is not a reserved key" do
+        it "has type equals to :string" do
+          parse(:foo, :bar).type.must == :string
+        end
+
+        it "has no default value" do
+          parse(:foo, :bar).default.must be_nil
+        end
+      end
+    end
+
+    describe "with value as hash" do
+      it "has default type :hash" do
+        parse(:foo, :a => :b).type.must == :hash
+      end
+
+      it "has default value equals to the hash" do
+        parse(:foo, :a => :b).default.must == { :a => :b }
+      end
+    end
+
+    describe "with value as array" do
+      it "has default type :array" do
+        parse(:foo, [:a, :b]).type.must == :array
+      end
+
+      it "has default value equals to the array" do
+        parse(:foo, [:a, :b]).default.must == [:a, :b]
+      end
+    end
+
+    describe "with value as string" do
+      it "has default type :string" do
+        parse(:foo, "bar").type.must == :string
+      end
+
+      it "has default value equals to the string" do
+        parse(:foo, "bar").default.must == "bar"
+      end
+    end
+
+    describe "with value as numeric" do
+      it "has default type :numeric" do
+        parse(:foo, 2.0).type.must == :numeric
+      end
+
+      it "has default value equals to the numeric" do
+        parse(:foo, 2.0).default.must == 2.0
+      end
+    end
+
+    describe "with value as boolean" do
+      it "has default type :boolean" do
+        parse(:foo, true).type.must == :boolean
+        parse(:foo, false).type.must == :boolean
+      end
+
+      it "has default value equals to the boolean" do
+        parse(:foo, true).default.must == true
+        parse(:foo, false).default.must == false
+      end
+    end
+
+    describe "with key as a symbol" do
+      it "sets the name equals to the key" do
+        parse(:foo, true).name.must == "foo"
+      end
+    end
+
+    describe "with key as an array" do
+      it "sets the first items in the array to the name" do
+        parse([:foo, :bar, :baz], true).name.must == "foo"
+      end
+
+      it "sets all other items as aliases" do
+        parse([:foo, :bar, :baz], true).aliases.must == [:bar, :baz]
+      end
+    end
+  end
+
+  it "returns the switch name" do
+    option("foo").switch_name.must == "--foo"
+    option("--foo").switch_name.must == "--foo"
+  end
+
+  it "returns the human name" do
+    option("foo").human_name.must == "foo"
+    option("--foo").human_name.must == "foo"
+  end
+
+  it "converts underscores to dashes" do
+    option("foo_bar").switch_name.must == "--foo-bar"
+  end
+
+  it "can be required and have default values" do
+    option = option("foo", nil, true, :string, "bar")
+    option.default.must == "bar"
+    option.must be_required
+  end
+
+  it "cannot be required and have type boolean" do
+    lambda {
+      option("foo", nil, true, :boolean)
+    }.must raise_error(ArgumentError, "An option cannot be boolean and required.")
+  end
+
+  it "allows type predicates" do
+    parse(:foo, :string).must be_string
+    parse(:foo, :boolean).must be_boolean
+    parse(:foo, :numeric).must be_numeric
+  end
+
+  it "raises an error on method missing" do
+    lambda {
+      parse(:foo, :string).unknown?
+    }.must raise_error(NoMethodError)
+  end
+
+  describe "#usage" do
+
+    it "returns usage for string types" do
+      parse(:foo, :string).usage.must == "[--foo=FOO]"
+    end
+
+    it "returns usage for numeric types" do
+      parse(:foo, :numeric).usage.must == "[--foo=N]"
+    end
+
+    it "returns usage for array types" do
+      parse(:foo, :array).usage.must == "[--foo=one two three]"
+    end
+
+    it "returns usage for hash types" do
+      parse(:foo, :hash).usage.must == "[--foo=key:value]"
+    end
+
+    it "returns usage for boolean types" do
+      parse(:foo, :boolean).usage.must == "[--foo]"
+    end
+
+    it "uses padding when no aliases is given" do
+      parse(:foo, :boolean).usage(4).must == "    [--foo]"
+    end
+
+    it "uses banner when supplied" do
+      option(:foo, nil, false, :string, nil, "BAR").usage.must == "[--foo=BAR]"
+    end
+
+    it "checkes when banner is an empty string" do
+      option(:foo, nil, false, :string, nil, "").usage.must == "[--foo]"
+    end
+
+    describe "with required values" do
+      it "does not show the usage between brackets" do
+        parse(:foo, :required).usage.must == "--foo=FOO"
+      end
+    end
+
+    describe "with aliases" do
+      it "does not show the usage between brackets" do
+        parse([:foo, "-f", "-b"], :required).usage.must == "-f, -b, --foo=FOO"
+      end
+    end
+  end
+end

data/spec/parser/options_spec.rb

@@ -0,0 +1,255 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Options do
+  def create(opts)
+    opts.each do |key, value|
+      opts[key] = Thor::Option.parse(key, value) unless value.is_a?(Thor::Option)
+    end
+
+    @opt = Thor::Options.new(opts)
+  end
+
+  def parse(*args)
+    @opt.parse(args.flatten)
+  end
+
+  describe "#to_switches" do
+    it "turns true values into a flag" do
+      Thor::Options.to_switches(:color => true).must == "--color"
+    end
+
+    it "ignores nil" do
+      Thor::Options.to_switches(:color => nil).must == ""
+    end
+
+    it "ignores false" do
+      Thor::Options.to_switches(:color => false).must == ""
+    end
+
+    it "writes --name value for anything else" do
+      Thor::Options.to_switches(:format => "specdoc").must == '--format "specdoc"'
+    end
+
+    it "joins several values" do
+      switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(' ').sort
+      switches.must == ['"bar"', "--color", "--foo"]
+    end
+
+    it "accepts arrays" do
+      Thor::Options.to_switches(:count => [1,2,3]).must == "--count 1 2 3"
+    end
+
+    it "accepts hashes" do
+      Thor::Options.to_switches(:count => {:a => :b}).must == "--count a:b"
+    end
+  end
+
+  describe "#parse" do
+    it "allows multiple aliases for a given switch" do
+      create ["--foo", "--bar", "--baz"] => :string
+      parse("--foo", "12")["foo"].must == "12"
+      parse("--bar", "12")["foo"].must == "12"
+      parse("--baz", "12")["foo"].must == "12"
+    end
+
+    it "allows custom short names" do
+      create "-f" => :string
+      parse("-f", "12").must == {"f" => "12"}
+    end
+
+    it "allows custom short-name aliases" do
+      create ["--bar", "-f"] => :string
+      parse("-f", "12").must == {"bar" => "12"}
+    end
+
+    it "accepts conjoined short switches" do
+      create ["--foo", "-f"] => true, ["--bar", "-b"] => true, ["--app", "-a"] => true
+      opts = parse("-fba")
+      opts["foo"].must be_true
+      opts["bar"].must be_true
+      opts["app"].must 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"].must be_true
+      opts["bar"].must be_true
+      opts["app"].must == "12"
+    end
+
+    it "returns the default value if none is provided" do
+      create :foo => "baz", :bar => :required
+      parse("--bar=boom")["foo"].must == "baz"
+    end
+
+    describe "with no input" do
+      it "and no switches returns an empty hash" do
+        create({})
+        parse.must == {}
+      end
+
+      it "and several switches returns an empty hash" do
+        create "--foo" => :boolean, "--bar" => :string
+        parse.must == {}
+      end
+
+      it "and a required switch raises an error" do
+        create "--foo" => :required
+        lambda { parse }.must raise_error(Thor::RequiredArgumentMissingError, "no value provided for required options '--foo'")
+      end
+    end
+
+    describe "with one required and one optional switch" do
+      before :each do
+        create "--foo" => :required, "--bar" => :boolean
+      end
+
+      it "raises an error if the required switch has no argument" do
+        lambda { parse("--foo") }.must raise_error(Thor::MalformattedArgumentError)
+      end
+
+      it "raises an error if the required switch isn't given" do
+        lambda { parse("--bar") }.must raise_error(Thor::RequiredArgumentMissingError)
+      end
+
+      it "raises an error if the required switch is set to nil" do
+        lambda { parse("--no-foo") }.must raise_error(Thor::RequiredArgumentMissingError)
+      end
+
+      it "does not raises an error if the required option has a default value" do
+        create :foo => Thor::Option.new("foo", nil, true, :string, "baz"), :bar => :boolean
+        lambda { parse("--bar") }.must_not raise_error
+      end
+    end
+
+    describe "with :string type" do
+      before(:each) do
+        create ["--foo", "-f"] => :required
+      end
+
+      it "accepts a switch <value> assignment" do
+        parse("--foo", "12")["foo"].must == "12"
+      end
+
+      it "accepts a switch=<value> assignment" do
+        parse("-f=12")["foo"].must == "12"
+        parse("--foo=12")["foo"].must == "12"
+        parse("--foo=bar=baz")["foo"].must == "bar=baz"
+      end
+
+      it "accepts a --no-switch format" do
+        create "--foo" => "bar"
+        parse("--no-foo")["foo"].must be_nil
+      end
+
+      it "accepts a --switch format on non required types" do
+        create "--foo" => "bar"
+        parse("--foo")["foo"].must == "foo"
+      end
+
+      it "overwrites earlier values with later values" do
+        parse("--foo=bar", "--foo", "12")["foo"].must == "12"
+        parse("--foo", "12", "--foo", "13")["foo"].must == "13"
+      end
+    end
+
+    describe "with :boolean type" do
+      before(:each) do
+        create "--foo" => false
+      end
+
+      it "accepts --opt assignment" do
+        parse("--foo")["foo"].must == true
+        parse("--foo", "--bar")["foo"].must == true
+      end
+
+      it "accepts --opt=value assignment" do
+        parse("--foo=true")["foo"].must == true
+        parse("--foo=false")["foo"].must == false
+      end
+
+      it "accepts --[no-]opt variant, setting false for value" do
+        parse("--no-foo")["foo"].must == false
+      end
+
+      it "accepts --[skip-]opt variant, setting false for value" do
+        parse("--skip-foo")["foo"].must == false
+      end
+
+      it "will prefer 'no-opt' variant over inverting 'opt' if explicitly set" do
+        create "--no-foo" => true
+        parse("--no-foo")["no-foo"].must == true
+      end
+
+      it "will prefer 'skip-opt' variant over inverting 'opt' if explicitly set" do
+        create "--skip-foo" => true
+        parse("--skip-foo")["skip-foo"].must == true
+      end
+
+      it "accepts inputs in the human name format" do
+        create :foo_bar => :boolean
+        parse("--foo-bar")["foo_bar"].must == true
+        parse("--no-foo-bar")["foo_bar"].must == false
+        parse("--skip-foo-bar")["foo_bar"].must == false
+      end
+    end
+
+    describe "with :hash type" do
+      before(:each) do
+        create "--attributes" => :hash
+      end
+
+      it "accepts a switch=<value> assignment" do
+        parse("--attributes=name:string", "age:integer")["attributes"].must == {"name" => "string", "age" => "integer"}
+      end
+
+      it "accepts a switch <value> assignment" do
+        parse("--attributes", "name:string", "age:integer")["attributes"].must == {"name" => "string", "age" => "integer"}
+      end
+
+      it "must not mix values with other switches" do
+        parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"].must == {"name" => "string", "age" => "integer"}
+      end
+    end
+
+    describe "with :array type" do
+      before(:each) do
+        create "--attributes" => :array
+      end
+
+      it "accepts a switch=<value> assignment" do
+        parse("--attributes=a", "b", "c")["attributes"].must == ["a", "b", "c"]
+      end
+
+      it "accepts a switch <value> assignment" do
+        parse("--attributes", "a", "b", "c")["attributes"].must == ["a", "b", "c"]
+      end
+
+      it "must not mix values with other switches" do
+        parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"].must == ["a", "b", "c"]
+      end
+    end
+
+    describe "with :numeric type" do
+      before(:each) do
+        create "n" => :numeric, "m" => 5
+      end
+
+      it "accepts a -nXY assignment" do
+        parse("-n12")["n"].must == 12
+      end
+
+      it "converts values to numeric types" do
+        parse("-n", "3", "-m", ".5").must == {"n" => 3, "m" => 0.5}
+      end
+
+      it "raises error when value isn't numeric" do
+        lambda { parse("-n", "foo") }.must raise_error(Thor::MalformattedArgumentError,
+          "expected numeric value for '-n'; got \"foo\"")
+      end
+    end
+
+  end
+end