puppet-module 0.3.0

data/vendor/thor-852190ae/spec/parser/options_spec.rb

@@ -0,0 +1,292 @@
+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).must == "--color"
+    end
+
+    it "ignores nil" do
+      Thor::Options.to_switches(:color => nil).must == ""
+    end
+
+    it "ignores false" do
+      Thor::Options.to_switches(:color => false).must == ""
+    end
+
+    it "writes --name value for anything else" do
+      Thor::Options.to_switches(:format => "specdoc").must == '--format "specdoc"'
+    end
+
+    it "joins several values" do
+      switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(' ').sort
+      switches.must == ['"bar"', "--color", "--foo"]
+    end
+
+    it "accepts arrays" do
+      Thor::Options.to_switches(:count => [1,2,3]).must == "--count 1 2 3"
+    end
+
+    it "accepts hashes" do
+      Thor::Options.to_switches(:count => {:a => :b}).must == "--count a:b"
+    end
+  end
+
+  describe "#parse" do
+    it "allows multiple aliases for a given switch" do
+      create ["--foo", "--bar", "--baz"] => :string
+      parse("--foo", "12")["foo"].must == "12"
+      parse("--bar", "12")["foo"].must == "12"
+      parse("--baz", "12")["foo"].must == "12"
+    end
+
+    it "allows custom short names" do
+      create "-f" => :string
+      parse("-f", "12").must == {"f" => "12"}
+    end
+
+    it "allows custom short-name aliases" do
+      create ["--bar", "-f"] => :string
+      parse("-f", "12").must == {"bar" => "12"}
+    end
+
+    it "accepts conjoined short switches" do
+      create ["--foo", "-f"] => true, ["--bar", "-b"] => true, ["--app", "-a"] => true
+      opts = parse("-fba")
+      opts["foo"].must be_true
+      opts["bar"].must be_true
+      opts["app"].must 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"].must be_true
+      opts["bar"].must be_true
+      opts["app"].must == "12"
+    end
+
+    it "returns the default value if none is provided" do
+      create :foo => "baz", :bar => :required
+      parse("--bar", "boom")["foo"].must == "baz"
+    end
+
+    it "returns the default value from defaults hash to required arguments" do
+      create Hash[:bar => :required], Hash[:bar => "baz"]
+      parse["bar"].must == "baz"
+    end
+
+    it "gives higher priority to defaults given in the hash" do
+      create Hash[:bar => true], Hash[:bar => false]
+      parse["bar"].must == false
+    end
+
+    it "raises an error for unknown switches" do
+      create :foo => "baz", :bar => :required
+      parse("--bar", "baz", "--baz", "unknown")
+      lambda { check_unknown! }.must raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
+    end
+    
+    it "skips leading non-switches" do
+      create(:foo => "baz")
+      
+      parse("asdf", "--foo", "bar").must == {"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").must == {"foo" => "--asdf---dsf--asdf"}
+      check_unknown!
+    end
+
+    describe "with no input" do
+      it "and no switches returns an empty hash" do
+        create({})
+        parse.must == {}
+      end
+
+      it "and several switches returns an empty hash" do
+        create "--foo" => :boolean, "--bar" => :string
+        parse.must == {}
+      end
+
+      it "and a required switch raises an error" do
+        create "--foo" => :required
+        lambda { parse }.must raise_error(Thor::RequiredArgumentMissingError, "No value provided for required options '--foo'")
+      end
+    end
+
+    describe "with one required and one optional switch" do
+      before :each do
+        create "--foo" => :required, "--bar" => :boolean
+      end
+
+      it "raises an error if the required switch has no argument" do
+        lambda { parse("--foo") }.must raise_error(Thor::MalformattedArgumentError)
+      end
+
+      it "raises an error if the required switch isn't given" do
+        lambda { parse("--bar") }.must raise_error(Thor::RequiredArgumentMissingError)
+      end
+
+      it "raises an error if the required switch is set to nil" do
+        lambda { parse("--no-foo") }.must raise_error(Thor::RequiredArgumentMissingError)
+      end
+
+      it "does not raises an error if the required option has a default value" do
+        create :foo => Thor::Option.new("foo", nil, true, :string, "baz"), :bar => :boolean
+        lambda { parse("--bar") }.must_not raise_error
+      end
+    end
+
+    describe "with :string type" do
+      before(:each) do
+        create ["--foo", "-f"] => :required
+      end
+
+      it "accepts a switch <value> assignment" do
+        parse("--foo", "12")["foo"].must == "12"
+      end
+
+      it "accepts a switch=<value> assignment" do
+        parse("-f=12")["foo"].must == "12"
+        parse("--foo=12")["foo"].must == "12"
+        parse("--foo=bar=baz")["foo"].must == "bar=baz"
+      end
+
+      it "accepts a --no-switch format" do
+        create "--foo" => "bar"
+        parse("--no-foo")["foo"].must be_nil
+      end
+
+      it "accepts a --switch format on non required types" do
+        create "--foo" => :string
+        parse("--foo")["foo"].must == "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"].must == "bar"
+      end
+
+      it "overwrites earlier values with later values" do
+        parse("--foo=bar", "--foo", "12")["foo"].must == "12"
+        parse("--foo", "12", "--foo", "13")["foo"].must == "13"
+      end
+    end
+
+    describe "with :boolean type" do
+      before(:each) do
+        create "--foo" => false
+      end
+
+      it "accepts --opt assignment" do
+        parse("--foo")["foo"].must == true
+        parse("--foo", "--bar")["foo"].must == true
+      end
+
+      it "accepts --opt=value assignment" do
+        parse("--foo=true")["foo"].must == true
+        parse("--foo=false")["foo"].must == false
+      end
+
+      it "accepts --[no-]opt variant, setting false for value" do
+        parse("--no-foo")["foo"].must == false
+      end
+
+      it "accepts --[skip-]opt variant, setting false for value" do
+        parse("--skip-foo")["foo"].must == false
+      end
+
+      it "will prefer 'no-opt' variant over inverting 'opt' if explicitly set" do
+        create "--no-foo" => true
+        parse("--no-foo")["no-foo"].must == true
+      end
+
+      it "will prefer 'skip-opt' variant over inverting 'opt' if explicitly set" do
+        create "--skip-foo" => true
+        parse("--skip-foo")["skip-foo"].must == true
+      end
+
+      it "accepts inputs in the human name format" do
+        create :foo_bar => :boolean
+        parse("--foo-bar")["foo_bar"].must == true
+        parse("--no-foo-bar")["foo_bar"].must == false
+        parse("--skip-foo-bar")["foo_bar"].must == false
+      end
+    end
+
+    describe "with :hash type" do
+      before(:each) do
+        create "--attributes" => :hash
+      end
+
+      it "accepts a switch=<value> assignment" do
+        parse("--attributes=name:string", "age:integer")["attributes"].must == {"name" => "string", "age" => "integer"}
+      end
+
+      it "accepts a switch <value> assignment" do
+        parse("--attributes", "name:string", "age:integer")["attributes"].must == {"name" => "string", "age" => "integer"}
+      end
+
+      it "must not mix values with other switches" do
+        parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"].must == {"name" => "string", "age" => "integer"}
+      end
+    end
+
+    describe "with :array type" do
+      before(:each) do
+        create "--attributes" => :array
+      end
+
+      it "accepts a switch=<value> assignment" do
+        parse("--attributes=a", "b", "c")["attributes"].must == ["a", "b", "c"]
+      end
+
+      it "accepts a switch <value> assignment" do
+        parse("--attributes", "a", "b", "c")["attributes"].must == ["a", "b", "c"]
+      end
+
+      it "must not mix values with other switches" do
+        parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"].must == ["a", "b", "c"]
+      end
+    end
+
+    describe "with :numeric type" do
+      before(:each) do
+        create "n" => :numeric, "m" => 5
+      end
+
+      it "accepts a -nXY assignment" do
+        parse("-n12")["n"].must == 12
+      end
+
+      it "converts values to numeric types" do
+        parse("-n", "3", "-m", ".5").must == {"n" => 3, "m" => 0.5}
+      end
+
+      it "raises error when value isn't numeric" do
+        lambda { parse("-n", "foo") }.must raise_error(Thor::MalformattedArgumentError,
+          "Expected numeric value for '-n'; got \"foo\"")
+      end
+    end
+
+  end
+end

data/vendor/thor-852190ae/spec/rake_compat_spec.rb

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

data/vendor/thor-852190ae/spec/runner_spec.rb

@@ -0,0 +1,202 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'thor/runner'
+
+describe Thor::Runner do
+  describe "#help" do
+    it "shows information about Thor::Runner itself" do
+      capture(:stdout){ Thor::Runner.start(["help"]) }.must =~ /List the available thor tasks/
+    end
+
+    it "shows information about an specific Thor::Runner task" do
+      content = capture(:stdout){ Thor::Runner.start(["help", "list"]) }
+      content.must =~ /List the available thor tasks/
+      content.must_not =~ /help \[TASK\]/
+    end
+
+    it "shows information about a specific Thor class" do
+      content = capture(:stdout){ Thor::Runner.start(["help", "my_script"]) }
+      content.must =~ /zoo\s+# zoo around/m
+    end
+
+    it "shows information about an specific task from an specific Thor class" do
+      content = capture(:stdout){ Thor::Runner.start(["help", "my_script:zoo"]) }
+      content.must =~ /zoo around/
+      content.must_not =~ /help \[TASK\]/
+    end
+
+    it "shows information about a specific Thor group class" do
+      content = capture(:stdout){ Thor::Runner.start(["help", "my_counter"]) }
+      content.must =~ /my_counter N/
+    end
+
+    it "raises error if a class/task cannot be found" do
+      Thor::Runner.should_receive(:exit).with(1)
+      content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
+      content.strip.must == 'Could not find namespace or task "unknown".'
+    end
+  end
+
+  describe "#start" do
+    it "invokes a task from Thor::Runner" do
+      ARGV.replace ["list"]
+      capture(:stdout){ Thor::Runner.start }.must =~ /my_counter N/
+    end
+
+    it "invokes a task from a specific Thor class" do
+      ARGV.replace ["my_script:zoo"]
+      Thor::Runner.start.must be_true
+    end
+
+    it "invokes the default task from a specific Thor class if none is specified" do
+      ARGV.replace ["my_script"]
+      Thor::Runner.start.must == "default task"
+    end
+
+    it "forwads arguments to the invoked task" do
+      ARGV.replace ["my_script:animal", "horse"]
+      Thor::Runner.start.must == ["horse"]
+    end
+
+    it "invokes tasks through shortcuts" do
+      ARGV.replace ["my_script", "-T", "horse"]
+      Thor::Runner.start.must == ["horse"]
+    end
+
+    it "invokes a Thor::Group" do
+      ARGV.replace ["my_counter", "1", "2", "--third", "3"]
+      Thor::Runner.start.must == [1, 2, 3]
+    end
+
+    it "raises an error if class/task can't be found" do
+      Thor::Runner.should_receive(:exit).with(1)
+      ARGV.replace ["unknown"]
+      content = capture(:stderr){ Thor::Runner.start }
+      content.strip.must == 'Could not find namespace or task "unknown".'
+    end
+
+    it "does not swallow NoMethodErrors that occur inside the called method" do
+      ARGV.replace ["my_script:call_unexistent_method"]
+      lambda { Thor::Runner.start }.must raise_error(NoMethodError)
+    end
+
+    it "does not swallow Thor::Group InvocationError" do
+      ARGV.replace ["whiny_generator"]
+      lambda { Thor::Runner.start }.must raise_error(ArgumentError, /Are you sure it has arity equals to 0\?/)
+    end
+
+    it "does not swallow Thor InvocationError" do
+      ARGV.replace ["my_script:animal"]
+      content = capture(:stderr) { Thor::Runner.start }
+      content.strip.must == '"animal" was called incorrectly. Call as "my_script:animal TYPE".'
+    end
+  end
+
+  describe "tasks" do
+    before(:each) do
+      @location = "#{File.dirname(__FILE__)}/fixtures/task.thor"
+      @original_yaml = {
+        "random" => {
+          :location  => @location,
+          :filename  => "4a33b894ffce85d7b412fc1b36f88fe0",
+          :namespaces => ["amazing"]
+        }
+      }
+
+      root_file = File.join(Thor::Util.thor_root, "thor.yml")
+
+      # Stub load and save to avoid thor.yaml from being overwritten
+      YAML.stub!(:load_file).and_return(@original_yaml)
+      File.stub!(:exists?).with(root_file).and_return(true)
+      File.stub!(:open).with(root_file, "w")
+    end
+
+    describe "list" do
+      it "gives a list of the available tasks" do
+        ARGV.replace ["list"]
+        content = capture(:stdout) { Thor::Runner.start }
+        content.must =~ /amazing:describe NAME\s+# say that someone is amazing/m
+      end
+
+      it "gives a list of the available Thor::Group classes" do
+        ARGV.replace ["list"]
+        capture(:stdout) { Thor::Runner.start }.must =~ /my_counter N/
+      end
+
+      it "can filter a list of the available tasks by --group" do
+        ARGV.replace ["list", "--group", "standard"]
+        capture(:stdout) { Thor::Runner.start }.must =~ /amazing:describe NAME/
+        ARGV.replace []
+        capture(:stdout) { Thor::Runner.start }.must_not =~ /my_script:animal TYPE/
+        ARGV.replace ["list", "--group", "script"]
+        capture(:stdout) { Thor::Runner.start }.must =~ /my_script:animal TYPE/
+      end
+
+      it "can skip all filters to show all tasks using --all" do
+        ARGV.replace ["list", "--all"]
+        content = capture(:stdout) { Thor::Runner.start }
+        content.must =~ /amazing:describe NAME/
+        content.must =~ /my_script:animal TYPE/
+      end
+
+      it "doesn't list superclass tasks in the subclass" do
+        ARGV.replace ["list"]
+        capture(:stdout) { Thor::Runner.start }.must_not =~ /amazing:help/
+      end
+
+      it "presents tasks in the default namespace with an empty namespace" do
+        ARGV.replace ["list"]
+        capture(:stdout) { Thor::Runner.start }.must =~ /^thor :test\s+# prints 'test'/m
+      end
+
+      it "runs tasks with an empty namespace from the default namespace" do
+        ARGV.replace [":test"]
+        capture(:stdout) { Thor::Runner.start }.must == "test\n"
+      end
+    end
+
+    describe "uninstall" do
+      before(:each) do
+        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
+        FileUtils.should_receive(:rm_rf).with(path)
+      end
+
+      it "uninstalls existing thor modules" do
+        silence(:stdout) { Thor::Runner.start(["uninstall", "random"]) }
+      end
+    end
+
+    describe "installed" do
+      before(:each) do
+        Dir.should_receive(:[]).and_return([])
+      end
+
+      it "displays the modules installed in a pretty way" do
+        stdout = capture(:stdout) { Thor::Runner.start(["installed"]) }
+        stdout.must =~ /random\s*amazing/
+        stdout.must =~ /amazing:describe NAME\s+# say that someone is amazing/m
+      end
+    end
+
+    describe "install/update" do
+      before(:each) do
+        FileUtils.stub!(:mkdir_p)
+        FileUtils.stub!(:touch)
+        $stdin.stub!(:gets).and_return("Y")
+
+        path = File.join(Thor::Util.thor_root, Digest::MD5.hexdigest(@location + "random"))
+        File.should_receive(:open).with(path, "w")
+      end
+
+      it "updates existing thor files" do
+        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
+        File.should_receive(:delete).with(path)
+        silence(:stdout) { Thor::Runner.start(["update", "random"]) }
+      end
+
+      it "installs thor files" do
+        ARGV.replace ["install", @location]
+        silence(:stdout) { Thor::Runner.start }
+      end
+    end
+  end
+end