sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/lib/thor/lib/thor/task_hash.rb

@@ -0,0 +1,22 @@
+require 'thor/ordered_hash'
+require 'thor/task'
+
+class Thor::TaskHash < Thor::OrderedHash
+  def initialize(klass)
+    super()
+    @klass = klass
+  end
+
+  def each(local = false, &block)
+    super() { |k, t| yield k, t.with_klass(@klass) }
+    @klass.superclass.tasks.each { |k, t| yield k, t.with_klass(@klass) } unless local || @klass == Thor
+  end
+
+  def [](name)
+    if task = super(name) || (@klass == Thor && @klass.superclass.tasks[name])
+      return task.with_klass(@klass)
+    end
+
+    Thor::Task.dynamic(name, @klass)
+  end
+end

data/lib/thor/lib/thor/tasks/package.rb

@@ -0,0 +1,18 @@
+require "thor/task"
+
+class Thor::PackageTask < Thor::Task
+  attr_accessor :spec
+  attr_accessor :opts
+
+  def initialize(gemspec, opts = {})
+    super(:package, "build a gem package")
+    @spec = gemspec
+    @opts = {:dir => File.join(Dir.pwd, "pkg")}.merge(opts)
+  end
+
+  def run
+    FileUtils.mkdir_p(@opts[:dir])
+    Gem::Builder.new(spec).build
+    FileUtils.mv(spec.file_name, File.join(@opts[:dir], spec.file_name))
+  end
+end

data/lib/thor/lib/thor/tasks.rb

@@ -0,0 +1,77 @@
+require "thor"
+require "fileutils"
+
+class Thor
+  def self.package_task(spec)
+    desc "package", "package up the gem"
+    define_method :package do
+      FileUtils.mkdir_p(File.join(Dir.pwd, "pkg"))
+      Gem::Builder.new(spec).build
+      FileUtils.mv(spec.file_name, File.join(Dir.pwd, "pkg", spec.file_name))
+    end
+  end
+  
+  def self.install_task(spec)
+    package_task spec
+
+    null, sudo, gem = RUBY_PLATFORM =~ /w(in)?32$/ ? ['NUL', '', 'gem.bat'] :
+                                                     ['/dev/null', 'sudo', 'gem']
+    
+    desc "install", "install the gem"
+    define_method :install do
+      old_stderr, $stderr = $stderr.dup, File.open(null, "w")
+      package
+      $stderr = old_stderr
+      system %{#{sudo} #{Gem.ruby} -S #{gem} install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
+    end
+  end
+  
+  def self.spec_task(file_list, opts = {})
+    name = opts.delete(:name) || "spec"
+    rcov_dir = opts.delete(:rcov_dir) || "coverage"
+    file_list = file_list.map {|f| %["#{f}"]}.join(" ")
+    verbose = opts.delete(:verbose)
+    opts = {:format => "specdoc", :color => true}.merge(opts)
+    
+    rcov_opts = convert_task_options(opts.delete(:rcov) || {})
+    rcov = !rcov_opts.empty?
+    options = convert_task_options(opts)
+    
+    if rcov
+      FileUtils.rm_rf(File.join(Dir.pwd, rcov_dir))
+    end
+    
+    desc(name, "spec task")
+    define_method(name) do
+      cmd = "ruby "
+      if rcov
+        cmd << "-S rcov -o #{rcov_dir} #{rcov_opts} "
+      end
+      cmd << `which spec`.chomp
+      cmd << " -- " if rcov
+      cmd << " "
+      cmd << file_list
+      cmd << " "
+      cmd << options
+      puts cmd if verbose
+      system(cmd)
+      exit($?.exitstatus)
+    end
+  end
+  
+  private
+  def self.convert_task_options(opts)
+    opts.map do |key, value|
+      case value
+      when true
+        "--#{key}"
+      when Array
+        value.map {|v| "--#{key} #{v.inspect}"}.join(" ")
+      when nil, false
+        ""
+      else
+        "--#{key} #{value.inspect}"
+      end
+    end.join(" ")    
+  end  
+end

data/lib/thor/lib/thor/util.rb

@@ -0,0 +1,75 @@
+require 'thor/error'
+
+module ObjectSpace
+  
+  class << self
+
+    # @return <Array[Class]> All the classes in the object space.
+    def classes
+      klasses = []
+      ObjectSpace.each_object(Class) {|o| klasses << o}
+      klasses
+    end
+  end
+  
+end
+
+class Thor
+  module Tasks; end
+  
+  module Util
+    
+    def self.full_const_get(obj, name)
+      list = name.split("::")
+      list.shift if list.first.empty?
+      list.each do |x| 
+        # This is required because const_get tries to look for constants in the 
+        # ancestor chain, but we only want constants that are HERE
+        obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+      end
+      obj
+    end
+    
+    def self.constant_to_thor_path(str, remove_default = true)
+      str = str.to_s.gsub(/^Thor::Tasks::/, "")
+      str = snake_case(str).squeeze(":")
+      str.gsub!(/^default/, '') if remove_default
+      str
+    end
+
+    def self.constant_from_thor_path(str)
+      make_constant(to_constant(str))
+    rescue NameError => e
+      raise e unless e.message =~ /^uninitialized constant (.*)$/
+      raise Error, "There was no available namespace `#{str}'."
+    end
+
+    def self.to_constant(str)
+      str = 'default' if str.empty?
+      str.gsub(/:(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def self.constants_in_contents(str, file = __FILE__)
+      klasses = ObjectSpace.classes.dup
+      Module.new.class_eval(str, file)
+      klasses = ObjectSpace.classes - klasses
+      klasses = klasses.select {|k| k < Thor }
+      klasses.map! {|k| k.to_s.gsub(/#<Module:\w+>::/, '')}
+    end
+
+    def self.make_constant(str, base = [Thor::Tasks, Object])
+      which = base.find do |obj|
+        full_const_get(obj, str) rescue nil
+      end
+      return full_const_get(which, str) if which
+      raise NameError, "uninitialized constant #{str}"
+    end
+    
+    def self.snake_case(str)
+      return str.downcase if str =~ /^[A-Z_]+$/
+      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+      return $+.downcase
+    end  
+    
+  end
+end

data/lib/thor/lib/thor.rb

@@ -0,0 +1,170 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+require "thor/options"
+require "thor/util"
+require "thor/task"
+require "thor/task_hash"
+
+class Thor
+  attr_accessor :options
+  
+  def self.default_task(meth=nil)
+    unless meth.nil?
+      @default_task = (meth == :none) ? 'help' : meth.to_s
+    end
+    @default_task ||= (self == Thor ? 'help' : superclass.default_task)
+  end
+    
+  def self.map(map)
+    @map ||= superclass.instance_variable_get("@map") || {}
+    map.each do |key, value|
+      if key.respond_to?(:each)
+        key.each {|subkey| @map[subkey] = value}
+      else
+        @map[key] = value
+      end
+    end
+  end
+
+  def self.desc(usage, description)
+    @usage, @desc = usage, description
+  end
+  
+  def self.group(name)
+    @group_name = name.to_s
+  end
+  
+  def self.group_name
+    @group_name || 'standard'
+  end
+  
+  def self.method_options(opts)
+    @method_options = (@method_options || {}).merge(opts)
+  end
+
+  def self.subclass_files
+    @subclass_files ||= Hash.new {|h,k| h[k] = []}
+  end
+  
+  def self.subclasses
+    @subclasses ||= []
+  end
+  
+  def self.tasks
+    @tasks ||= TaskHash.new(self)
+  end
+
+  def self.opts
+    (@opts || {}).merge(self == Thor ? {} : superclass.opts)
+  end
+
+  def self.[](task)
+    namespaces = task.split(":")
+    klass = Thor::Util.constant_from_thor_path(namespaces[0...-1].join(":"))
+    raise Error, "`#{klass}' is not a Thor class" unless klass <= Thor
+    klass.tasks[namespaces.last]
+  end
+
+  def self.maxima
+    @maxima ||= begin
+      max_usage = tasks.map {|_, t| t.usage}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
+      max_desc  = tasks.map {|_, t| t.description}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
+      max_opts  = tasks.map {|_, t| t.opts ? t.opts.formatted_usage : ""}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
+      Struct.new(:description, :usage, :opt).new(max_desc, max_usage, max_opts)
+    end
+  end
+  
+  def self.start(args = ARGV)
+    
+    options = Thor::Options.new(self.opts)
+    opts = options.parse(args, false)
+    args = options.trailing_non_opts
+
+    meth = args.first
+    meth = @map[meth].to_s if @map && @map[meth]
+    meth ||= default_task
+    meth = meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
+    
+    tasks[meth].parse new(opts, *args), args[1..-1]
+  rescue Thor::Error => e
+    $stderr.puts e.message
+  end
+  
+  # Invokes a specific task.  You can use this method instead of start() 
+  # to run a thor task if you know the specific task you want to invoke.
+  def self.invoke(task_name=nil, args = ARGV)
+    args = args.dup
+    args.unshift(task_name || default_task)
+    start(args)
+  end
+
+  # Main entry point method that should actually invoke the method.  You
+  # can override this to provide some class-wide processing.  The default
+  # implementation simply invokes the named method
+  def invoke(meth, *args)
+    self.send(meth, *args)
+  end
+  
+  class << self
+    protected
+    def inherited(klass)
+      register_klass_file klass
+    end
+
+    def method_added(meth)
+      meth = meth.to_s
+      
+      if meth == "initialize"
+        @opts = @method_options
+        @method_options = nil
+        return
+      end
+
+      return if !public_instance_methods.include?(meth) || !@usage
+      register_klass_file self
+
+      tasks[meth] = Task.new(meth, @desc, @usage, @method_options)
+
+      @usage, @desc, @method_options = nil
+    end
+
+    def register_klass_file(klass, file = caller[1].split(":")[0])
+      unless self == Thor
+        superclass.register_klass_file(klass, file)
+        return
+      end
+
+      file_subclasses = subclass_files[File.expand_path(file)]
+      file_subclasses << klass unless file_subclasses.include?(klass)
+      subclasses << klass unless subclasses.include?(klass)
+    end
+  end
+
+  def initialize(opts = {}, *args)
+  end
+  
+  map ["-h", "-?", "--help", "-D"] => :help
+  
+  desc "help [TASK]", "describe available tasks or one specific task"
+  def help(task = nil)
+    if task
+      if task.include? ?:
+        task = self.class[task]
+        namespace = true
+      else
+        task = self.class.tasks[task]
+      end
+
+      puts task.formatted_usage(namespace)
+      puts task.description
+    else
+      puts "Options"
+      puts "-------"
+      self.class.tasks.each do |_, task|
+        format = "%-" + (self.class.maxima.usage + self.class.maxima.opt + 4).to_s + "s"
+        print format % ("#{task.formatted_usage}")      
+        puts  task.description.split("\n").first
+      end
+    end
+  end
+  
+end

data/lib/thor/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:newgem_simple, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/lib/thor/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:newgem_simple, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/lib/thor/spec/fixtures/task.thor

@@ -0,0 +1,10 @@
+# module: randomness
+
+class Amazing < Thor
+  desc "describe NAME", "say that someone is amazing"
+  method_options :forcefully => :boolean
+  def describe(name, opts)
+    ret = "#{name} is amazing"
+    puts opts["forcefully"] ? ret.upcase : ret
+  end
+end

data/lib/thor/spec/options_spec.rb

@@ -0,0 +1,271 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "thor/options"
+
+describe Thor::Options do
+  def create(opts)
+    @opt = Thor::Options.new(opts)
+  end
+  
+  def parse(*args)
+    @non_opts = []
+    @opt.parse(args.flatten)
+  end
+  
+  describe "naming" do
+    it "automatically aliases long switches with their first letter" do
+      create "--foo" => true
+      parse("-f")["foo"].must be_true
+    end
+    
+    it "doesn't auto-alias switches that have multiple names given" do
+      create ["--foo", "--bar"] => :boolean
+      parse("-f")["foo"].must_not be
+    end
+    
+    it "allows multiple aliases for a given switch" do
+      create ["--foo", "--bar", "--baz"] => :optional
+      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" => :optional
+      parse("-f", "12").must == {"f" => "12"}
+    end
+    
+    it "allows custom short-name aliases" do
+      create ["--bar", "-f"] => :optional
+      parse("-f", "12").must == {"bar" => "12"}
+    end
+    
+    it "should allows humanized switch input" do
+      create 'foo' => :optional, :bar => :required
+      parse("-f", "1", "-b", "2").must == {"foo" => "1", "bar" => "2"}
+    end
+    
+    it "doesn't recognize long switch format for a switch that is originally short" do
+      create 'f' => :optional
+      parse("-f", "1").must == {"f" => "1"}
+      parse("--f", "1").must == {}
+    end
+    
+    it "accepts --[no-]opt variant for booleans, setting false for value" do
+      create "--foo" => false
+      parse("--foo")["foo"].must == true
+      parse("--no-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
+    
+  end
+  
+  it "accepts a switch=<value> assignment" do
+    create "--foo" => :required
+    parse("--foo=12")["foo"].must == "12"
+    parse("-f=12")["foo"].must == "12"
+    parse("--foo=bar=baz")["foo"].must == "bar=baz"
+    parse("--foo=sentence with spaces")["foo"].must == "sentence with spaces"
+  end
+  
+  it "accepts a -nXY assignment" do
+    create "--num" => :required
+    parse("-n12")["num"].must == "12"
+  end
+  
+  it "accepts conjoined short switches" do
+    create "--foo" => true, "--bar" => true, "--app" => 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 argument" do
+    create "--foo" => true, "--bar" => true, "--app" => :required
+    opts = parse "-fba", "12"
+    opts["foo"].must be_true
+    opts["bar"].must be_true
+    opts["app"].must == "12"
+  end
+  
+  it "makes hash keys available as symbols as well" do
+    create "--foo" => :optional
+    parse("--foo", "12")[:foo].must == "12"
+  end
+  
+  it "result is immutable" do
+    create "--foo" => :optional
+    lambda {
+      hash = parse
+      hash['foo'] = 'baz'
+    }.must raise_error(TypeError)
+  end
+  
+  describe "with no arguments" 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" => :optional
+      parse.must == {}
+    end
+  
+    it "and a required switch raises an error" do
+      create "--foo" => :required
+      lambda { parse }.must raise_error(Thor::Options::Error, "no value provided for required argument '--foo'")
+    end
+  end
+  
+  it "doesn't set nonexistant switches" do
+    create "--foo" => :boolean
+    parse("--foo")["bar"].must_not be
+    opts = parse
+    opts["foo"].must_not be
+  end
+  
+  describe " with several optional switches" do
+    before :each do
+      create "--foo" => :optional, "--bar" => :optional
+    end
+  
+    it "sets switches without arguments to true" do
+      parse("--foo")["foo"].must be_true
+      parse("--bar")["bar"].must be_true
+    end
+  
+    it "doesn't set nonexistant switches" do
+      parse("--foo")["bar"].must_not be
+      parse("--bar")["foo"].must_not be
+    end
+  
+    it "sets switches with arguments to their arguments" do
+      parse("--foo", "12")["foo"].must == "12"
+      parse("--bar", "12")["bar"].must == "12"
+    end
+  
+    it "assumes something that could be either a switch or an argument is a switch" do
+      parse("--foo", "--bar")["foo"].must be_true
+    end
+  
+    it "overwrites earlier values with later values" do
+      parse("--foo", "--foo", "12")["foo"].must == "12"
+      parse("--foo", "12", "--foo", "13")["foo"].must == "13"
+    end
+  end
+  
+  describe " with one required and one optional switch" do
+    before :each do
+      create "--foo" => :required, "--bar" => :optional
+    end
+  
+    it "raises an error if the required switch has no argument" do
+      lambda { parse("--foo") }.must raise_error(Thor::Options::Error)
+    end
+  
+    it "raises an error if the required switch isn't given" do
+      lambda { parse("--bar") }.must raise_error(Thor::Options::Error)
+    end
+  
+    it "raises an error if a switch name is given as the argument to the required switch" do
+      lambda { parse("--foo", "--bar") }.must raise_error(Thor::Options::Error, "cannot pass switch '--bar' as an argument")
+    end
+  end
+  
+  it "extracts non-option arguments" do
+    create "--foo" => :required, "--bar" => true
+    parse("foo", "bar", "--baz", "--foo", "12", "--bar", "-T", "bang").must == {
+      "foo" => "12", "bar" => true
+    }
+    @opt.leading_non_opts.must == ["foo", "bar", "--baz"]
+    @opt.trailing_non_opts.must == ["-T", "bang"]
+    @opt.non_opts.must == ["foo", "bar", "--baz", "-T", "bang"]
+  end
+  
+  describe "optional arguments with default values" do
+    before(:each) do
+      create "--branch" => "master"
+    end
+    
+    it "must get the specified value" do
+      parse("--branch", "bugfix").must == { "branch" => "bugfix" }
+    end
+  
+    it "must get the default value when not specified" do
+      parse.must == { "branch" => "master" }
+    end
+  end
+  
+  describe 'Hash' do
+    before(:each) do
+      @hash = Thor::Options::Hash.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+    end
+    
+    it "has values accessible by either strings or symbols" do
+      @hash['foo'].must == 'bar'
+      @hash[:foo].must  == 'bar'
+      @hash.values_at(:foo, :baz).must == ['bar', 'bee']
+    end
+    
+    it "should handles magic boolean predicates" do
+      @hash.force?.must be_true
+      @hash.foo?.must be_true
+      @hash.nothing?.must be_false
+    end
+    
+    it "should map methods to keys: hash.foo => hash[:foo]" do
+      @hash.foo.must == @hash['foo']
+    end
+    
+    it "should map setters to keys: hash.foo=bar => hash[:foo] => bar" do
+      @hash.foo = :bar2
+      @hash.foo.must == :bar2
+    end
+    
+  end
+  
+  describe ":numeric type" do
+    before(:each) do
+      create "n" => :numeric, "m" => 5
+    end
+    
+    it "supports numeric defaults" do
+      parse["m"].must == 5
+    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::Options::Error,
+        "expected numeric value for '-n'; got \"foo\"")
+    end
+    
+    it "raises error when switch is present without value" do
+      lambda { parse("-n") }.must raise_error(Thor::Options::Error,
+        "no value provided for argument '-n'")
+    end
+  end
+  
+  describe "#formatted_usage" do
+    def usage
+      @opt.formatted_usage.split(" ").sort
+    end
+    
+    it "outputs optional args with sample values" do
+      create "--repo" => :optional, "--branch" => "bugfix", "-n" => 6
+      usage.must == %w([--branch=bugfix] [--repo=REPO] [-n=6])
+    end
+    
+    it "outputs numeric args with 'N' as sample value" do
+      create "--iter" => :numeric
+      usage.must == ["[--iter=N]"]
+    end
+  end
+end