thor 0.19.1 → 0.19.2

data/spec/quality_spec.rb

@@ -1,75 +0,0 @@
-if defined?(Encoding) && Encoding.default_external != "UTF-8"
-  Encoding.default_external = "UTF-8"
-end
-
-describe "The library itself" do
-  def check_for_spec_defs_with_single_quotes(filename)
-    failing_lines = []
-
-    File.readlines(filename).each_with_index do |line,number|
-      failing_lines << number + 1 if line =~ /^ *(describe|it|context) {1}'{1}/
-    end
-
-    unless failing_lines.empty?
-      "#{filename} uses inconsistent single quotes on lines #{failing_lines.join(', ')}"
-    end
-  end
-
-  def check_for_tab_characters(filename)
-    failing_lines = []
-    File.readlines(filename).each_with_index do |line,number|
-      failing_lines << number + 1 if line =~ /\t/
-    end
-
-    unless failing_lines.empty?
-      "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
-    end
-  end
-
-  def check_for_extra_spaces(filename)
-    failing_lines = []
-    File.readlines(filename).each_with_index do |line,number|
-      next if line =~ /^\s+#.*\s+\n$/
-      failing_lines << number + 1 if line =~ /\s+\n$/
-    end
-
-    unless failing_lines.empty?
-      "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
-    end
-  end
-
-  RSpec::Matchers.define :be_well_formed do
-    failure_message_for_should do |actual|
-      actual.join("\n")
-    end
-
-    match do |actual|
-      actual.empty?
-    end
-  end
-
-  it "has no malformed whitespace" do
-    exempt = /\.gitmodules|\.marshal|fixtures|vendor|spec|ssl_certs|LICENSE/
-    error_messages = []
-    Dir.chdir(File.expand_path("../..", __FILE__)) do
-      `git ls-files`.split("\n").each do |filename|
-        next if filename =~ exempt
-        error_messages << check_for_tab_characters(filename)
-        error_messages << check_for_extra_spaces(filename)
-      end
-    end
-    expect(error_messages.compact).to be_well_formed
-  end
-
-  it "uses double-quotes consistently in specs" do
-    included = /spec/
-    error_messages = []
-    Dir.chdir(File.expand_path("../", __FILE__)) do
-      `git ls-files`.split("\n").each do |filename|
-        next unless filename =~ included
-        error_messages << check_for_spec_defs_with_single_quotes(filename)
-      end
-    end
-    expect(error_messages.compact).to be_well_formed
-  end
-end

data/spec/rake_compat_spec.rb

@@ -1,72 +0,0 @@
-require "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
-    expect(%w[rake_compat_spec.rb Thorfile]).to include(Rake.application.rakefile)
-  end
-
-  it "adds rake tasks to thor classes too" do
-    task = ThorTask.tasks["cool"]
-    expect(task).to be
-  end
-
-  it "uses rake tasks descriptions on thor" do
-    expect(ThorTask.tasks["cool"].description).to eq("Say it's cool")
-  end
-
-  it "gets usage from rake tasks name" do
-    expect(ThorTask.tasks["cool"].usage).to eq("cool")
-  end
-
-  it "uses non namespaced name as description if non is available" do
-    expect(ThorTask::HiperMega.tasks["super"].description).to eq("super")
-  end
-
-  it "converts namespaces to classes" do
-    expect(ThorTask.const_get(:HiperMega)).to eq(ThorTask::HiperMega)
-  end
-
-  it "does not add tasks from higher namespaces in lowers namespaces" do
-    expect(ThorTask.tasks["super"]).not_to be
-  end
-
-  it "invoking the thor task invokes the rake task" do
-    expect(capture(:stdout) do
-      ThorTask.start %w[cool]
-    end).to eq("COOL\n")
-
-    expect(capture(:stdout) do
-      ThorTask::HiperMega.start %w[super]
-    end).to eq("HIPER MEGA SUPER\n")
-  end
-end

data/spec/register_spec.rb

@@ -1,227 +0,0 @@
-require "helper"
-
-class BoringVendorProvidedCLI < Thor
-  desc "boring", "do boring stuff"
-  def boring
-    puts "bored. <yawn>"
-  end
-end
-
-class ExcitingPluginCLI < Thor
-  desc "hooray", "say hooray!"
-  def hooray
-    puts "hooray!"
-  end
-
-  desc "fireworks", "exciting fireworks!"
-  def fireworks
-    puts "kaboom!"
-  end
-end
-
-class SuperSecretPlugin < Thor
-  default_command :squirrel
-
-  desc "squirrel", "All of secret squirrel's secrets"
-  def squirrel
-    puts "I love nuts"
-  end
-end
-
-class GroupPlugin < Thor::Group
-  desc "part one"
-  def part_one
-    puts "part one"
-  end
-
-  desc "part two"
-  def part_two
-    puts "part two"
-  end
-end
-
-class ClassOptionGroupPlugin < Thor::Group
-  class_option :who,
-               :type => :string,
-               :aliases => "-w",
-               :default => "zebra"
-end
-
-class CompatibleWith19Plugin < ClassOptionGroupPlugin
-  desc "animal"
-  def animal
-    p options[:who]
-  end
-end
-
-class PluginWithDefault < Thor
-  desc "say MSG", "print MSG"
-  def say(msg)
-    puts msg
-  end
-
-  default_command :say
-end
-
-class PluginWithDefaultMultipleArguments < Thor
-  desc "say MSG [MSG]", "print multiple messages"
-  def say(*args)
-    puts args
-  end
-
-  default_command :say
-end
-
-class PluginWithDefaultcommandAndDeclaredArgument < Thor
-  desc "say MSG [MSG]", "print multiple messages"
-  argument :msg
-  def say
-    puts msg
-  end
-
-  default_command :say
-end
-
-class SubcommandWithDefault < Thor
-  default_command :default
-
-  desc "default", "default subcommand"
-  def default
-    puts "default"
-  end
-
-  desc "with_args", "subcommand with arguments"
-  def with_args(*args)
-    puts "received arguments: " + args.join(",")
-  end
-end
-
-BoringVendorProvidedCLI.register(
-  ExcitingPluginCLI,
-  "exciting",
-  "do exciting things",
-  "Various non-boring actions")
-
-BoringVendorProvidedCLI.register(
-  SuperSecretPlugin,
-  "secret",
-  "secret stuff",
-  "Nothing to see here. Move along.",
-  :hide => true)
-
-BoringVendorProvidedCLI.register(
-  GroupPlugin,
-  "groupwork",
-  "Do a bunch of things in a row",
-  "purple monkey dishwasher")
-
-BoringVendorProvidedCLI.register(
-  CompatibleWith19Plugin,
-  "zoo",
-  "zoo [-w animal]",
-  "Shows a provided animal or just zebra")
-
-BoringVendorProvidedCLI.register(
-  PluginWithDefault,
-  "say",
-  "say message",
-  "subcommands ftw")
-
-BoringVendorProvidedCLI.register(
-  PluginWithDefaultMultipleArguments,
-  "say_multiple",
-  "say message",
-  "subcommands ftw")
-
-BoringVendorProvidedCLI.register(
-  PluginWithDefaultcommandAndDeclaredArgument,
-  "say_argument",
-  "say message",
-  "subcommands ftw")
-
-BoringVendorProvidedCLI.register(SubcommandWithDefault,
-  "subcommand", "subcommand", "Run subcommands")
-
-describe ".register-ing a Thor subclass" do
-  it "registers the plugin as a subcommand" do
-    fireworks_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting fireworks]) }
-    expect(fireworks_output).to eq("kaboom!\n")
-  end
-
-  it "includes the plugin's usage in the help" do
-    help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
-    expect(help_output).to include("do exciting things")
-  end
-
-  context "with a default command," do
-    it "invokes the default command correctly" do
-      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say hello]) }
-      expect(output).to include("hello")
-    end
-
-    it "invokes the default command correctly with multiple args" do
-      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_multiple hello adam]) }
-      expect(output).to include("hello")
-      expect(output).to include("adam")
-    end
-
-    it "invokes the default command correctly with a declared argument" do
-      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_argument hello]) }
-      expect(output).to include("hello")
-    end
-
-    it "displays the subcommand's help message" do
-      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[subcommand help]) }
-      expect(output).to include("default subcommand")
-      expect(output).to include("subcommand with argument")
-    end
-
-    it "invokes commands with their actual args" do
-      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[subcommand with_args actual_argument]) }
-      expect(output.strip).to eql("received arguments: actual_argument")
-    end
-  end
-
-  context "when $thor_runner is false" do
-    it "includes the plugin's subcommand name in subcommand's help" do
-      begin
-        $thor_runner = false
-        help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting]) }
-        expect(help_output).to include("thor exciting_plugin_c_l_i fireworks")
-      ensure
-        $thor_runner = true
-      end
-    end
-  end
-
-  context "when hidden" do
-    it "omits the hidden plugin's usage from the help" do
-      help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
-      expect(help_output).not_to include("secret stuff")
-    end
-
-    it "registers the plugin as a subcommand" do
-      secret_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[secret squirrel]) }
-      expect(secret_output).to eq("I love nuts\n")
-    end
-  end
-end
-
-describe ".register-ing a Thor::Group subclass" do
-  it "registers the group as a single command" do
-    group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[groupwork]) }
-    expect(group_output).to eq("part one\npart two\n")
-  end
-end
-
-describe "1.8 and 1.9 syntax compatibility" do
-  it "is compatible with both 1.8 and 1.9 syntax w/o command options" do
-    group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[zoo]) }
-    expect(group_output).to match(/zebra/)
-  end
-
-  it "is compatible with both 1.8 and 1.9 syntax w/command options" do
-    group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[zoo -w lion]) }
-    expect(group_output).to match(/lion/)
-  end
-end

data/spec/runner_spec.rb

@@ -1,246 +0,0 @@
-require "helper"
-require "thor/runner"
-
-describe Thor::Runner do
-  def when_no_thorfiles_exist
-    old_dir = Dir.pwd
-    Dir.chdir ".."
-    delete = Thor::Base.subclasses.select { |e| e.namespace == "default" }
-    delete.each { |e| Thor::Base.subclasses.delete e }
-    yield
-    Thor::Base.subclasses.concat delete
-    Dir.chdir old_dir
-  end
-
-  describe "#help" do
-    it "shows information about Thor::Runner itself" do
-      expect(capture(:stdout) { Thor::Runner.start(%w[help]) }).to match(/List the available thor commands/)
-    end
-
-    it "shows information about a specific Thor::Runner command" do
-      content = capture(:stdout) { Thor::Runner.start(%w[help list]) }
-      expect(content).to match(/List the available thor commands/)
-      expect(content).not_to match(/help \[COMMAND\]/)
-    end
-
-    it "shows information about a specific Thor class" do
-      content = capture(:stdout) { Thor::Runner.start(%w[help my_script]) }
-      expect(content).to match(/zoo\s+# zoo around/m)
-    end
-
-    it "shows information about a specific command from a specific Thor class" do
-      content = capture(:stdout) { Thor::Runner.start(%w[help my_script:zoo]) }
-      expect(content).to match(/zoo around/)
-      expect(content).not_to match(/help \[COMMAND\]/)
-    end
-
-    it "shows information about a specific Thor group class" do
-      content = capture(:stdout) { Thor::Runner.start(%w[help my_counter]) }
-      expect(content).to match(/my_counter N/)
-    end
-
-    it "raises error if a class/command cannot be found" do
-      content = capture(:stderr) { Thor::Runner.start(%w[help unknown]) }
-      expect(content.strip).to eq('Could not find command "unknown" in "default" namespace.')
-    end
-
-    it "raises error if a class/command cannot be found for a setup without thorfiles" do
-      when_no_thorfiles_exist do
-        expect(Thor::Runner).to receive :exit
-        content = capture(:stderr) { Thor::Runner.start(%w[help unknown]) }
-        expect(content.strip).to eq('Could not find command "unknown".')
-      end
-    end
-  end
-
-  describe "#start" do
-    it "invokes a command from Thor::Runner" do
-      ARGV.replace %w[list]
-      expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
-    end
-
-    it "invokes a command from a specific Thor class" do
-      ARGV.replace %w[my_script:zoo]
-      expect(Thor::Runner.start).to be true
-    end
-
-    it "invokes the default command from a specific Thor class if none is specified" do
-      ARGV.replace %w[my_script]
-      expect(Thor::Runner.start).to eq("default command")
-    end
-
-    it "forwards arguments to the invoked command" do
-      ARGV.replace %w[my_script:animal horse]
-      expect(Thor::Runner.start).to eq(%w[horse])
-    end
-
-    it "invokes commands through shortcuts" do
-      ARGV.replace %w[my_script -T horse]
-      expect(Thor::Runner.start).to eq(%w[horse])
-    end
-
-    it "invokes a Thor::Group" do
-      ARGV.replace %w[my_counter 1 2 --third 3]
-      expect(Thor::Runner.start).to eq([1, 2, 3, nil, nil, nil])
-    end
-
-    it "raises an error if class/command can't be found" do
-      ARGV.replace %w[unknown]
-      content = capture(:stderr) { Thor::Runner.start }
-      expect(content.strip).to eq('Could not find command "unknown" in "default" namespace.')
-    end
-
-    it "raises an error if class/command can't be found in a setup without thorfiles" do
-      when_no_thorfiles_exist do
-        ARGV.replace %w[unknown]
-        expect(Thor::Runner).to receive :exit
-        content = capture(:stderr) { Thor::Runner.start }
-        expect(content.strip).to eq('Could not find command "unknown".')
-      end
-    end
-
-    it "does not swallow NoMethodErrors that occur inside the called method" do
-      ARGV.replace %w[my_script:call_unexistent_method]
-      expect { Thor::Runner.start }.to raise_error(NoMethodError)
-    end
-
-    it "does not swallow Thor::Group InvocationError" do
-      ARGV.replace %w[whiny_generator]
-      expect { Thor::Runner.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
-    end
-
-    it "does not swallow Thor InvocationError" do
-      ARGV.replace %w[my_script:animal]
-      content = capture(:stderr) { Thor::Runner.start }
-      expect(content.strip).to eq(%Q(ERROR: "thor animal" was called with no arguments
-Usage: "thor my_script:animal TYPE"))
-    end
-  end
-
-  describe "commands" do
-    before do
-      @location = "#{File.dirname(__FILE__)}/fixtures/command.thor"
-      @original_yaml = {
-        "random" => {
-          :location  => @location,
-          :filename  => "4a33b894ffce85d7b412fc1b36f88fe0",
-          :namespaces => %w[amazing]
-        }
-      }
-
-      root_file = File.join(Thor::Util.thor_root, "thor.yml")
-
-      # Stub load and save to avoid thor.yaml from being overwritten
-      allow(YAML).to receive(:load_file).and_return(@original_yaml)
-      allow(File).to receive(:exist?).with(root_file).and_return(true)
-      allow(File).to receive(:open).with(root_file, "w")
-    end
-
-    describe "list" do
-      it "gives a list of the available commands" do
-        ARGV.replace %w[list]
-        content = capture(:stdout) { Thor::Runner.start }
-        expect(content).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
-      end
-
-      it "gives a list of the available Thor::Group classes" do
-        ARGV.replace %w[list]
-        expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
-      end
-
-      it "can filter a list of the available commands by --group" do
-        ARGV.replace %w[list --group standard]
-        expect(capture(:stdout) { Thor::Runner.start }).to match(/amazing:describe NAME/)
-        ARGV.replace []
-        expect(capture(:stdout) { Thor::Runner.start }).not_to match(/my_script:animal TYPE/)
-        ARGV.replace %w[list --group script]
-        expect(capture(:stdout) { Thor::Runner.start }).to match(/my_script:animal TYPE/)
-      end
-
-      it "can skip all filters to show all commands using --all" do
-        ARGV.replace %w[list --all]
-        content = capture(:stdout) { Thor::Runner.start }
-        expect(content).to match(/amazing:describe NAME/)
-        expect(content).to match(/my_script:animal TYPE/)
-      end
-
-      it "doesn't list superclass commands in the subclass" do
-        ARGV.replace %w[list]
-        expect(capture(:stdout) { Thor::Runner.start }).not_to match(/amazing:help/)
-      end
-
-      it "presents commands in the default namespace with an empty namespace" do
-        ARGV.replace %w[list]
-        expect(capture(:stdout) { Thor::Runner.start }).to match(/^thor :cow\s+# prints 'moo'/m)
-      end
-
-      it "runs commands with an empty namespace from the default namespace" do
-        ARGV.replace %w[:command_conflict]
-        expect(capture(:stdout) { Thor::Runner.start }).to eq("command\n")
-      end
-
-      it "runs groups even when there is a command with the same name" do
-        ARGV.replace %w[command_conflict]
-        expect(capture(:stdout) { Thor::Runner.start }).to eq("group\n")
-      end
-
-      it "runs commands with no colon in the default namespace" do
-        ARGV.replace %w[cow]
-        expect(capture(:stdout) { Thor::Runner.start }).to eq("moo\n")
-      end
-    end
-
-    describe "uninstall" do
-      before do
-        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
-        expect(FileUtils).to receive(:rm_rf).with(path)
-      end
-
-      it "uninstalls existing thor modules" do
-        silence(:stdout) { Thor::Runner.start(%w[uninstall random]) }
-      end
-    end
-
-    describe "installed" do
-      before do
-        expect(Dir).to receive(:[]).and_return([])
-      end
-
-      it "displays the modules installed in a pretty way" do
-        stdout = capture(:stdout) { Thor::Runner.start(%w[installed]) }
-        expect(stdout).to match(/random\s*amazing/)
-        expect(stdout).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
-      end
-    end
-
-    describe "install/update" do
-      before do
-        allow(FileUtils).to receive(:mkdir_p)
-        allow(FileUtils).to receive(:touch)
-        allow(Thor::LineEditor).to receive(:readline).and_return("Y")
-
-        path = File.join(Thor::Util.thor_root, Digest::MD5.hexdigest(@location + "random"))
-        expect(File).to receive(:open).with(path, "w")
-      end
-
-      it "updates existing thor files" do
-        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
-        if File.directory? path
-          expect(FileUtils).to receive(:rm_rf).with(path)
-        else
-          expect(File).to receive(:delete).with(path)
-        end
-        silence_warnings do
-          silence(:stdout) { Thor::Runner.start(%w[update random]) }
-        end
-      end
-
-      it "installs thor files" do
-        ARGV.replace %W[install #{@location}]
-        silence_warnings do
-          silence(:stdout) { Thor::Runner.start }
-        end
-      end
-    end
-  end
-end