sproutcore 1.0.1003 → 1.0.1008

data/lib/thor/spec/thor_runner_spec.rb

@@ -1,194 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,15 +0,0 @@
-# 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

data/lib/thor/thor.gemspec

@@ -1,29 +0,0 @@
-Gem::Specification.new do |s|
-  s.name = %q{thor}
-  s.version = "0.9.8"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Yehuda Katz"]
-  s.date = %q{2008-08-27}
-  s.description = %q{A gem that maps options to a class}
-  s.email = %q{wycats@gmail.com}
-  s.executables = ["thor", "rake2thor"]
-  s.extra_rdoc_files = ["README.markdown", "CHANGELOG.rdoc", "LICENSE"]
-  s.files = ["README.markdown", "LICENSE", "CHANGELOG.rdoc", "Rakefile", "bin/rake2thor", "bin/thor", "lib/thor", "lib/thor/error.rb", "lib/thor/options.rb", "lib/thor/ordered_hash.rb", "lib/thor/runner.rb", "lib/thor/task.rb", "lib/thor/task_hash.rb", "lib/thor/tasks", "lib/thor/tasks/package.rb", "lib/thor/tasks.rb", "lib/thor/util.rb", "lib/thor.rb"]
-  s.has_rdoc = true
-  s.homepage = %q{http://yehudakatz.com}
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{thor}
-  s.rubygems_version = %q{1.2.0}
-  s.summary = %q{A gem that maps options to a class}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
-
-    if current_version >= 3 then
-    else
-    end
-  else
-  end
-end