angry_mob 0.1.0

data/vendor/thor/spec/shell/basic_spec.rb

@@ -0,0 +1,205 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Thor::Shell::Basic do
+  def shell
+    @shell ||= Thor::Shell::Basic.new
+  end
+
+  describe "#padding" do
+    it "cannot be set to below zero" do
+      shell.padding = 10
+      shell.padding.must == 10
+
+      shell.padding = -1
+      shell.padding.must == 0
+    end
+  end
+
+  describe "#ask" do
+    it "prints a message to the user and gets the response" do
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+      $stdin.should_receive(:gets).and_return('Sure')
+      shell.ask("Should I overwrite it?").must == "Sure"
+    end
+  end
+
+  describe "#yes?" do
+    it "asks the user and returns true if the user replies yes" do
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('y')
+      shell.yes?("Should I overwrite it?").must be_true
+
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('n')
+      shell.yes?("Should I overwrite it?").must_not be_true
+    end
+  end
+
+  describe "#no?" do
+    it "asks the user and returns true if the user replies no" do
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('n')
+      shell.no?("Should I overwrite it?").must be_true
+
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('Yes')
+      shell.no?("Should I overwrite it?").must be_false
+    end
+  end
+
+  describe "#say" do
+    it "prints a message to the user" do
+      $stdout.should_receive(:puts).with("Running...")
+      shell.say("Running...")
+    end
+
+    it "prints a message to the user without new line if it ends with a whitespace" do
+      $stdout.should_receive(:print).with("Running... ")
+      shell.say("Running... ")
+    end
+
+    it "prints a message to the user without new line" do
+      $stdout.should_receive(:print).with("Running...")
+      shell.say("Running...", nil, false)
+    end
+  end
+
+  describe "#say_status" do
+    it "prints a message to the user with status" do
+      $stdout.should_receive(:puts).with("      create  ~/.thor/task.thor")
+      shell.say_status(:create, "~/.thor/task.thor")
+    end
+
+    it "always use new line" do
+      $stdout.should_receive(:puts).with("      create  ")
+      shell.say_status(:create, "")
+    end
+
+    it "does not print a message if base is set to quiet" do
+      base = MyCounter.new [1,2]
+      base.should_receive(:options).and_return(:quiet => true)
+
+      $stdout.should_not_receive(:puts)
+      shell.base = base
+      shell.say_status(:created, "~/.thor/task.thor")
+    end
+
+    it "does not print a message if log status is set to false" do
+      $stdout.should_not_receive(:puts)
+      shell.say_status(:created, "~/.thor/task.thor", false)
+    end
+
+    it "uses padding to set messages left margin" do
+      shell.padding = 2
+      $stdout.should_receive(:puts).with("      create      ~/.thor/task.thor")
+      shell.say_status(:create, "~/.thor/task.thor")
+    end
+  end
+
+  describe "#print_table" do
+    before(:each) do
+      @table = []
+      @table << ["abc", "#123", "first three"]
+      @table << ["", "#0", "empty"]
+      @table << ["xyz", "#786", "last three"]
+    end
+
+    it "prints a table" do
+      content = capture(:stdout){ shell.print_table(@table) }
+      content.must == <<-TABLE
+abc  #123  first three
+     #0    empty
+xyz  #786  last three
+TABLE
+    end
+
+    it "prints a table with identation" do
+      content = capture(:stdout){ shell.print_table(@table, :ident => 2) }
+      content.must == <<-TABLE
+  abc  #123  first three
+       #0    empty
+  xyz  #786  last three
+TABLE
+    end
+
+    it "uses maximum terminal width" do
+      shell.should_receive(:terminal_width).and_return(20)
+      content = capture(:stdout){ shell.print_table(@table, :ident => 2, :truncate => true) }
+      content.must == <<-TABLE
+  abc  #123  firs...
+       #0    empty
+  xyz  #786  last...
+TABLE
+    end
+  end
+
+  describe "#file_collision" do
+    it "shows a menu with options" do
+      $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
+      $stdin.should_receive(:gets).and_return('n')
+      shell.file_collision('foo')
+    end
+
+    it "returns true if the user choose default option" do
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('')
+      shell.file_collision('foo').must be_true
+    end
+
+    it "returns false if the user choose no" do
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('n')
+      shell.file_collision('foo').must be_false
+    end
+
+    it "returns true if the user choose yes" do
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('y')
+      shell.file_collision('foo').must be_true
+    end
+
+    it "shows help usage if the user choose help" do
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('h')
+      $stdin.should_receive(:gets).and_return('n')
+      help = capture(:stdout){ shell.file_collision('foo') }
+      help.must =~ /h \- help, show this help/
+    end
+
+    it "quits if the user choose quit" do
+      $stdout.stub!(:print)
+      $stdout.should_receive(:puts).with('Aborting...')
+      $stdin.should_receive(:gets).and_return('q')
+
+      lambda {
+        shell.file_collision('foo')
+      }.must raise_error(SystemExit)
+    end
+
+    it "always returns true if the user choose always" do
+      $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
+      $stdin.should_receive(:gets).and_return('a')
+
+      shell.file_collision('foo').must be_true
+
+      $stdout.should_not_receive(:print)
+      shell.file_collision('foo').must be_true
+    end
+
+    describe "when a block is given" do
+      it "displays diff options to the user" do
+        $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqdh] ')
+        $stdin.should_receive(:gets).and_return('s')
+        shell.file_collision('foo'){ }
+      end
+
+      it "invokes the diff command" do
+        $stdout.stub!(:print)
+        $stdin.should_receive(:gets).and_return('d')
+        $stdin.should_receive(:gets).and_return('n')
+        shell.should_receive(:system).with(/diff -u/)
+        capture(:stdout){ shell.file_collision('foo'){ } }
+      end
+    end
+  end
+end

data/vendor/thor/spec/shell/color_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Thor::Shell::Color do
+  def shell
+    @shell ||= Thor::Shell::Color.new
+  end
+
+  describe "#say" do
+    it "set the color if specified" do
+      $stdout.should_receive(:puts).with("\e[32mWow! Now we have colors!\e[0m")
+      shell.say "Wow! Now we have colors!", :green
+    end
+
+    it "does not use a new line even with colors" do
+      $stdout.should_receive(:print).with("\e[32mWow! Now we have colors! \e[0m")
+      shell.say "Wow! Now we have colors! ", :green
+    end
+  end
+
+  describe "#say_status" do
+    it "uses color to say status" do
+      $stdout.should_receive(:puts).with("\e[1m\e[31m    conflict\e[0m  README")
+      shell.say_status :conflict, "README", :red
+    end
+  end
+
+  describe "#file_collision" do
+    describe "when a block is given" do
+      it "invokes the diff command" do
+        $stdout.stub!(:print)
+        $stdin.should_receive(:gets).and_return('d')
+        $stdin.should_receive(:gets).and_return('n')
+
+        output = capture(:stdout){ shell.file_collision('spec/fixtures/doc/README'){ "README\nEND\n" } }
+        output.must =~ /\e\[31m\- __start__\e\[0m/
+        output.must =~ /^  README/
+        output.must =~ /\e\[32m\+ END\e\[0m/
+      end
+    end
+  end
+end

data/vendor/thor/spec/shell_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Thor::Shell do
+  def shell
+    @shell ||= Thor::Base.shell.new
+  end
+
+  describe "#initialize" do
+    it "sets shell value" do
+      base = MyCounter.new [1, 2], { }, :shell => shell
+      base.shell.must == shell
+    end
+
+    it "sets the base value on the shell if an accessor is available" do
+      base = MyCounter.new [1, 2], { }, :shell => shell
+      shell.base.must == base
+    end
+  end
+
+  describe "#shell" do
+    it "returns the shell in use" do
+      MyCounter.new([1,2]).shell.must be_kind_of(Thor::Base.shell)
+    end
+  end
+
+  describe "with_padding" do
+    it "uses padding for inside block outputs" do
+      base = MyCounter.new([1,2])
+      base.with_padding do
+        capture(:stdout){ base.say_status :padding, "cool" }.strip.must == "padding    cool"
+      end
+    end
+  end
+end

data/vendor/thor/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/vendor/thor/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+$TESTING=true
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'thor'
+require 'thor/group'
+require 'stringio'
+
+require 'rubygems'
+require 'rdoc'
+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).
+
+$thor_runner = true
+
+# Load fixtures
+load File.join(File.dirname(__FILE__), "fixtures", "task.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "script.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "invoke.thor")
+
+# Set shell to basic
+Thor::Base.shell = Thor::Shell::Basic
+
+Kernel.module_eval do
+  alias_method :must, :should
+  alias_method :must_not, :should_not
+  undef_method :should
+  undef_method :should_not
+end
+
+Spec::Runner.configure do |config|
+  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
+
+  alias :silence :capture
+end

data/vendor/thor/spec/task_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Thor::Task do
+  def task(options={})
+    options.each do |key, value|
+      options[key] = Thor::Option.parse(key, value)
+    end
+
+    @task ||= Thor::Task.new(:can_has, "I can has cheezburger", "can_has", options)
+  end
+
+  describe "#formatted_usage" do
+    it "includes namespace within usage" do
+      Object.stub!(:namespace).and_return("foo")
+      Object.stub!(:arguments).and_return([])
+      task(:bar => :required).formatted_usage(Object).must == "foo:can_has --bar=BAR"
+    end
+
+    it "removes default from namespace" do
+      Object.stub!(:namespace).and_return("default:foo")
+      Object.stub!(:arguments).and_return([])
+      task(:bar => :required).formatted_usage(Object).must == ":foo:can_has --bar=BAR"
+    end
+
+    it "injects arguments into usage" do
+      Object.stub!(:namespace).and_return("foo")
+      Object.stub!(:arguments).and_return([ Thor::Argument.new(:bar, nil, true, :string) ])
+      task(:foo => :required).formatted_usage(Object).must == "foo:can_has BAR --foo=FOO"
+    end
+  end
+
+  describe "#dynamic" do
+    it "creates a dynamic task with the given name" do
+      Thor::Task::Dynamic.new('task').name.must == 'task'
+      Thor::Task::Dynamic.new('task').description.must == 'A dynamically-generated task'
+      Thor::Task::Dynamic.new('task').usage.must == 'task'
+      Thor::Task::Dynamic.new('task').options.must == {}
+    end
+
+    it "does not invoke an existing method" do
+      mock = mock()
+      mock.class.should_receive(:handle_no_task_error).with("to_s")
+      Thor::Task::Dynamic.new('to_s').run(mock)
+    end
+  end
+
+  describe "#dup" do
+    it "dup options hash" do
+      task = Thor::Task.new("can_has", nil, nil, :foo => true, :bar => :required)
+      task.dup.options.delete(:foo)
+      task.options[:foo].must_not be_nil
+    end
+  end
+
+  describe "#run" do
+    it "runs a task by calling a method in the given instance" do
+      mock = mock()
+      mock.should_receive(:send).with("can_has", 1, 2, 3)
+      task.run(mock, [1, 2, 3])
+    end
+
+    it "raises an error if the method to be invoked is private" do
+      mock = mock()
+      mock.should_receive(:private_methods).and_return(['can_has'])
+      mock.class.should_receive(:handle_no_task_error).with("can_has")
+      task.run(mock)
+    end
+  end
+end

data/vendor/thor/spec/thor_spec.rb

@@ -0,0 +1,237 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Thor do
+  describe "#method_option" do
+    it "sets options to the next method to be invoked" do
+      args = ["foo", "bar", "--force"]
+      arg, options = MyScript.start(args)
+      options.must == { "force" => true }
+    end
+
+    describe "when :for is supplied" do
+      it "updates an already defined task" do
+        args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
+        options[:other].must == "fish"
+      end
+
+      describe "and the target is on the parent class" do
+        it "updates an already defined task" do
+          args = ["example_default_task", "my_param", "--new-option=verified"]
+          options = Scripts::MyScript.start(args)
+          options[:new_option].must == "verified"
+        end
+
+        it "adds a task to the tasks list if the updated task is on the parent class" do
+          Scripts::MyScript.tasks["example_default_task"].must_not be_nil
+        end
+
+        it "clones the parent task" do
+          Scripts::MyScript.tasks["example_default_task"].must_not == MyChildScript.tasks["example_default_task"]
+        end
+      end
+    end
+  end
+
+  describe "#default_task" do
+    it "sets a default task" do
+      MyScript.default_task.must == "example_default_task"
+    end
+
+    it "invokes the default task if no command is specified" do
+      MyScript.start([]).must == "default task"
+    end
+
+    it "inherits the default task from parent" do
+      MyChildScript.default_task.must == "example_default_task"
+    end
+  end
+
+  describe "#map" do
+    it "calls the alias of a method if one is provided" do
+      MyScript.start(["-T", "fish"]).must == ["fish"]
+    end
+
+    it "calls the alias of a method if several are provided via .map" do
+      MyScript.start(["-f", "fish"]).must == ["fish", {}]
+      MyScript.start(["--foo", "fish"]).must == ["fish", {}]
+    end
+
+    it "inherits all mappings from parent" do
+      MyChildScript.default_task.must == "example_default_task"
+    end
+  end
+
+  describe "#desc" do
+    before(:all) do
+      @content = capture(:stdout) { MyScript.start(["help"]) }
+    end
+
+    it "provides description for a task" do
+      @content.must =~ /zoo\s+# zoo around/m
+    end
+
+    describe "when :for is supplied" do
+      it "overwrites a previous defined task" do
+        capture(:stdout) { MyChildScript.start(["help"]) }.must =~ /animal KIND \s+# fish around/m
+      end
+    end
+  end
+
+  describe "#method_options" do
+    it "sets default options if called before an initializer" do
+      options = MyChildScript.class_options
+      options[:force].type.must == :boolean
+      options[:param].type.must == :numeric
+    end
+
+    it "overwrites default options if called on the method scope" do
+      args = ["zoo", "--force", "--param", "feathers"]
+      options = MyChildScript.start(args)
+      options.must == { "force" => true, "param" => "feathers" }
+    end
+
+    it "allows default options to be merged with method options" do
+      args = ["animal", "bird", "--force", "--param", "1.0", "--other", "tweets"]
+      arg, options = MyChildScript.start(args)
+      arg.must == 'bird'
+      options.must == { "force"=>true, "param"=>1.0, "other"=>"tweets" }
+    end
+  end
+
+  describe "#start" do
+    it "calls a no-param method when no params are passed" do
+      MyScript.start(["zoo"]).must == true
+    end
+
+    it "calls a single-param method when a single param is passed" do
+      MyScript.start(["animal", "fish"]).must == ["fish"]
+    end
+
+    it "does not set options in attributes" do
+      MyScript.start(["with_optional", "--all"]).must == [nil, { "all" => true }]
+    end
+
+    it "raises an error if a required param is not provided" do
+      capture(:stderr) { MyScript.start(["animal"]) }.strip.must == '"animal" was called incorrectly. Call as "my_script:animal TYPE".'
+    end
+
+    it "raises an error if the invoked task does not exist" do
+      capture(:stderr) { Amazing.start(["animal"]) }.strip.must == 'Could not find task "animal" in "amazing" namespace.'
+    end
+
+    it "calls method_missing if an unknown method is passed in" do
+      MyScript.start(["unk", "hello"]).must == [:unk, ["hello"]]
+    end
+
+    it "does not call a private method no matter what" do
+      capture(:stderr) { MyScript.start(["what"]) }.strip.must == 'Could not find task "what" in "my_script" namespace.'
+    end
+
+    it "uses task default options" do
+      options = MyChildScript.start(["animal", "fish"]).last
+      options.must == { "other" => "method default" }
+    end
+
+    it "raises when an exception happens within the task call" do
+      lambda { MyScript.start(["call_myself_with_wrong_arity"]) }.must raise_error(ArgumentError)
+    end
+  end
+
+  describe "#help" do
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+
+    describe "on general" do
+      before(:each) do
+        @content = capture(:stdout){ MyScript.help(shell) }
+      end
+
+      it "provides useful help info for the help method itself" do
+        @content.must =~ /help \[TASK\]\s+# Describe available tasks/
+      end
+
+      it "provides useful help info for a method with params" do
+        @content.must =~ /animal TYPE\s+# horse around/
+      end
+
+      it "uses the maximum terminal size to show tasks" do
+        @shell.should_receive(:terminal_width).and_return(80)
+        content = capture(:stdout){ MyScript.help(shell) }
+        content.must =~ /aaa\.\.\.$/
+      end
+
+      it "provides description for tasks from classes in the same namespace" do
+        @content.must =~ /baz\s+# do some bazing/
+      end
+
+      it "shows superclass tasks" do
+        content = capture(:stdout){ MyChildScript.help(shell) }
+        content.must =~ /foo BAR \s+# do some fooing/
+      end
+
+      it "shows class options information" do
+        content = capture(:stdout){ MyChildScript.help(shell) }
+        content.must =~ /Options\:/
+        content.must =~ /\[\-\-param=N\]/
+      end
+
+      it "injects class arguments into default usage" do
+        content = capture(:stdout){ Scripts::MyScript.help(shell) }
+        content.must =~ /zoo ACCESSOR \-\-param\=PARAM/
+      end
+    end
+
+    describe "for a specific task" do
+      it "provides full help info when talking about a specific task" do
+        capture(:stdout) { MyScript.task_help(shell, "foo") }.must == <<END
+Usage:
+  thor my_script:foo BAR
+
+Options:
+  [--force]  # Force to do some fooing
+
+do some fooing
+  This is more info!
+  Everyone likes more info!
+END
+      end
+
+      it "raises an error if the task can't be found" do
+        lambda {
+          MyScript.task_help(shell, "unknown")
+        }.must raise_error(Thor::UndefinedTaskError, 'Could not find task "unknown" in "my_script" namespace.')
+      end
+
+      it "normalizes names before claiming they don't exist" do
+        capture(:stdout) { MyScript.task_help(shell, "name-with-dashes") }.must =~ /thor my_script:name-with-dashes/
+      end
+    end
+
+    describe "instance method" do
+      it "calls the class method" do
+        capture(:stdout){ MyScript.start(["help"]) }.must =~ /Tasks:/
+      end
+
+      it "calls the class method" do
+        capture(:stdout){ MyScript.start(["help", "foo"]) }.must =~ /Usage:/
+      end
+    end
+  end
+
+  describe "when creating tasks" do
+    it "prints a warning if a public method is created without description or usage" do
+      capture(:stdout) {
+        klass = Class.new(Thor)
+        klass.class_eval "def hello_from_thor; end"
+      }.must =~ /\[WARNING\] Attempted to create task "hello_from_thor" without usage or description/
+    end
+
+    it "does not print if overwriting a previous task" do
+      capture(:stdout) {
+        klass = Class.new(Thor)
+        klass.class_eval "def help; end"
+      }.must be_empty
+    end
+  end
+end