thor 0.16.0 → 1.2.1

data/spec/parser/arguments_spec.rb

@@ -1,66 +0,0 @@
-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|
-      options = {:required => default.nil?, :type => type, :default => default}
-      Thor::Argument.new(type.to_s, options)
-    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"].should == "name"
-      parse("name", "13")["numeric"].should == 13
-    end
-
-    it "accepts hashes" do
-      create :string => nil, :hash => nil
-      parse("product", "title:string", "age:integer")["string"].should == "product"
-      parse("product", "title:string", "age:integer")["hash"].should == { "title" => "string", "age" => "integer"}
-      parse("product", "url:http://www.amazon.com/gp/product/123")["hash"].should == { "url" => "http://www.amazon.com/gp/product/123" }
-    end
-
-    it "accepts arrays" do
-      create :string => nil, :array => nil
-      parse("product", "title", "age")["string"].should == "product"
-      parse("product", "title", "age")["array"].should == %w(title age)
-    end
-
-    describe "with no inputs" do
-      it "and no arguments returns an empty hash" do
-        create
-        parse.should == {}
-      end
-
-      it "and required arguments raises an error" do
-        create :string => nil, :numeric => nil
-        lambda { parse }.should 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.should == { "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, {}, []).should == { "string" => "", "numeric" => 0, "hash" => {}, "array" => [] }
-    end
-
-    it "returns the default value if none is provided" do
-      create :string => "foo", :numeric => 3.0
-      parse("bar").should == { "string" => "bar", "numeric" => 3.0 }
-    end
-  end
-end

data/spec/parser/option_spec.rb

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

data/spec/parser/options_spec.rb

@@ -1,330 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'thor/parser'
-
-describe Thor::Options do
-  def create(opts, defaults={})
-    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)
-  end
-
-  def parse(*args)
-    @opt.parse(args.flatten)
-  end
-
-  def check_unknown!
-    @opt.check_unknown!
-  end
-
-  describe "#to_switches" do
-    it "turns true values into a flag" do
-      Thor::Options.to_switches(:color => true).should == "--color"
-    end
-
-    it "ignores nil" do
-      Thor::Options.to_switches(:color => nil).should == ""
-    end
-
-    it "ignores false" do
-      Thor::Options.to_switches(:color => false).should == ""
-    end
-
-    it "writes --name value for anything else" do
-      Thor::Options.to_switches(:format => "specdoc").should == '--format "specdoc"'
-    end
-
-    it "joins several values" do
-      switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(' ').sort
-      switches.should == ['"bar"', "--color", "--foo"]
-    end
-
-    it "accepts arrays" do
-      Thor::Options.to_switches(:count => [1,2,3]).should == "--count 1 2 3"
-    end
-
-    it "accepts hashes" do
-      Thor::Options.to_switches(:count => {:a => :b}).should == "--count a:b"
-    end
-
-    it "accepts underscored options" do
-      Thor::Options.to_switches(:under_score_option => "foo bar").should == '--under_score_option "foo bar"'
-    end
-
-  end
-
-  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"
-    end
-
-    it "allows custom short names" do
-      create "-f" => :string
-      parse("-f", "12").should == {"f" => "12"}
-    end
-
-    it "allows custom short-name aliases" do
-      create ["--bar", "-f"] => :string
-      parse("-f", "12").should == {"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
-    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"
-    end
-
-    it "returns the default value if none is provided" do
-      create :foo => "baz", :bar => :required
-      parse("--bar", "boom")["foo"].should == "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"
-    end
-
-    it "gives higher priority to defaults given in the hash" do
-      create Hash[:bar => true], Hash[:bar => false]
-      parse["bar"].should == 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'")
-    end
-
-    it "skips leading non-switches" do
-      create(:foo => "baz")
-
-      parse("asdf", "--foo", "bar").should == {"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"}
-      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
-    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"
-    end
-
-    describe "with no input" do
-      it "and no switches returns an empty hash" do
-        create({})
-        parse.should == {}
-      end
-
-      it "and several switches returns an empty hash" do
-        create "--foo" => :boolean, "--bar" => :string
-        parse.should == {}
-      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'")
-      end
-    end
-
-    describe "with one required and one optional switch" do
-      before do
-        create "--foo" => :required, "--bar" => :boolean
-      end
-
-      it "raises an error if the required switch has no argument" do
-        lambda { parse("--foo") }.should 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)
-      end
-
-      it "raises an error if the required switch is set to nil" do
-        lambda { parse("--no-foo") }.should 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
-      end
-    end
-
-    describe "with :string type" do
-      before do
-        create ["--foo", "-f"] => :required
-      end
-
-      it "accepts a switch <value> assignment" do
-        parse("--foo", "12")["foo"].should == "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"
-      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/"
-      end
-
-      it "accepts a --no-switch format" do
-        create "--foo" => "bar"
-        parse("--no-foo")["foo"].should 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
-      end
-
-      it "accepts a --switch format on non required types" do
-        create "--foo" => :string
-        parse("--foo")["foo"].should == "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"
-      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"
-      end
-    end
-
-    describe "with :boolean type" do
-      before do
-        create "--foo" => false
-      end
-
-      it "accepts --opt assignment" do
-        parse("--foo")["foo"].should == true
-        parse("--foo", "--bar")["foo"].should == true
-      end
-
-      it "uses the default value if no switch is given" do
-        parse("")["foo"].should == false
-      end
-
-      it "accepts --opt=value assignment" do
-        parse("--foo=true")["foo"].should == true
-        parse("--foo=false")["foo"].should == false
-      end
-
-      it "accepts --[no-]opt variant, setting false for value" do
-        parse("--no-foo")["foo"].should == false
-      end
-
-      it "accepts --[skip-]opt variant, setting false for value" do
-        parse("--skip-foo")["foo"].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
-
-      it "will prefer 'skip-opt' variant over inverting 'opt' if explicitly set" do
-        create "--skip-foo" => true
-        parse("--skip-foo")["skip-foo"].should == 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
-      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"]
-      end
-    end
-
-    describe "with :hash type" do
-      before do
-        create "--attributes" => :hash
-      end
-
-      it "accepts a switch=<value> assignment" do
-        parse("--attributes=name:string", "age:integer")["attributes"].should == {"name" => "string", "age" => "integer"}
-      end
-
-      it "accepts a switch <value> assignment" do
-        parse("--attributes", "name:string", "age:integer")["attributes"].should == {"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"}
-      end
-    end
-
-    describe "with :array type" do
-      before do
-        create "--attributes" => :array
-      end
-
-      it "accepts a switch=<value> assignment" do
-        parse("--attributes=a", "b", "c")["attributes"].should == ["a", "b", "c"]
-      end
-
-      it "accepts a switch <value> assignment" do
-        parse("--attributes", "a", "b", "c")["attributes"].should == ["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"]
-      end
-    end
-
-    describe "with :numeric type" do
-      before do
-        create "n" => :numeric, "m" => 5
-      end
-
-      it "accepts a -nXY assignment" do
-        parse("-n12")["n"].should == 12
-      end
-
-      it "converts values to numeric types" do
-        parse("-n", "3", "-m", ".5").should == {"n" => 3, "m" => 0.5}
-      end
-
-      it "raises error when value isn't numeric" do
-        lambda { parse("-n", "foo") }.should raise_error(Thor::MalformattedArgumentError,
-          "Expected numeric value for '-n'; got \"foo\"")
-      end
-    end
-
-  end
-end

data/spec/rake_compat_spec.rb

@@ -1,72 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'thor/rake_compat'
-require 'rake/tasklib'
-
-$main = self
-
-class RakeTask < Rake::TaskLib
-  def initialize
-    define
-  end
-
-  def define
-    $main.instance_eval do
-      desc "Say it's cool"
-      task :cool do
-        puts "COOL"
-      end
-
-      namespace :hiper_mega do
-        task :super do
-          puts "HIPER MEGA SUPER"
-        end
-      end
-    end
-  end
-end
-
-class ThorTask < Thor
-  include Thor::RakeCompat
-  RakeTask.new
-end
-
-describe Thor::RakeCompat do
-  it "sets the rakefile application" do
-    ["rake_compat_spec.rb", "Thorfile"].should include(Rake.application.rakefile)
-  end
-
-  it "adds rake tasks to thor classes too" do
-    task = ThorTask.tasks["cool"]
-    task.should be
-  end
-
-  it "uses rake tasks descriptions on thor" do
-    ThorTask.tasks["cool"].description.should == "Say it's cool"
-  end
-
-  it "gets usage from rake tasks name" do
-    ThorTask.tasks["cool"].usage.should == "cool"
-  end
-
-  it "uses non namespaced name as description if non is available" do
-    ThorTask::HiperMega.tasks["super"].description.should == "super"
-  end
-
-  it "converts namespaces to classes" do
-    ThorTask.const_get(:HiperMega).should == ThorTask::HiperMega
-  end
-
-  it "does not add tasks from higher namespaces in lowers namespaces" do
-    ThorTask.tasks["super"].should_not be
-  end
-
-  it "invoking the thor task invokes the rake task" do
-    capture(:stdout) do
-      ThorTask.start ["cool"]
-    end.should == "COOL\n"
-
-    capture(:stdout) do
-      ThorTask::HiperMega.start ["super"]
-    end.should == "HIPER MEGA SUPER\n"
-  end
-end