botanicus-thor 0.9.8

data/CHANGELOG.rdoc

@@ -0,0 +1,52 @@
+== TODO
+
+* Change Thor.start to parse ARGV in a single pass
+* Improve spec coverage for Thor::Runner
+* Improve help output to list shorthand switches, too
+* Investigate and fix deep namespacing ("foo:bar:baz") issues
+
+== 0.9.8, released 2008-10-20
+
+* Fixed some tiny issues that were introduced lately.
+
+== 0.9.7, released 2008-10-13
+
+* Setting global method options on the initialize method works as expected:
+  All other tasks will accept these global options in addition to their own.
+* Added 'group' notion to Thor task sets (class Thor); by default all tasks
+  are in the 'standard' group. Running 'thor -T' will only show the standard
+  tasks - adding --all will show all tasks. You can also filter on a specific
+  group using the --group option: thor -T --group advanced
+  
+== 0.9.6, released 2008-09-13
+
+* Generic improvements
+
+== 0.9.5, released 2008-08-27
+
+* Improve Windows compatibility
+* Update (incorrect) README and task.thor sample file
+* Options hash is now frozen (once returned)
+* Allow magic predicates on options object. For instance: `options.force?`
+* Add support for :numeric type
+* BACKWARDS INCOMPATIBLE: Refactor Thor::Options. You cannot access shorthand forms in options hash anymore (for instance, options[:f])
+* Allow specifying optional args with default values: method_options(:user => "mislav")
+* Don't write options for nil or false values. This allows, for example, turning color off when running specs.
+* Exit with the status of the spec command to help CI stuff out some.
+
+== 0.9.4, released 2008-08-13
+
+* Try to add Windows compatibility.
+* BACKWARDS INCOMPATIBLE: options hash is now accessed as a property in your class and is not passed as last argument anymore
+* Allow options at the beginning of the argument list as well as the end.
+* Make options available with symbol keys in addition to string keys.
+* Allow true to be passed to Thor#method_options to denote a boolean option.
+* If loading a thor file fails, don't give up, just print a warning and keep going.
+* Make sure that we re-raise errors if they happened further down the pipe than we care about.
+* Only delete the old file on updating when the installation of the new one is a success
+* Make it Ruby 1.8.5 compatible.
+* Don't raise an error if a boolean switch is defined multiple times.
+* Thor::Options now doesn't parse through things that look like options but aren't.
+* Add URI detection to install task, and make sure we don't append ".thor" to URIs
+* Add rake2thor to the gem binfiles.
+* Make sure local Thorfiles override system-wide ones.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,76 @@
+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/Rakefile

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

data/bin/rake2thor

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'rubygems'
+require 'ruby2ruby'
+require 'parse_tree'
+if Ruby2Ruby::VERSION >= "1.2.0"
+  require 'parse_tree_extensions'
+end
+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/bin/thor

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

data/lib/thor/error.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+class Thor
+  class Error < Exception; end
+end

data/lib/thor/options.rb

@@ -0,0 +1,269 @@
+# coding: utf-8
+
+# 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