sproutcore 1.0.1003 → 1.0.1008

data/lib/thor/README.markdown

@@ -1,76 +0,0 @@
-thor
-====
-
-Map options to a class. Simply create a class with the appropriate annotations, and have options automatically map
-to functions and parameters.
-
-Example:
-
-    class MyApp < Thor                                                # [1]
-      map "-L" => :list                                               # [2]
-                                                                    
-      desc "install APP_NAME", "install one of the available apps"    # [3]
-      method_options :force => :boolean, :alias => :optional          # [4]
-      def install(name)
-        user_alias = options[:alias]
-        if options.force?
-          # do something
-        end
-        # ... other code ...
-      end
-      
-      desc "list [SEARCH]", "list all of the available apps, limited by SEARCH"
-      def list(search = "")
-        # list everything
-      end
-    end
-    
-Thor automatically maps commands as such:
-
-    app install myname --force
-    
-That gets converted to:
-
-    MyApp.new.install("myname")
-    # with {'force' => true} as options hash
-
-1.  Inherit from Thor to turn a class into an option mapper
-2.  Map additional non-valid identifiers to specific methods. In this case,
-    convert -L to :list
-3.  Describe the method immediately below. The first parameter is the usage information,
-    and the second parameter is the description.
-4.  Provide any additional options. These will be marshaled from `--` and `-` params.
-    In this case, a `--force` and a `-f` option is added.
-    
-Types for `method_options`
---------------------------
-
-<dl>
-  <dt><code>:boolean</code></dt>
-    <dd>true if the option is passed</dd>
-  <dt><code>true or false</code></dt>
-    <dd>same as <code>:boolean</code>, but fall back to given boolean as default value</dd>
-  <dt><code>:required</code></dt>
-    <dd>the value for this option MUST be provided</dd>
-  <dt><code>:optional</code></dt>
-    <dd>the value for this option MAY be provided</dd>
-  <dt><code>:numeric</code></dt>
-    <dd>the value MAY be provided, but MUST be in numeric form</dd>
-  <dt>a String or Numeric</dt>
-    <dd>same as <code>:optional</code>, but fall back to the given object as default value</dd>
-</dl>
-
-In case of unsatisfied requirements, `Thor::Options::Error` is raised.
-
-Examples of option parsing:
-
-    # let's say this is how we defined options for a method:
-    method_options(:force => :boolean, :retries => :numeric)
-    
-    # here is how the following command-line invocations would be parsed:
-    
-    command -f --retries 5    # => {'force' => true, 'retries' => 5}
-    command --force -r=5      # => {'force' => true, 'retries' => 5}
-    command -fr 5             # => {'force' => true, 'retries' => 5}
-    command --retries=5       # => {'retries' => 5}
-    command -r5               # => {'retries' => 5}

data/lib/thor/Rakefile

@@ -1,6 +0,0 @@
-task :default => :install
-
-desc "install the gem locally"
-task :install do
-  sh %{ruby "#{File.dirname(__FILE__)}/bin/thor" :install}
-end

data/lib/thor/Thorfile

@@ -1,45 +0,0 @@
-require 'rubygems'
-require 'rubygems/specification'
-require 'thor/tasks'
-
-GEM = "thor"
-GEM_VERSION = "0.9.9"
-AUTHOR = "Yehuda Katz"
-EMAIL = "wycats@gmail.com"
-HOMEPAGE = "http://yehudakatz.com"
-SUMMARY = "A gem that maps options to a class"
-PROJECT = "thor"
-
-SPEC = Gem::Specification.new do |s|
-  s.name = GEM
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README.markdown", "LICENSE", "CHANGELOG.rdoc"]
-  s.summary = SUMMARY
-  s.description = s.summary
-  s.author = AUTHOR
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-  s.rubyforge_project = PROJECT
-    
-  s.require_path = 'lib'
-  s.bindir = "bin"
-  s.executables = %w( thor rake2thor )
-  s.files = s.extra_rdoc_files + %w(Rakefile) + Dir.glob("{bin,lib,specs}/**/*")
-end
-
-class Default < Thor
-  # Set up standard Thortasks
-  spec_task(Dir["spec/**/*_spec.rb"])
-  spec_task(Dir["spec/**/*_spec.rb"], :name => "rcov", :rcov =>
-    {:exclude => %w(spec /Library /Users task.thor lib/getopt.rb)})
-  install_task SPEC
-  
-  desc "gemspec", "make a gemspec file"
-  def gemspec
-    File.open("#{GEM}.gemspec", "w") do |file|
-      file.puts SPEC.to_ruby
-    end    
-  end
-end

data/lib/thor/bin/rake2thor

@@ -1,83 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'ruby2ruby'
-require 'rake'
-
-input  = ARGV[0] || 'Rakefile'
-output = ARGV[1] || 'Thorfile'
-
-$requires = []
-
-module Kernel
-  def require_with_record(file)
-    $requires << file if caller[1] =~ /rake2thor:/
-    require_without_record file
-  end
-  alias_method :require_without_record, :require
-  alias_method :require, :require_with_record
-end
-
-load input
-
-@private_methods = []
-
-def file_task_name(name)
-  "compile_" + name.gsub('/', '_slash_').gsub('.', '_dot_').gsub(/\W/, '_')
-end
-
-def method_for_task(task)
-  file_task = task.is_a?(Rake::FileTask)
-  comment = task.instance_variable_get('@comment')
-  prereqs = task.instance_variable_get('@prerequisites').select(&Rake::Task.method(:task_defined?))
-  actions = task.instance_variable_get('@actions')
-  name = task.name.gsub(/^([^:]+:)+/, '')
-  name = file_task_name(name) if file_task
-  meth = ''
-
-  meth << "desc #{name.inspect}, #{comment.inspect}\n" if comment
-  meth << "def #{name}\n"
-
-  meth << prereqs.map do |pre|
-    pre = pre.to_s
-    pre = file_task_name(pre) if Rake::Task[pre].is_a?(Rake::FileTask)
-    '  ' + pre
-  end.join("\n")
-
-  meth << "\n\n" unless prereqs.empty? || actions.empty?
-
-  meth << actions.map do |act|
-    act = act.to_ruby
-    unless act.gsub!(/^proc \{ \|(\w+)\|\n/,
-                     "  \\1 = Struct.new(:name).new(#{name.inspect}) # A crude mock Rake::Task object\n")
-      act.gsub!(/^proc \{\n/, '')
-    end
-    act.gsub(/\n\}$/, '')
-  end.join("\n")
-
-  meth << "\nend"
-
-  if file_task
-    @private_methods << meth
-    return
-  end
-
-  meth
-end
-
-body = Rake::Task.tasks.map(&method(:method_for_task)).compact.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
-
-unless @private_methods.empty?
-  body << "\n\n  private\n\n"
-  body << @private_methods.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
-end
-
-requires = $requires.map { |r| "require #{r.inspect}" }.join("\n")
-
-File.open(output, 'w') { |f| f.write(<<END.lstrip) }
-#{requires}
-
-class Default < Thor
-#{body}
-end
-END

data/lib/thor/bin/thor

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby -*-
-
-require File.dirname(__FILE__) + "/../lib/thor"
-require 'thor/runner'
-
-Thor::Runner.start

data/lib/thor/lib/thor/error.rb

@@ -1,3 +0,0 @@
-class Thor
-  class Error < Exception; end
-end

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

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

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