groovenauts-thor 0.19.1 → 0.19.1.1

data/spec/fixtures/subcommand.thor

@@ -0,0 +1,17 @@
+module TestSubcommands
+
+  class Subcommand < Thor
+    desc "print_opt", "My method"
+    def print_opt
+      print options["opt"]
+    end
+  end
+
+  class Parent < Thor
+    class_option "opt"
+
+    desc "sub", "My subcommand"
+    subcommand "sub", Subcommand
+  end
+
+end

data/spec/group_spec.rb

@@ -0,0 +1,222 @@
+require "helper"
+
+describe Thor::Group do
+  describe "command" do
+    it "allows to use private methods from parent class as commands" do
+      expect(ChildGroup.start).to eq(%w[bar foo baz])
+      expect(ChildGroup.new.baz("bar")).to eq("bar")
+    end
+  end
+
+  describe "#start" do
+    it "invokes all the commands under the Thor group" do
+      expect(MyCounter.start(%w[1 2 --third 3])).to eq([1, 2, 3, nil, nil, nil])
+    end
+
+    it "uses argument's default value" do
+      expect(MyCounter.start(%w[1 --third 3])).to eq([1, 2, 3, nil, nil, nil])
+    end
+
+    it "invokes all the commands in the Thor group and its parents" do
+      expect(BrokenCounter.start(%w[1 2 --third 3])).to eq([nil, 2, 3, false, 5, nil])
+    end
+
+    it "raises an error if a required argument is added after a non-required" do
+      expect do
+        MyCounter.argument(:foo, :type => :string)
+      end.to raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
+    end
+
+    it "raises when an exception happens within the command call" do
+      expect { BrokenCounter.start(%w[1 2 --fail]) }.to raise_error
+    end
+
+    it "raises an error when a Thor group command expects arguments" do
+      expect { WhinyGenerator.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+    end
+
+    it "invokes help message if any of the shortcuts are given" do
+      expect(MyCounter).to receive(:help)
+      MyCounter.start(%w[-h])
+    end
+  end
+
+  describe "#desc" do
+    it "sets the description for a given class" do
+      expect(MyCounter.desc).to eq("Description:\n  This generator runs three commands: one, two and three.\n")
+    end
+
+    it "can be inherited" do
+      expect(BrokenCounter.desc).to eq("Description:\n  This generator runs three commands: one, two and three.\n")
+    end
+
+    it "can be nil" do
+      expect(WhinyGenerator.desc).to be nil
+    end
+  end
+
+  describe "#help" do
+    before do
+      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
+    end
+
+    it "provides usage information" do
+      expect(@content).to match(/my_counter N \[N\]/)
+    end
+
+    it "shows description" do
+      expect(@content).to match(/Description:/)
+      expect(@content).to match(/This generator runs three commands: one, two and three./)
+    end
+
+    it "shows options information" do
+      expect(@content).to match(/Options/)
+      expect(@content).to match(/\[\-\-third=THREE\]/)
+    end
+  end
+
+  describe "#invoke" do
+    before do
+      @content = capture(:stdout) { E.start }
+    end
+
+    it "allows to invoke a class from the class binding" do
+      expect(@content).to match(/1\n2\n3\n4\n5\n/)
+    end
+
+    it "shows invocation information to the user" do
+      expect(@content).to match(/invoke  Defined/)
+    end
+
+    it "uses padding on status generated by the invoked class" do
+      expect(@content).to match(/finished    counting/)
+    end
+
+    it "allows invocation to be configured with blocks" do
+      capture(:stdout) do
+        expect(F.start).to eq(["Valim, Jose"])
+      end
+    end
+
+    it "shows invoked options on help" do
+      content = capture(:stdout) { E.help(Thor::Base.shell.new) }
+      expect(content).to match(/Defined options:/)
+      expect(content).to match(/\[--unused\]/)
+      expect(content).to match(/# This option has no use/)
+    end
+  end
+
+  describe "#invoke_from_option" do
+    describe "with default type" do
+      before do
+        @content = capture(:stdout) { G.start }
+      end
+
+      it "allows to invoke a class from the class binding by a default option" do
+        expect(@content).to match(/1\n2\n3\n4\n5\n/)
+      end
+
+      it "does not invoke if the option is nil" do
+        expect(capture(:stdout) { G.start(%w[--skip-invoked]) }).not_to match(/invoke/)
+      end
+
+      it "prints a message if invocation cannot be found" do
+        content = capture(:stdout) { G.start(%w[--invoked unknown]) }
+        expect(content).to match(/error  unknown \[not found\]/)
+      end
+
+      it "allows to invoke a class from the class binding by the given option" do
+        error = nil
+        content = capture(:stdout) do
+          error = capture(:stderr) do
+            G.start(%w[--invoked e])
+          end
+        end
+        expect(content).to match(/invoke  e/)
+        expect(error).to match(/ERROR: "thor two" was called with arguments/)
+      end
+
+      it "shows invocation information to the user" do
+        expect(@content).to match(/invoke  defined/)
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        expect(@content).to match(/finished    counting/)
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout) { G.help(Thor::Base.shell.new) }
+        expect(content).to match(/defined options:/)
+        expect(content).to match(/\[--unused\]/)
+        expect(content).to match(/# This option has no use/)
+      end
+    end
+
+    describe "with boolean type" do
+      before do
+        @content = capture(:stdout) { H.start }
+      end
+
+      it "allows to invoke a class from the class binding by a default option" do
+        expect(@content).to match(/1\n2\n3\n4\n5\n/)
+      end
+
+      it "does not invoke if the option is false" do
+        expect(capture(:stdout) { H.start(%w[--no-defined]) }).not_to match(/invoke/)
+      end
+
+      it "shows invocation information to the user" do
+        expect(@content).to match(/invoke  defined/)
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        expect(@content).to match(/finished    counting/)
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout) { H.help(Thor::Base.shell.new) }
+        expect(content).to match(/defined options:/)
+        expect(content).to match(/\[--unused\]/)
+        expect(content).to match(/# This option has no use/)
+      end
+    end
+  end
+
+  describe "edge-cases" do
+    it "can handle boolean options followed by arguments" do
+      klass = Class.new(Thor::Group) do
+        desc "say hi to name"
+        argument :name, :type => :string
+        class_option :loud, :type => :boolean
+
+        def hi
+          name.upcase! if options[:loud]
+          "Hi #{name}"
+        end
+      end
+
+      expect(klass.start(%w[jose])).to eq(["Hi jose"])
+      expect(klass.start(%w[jose --loud])).to eq(["Hi JOSE"])
+      expect(klass.start(%w[--loud jose])).to eq(["Hi JOSE"])
+    end
+
+    it "provides extra args as `args`" do
+      klass = Class.new(Thor::Group) do
+        desc "say hi to name"
+        argument :name, :type => :string
+        class_option :loud, :type => :boolean
+
+        def hi
+          name.upcase! if options[:loud]
+          out = "Hi #{name}"
+          out << ": " << args.join(", ") unless args.empty?
+          out
+        end
+      end
+
+      expect(klass.start(%w[jose])).to eq(["Hi jose"])
+      expect(klass.start(%w[jose --loud])).to eq(["Hi JOSE"])
+      expect(klass.start(%w[--loud jose])).to eq(["Hi JOSE"])
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,80 @@
+$TESTING = true
+
+require "simplecov"
+require "coveralls"
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter "/spec/"
+  minimum_coverage(92.21)
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "thor"
+require "thor/group"
+require "stringio"
+
+require "rdoc"
+require "rspec"
+require "diff/lcs" # You need diff/lcs installed to run specs (but not to run Thor).
+require "fakeweb"  # You need fakeweb installed to run specs (but not to run Thor).
+
+# Set shell to basic
+$0 = "thor"
+$thor_runner = true
+ARGV.clear
+Thor::Base.shell = Thor::Shell::Basic
+
+# Load fixtures
+load File.join(File.dirname(__FILE__), "fixtures", "enum.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "invoke.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "script.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "subcommand.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "command.thor")
+
+RSpec.configure do |config|
+  config.before do
+    ARGV.replace []
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+
+  def source_root
+    File.join(File.dirname(__FILE__), "fixtures")
+  end
+
+  def destination_root
+    File.join(File.dirname(__FILE__), "sandbox")
+  end
+
+  # This code was adapted from Ruby on Rails, available under MIT-LICENSE
+  # Copyright (c) 2004-2013 David Heinemeier Hansson
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  alias silence capture
+end

data/spec/invocation_spec.rb

@@ -0,0 +1,120 @@
+require "helper"
+require "thor/base"
+
+describe Thor::Invocation do
+  describe "#invoke" do
+    it "invokes a command inside another command" do
+      expect(capture(:stdout) { A.new.invoke(:two) }).to eq("2\n3\n")
+    end
+
+    it "invokes a command just once" do
+      expect(capture(:stdout) { A.new.invoke(:one) }).to eq("1\n2\n3\n")
+    end
+
+    it "invokes a command just once even if they belongs to different classes" do
+      expect(capture(:stdout) { Defined.new.invoke(:one) }).to eq("1\n2\n3\n4\n5\n")
+    end
+
+    it "invokes a command with arguments" do
+      expect(A.new.invoke(:five, [5])).to be true
+      expect(A.new.invoke(:five, [7])).to be false
+    end
+
+    it "invokes the default command if none is given to a Thor class" do
+      content = capture(:stdout) { A.new.invoke("b") }
+      expect(content).to match(/Commands/)
+      expect(content).to match(/LAST_NAME/)
+    end
+
+    it "accepts a class as argument without a command to invoke" do
+      content = capture(:stdout) { A.new.invoke(B) }
+      expect(content).to match(/Commands/)
+      expect(content).to match(/LAST_NAME/)
+    end
+
+    it "accepts a class as argument with a command to invoke" do
+      base = A.new([], :last_name => "Valim")
+      expect(base.invoke(B, :one, %w[Jose])).to eq("Valim, Jose")
+    end
+
+    it "allows customized options to be given" do
+      base = A.new([], :last_name => "Wrong")
+      expect(base.invoke(B, :one, %w[Jose], :last_name => "Valim")).to eq("Valim, Jose")
+    end
+
+    it "reparses options in the new class" do
+      expect(A.start(%w[invoker --last-name Valim])).to eq("Valim, Jose")
+    end
+
+    it "shares initialize options with invoked class" do
+      expect(A.new([], :foo => :bar).invoke("b:two")).to eq("foo" => :bar)
+    end
+
+    it "uses default options from invoked class if no matching arguments are given" do
+      expect(A.new([]).invoke("b:four")).to eq("default")
+    end
+
+    it "overrides default options if options are passed to the invoker" do
+      expect(A.new([], :defaulted_value => "not default").invoke("b:four")).to eq("not default")
+    end
+
+    it "returns the command chain" do
+      expect(I.new.invoke("two")).to eq([:two])
+
+      if RUBY_VERSION < "1.9.3"
+        result = J.start(["one", "two" ])
+        expect(result).to include(:one)
+        expect(result).to include(:two)
+      else
+        expect(J.start(["one", "two" ])).to eq([:one, :two])
+      end
+    end
+
+    it "dump configuration values to be used in the invoked class" do
+      base = A.new
+      expect(base.invoke("b:three").shell).to eq(base.shell)
+    end
+
+    it "allow extra configuration values to be given" do
+      base, shell = A.new, Thor::Base.shell.new
+      expect(base.invoke("b:three", [], {}, :shell => shell).shell).to eq(shell)
+    end
+
+    it "invokes a Thor::Group and all of its commands" do
+      expect(capture(:stdout) { A.new.invoke(:c) }).to eq("1\n2\n3\n")
+    end
+
+    it "does not invoke a Thor::Group twice" do
+      base = A.new
+      silence(:stdout) { base.invoke(:c) }
+      expect(capture(:stdout) { base.invoke(:c) }).to be_empty
+    end
+
+    it "does not invoke any of Thor::Group commands twice" do
+      base = A.new
+      silence(:stdout) { base.invoke(:c) }
+      expect(capture(:stdout) { base.invoke("c:one") }).to be_empty
+    end
+
+    it "raises Thor::UndefinedCommandError if the command can't be found" do
+      expect do
+        A.new.invoke("foo:bar")
+      end.to raise_error(Thor::UndefinedCommandError)
+    end
+
+    it "raises Thor::UndefinedCommandError if the command can't be found even if all commands were already executed" do
+      base = C.new
+      silence(:stdout) { base.invoke_all }
+
+      expect do
+        base.invoke("foo:bar")
+      end.to raise_error(Thor::UndefinedCommandError)
+    end
+
+    it "raises an error if a non Thor class is given" do
+      expect do
+        A.new.invoke(Object)
+      end.to raise_error(RuntimeError, "Expected Thor class, got Object")
+    end
+  end
+end

data/spec/line_editor/basic_spec.rb

@@ -0,0 +1,28 @@
+require "helper"
+
+describe Thor::LineEditor::Basic do
+  describe ".available?" do
+    it "returns true" do
+      expect(Thor::LineEditor::Basic).to be_available
+    end
+  end
+
+  describe "#readline" do
+    it "uses $stdin and $stdout to get input from the user" do
+      expect($stdout).to receive(:print).with("Enter your name ")
+      expect($stdin).to receive(:gets).and_return("George")
+      expect($stdin).not_to receive(:noecho)
+      editor = Thor::LineEditor::Basic.new("Enter your name ", {})
+      expect(editor.readline).to eq("George")
+    end
+
+    it "disables echo when asked to" do
+      expect($stdout).to receive(:print).with("Password: ")
+      noecho_stdin = double("noecho_stdin")
+      expect(noecho_stdin).to receive(:gets).and_return("secret")
+      expect($stdin).to receive(:noecho).and_yield(noecho_stdin)
+      editor = Thor::LineEditor::Basic.new("Password: ", :echo => false)
+      expect(editor.readline).to eq("secret")
+    end
+  end
+end