sproutcore 1.0.1003 → 1.0.1008

data/lib/thor/lib/thor/runner.rb

@@ -1,305 +0,0 @@
-require 'thor'
-require "thor/util"
-require "open-uri"
-require "fileutils"
-require "yaml"
-require "digest/md5"
-require "readline"
-
-class Thor::Runner < Thor
-  
-  def self.globs_for(path)
-    ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
-  end
-
-  map "-T" => :list, "-i" => :install, "-u" => :update
-  
-  desc "install NAME", "install a Thor file into your system tasks, optionally named for future updates"
-  method_options :as => :optional, :relative => :boolean
-  def install(name)
-    initialize_thorfiles
-
-    base = name
-    package = :file
-
-    begin
-      if File.directory?(File.expand_path(name))
-        base, package = File.join(name, "main.thor"), :directory
-        contents = open(base).read
-      else
-        contents = open(name).read
-      end
-    rescue OpenURI::HTTPError
-      raise Error, "Error opening URI `#{name}'"
-    rescue Errno::ENOENT
-      raise Error, "Error opening file `#{name}'"
-    end
-    
-    is_uri = File.exist?(name) ? false : true
-    
-    puts "Your Thorfile contains: "
-    puts contents
-    print "Do you wish to continue [y/N]? "
-    response = Readline.readline
-    
-    return false unless response =~ /^\s*y/i
-    
-    constants = Thor::Util.constants_in_contents(contents, base)
-    
-    as = options["as"] || begin
-      first_line = contents.split("\n")[0]
-      (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
-    end
-        
-    if !as
-      print "Please specify a name for #{name} in the system repository [#{name}]: "
-      as = Readline.readline
-      as = name if as.empty?
-    end
-    
-    FileUtils.mkdir_p thor_root
-    
-    yaml_file = File.join(thor_root, "thor.yml")
-    FileUtils.touch(yaml_file)
-    yaml = thor_yaml
-    
-    location = (options[:relative] || is_uri) ? name : File.expand_path(name)
-    yaml[as] = {:filename => Digest::MD5.hexdigest(name + as), :location => location, :constants => constants}
-    
-    save_yaml(yaml)
-    
-    puts "Storing thor file in your system repository"
-    
-    destination = File.join(thor_root, yaml[as][:filename])
-    
-    if package == :file
-      File.open(destination, "w") {|f| f.puts contents }
-    else
-      FileUtils.cp_r(name, destination)
-    end
-    
-    yaml[as][:filename] # Indicate sucess
-  end
-  
-  desc "uninstall NAME", "uninstall a named Thor module"
-  def uninstall(name)
-    yaml = thor_yaml
-    raise Error, "Can't find module `#{name}'" unless yaml[name]
-    
-    puts "Uninstalling #{name}."
-    
-    file = File.join(thor_root, "#{yaml[name][:filename]}")
-    FileUtils.rm_rf(file)
-    yaml.delete(name)
-    save_yaml(yaml)
-    
-    puts "Done."
-  end
-  
-  desc "update NAME", "update a Thor file from its original location"
-  def update(name)
-    yaml = thor_yaml
-    raise Error, "Can't find module `#{name}'" if !yaml[name] || !yaml[name][:location]
-
-    puts "Updating `#{name}' from #{yaml[name][:location]}"
-    old_filename = yaml[name][:filename]
-    self.options = self.options.merge("as" => name)
-    filename = install(yaml[name][:location])
-    unless filename == old_filename
-      File.delete(File.join(thor_root, old_filename))
-    end
-  end
-  
-  desc "installed", "list the installed Thor modules and tasks (--internal means list the built-in tasks as well)"
-  method_options :internal => :boolean
-  def installed
-    thor_root_glob.each do |f|
-      next if f =~ /thor\.yml$/
-      load_thorfile f unless Thor.subclass_files.keys.include?(File.expand_path(f))
-    end
-
-    klasses = Thor.subclasses
-    klasses -= [Thor, Thor::Runner] unless options['internal']
-    display_klasses(true, klasses)
-  end
-  
-  desc "list [SEARCH]", "list the available thor tasks (--substring means SEARCH can be anywhere in the module)"
-  method_options :substring => :boolean,
-                 :group => :optional,
-                 :all => :boolean
-  def list(search = "")
-    initialize_thorfiles
-    search = ".*#{search}" if options["substring"]
-    search = /^#{search}.*/i
-    group  = options[:group] || 'standard'
-
-    classes = Thor.subclasses.select do |k|
-      (options[:all] || k.group_name == group) && 
-      Thor::Util.constant_to_thor_path(k.name) =~ search
-    end
-    display_klasses(false, classes)
-  end
-
-  # Override Thor#help so we can give info about not-yet-loaded tasks
-  def help(task = nil)
-    initialize_thorfiles(task) if task && task.include?(?:)
-    super
-  end
-    
-  def method_missing(meth, *args)
-    meth = meth.to_s
-    super(meth.to_sym, *args) unless meth.include? ?:
-
-    initialize_thorfiles(meth)
-    task = Thor[meth]
-    task.parse task.klass.new, ARGV[1..-1]
-  end
-
-  def self.thor_root
-    File.join(ENV["HOME"] || ENV["APPDATA"], ".thor")
-  end
-
-  def self.thor_root_glob
-    # On Windows thor_root will be something like this:
-    #
-    #   C:\Documents and Settings\james\.thor
-    #
-    # If we don't #gsub the \ character, Dir.glob will fail.
-    files = Dir["#{thor_root.gsub(/\\/, '/')}/*"]
-    files.map! do |file|
-      File.directory?(file) ? File.join(file, "main.thor") : file
-    end
-  end
-  
-  private
-  def thor_root
-    self.class.thor_root
-  end
-
-  def thor_root_glob
-    self.class.thor_root_glob
-  end
-  
-  def thor_yaml
-    yaml_file = File.join(thor_root, "thor.yml")
-    yaml = YAML.load_file(yaml_file) if File.exists?(yaml_file)
-    yaml || {}
-  end
-  
-  def save_yaml(yaml)
-    yaml_file = File.join(thor_root, "thor.yml")
-    File.open(yaml_file, "w") {|f| f.puts yaml.to_yaml }
-  end
-  
-  def display_klasses(with_modules = false, klasses = Thor.subclasses)
-    klasses -= [Thor, Thor::Runner] unless with_modules
-    raise Error, "No Thor tasks available" if klasses.empty?
-    
-    if with_modules && !(yaml = thor_yaml).empty?
-      max_name = yaml.max {|(xk,xv),(yk,yv)| xk.to_s.size <=> yk.to_s.size }.first.size
-      modules_label = "Modules"
-      namespaces_label = "Namespaces"
-      column_width = [max_name + 4, modules_label.size + 1].max
-      
-      print "%-#{column_width}s" % modules_label
-      puts namespaces_label
-      print "%-#{column_width}s" % ("-" * modules_label.size)
-      puts "-" * namespaces_label.size
-      
-      yaml.each do |name, info|
-        print "%-#{column_width}s" % name
-        puts info[:constants].map {|c| Thor::Util.constant_to_thor_path(c)}.join(", ")
-      end
-    
-      puts
-    end
-    
-    # Calculate the largest base class name
-    max_base = klasses.max do |x,y| 
-      Thor::Util.constant_to_thor_path(x.name).size <=> Thor::Util.constant_to_thor_path(y.name).size
-    end.name.size
-    
-    # Calculate the size of the largest option description
-    max_left_item = klasses.max do |x,y| 
-      (x.maxima.usage + x.maxima.opt).to_i <=> (y.maxima.usage + y.maxima.opt).to_i
-    end
-    
-    max_left = max_left_item.maxima.usage + max_left_item.maxima.opt
-    
-    unless klasses.empty?
-      puts # add some spacing
-      klasses.each { |k| display_tasks(k, max_base, max_left); }
-    else
-      puts "\033[1;34mNo Thor tasks available\033[0m"
-    end
-  end  
-  
-  def display_tasks(klass, max_base, max_left)
-    if klass.tasks.values.length > 1
-      
-      base = Thor::Util.constant_to_thor_path(klass.name)
-      
-      if base.to_a.empty?
-        base = 'default' 
-        puts "\033[1;35m#{base}\033[0m"
-      else
-        puts "\033[1;34m#{base}\033[0m"
-      end
-      puts "-" * base.length
-      
-      klass.tasks.each true do |name, task|
-        format_string = "%-#{max_left + max_base + 5}s"
-        print format_string % task.formatted_usage(true)
-        puts task.description
-      end
-      
-      unless klass.opts.empty?
-        puts "\nglobal options: #{Options.new(klass.opts)}"
-      end
-      
-      puts # add some spacing
-    end
-  end
-
-  def initialize_thorfiles(relevant_to = nil)
-    thorfiles(relevant_to).each {|f| load_thorfile f unless Thor.subclass_files.keys.include?(File.expand_path(f))}
-  end
-  
-  def load_thorfile(path)
-    txt = File.read(path)
-    begin
-      Thor::Tasks.class_eval txt, path
-    rescue Object => e
-      $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
-    end
-  end
-  
-  def thorfiles(relevant_to = nil)
-    path = Dir.pwd
-    thorfiles = []
-    
-    # Look for Thorfile or *.thor in the current directory or a parent directory, until the root
-    while thorfiles.empty?
-      thorfiles = Thor::Runner.globs_for(path).map {|g| Dir[g]}.flatten
-      path = File.dirname(path)
-      break if path == "/"
-    end
-
-    # We want to load system-wide Thorfiles first
-    # so the local Thorfiles will override them.
-    files = (relevant_to ? thorfiles_relevant_to(relevant_to) :
-     thor_root_glob) + thorfiles - ["#{thor_root}/thor.yml"]
-     
-    files.map! do |file|
-      File.directory?(file) ? File.join(file, "main.thor") : file
-    end
-  end
-
-  def thorfiles_relevant_to(meth)
-    klass_str = Thor::Util.to_constant(meth.split(":")[0...-1].join(":"))
-    thor_yaml.select do |k, v|
-      v[:constants] && v[:constants].include?(klass_str)
-    end.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
-  end
-
-end

data/lib/thor/lib/thor/task.rb

@@ -1,83 +0,0 @@
-require 'thor/error'
-require 'thor/util'
-
-class Thor
-  class Task < Struct.new(:meth, :description, :usage, :opts, :klass)
-    
-    def self.dynamic(meth, klass)
-      new(meth, "A dynamically-generated task", meth.to_s, nil, klass)
-    end
-    
-    def initialize(*args)
-      # keep the original opts - we need them later on
-      @options = args[3] || {}
-      super
-    end
-
-    def parse(obj, args)
-      list, hash = parse_args(args)
-      obj.options = hash
-      run(obj, *list)
-    end
-
-    def run(obj, *params)
-      raise NoMethodError, "the `#{meth}' task of #{obj.class} is private" if
-        (obj.private_methods + obj.protected_methods).include?(meth)
-      
-      obj.invoke(meth, *params)
-    rescue ArgumentError => e
-      
-      # backtrace sans anything in this file
-      backtrace = e.backtrace.reject {|frame| frame =~ /^#{Regexp.escape(__FILE__)}/}
-      # also nix anything in thor.rb
-      backtrace = backtrace.reject { |frame| frame =~ /\/thor.rb/ }
-      
-      # and sans anything that got us here
-      backtrace -= caller
-      raise e unless backtrace.empty?
-      
-      # okay, they really did call it wrong
-      raise Error, "`#{meth}' was called incorrectly. Call as `#{formatted_usage}'"
-    rescue NoMethodError => e
-      begin
-        raise e unless e.message =~ /^undefined method `#{meth}' for #{Regexp.escape(obj.inspect)}$/
-      rescue
-        raise e
-      end
-      raise Error, "The #{namespace false} namespace doesn't have a `#{meth}' task"
-    end
-
-    def namespace(remove_default = true)
-      Thor::Util.constant_to_thor_path(klass, remove_default)
-    end
-
-    def with_klass(klass)
-      new = self.dup
-      new.klass = klass
-      new
-    end
-    
-    def opts
-      return super unless super.kind_of? Hash
-      @_opts ||= Options.new(super)
-    end
-        
-    def full_opts
-      @_full_opts ||= Options.new((klass.opts || {}).merge(@options))
-    end
-    
-    def formatted_usage(namespace = false)
-      (namespace ? self.namespace + ':' : '') + usage +
-        (opts ? " " + opts.formatted_usage : "")
-    end
-
-    protected
-
-    def parse_args(args)
-      return [[], {}] if args.nil?
-      hash = full_opts.parse(args)
-      list = full_opts.non_opts
-      [list, hash]
-    end
-  end
-end

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

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

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

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

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