sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/lib/thor/spec/ordered_hash_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor/ordered_hash"
+
+describe Thor::OrderedHash do
+  describe " without any items" do
+    before :each do
+      @hash = Thor::OrderedHash.new
+    end
+
+    it "returns nil for an undefined key" do
+      @hash["foo"].must be_nil
+    end
+
+    it "doesn't iterate through any items" do
+      @hash.each { fail }
+    end
+
+    it "has an empty values list" do
+      @hash.values.must be_empty
+    end
+  end
+
+  describe " with several items" do
+    before :each do
+      @hash = Thor::OrderedHash.new
+      @hash[:foo] = "Foo!"
+      @hash[:bar] = "Bar!"
+      @hash[:baz] = "Baz!"
+      @hash[:bop] = "Bop!"
+      @hash[:bat] = "Bat!"
+    end
+
+    it "shouldn't be the same as its clone" do
+      new_hash = @hash.clone
+      new_hash[:bang] = "Bang!"
+      @hash[:bang].must be_nil
+    end
+
+    it "returns nil for an undefined key" do
+      @hash[:boom].must be_nil
+    end
+
+    it "returns the value for each key" do
+      @hash[:foo].must == "Foo!"
+      @hash[:bar].must == "Bar!"
+      @hash[:baz].must == "Baz!"
+      @hash[:bop].must == "Bop!"
+      @hash[:bat].must == "Bat!"
+    end
+
+    it "iterates through the keys and values in order of assignment" do
+      arr = []
+      @hash.each do |key, value|
+        arr << [key, value]
+      end
+      arr.must == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
+                     [:bop, "Bop!"], [:bat, "Bat!"]]
+    end
+
+    it "returns the values in order of insertion" do
+      @hash.values.must == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!"]
+    end
+
+    it "should move an overwritten node to the end of the ordering" do
+      @hash[:bar] = "Bip!"
+      @hash.values.must == ["Foo!", "Baz!", "Bop!", "Bat!", "Bip!"]
+    end
+
+    it "should append another ordered hash while preserving ordering" do
+      other_hash = Thor::OrderedHash.new
+      other_hash[1] = "one"
+      other_hash[2] = "two"
+      other_hash[3] = "three"
+      (@hash + other_hash).values.must ==
+        ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!", "one", "two", "three"]
+    end
+
+    it "shouldn't overwrite hash keys with matching appended keys" do
+      other_hash = Thor::OrderedHash.new
+      other_hash[:bar] = "bar"
+      (@hash + other_hash)[:bar].must == "Bar!"
+    end
+  end
+end

data/lib/thor/spec/spec.opts

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

data/lib/thor/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'stringio'
+
+module Spec::Expectations::ObjectExpectations
+  alias_method :must, :should
+  alias_method :must_not, :should_not
+  undef_method :should
+  undef_method :should_not
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+  
+  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
+  
+  alias silence capture
+end

data/lib/thor/spec/task_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor"
+require "thor/task"
+
+describe Thor::Task do
+  it "#formatted_usage" do
+    opts = { 'foo' => true, :bar => :required }
+    @task = Thor::Task.new(nil, "I can has cheezburger", "can_has", opts, nil)
+    @task.formatted_usage.must == "can_has [--foo] --bar=BAR"
+  end
+end

data/lib/thor/spec/tasks_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor"
+require "thor/tasks"
+
+# bleh. testing private methods?
+class <<Thor
+  public :convert_task_options
+end
+
+describe "thor" do
+  describe "convert_task_options" do
+    it "turns true values into a flag" do
+      Thor.convert_task_options(:color => true).must == "--color"
+    end
+    
+    it "ignores nil" do
+      Thor.convert_task_options(:color => nil).must == ""
+    end
+    
+    it "ignores false" do
+      Thor.convert_task_options(:color => false).must == ""
+    end
+    
+    it "writes --name value for anything else" do
+      Thor.convert_task_options(:format => "specdoc").must == %{--format "specdoc"}
+    end
+  end
+end

data/lib/thor/spec/thor_runner_spec.rb

@@ -0,0 +1,194 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor/runner"
+require "rr"
+
+load File.join(File.dirname(__FILE__), "fixtures", "task.thor")
+
+module MyTasks
+  class ThorTask < Thor
+    desc "foo", "bar"
+    def foo
+      "foo"
+    end
+    
+    desc "uhoh", "raises NoMethodError"
+    def uhoh
+      Object.new.raise_no_method_error_please
+    end
+  end
+  
+  class AdvancedTask < Thor
+    
+    group :advanced
+    
+    desc "zoo", "zip"
+    def zoo
+      "zip"
+    end
+  end  
+end
+
+module Thor::Tasks
+  class Default < Thor
+    desc "test", "prints 'test'"
+    def test
+      puts "test"
+    end
+  end
+end
+
+class Amazing
+  desc "hello", "say hello"
+  def hello
+    puts "Hello"
+  end
+end
+
+class ThorTask2 < Thor
+end
+
+describe Thor::Util do
+  it "knows how to convert class names into thor names" do
+    Thor::Util.constant_to_thor_path("FooBar::BarBaz::BazBat").must == "foo_bar:bar_baz:baz_bat"
+  end
+  
+  it "knows how to convert a thor name to a constant" do
+    Thor::Util.constant_from_thor_path("my_tasks:thor_task").must == MyTasks::ThorTask
+  end
+end
+
+describe Thor do
+  it "tracks its subclasses, grouped by the files they come from" do
+    Thor.subclass_files[File.expand_path(__FILE__)].must == [MyTasks::ThorTask, MyTasks::AdvancedTask, Thor::Tasks::Default, Amazing, ThorTask2]
+  end
+
+  it "tracks a single subclass across multiple files" do
+    thorfile = File.join(File.dirname(__FILE__), "fixtures", "task.thor")
+    Thor.subclass_files[File.expand_path(thorfile)].must include(Amazing)
+    Thor.subclass_files[File.expand_path(__FILE__)].must include(Amazing)
+  end
+  
+  it "tracks its subclasses in an Array" do
+    Thor.subclasses.must include(MyTasks::ThorTask)
+    Thor.subclasses.must include(ThorTask2)
+  end
+end
+
+describe Thor::Runner do
+  it "can give a list of the available tasks" do
+    ARGV.replace ["list"]
+    capture(:stdout) { Thor::Runner.start }.must =~ /my_tasks:thor_task:foo +bar/
+  end
+  
+  it "can filter a list of the available tasks by --group" do
+    ARGV.replace ["list", "--group", "standard"]
+    capture(:stdout) { Thor::Runner.start }.must =~ /my_tasks:thor_task:foo +bar/
+    capture(:stdout) { Thor::Runner.start }.must_not =~ /my_tasks:advanced_task:zoo +zip/
+    ARGV.replace ["list", "--group", "advanced"]
+    capture(:stdout) { Thor::Runner.start }.must =~ /my_tasks:advanced_task:zoo +zip/
+  end
+  
+  it "can skip all filters to show all tasks using --all" do
+    ARGV.replace ["list", "--all"]
+    capture(:stdout) { Thor::Runner.start }.must =~ /my_tasks:thor_task:foo +bar/
+    capture(:stdout) { Thor::Runner.start }.must =~ /my_tasks:advanced_task:zoo +zip/
+  end
+
+  it "doesn't list superclass tasks in the subclass" do
+    ARGV.replace ["list"]
+    capture(:stdout) { Thor::Runner.start }.must_not =~ /my_tasks:thor_task:help/
+  end
+  
+  it "runs tasks from other Thor files" do
+    ARGV.replace ["my_tasks:thor_task:foo"]
+    Thor::Runner.start.must == "foo"
+  end
+  
+  it "prints an error if a toplevel thor task is not found" do
+    ARGV.replace ["hello"]
+    capture(:stderr) { Thor::Runner.start }.must =~ /The thor:runner namespace doesn't have a `hello' task/
+  end
+  
+  it "prints an error if the namespace could not be found" do
+    ARGV.replace ["hello:goodbye"]
+    capture(:stderr) { Thor::Runner.start }.must =~ /There was no available namespace `hello'/
+  end  
+  
+  it "does not swallow NoMethodErrors that occur inside the called method" do
+    ARGV.replace ["my_tasks:thor_task:uhoh"]
+    proc { Thor::Runner.start }.must raise_error(NoMethodError)
+  end
+
+  it "presents tasks in the default namespace with an empty namespace" do
+    ARGV.replace ["list"]
+    capture(:stdout) { Thor::Runner.start }.must =~ /^:test +prints 'test'/
+  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 Thor::Runner, " install" do
+#   it "installs thor files" do
+#     ARGV.replace ["install", "#{File.dirname(__FILE__)}/fixtures/task.thor"]
+# 
+#     # Stubs for the file system interactions
+#     stub(Kernel).puts
+#     stub(Readline).readline { "y" }
+#     stub(FileUtils).mkdir_p
+#     stub(FileUtils).touch
+#     original_yaml = {:random => 
+#       {:location => "task.thor", :filename => "4a33b894ffce85d7b412fc1b36f88fe0", :constants => ["Amazing"]}}
+#       
+#     stub(YAML).load_file { original_yaml }
+#     
+#     file = mock("File").puts
+#     
+#     mock(File).open(File.join(Thor::Runner.thor_root, Digest::MD5.hexdigest("#{File.dirname(__FILE__)}/fixtures/task.thor" + "randomness")), "w")
+#     mock(File).open(File.join(Thor::Runner.thor_root, "thor.yml"), "w") { yield file }
+# 
+#     silence(:stdout) { Thor::Runner.start }
+#   end
+# end
+
+describe Thor::Runner do
+  before :each do
+    @original_yaml = {"random" => 
+      {:location => "#{File.dirname(__FILE__)}/fixtures/task.thor", :filename => "4a33b894ffce85d7b412fc1b36f88fe0", :constants => ["Amazing"]}}
+    stub(File).exists? {true}
+    stub(YAML).load_file { @original_yaml }
+  end
+  
+  describe " update" do
+    it "updates existing thor files" do
+      mock.instance_of(Thor::Runner).install(@original_yaml["random"][:location]) {true}
+      mock(File).delete(File.join(Thor::Runner.thor_root, @original_yaml["random"][:filename]))
+    
+      silence(:stdout) { Thor::Runner.start(["update", "random"]) }
+    end
+  end
+
+
+  describe " uninstall" do
+    it "uninstalls existing thor modules" do
+      stub.instance_of(Thor::Runner).save_yaml(anything)
+      
+      stub(File).delete(anything)
+      stub(@original_yaml).delete(anything)
+    
+      silence(:stdout) { Thor::Runner.start(["uninstall", "random"]) }
+    end
+  end
+
+  describe " installed" do
+    it "displays the modules installed in a pretty way" do
+      stub(Dir).[](anything) { [] }
+      stdout = capture(:stdout) { Thor::Runner.start(["installed"]) }
+      stdout.must =~ /random\s*amazing/
+      stdout.must =~ /amazing:describe NAME \[\-\-forcefully\]\s*say that someone is amazing/
+      stdout.must =~ /amazing:hello\s*say hello/
+    end
+  end
+end

data/lib/thor/spec/thor_spec.rb

@@ -0,0 +1,206 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor"
+
+class MyApp < Thor
+  
+  map "-T" => :animal, ["-f", "--foo"] => :foo
+  
+  desc "zoo", "zoo around"
+  def zoo
+    true
+  end
+  
+  desc "animal TYPE", "horse around"
+  def animal(type)
+    [type]
+  end
+  
+  desc "foo BAR", "do some fooing"
+  method_options :force => :boolean
+  def foo(bar)
+    [bar, options]
+  end
+  
+  desc "bar BAZ BAT", "do some barring"
+  method_options :option1 => :required
+  def bar(baz, bat)
+    [baz, bat, options]
+  end
+  
+  desc "baz BAT", "do some bazzing"
+  method_options :option1 => :optional
+  def baz(bat)
+    [bat, options]
+  end
+
+  desc "bang FOO", <<END
+bangs around some
+  This is more info!
+  Everyone likes more info!
+END
+  method_options :fup => :boolean
+  def bang(foo)
+    "bang"
+  end
+  
+  desc "call_myself_with_wrong_arity", "get the right error"
+  def call_myself_with_wrong_arity
+    call_myself_with_wrong_arity(4)
+  end
+  
+  default_task :example_default_task
+  
+  desc "example_default_task", "example!"
+  def example_default_task
+    "default task"
+  end
+  
+  
+  def method_missing(meth, *args)
+    [meth, args]
+  end
+  
+  private
+  desc "what", "what"
+  def what
+  end
+end
+
+class GlobalOptionsTasks < Thor
+
+  method_options :force => :boolean, :param => :optional
+  def initialize(*args)
+    super
+  end
+  
+  desc "animal TYPE", "horse around"
+  method_options :other => :optional
+  def animal(type)
+    [type, options]
+  end
+  
+  desc "zoo", "zoo around"
+  def zoo
+    options
+  end
+  
+end
+
+describe "thor" do
+  it "calls a no-param method when no params are passed" do
+    MyApp.start(["zoo"]).must == true
+  end
+  
+  it "calls a single-param method when a single param is passed" do
+    MyApp.start(["animal", "fish"]).must == ["fish"]
+  end
+  
+  it "calls the alias of a method if one is provided via .map" do
+    MyApp.start(["-T", "fish"]).must == ["fish"]
+  end
+
+  it "calls the alias of a method if several are provided via .map" do
+    MyApp.start(["-f", "fish"]).must == ["fish", {}]
+    MyApp.start(["--foo", "fish"]).must == ["fish", {}]
+  end
+  
+  it "raises an error if a required param is not provided" do
+    capture(:stderr) { MyApp.start(["animal"]) }.must =~ /`animal' was called incorrectly\. Call as `animal TYPE'/
+  end
+  
+  it "calls a method with an optional boolean param when the param is passed" do
+    MyApp.start(["foo", "one", "--force"]).must == ["one", {"force" => true}]
+  end
+  
+  it "calls a method with an optional boolean param when the param is not passed" do
+    MyApp.start(["foo", "one"]).must == ["one", {}]
+  end
+  
+  it "calls a method with a required key/value param" do
+    MyApp.start(["bar", "one", "two", "--option1", "hello"]).must == ["one", "two", {"option1" => "hello"}]
+  end
+  
+  it "calls a method with an optional key/value param" do
+    MyApp.start(["baz", "one", "--option1", "hello"]).must == ["one", {"option1" => "hello"}]
+  end
+
+  it "allows options at the beginning and end of the arguments" do
+    MyApp.start(["baz", "--option1", "hello", "one"]).must == ["one", {"option1" => "hello"}]
+  end
+  
+  it "calls a method with an empty Hash for options if an optional key/value param is not provided" do
+    MyApp.start(["baz", "one"]).must == ["one", {}]
+  end
+  
+  it "calls method_missing if an unknown method is passed in" do
+    MyApp.start(["unk", "hello"]).must == [:unk, ["hello"]]
+  end
+  
+  it "allows global options to be set" do
+    args = ["zoo", "--force", "--param", "feathers"]
+    options = GlobalOptionsTasks.start(args)
+    options.must == { "force"=>true, "param"=>"feathers" }
+  end
+  
+  it "allows global options to be merged with method options" do
+    args = ["animal", "bird", "--force", "--param", "feathers", "--other", "tweets"]
+    arg, options = GlobalOptionsTasks.start(args)
+    arg.must == 'bird'
+    options.must == { "force"=>true, "param"=>"feathers", "other"=>"tweets" }
+    GlobalOptionsTasks.opts.must == { :force=>:boolean, :param=>:optional }
+  end
+  
+  it "does not call a private method no matter what" do
+    lambda { MyApp.start(["what"]) }.must raise_error(NoMethodError, "the `what' task of MyApp is private")
+  end
+  
+  it "invokes the default task if no command is specified" do
+    MyApp.start([]).must =~ /default/
+  end
+  
+  it "provides useful help info for a simple method" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /zoo +zoo around/
+  end
+  
+  it "provides useful help info for a method with one param" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /animal TYPE +horse around/
+  end  
+  
+  it "provides useful help info for a method with boolean options" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /foo BAR \[\-\-force\] +do some fooing/
+  end
+  
+  it "provides useful help info for a method with required options" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /bar BAZ BAT \-\-option1=OPTION1 +do some barring/
+  end
+  
+  it "provides useful help info for a method with optional options" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /baz BAT \[\-\-option1=OPTION1\] +do some bazzing/
+  end
+
+  it "provides useful help info for the help method itself" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /help \[TASK\] +describe available tasks/
+  end
+
+  it "provides one line of help info per task when talking about all tasks" do
+    capture(:stdout) { MyApp.start(["help"]) }.must =~ /bang FOO \[--fup\] +bangs around some/
+  end
+
+  it "provides full help info when talking about a specific task" do
+    capture(:stdout) { MyApp.start(["help", "bang"]) }.must == <<END
+bang FOO [--fup]
+bangs around some
+  This is more info!
+  Everyone likes more info!
+END
+  end
+  
+  it "raises when an exception happens within the task call" do
+    lambda { MyApp.start(["call_myself_with_wrong_arity"]) }.must raise_error
+  end
+  
+  it "invokes the named command regardless of the command line options with invoke()" do
+    MyApp.invoke(:baz, ["one"]).must == ["one", {}]
+  end
+  
+end

data/lib/thor/spec/util_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor/util"
+
+describe Thor::Util do
+  describe ".snake_case" do
+    it "preserves no-cap strings" do
+      Thor::Util.snake_case("foo").must == "foo"
+      Thor::Util.snake_case("foo_bar").must == "foo_bar"
+    end
+
+    it "downcases all-caps strings" do
+      Thor::Util.snake_case("FOO").must == "foo"
+      Thor::Util.snake_case("FOO_BAR").must == "foo_bar"
+    end
+
+    it "downcases initial-cap strings" do
+      Thor::Util.snake_case("Foo").must == "foo"
+    end
+
+    it "replaces camel-casing with underscores" do
+      Thor::Util.snake_case("FooBarBaz").must == "foo_bar_baz"
+      Thor::Util.snake_case("Foo_BarBaz").must == "foo_bar_baz"
+    end
+
+    it "places underscores between multiple capitals" do
+      Thor::Util.snake_case("ABClass").must == "a_b_class"
+    end
+  end
+
+  describe ".constant_to_thor_path" do
+    it "replaces constant nesting with task namespacing" do
+      Thor::Util.constant_to_thor_path("Foo::Bar::Baz").must == "foo:bar:baz"
+    end
+
+    it "snake-cases component strings" do
+      Thor::Util.constant_to_thor_path("FooBar::BarBaz::BazBoom").must == "foo_bar:bar_baz:baz_boom"
+    end
+
+    it "gets rid of an initial Default module" do
+      Thor::Util.constant_to_thor_path("Default::Foo::Bar").must == ":foo:bar"
+      Thor::Util.constant_to_thor_path("Default").must == ""
+    end
+
+    it "accepts class and module objects" do
+      require 'thor/ordered_hash'
+      Thor::Util.constant_to_thor_path(Thor::OrderedHash).must == "thor:ordered_hash"
+      Thor::Util.constant_to_thor_path(Thor::Util).must == "thor:util"
+    end
+  end
+
+  describe ".to_constant" do
+    it "returns 'Default' if no name is given" do
+      Thor::Util.to_constant("").must == "Default"
+    end
+
+    it "upcases the namespaces" do
+      Thor::Util.to_constant("foo").must == "Foo"
+      Thor::Util.to_constant("foo:bar").must == "Foo::Bar"
+    end
+
+    it "expands task namespacing into constant nesting" do
+      Thor::Util.to_constant("foo:bar:baz").must == "Foo::Bar::Baz"
+    end
+
+    it "replaces snake-casing with camel-casing" do
+      Thor::Util.to_constant("foo_bar:bar_baz").must == "FooBar::BarBaz"
+    end
+  end
+
+  describe ".make_constant" do
+    it "returns the constant given by the string" do
+      Thor::Util.make_constant("Object").must == Object
+    end
+
+    it "resolves constant nesting" do
+      Thor::Util.make_constant("Thor::Util").must == Thor::Util
+    end
+  end
+
+  describe ".constant_from_thor_path" do
+    it "returns the named constant" do
+      require 'thor/ordered_hash'
+      Thor::Util.constant_from_thor_path('thor:ordered_hash').must == Thor::OrderedHash
+    end
+  end
+
+  describe ".constants_in_contents" do
+    it "returns an array of names of constants defined in the string" do
+      list = Thor::Util.constants_in_contents("class Foo; class Bar < Thor; end; end; class Baz; class Bat; end; end")
+      list.must include("Foo::Bar")
+      list.must_not include("Baz::Bat")
+    end
+
+    it "doesn't put the newly-defined constants in the enclosing namespace" do
+      Thor::Util.constants_in_contents("class Blat; end")
+      defined?(Blat).must_not be
+    end
+  end
+end

data/lib/thor/task.thor

@@ -0,0 +1,15 @@
+# module: random
+
+class Amazing < Thor
+  desc "describe NAME", "say that someone is amazing"
+  method_options :forcefully => :boolean
+  def describe(name)
+    ret = "#{name} is amazing"
+    puts options.forcefully?? ret.upcase : ret
+  end
+  
+  desc "hello", "say hello"
+  def hello
+    puts "Hello"
+  end
+end