sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/lib/thor/lib/thor/options.rb

@@ -0,0 +1,267 @@
+# This is a modified version of Daniel Berger's Getopt::Long class,
+# licensed under Ruby's license.
+
+class Thor
+  class Options
+    class Error < StandardError; end
+    
+    # simple Hash with indifferent access
+    class Hash < ::Hash
+      def initialize(hash)
+        super()
+        update hash
+      end
+      
+      def [](key)
+        super convert_key(key)
+      end
+      
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+      
+      protected
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.to_s : key
+        end
+        
+        # Magic predicates. For instance:
+        #   options.force? # => !!options['force']
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /^(\w+)=$/ 
+            self[$1] = args.first
+          elsif method =~ /^(\w+)\?$/
+            !!self[$1]
+          else 
+            self[method]
+          end
+        end
+    end
+
+    NUMERIC     = /(\d*\.\d+|\d+)/
+    LONG_RE     = /^(--\w+[-\w+]*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+[-\w+]*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+    
+    attr_reader :leading_non_opts, :trailing_non_opts
+    
+    def non_opts
+      leading_non_opts + trailing_non_opts
+    end
+
+    # Takes an array of switches. Each array consists of up to three
+    # elements that indicate the name and type of switch. Returns a hash
+    # containing each switch name, minus the '-', as a key. The value
+    # for each key depends on the type of switch and/or the value provided
+    # by the user.
+    #
+    # The long switch _must_ be provided. The short switch defaults to the
+    # first letter of the short switch. The default type is :boolean.
+    #
+    # Example:
+    #
+    #   opts = Thor::Options.new(
+    #      "--debug" => true,
+    #      ["--verbose", "-v"] => true,
+    #      ["--level", "-l"] => :numeric
+    #   ).parse(args)
+    #
+    def initialize(switches)
+      @defaults = {}
+      @shorts = {}
+      
+      @leading_non_opts, @trailing_non_opts = [], []
+
+      @switches = switches.inject({}) do |mem, (name, type)|
+        if name.is_a?(Array)
+          name, *shorts = name
+        else
+          name = name.to_s
+          shorts = []
+        end
+        # we need both nice and dasherized form of switch name
+        if name.index('-') == 0
+          nice_name = undasherize name
+        else
+          nice_name = name
+          name = dasherize name
+        end
+        # if there are no shortcuts specified, generate one using the first character
+        shorts << "-" + nice_name[0,1] if shorts.empty? and nice_name.length > 1
+        shorts.each { |short| @shorts[short] = name }
+        
+        # normalize type
+        case type
+        when TrueClass
+          @defaults[nice_name] = true
+          type = :boolean
+        when FalseClass
+          @defaults[nice_name] = false
+          type = :boolean
+        when String
+          @defaults[nice_name] = type
+          type = :optional
+        when Numeric
+          @defaults[nice_name] = type
+          type = :numeric
+        end
+        
+        mem[name] = type
+        mem
+      end
+      
+      # remove shortcuts that happen to coincide with any of the main switches
+      @shorts.keys.each do |short|
+        @shorts.delete(short) if @switches.key?(short)
+      end
+    end
+
+    def parse(args, skip_leading_non_opts = true)
+      @args = args
+      # start with Thor::Options::Hash pre-filled with defaults
+      hash = Hash.new @defaults
+      
+      @leading_non_opts = []
+      if skip_leading_non_opts
+        @leading_non_opts << shift until current_is_option? || @args.empty?
+      end
+
+      while current_is_option?
+        case shift
+        when SHORT_SQ_RE
+          unshift $1.split('').map { |f| "-#{f}" }
+          next
+        when EQ_RE, SHORT_NUM
+          unshift $2
+          switch = $1
+        when LONG_RE, SHORT_RE
+          switch = $1
+        end
+        
+        switch    = normalize_switch(switch)
+        nice_name = undasherize(switch)
+        type      = switch_type(switch)
+        
+        case type
+        when :required
+          assert_value!(switch)
+          raise Error, "cannot pass switch '#{peek}' as an argument" if valid?(peek)
+          hash[nice_name] = shift
+        when :optional
+          hash[nice_name] = peek.nil? || valid?(peek) || shift
+        when :boolean
+          if !@switches.key?(switch) && nice_name =~ /^no-(\w+)$/
+            hash[$1] = false
+          else
+            hash[nice_name] = true
+          end
+          
+        when :numeric
+          assert_value!(switch)
+          unless peek =~ NUMERIC and $& == peek
+            raise Error, "expected numeric value for '#{switch}'; got #{peek.inspect}"
+          end
+          hash[nice_name] = $&.index('.') ? shift.to_f : shift.to_i
+        end
+      end
+      
+      @trailing_non_opts = @args
+
+      check_required! hash
+      hash.freeze
+      hash
+    end
+    
+    def formatted_usage
+      return "" if @switches.empty?
+      @switches.map do |opt, type|
+        case type
+        when :boolean
+          "[#{opt}]"
+        when :required
+          opt + "=" + opt.gsub(/\-/, "").upcase
+        else
+          sample = @defaults[undasherize(opt)]
+          sample ||= case type
+            when :optional then undasherize(opt).gsub(/\-/, "_").upcase
+            when :numeric  then "N"
+            end
+          "[" + opt + "=" + sample.to_s + "]"
+        end
+      end.join(" ")
+    end
+    
+    alias :to_s :formatted_usage
+
+    private
+    
+    def assert_value!(switch)
+      raise Error, "no value provided for argument '#{switch}'" if peek.nil?
+    end
+    
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
+    
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str
+    end
+    
+    def peek
+      @args.first
+    end
+
+    def shift
+      @args.shift
+    end
+
+    def unshift(arg)
+      unless arg.kind_of?(Array)
+        @args.unshift(arg)
+      else
+        @args = arg + @args
+      end
+    end
+    
+    def valid?(arg)
+      if arg.to_s =~ /^--no-(\w+)$/
+        @switches.key?(arg) or (@switches["--#{$1}"] == :boolean)
+      else
+        @switches.key?(arg) or @shorts.key?(arg)
+      end
+    end
+
+    def current_is_option?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        valid?($1)
+      when SHORT_SQ_RE
+        $1.split('').any? { |f| valid?("-#{f}") }
+      end
+    end
+    
+    def normalize_switch(switch)
+      @shorts.key?(switch) ? @shorts[switch] : switch
+    end
+    
+    def switch_type(switch)
+      if switch =~ /^--no-(\w+)$/
+        @switches[switch] || @switches["--#{$1}"]
+      else
+        @switches[switch]
+      end
+    end
+    
+    def check_required!(hash)
+      for name, type in @switches
+        if type == :required and !hash[undasherize(name)]
+          raise Error, "no value provided for required argument '#{name}'"
+        end
+      end
+    end
+    
+  end
+end

data/lib/thor/lib/thor/ordered_hash.rb

@@ -0,0 +1,64 @@
+class Thor
+  # This class is based on the Ruby 1.9 ordered hashes.
+  # It keeps the semantics and most of the efficiency of normal hashes
+  # while also keeping track of the order in which elements were set.
+  class OrderedHash
+    Node = Struct.new(:key, :value, :next, :prev)
+    include Enumerable
+
+    def initialize
+      @hash = {}
+    end
+
+    def initialize_copy(other)
+      @hash = other.instance_variable_get('@hash').clone
+    end
+
+    def [](key)
+      @hash[key] && @hash[key].value
+    end
+
+    def []=(key, value)
+      node = Node.new(key, value)
+
+      if old = @hash[key]
+        if old.prev
+          old.prev.next = old.next
+        else # old is @first and @last
+          @first = @last = nil
+        end
+      end
+
+      if @first.nil?
+        @first = @last = node
+      else
+        node.prev = @last
+        @last.next = node
+        @last = node
+      end
+
+      @hash[key] = node
+      value
+    end
+
+    def each
+      return unless @first
+      yield [@first.key, @first.value]
+      node = @first
+      yield [node.key, node.value] while node = node.next
+      self
+    end
+
+    def values
+      self.map { |k, v| v }
+    end
+
+    def +(other)
+      new = clone
+      other.each do |key, value|
+        new[key] = value unless self[key]
+      end
+      new
+    end
+  end
+end

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

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

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