angry_mob 0.1.0

data/vendor/thor/spec/actions_spec.rb

@@ -0,0 +1,292 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Thor::Actions do
+  def runner(options={})
+    @runner ||= MyCounter.new([1], options, { :destination_root => destination_root })
+  end
+
+  def action(*args, &block)
+    capture(:stdout){ runner.send(*args, &block) }
+  end
+
+  def file
+    File.join(destination_root, "foo")
+  end
+
+  describe "on include" do
+    it "adds runtime options to the base class" do
+      MyCounter.class_options.keys.must include(:pretend)
+      MyCounter.class_options.keys.must include(:force)
+      MyCounter.class_options.keys.must include(:quiet)
+      MyCounter.class_options.keys.must include(:skip)
+    end
+  end
+
+  describe "#initialize" do
+    it "has default behavior invoke" do
+      runner.behavior.must == :invoke
+    end
+
+    it "can have behavior revoke" do
+      MyCounter.new([1], {}, :behavior => :revoke).behavior.must == :revoke
+    end
+
+    it "when behavior is set to force, overwrite options" do
+      runner = MyCounter.new([1], { :force => false, :skip => true }, :behavior => :force)
+      runner.behavior.must == :invoke
+      runner.options.force.must be_true
+      runner.options.skip.must_not be_true
+    end
+
+    it "when behavior is set to skip, overwrite options" do
+      runner = MyCounter.new([1], ["--force"], :behavior => :skip)
+      runner.behavior.must == :invoke
+      runner.options.force.must_not be_true
+      runner.options.skip.must be_true
+    end
+  end
+
+  describe "accessors" do
+    describe "#destination_root=" do
+      it "gets the current directory and expands the path to set the root" do
+        base = MyCounter.new([1])
+        base.destination_root = "here"
+        base.destination_root.must == File.expand_path(File.join(File.dirname(__FILE__), "..", "here"))
+      end
+
+      it "does not use the current directory if one is given" do
+        root = File.expand_path("/")
+        base = MyCounter.new([1])
+        base.destination_root = root
+        base.destination_root.must == root
+      end
+
+      it "uses the current directory if none is given" do
+        base = MyCounter.new([1])
+        base.destination_root.must == File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      end
+    end
+
+    describe "#relative_to_original_destination_root" do
+      it "returns the path relative to the absolute root" do
+        runner.relative_to_original_destination_root(file).must == "foo"
+      end
+
+      it "does not remove dot if required" do
+        runner.relative_to_original_destination_root(file, false).must == "./foo"
+      end
+
+      it "always use the absolute root" do
+        runner.inside("foo") do
+          runner.relative_to_original_destination_root(file).must == "foo"
+        end
+      end
+
+      describe "#source_paths_for_search" do
+        it "add source_root to source_paths_for_search" do
+          MyCounter.source_paths_for_search.must include(File.expand_path("fixtures", File.dirname(__FILE__)))
+        end
+
+        it "keeps only current source root in source paths" do
+          ClearCounter.source_paths_for_search.must include(File.expand_path("fixtures/bundle", File.dirname(__FILE__)))
+          ClearCounter.source_paths_for_search.must_not include(File.expand_path("fixtures", File.dirname(__FILE__)))
+        end
+
+        it "customized source paths should be before source roots" do
+          ClearCounter.source_paths_for_search[0].must == File.expand_path("fixtures/doc", File.dirname(__FILE__))
+          ClearCounter.source_paths_for_search[1].must == File.expand_path("fixtures/bundle", File.dirname(__FILE__))
+        end
+
+        it "keeps inherited source paths at the end" do
+          ClearCounter.source_paths_for_search.last.must == File.expand_path("fixtures/broken", File.dirname(__FILE__))
+        end
+      end
+    end
+
+    describe "#find_in_source_paths" do
+      it "raises an error if source path is empty" do
+        lambda {
+          A.new.find_in_source_paths("foo")
+        }.must raise_error(Thor::Error, /You don't have any source path defined for class A/)
+      end
+
+      it "finds a template inside the source path" do
+        runner.find_in_source_paths("doc").must == File.expand_path("doc", source_root)
+        lambda { runner.find_in_source_paths("README") }.must raise_error
+
+        new_path = File.join(source_root, "doc")
+        runner.instance_variable_set(:@source_paths, nil)
+        runner.source_paths.unshift(new_path)
+        runner.find_in_source_paths("README").must == File.expand_path("README", new_path)
+      end
+    end
+  end
+
+  describe "#inside" do
+    it "executes the block inside the given folder" do
+      runner.inside("foo") do
+        Dir.pwd.must == file
+      end
+    end
+
+    it "changes the base root" do
+      runner.inside("foo") do
+        runner.destination_root.must == file
+      end
+    end
+
+    it "creates the directory if it does not exist" do
+      runner.inside("foo") do
+        File.exists?(file).must be_true
+      end
+    end
+
+    describe "when verbose" do
+      it "logs status" do
+        capture(:stdout) do
+          runner.inside("foo", :verbose => true) {}
+        end.must =~ /inside  foo/
+      end
+
+      it "uses padding in next status" do
+        capture(:stdout) do
+          runner.inside("foo", :verbose => true) do
+            runner.say_status :cool, :padding
+          end
+        end.must =~ /cool    padding/
+      end
+
+      it "removes padding after block" do
+        capture(:stdout) do
+          runner.inside("foo", :verbose => true) {}
+          runner.say_status :no, :padding
+        end.must =~ /no  padding/
+      end
+    end
+  end
+
+  describe "#in_root" do
+    it "executes the block in the root folder" do
+      runner.inside("foo") do
+        runner.in_root { Dir.pwd.must == destination_root }
+      end
+    end
+
+    it "changes the base root" do
+      runner.inside("foo") do
+        runner.in_root { runner.destination_root.must == destination_root }
+      end
+    end
+
+    it "returns to the previous state" do
+      runner.inside("foo") do
+        runner.in_root { }
+        runner.destination_root.must == file
+      end
+    end
+  end
+
+  describe "#apply" do
+    before(:each) do
+      @template = <<-TEMPLATE
+        @foo = "FOO"
+        say_status :cool, :padding
+      TEMPLATE
+      @template.instance_eval "def read; self; end" # Make the string respond to read
+
+      @file = "http://gist.github.com/103208.txt"
+      runner.should_receive(:open).and_return(@template)
+    end
+
+    it "opens a file and executes its content in the instance binding" do
+      action :apply, @file
+      runner.instance_variable_get("@foo").must == "FOO"
+    end
+
+    it "applies padding to the content inside the file" do
+      action(:apply, @file).must =~ /cool    padding/
+    end
+
+    it "logs its status" do
+      action(:apply, @file).must =~ /       apply  #{@file}\n/
+    end
+
+    it "does not log status" do
+      content = action(:apply, @file, :verbose => false)
+      content.must =~ /cool  padding/
+      content.must_not =~ /apply http/
+    end
+  end
+
+  describe "#run" do
+    before(:each) do
+      runner.should_receive(:`).with("ls")
+    end
+
+    it "executes the command given" do
+      action :run, "ls"
+    end
+
+    it "logs status" do
+      action(:run, "ls").must == "         run  ls from \".\"\n"
+    end
+
+    it "does not log status if required" do
+      action(:run, "ls", :verbose => false).must be_empty
+    end
+
+    it "accepts a color as status" do
+      runner.shell.should_receive(:say_status).with(:run, 'ls from "."', :yellow)
+      action :run, "ls", :verbose => :yellow
+    end
+  end
+
+  describe "#run_ruby_script" do
+    before(:each) do
+      Thor::Util.stub!(:ruby_command).and_return("/opt/jruby")
+      runner.should_receive(:`).with("/opt/jruby script.rb")
+    end
+
+    it "executes the ruby script" do
+      action :run_ruby_script, "script.rb"
+    end
+
+    it "logs status" do
+      action(:run_ruby_script, "script.rb").must == "         run  jruby script.rb from \".\"\n"
+    end
+
+    it "does not log status if required" do
+      action(:run_ruby_script, "script.rb", :verbose => false).must be_empty
+    end
+  end
+
+  describe "#thor" do
+    it "executes the thor command" do
+      runner.should_receive(:`).with("thor list")
+      action :thor, :list, :verbose => true
+    end
+
+    it "converts extra arguments to command arguments" do
+      runner.should_receive(:`).with("thor list foo bar")
+      action :thor, :list, "foo", "bar"
+    end
+
+    it "converts options hash to switches" do
+      runner.should_receive(:`).with("thor list foo bar --foo")
+      action :thor, :list, "foo", "bar", :foo => true
+
+      runner.should_receive(:`).with("thor list --foo 1 2 3")
+      action :thor, :list, :foo => [1,2,3]
+    end
+
+    it "logs status" do
+      runner.should_receive(:`).with("thor list")
+      action(:thor, :list).must == "         run  thor list from \".\"\n"
+    end
+
+    it "does not log status if required" do
+      runner.should_receive(:`).with("thor list --foo 1 2 3")
+      action(:thor, :list, :foo => [1,2,3], :verbose => false).must be_empty
+    end
+  end
+end

data/vendor/thor/spec/base_spec.rb

@@ -0,0 +1,263 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'thor/base'
+
+class Amazing
+  desc "hello", "say hello"
+  def hello
+    puts "Hello"
+  end
+end
+
+describe Thor::Base do
+  describe "#initialize" do
+    it "sets arguments array" do
+      base = MyCounter.new [1, 2]
+      base.first.must == 1
+      base.second.must == 2
+    end
+
+    it "sets arguments default values" do
+      base = MyCounter.new [1]
+      base.second.must == 2
+    end
+
+    it "sets options default values" do
+      base = MyCounter.new [1, 2]
+      base.options[:third].must == 3
+    end
+
+    it "allows options to be given as symbols or strings" do
+      base = MyCounter.new [1, 2], :third => 4
+      base.options[:third].must == 4
+
+      base = MyCounter.new [1, 2], "third" => 4
+      base.options[:third].must == 4
+    end
+
+    it "creates options with indifferent access" do
+      base = MyCounter.new [1, 2], :third => 3
+      base.options['third'].must == 3
+    end
+
+    it "creates options with magic predicates" do
+      base = MyCounter.new [1, 2], :third => 3
+      base.options.third.must == 3
+    end
+  end
+
+  describe "#no_tasks" do
+    it "avoids methods being added as tasks" do
+      MyScript.tasks.keys.must include("animal")
+      MyScript.tasks.keys.must_not include("this_is_not_a_task")
+    end
+  end
+
+  describe "#argument" do
+    it "sets a value as required and creates an accessor for it" do
+      MyCounter.start(["1", "2", "--third", "3"])[0].must == 1
+      Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"]).must == "my_special_param"
+    end
+
+    it "does not set a value in the options hash" do
+      BrokenCounter.start(["1", "2", "--third", "3"])[0].must be_nil
+    end
+  end
+
+  describe "#arguments" do
+    it "returns the arguments for the class" do
+      MyCounter.arguments.must have(2).items
+    end
+  end
+
+  describe "#class_option" do
+    it "sets options class wise" do
+      MyCounter.start(["1", "2", "--third", "3"])[2].must == 3
+    end
+
+    it "does not create an acessor for it" do
+      BrokenCounter.start(["1", "2", "--third", "3"])[3].must be_false
+    end
+  end
+
+  describe "#class_options" do
+    it "sets default options overwriting superclass definitions" do
+      options = Scripts::MyScript.class_options
+      options[:force].must_not be_required
+    end
+  end
+
+  describe "#remove_argument" do
+    it "removes previous defined arguments from class" do
+      ClearCounter.arguments.must be_empty
+    end
+
+    it "undefine accessors if required" do
+      ClearCounter.new.must_not respond_to(:first)
+      ClearCounter.new.must_not respond_to(:second)
+    end
+  end
+
+  describe "#remove_class_option" do
+    it "removes previous defined class option" do
+      ClearCounter.class_options[:third].must be_nil
+    end
+  end
+
+  describe "#class_options_help" do
+    before(:each) do
+      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
+    end
+
+    it "shows options description" do
+      @content.must =~ /# The third argument/
+    end
+
+    it "shows usage with banner content" do
+      @content.must =~ /\[\-\-third=THREE\]/
+    end
+
+    it "shows default values below description" do
+      @content.must =~ /# Default: 3/
+    end
+
+    it "shows options in different groups" do
+      @content.must =~ /Options\:/
+      @content.must =~ /Runtime options\:/
+      @content.must =~ /\-p, \[\-\-pretend\]/
+    end
+
+    it "use padding in options that does not have aliases" do
+      @content.must =~ /^  -t, \[--third/
+      @content.must =~ /^      \[--fourth/
+    end
+
+    it "allows extra options to be given" do
+      hash = { "Foo" => B.class_options.values }
+
+      content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, hash) }
+      content.must =~ /Foo options\:/
+      content.must =~ /--last-name=LAST_NAME/
+    end
+  end
+
+  describe "#namespace" do
+    it "returns the default class namespace" do
+      Scripts::MyScript.namespace.must == "scripts:my_script"
+    end
+
+    it "sets a namespace to the class" do
+      Scripts::MyDefaults.namespace.must == "default"
+    end
+  end
+
+  describe "#group" do
+    it "sets a group" do
+      MyScript.group.must == "script"
+    end
+
+    it "inherits the group from parent" do
+      MyChildScript.group.must == "script"
+    end
+
+    it "defaults to standard if no group is given" do
+      Amazing.group.must == "standard"
+    end
+  end
+
+  describe "#subclasses" do
+    it "tracks its subclasses in an Array" do
+      Thor::Base.subclasses.must include(MyScript)
+      Thor::Base.subclasses.must include(MyChildScript)
+      Thor::Base.subclasses.must include(Scripts::MyScript)
+    end
+  end
+
+  describe "#subclass_files" do
+    it "returns tracked subclasses, grouped by the files they come from" do
+      thorfile = File.join(File.dirname(__FILE__), "fixtures", "script.thor")
+      Thor::Base.subclass_files[File.expand_path(thorfile)].must == [
+        MyScript, MyScript::AnotherScript, MyChildScript, Scripts::MyScript,
+        Scripts::MyDefaults, Scripts::ChildDefault
+      ]
+    end
+
+    it "tracks a single subclass across multiple files" do
+      thorfile = File.join(File.dirname(__FILE__), "fixtures", "task.thor")
+      Thor::Base.subclass_files[File.expand_path(thorfile)].must include(Amazing)
+      Thor::Base.subclass_files[File.expand_path(__FILE__)].must include(Amazing)
+    end
+  end
+
+  describe "#tasks" do
+    it "returns a list with all tasks defined in this class" do
+      MyChildScript.new.must respond_to("animal")
+      MyChildScript.tasks.keys.must include("animal")
+    end
+
+    it "raises an error if a task with reserved word is defined" do
+      lambda {
+        klass = Class.new(Thor::Group)
+        klass.class_eval "def shell; end"
+      }.must raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as task/)
+    end
+  end
+
+  describe "#all_tasks" do
+    it "returns a list with all tasks defined in this class plus superclasses" do
+      MyChildScript.new.must respond_to("foo")
+      MyChildScript.all_tasks.keys.must include("foo")
+    end
+  end
+
+  describe "#remove_task" do
+    it "removes the task from its tasks hash" do
+      MyChildScript.tasks.keys.must_not include("bar")
+      MyChildScript.tasks.keys.must_not include("boom")
+    end
+
+    it "undefines the method if desired" do
+      MyChildScript.new.must_not respond_to("boom")
+    end
+  end
+
+  describe "#from_superclass" do
+    it "does not send a method to the superclass if the superclass does not respond to it" do
+      MyCounter.get_from_super.must == 13
+    end
+  end
+
+  describe "#start" do
+    it "raises an error instead of rescueing if --debug is given" do
+      lambda {
+        MyScript.start ["what", "--debug"]
+      }.must raise_error(Thor::UndefinedTaskError, 'Could not find task "what" in "my_script" namespace.')
+    end
+
+    it "does not steal args" do
+      args = ["foo", "bar", "--force", "true"]
+      MyScript.start(args)
+      args.must == ["foo", "bar", "--force", "true"]
+    end
+
+    it "checks unknown options" do
+      capture(:stderr) {
+        MyScript.start(["foo", "bar", "--force", "true", "--unknown", "baz"])
+      }.strip.must == "Unknown switches '--unknown'"
+    end
+  end
+
+  describe "attr_*" do
+    it "should not add attr_reader as a task" do
+      capture(:stderr){ MyScript.start(["another_attribute"]) }.must =~ /Could not find/
+    end
+
+    it "should not add attr_writer as a task" do
+      capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }.must =~ /Could not find/
+    end
+
+    it "should not add attr_accessor as a task" do
+      capture(:stderr){ MyScript.start(["some_attribute"]) }.must =~ /Could not find/
+      capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }.must =~ /Could not find/
+    end
+  end
+end