domo 0.0.3 → 0.0.4

data/vendor/bundle/ruby/1.9.1/gems/thor-0.14.6/README.md

@@ -0,0 +1,307 @@
+# Thor 
+
+## Description
+
+Thor is a simple and efficient tool for building self-documenting command line utilities.  It removes the pain of parsing command line options, writing "USAGE:" banners, and can also be used as an alternative to the [Rake](http://github.com/jimweirich/rake) build tool.  The syntax is Rake-like, so it should be familiar to most Rake users. 
+
+## Installation
+
+$ gem install thor
+
+or
+
+$ gem install wycats-thor -s http://gems.github.com
+
+## Usage
+
+Map options to a class.  Simply create a class with the appropriate annotations
+and have options automatically map to functions and parameters.  
+
+Example:
+
+    class App < Thor                                                 # [1]
+      map "-L" => :list                                              # [2]
+      
+      desc "install APP_NAME", "install one of the available apps"   # [3]
+      method_options :force => :boolean, :alias => :string           # [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: 
+
+    thor app:install myname --force
+
+That gets converted to:
+
+    App.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 that will be available the instance method options.  
+
+## Types for <tt>method_options</tt>
+
+* :boolean - is parsed as <tt>--option</tt> or <tt>--option=true</tt>
+* :string  - is parsed as <tt>--option=VALUE</tt>
+* :numeric - is parsed as <tt>--option=N</tt>
+* :array   - is parsed as <tt>--option=one two three</tt>
+* :hash    - is parsed as <tt>--option=name:string age:integer</tt>
+
+Besides, method_option allows a default value to be given.  Examples:
+
+    method_options :force => false
+    #=> Creates a boolean option with default value false
+
+    method_options :alias => "bar"
+    #=> Creates a string option with default value "bar"
+
+    method_options :threshold => 3.0
+    #=> Creates a numeric option with default value 3.0
+
+You can also supply <tt>:option => :required</tt> to mark an option as required.  The
+type is assumed to be string.  If you want a required hash with default values
+as option, you can use <tt>method_option</tt> which uses a more declarative style:
+
+    method_option :attributes, :type => :hash, :default => {}, :required => true
+
+All arguments can be set to nil (except required arguments), by suppling a no or
+skip variant.  For example: 
+
+    thor app name --no-attributes
+
+In previous versions, aliases for options were created automatically, but now
+they should be explicit.  You can supply aliases in both short and declarative
+styles:
+
+    method_options %w( force -f ) => :boolean
+
+Or:
+
+    method_option :force, :type => :boolean, :aliases => "-f"
+
+You can supply as many aliases as you want.
+
+NOTE: Type :optional available in Thor 0.9.0 was deprecated. Use :string or :boolean instead.
+
+## Namespaces
+
+By default, your Thor tasks are invoked using Ruby namespace.  In the example
+above, tasks are invoked as:
+
+    thor app:install name --force
+
+However, you could namespace your class as:
+
+    module Sinatra
+      class App < Thor
+        # tasks
+      end
+    end
+
+And then you should invoke your tasks as:
+
+    thor sinatra:app:install name --force
+
+If desired, you can change the namespace:
+
+    module Sinatra
+      class App < Thor
+        namespace :myapp
+        # tasks
+      end
+    end
+
+And then your tasks should be invoked as:
+
+    thor myapp:install name --force
+
+## Invocations
+
+Thor comes with a invocation-dependency system as well, which allows a task to be invoked only once.  For example:
+
+    class Counter < Thor
+      desc "one", "Prints 1, 2, 3"
+      def one
+        puts 1
+        invoke :two
+        invoke :three
+      end
+      
+      desc "two", "Prints 2, 3"
+      def two
+        puts 2
+        invoke :three
+      end
+      
+      desc "three", "Prints 3"
+      def three
+        puts 3
+      end
+    end
+
+When invoking the task one:
+
+    thor counter:one
+
+The output is "1 2 3", which means that the three task was invoked only once.  
+You can even invoke tasks from another class, so be sure to check the
+[documentation](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor.html).
+
+Notice invocations do not share the same object. I.e, Thor will instantiate Counter once to invoke the task one, then, it instantiates another to invoke the task two and another for task three. This happens to allow options and arguments to parsed again. For example, if two and three have different options and both of them were given to the command line, calling invoke makes them be parsed each time and used accordingly by each task.
+
+## Thor::Group
+
+Thor has a special class called Thor::Group.  The main difference to Thor class
+is that it invokes all tasks at once.  The example above could be rewritten in
+Thor::Group as this:
+
+    class Counter < Thor::Group
+      desc "Prints 1, 2, 3"
+      
+      def one
+        puts 1
+      end
+     
+      def two
+        puts 2
+      end
+      
+      def three
+        puts 3
+      end
+    end
+
+When invoked:
+
+    thor counter
+
+It prints "1 2 3" as well.  Notice you should describe (using the method <tt>desc</tt>)
+only the class and not each task anymore.  Thor::Group is a great tool to create
+generators, since you can define several steps which are invoked in the order they
+are defined (Thor::Group is the tool use in generators in Rails 3.0). 
+
+Besides, Thor::Group can parse arguments and options as Thor tasks: 
+
+    class Counter < Thor::Group
+      # number will be available as attr_accessor
+      argument :number, :type => :numeric, :desc => "The number to start counting"
+      desc "Prints the 'number' given upto 'number+2'"
+      
+      def one
+        puts number + 0
+      end
+      
+      def two
+        puts number + 1
+      end
+      
+      def three
+        puts number + 2
+      end
+    end
+
+The counter above expects one parameter and has the folling outputs:
+
+    thor counter 5
+    # Prints "5 6 7"
+
+    thor counter 11
+    # Prints "11 12 13"
+
+You can also give options to Thor::Group, but instead of using <tt>method_option</tt>
+and <tt>method_options</tt>, you should use <tt>class_option</tt> and <tt>class_options</tt>.
+Both argument and class_options methods are available to Thor class as well.
+
+## Actions
+
+Thor comes with several actions which helps with script and generator tasks.  You
+might be familiar with them since some came from Rails Templates.  They are:
+<tt>say</tt>, <tt>ask</tt>, <tt>yes?</tt>, <tt>no?</tt>, <tt>add_file</tt>,
+<tt>remove_file</tt>, <tt>copy_file</tt>, <tt>template</tt>, <tt>directory</tt>,
+<tt>inside</tt>, <tt>run</tt>, <tt>inject_into_file</tt> and a couple more. 
+
+To use them, you just need to include Thor::Actions in your Thor classes:
+
+    class App < Thor
+      include Thor::Actions
+      # tasks
+    end
+
+Some actions like copy file requires that a class method called source_root is
+defined in your class.  This is the directory where your templates should be
+placed.  Be sure to check the documentation on [actions](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor/Actions.html).
+
+## Generators
+
+A great use for Thor is creating custom generators.  Combining Thor::Group,
+Thor::Actions and ERB templates makes this very easy.  Here is an example:
+
+    class Newgem < Thor::Group
+      include Thor::Actions
+
+      # Define arguments and options
+      argument :name
+      class_option :test_framework, :default => :test_unit
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def create_lib_file
+        template('templates/newgem.tt', "#{name}/lib/#{name}.rb")
+      end
+
+      def create_test_file
+        test = options[:test_framework] == "rspec" ? :spec : :test
+        create_file "#{name}/#{test}/#{name}_#{test}.rb"
+      end
+
+      def copy_licence
+        if yes?("Use MIT license?")
+          # Make a copy of the MITLICENSE file at the source root
+          copy_file "MITLICENSE", "#{name}/MITLICENSE"
+        else
+          say "Shame on you…", :red
+        end
+      end
+    end
+
+Doing a <tt>thor -T</tt> will show how to run our generator.  It should read:
+<tt>thor newgem NAME</tt>.  This shows that we have to supply a NAME
+argument for our generator to run.
+
+The <tt>create_lib_file</tt> uses an ERB template. This is what it looks like:
+
+    class <%= name.capitalize %>
+    end
+
+The arguments that you set in your generator will automatically be passed in
+when <tt>template</tt> gets called.  Be sure to read the [documentation](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor/Actions.html) for
+more options.
+
+Running the generator with <tt>thor newgem devise</tt> will
+create two files: "devise/lib/devise.rb", and "devise/test/devise_test.rb".  The user will then be asked (via a prompt by the <tt>yes?</tt> method) whether or not they would like to copy the MIT License.  If you want to change the test framework, you can add the option: <tt>thor newgem devise --test-framework=rspec</tt> 
+
+This will generate two files - "devise/lib/devise.rb" and "devise/spec/devise_spec.rb".
+
+## Further Reading
+
+Thor offers many scripting possibilities beyond these examples.  Be sure to read
+through the [documentation](http://rdoc.info/rdoc/wycats/thor/blob/f939a3e8a854616784cac1dcff04ef4f3ee5f7ff/Thor.html) and [specs](http://github.com/wycats/thor/tree/master/spec/) to get a better understanding of the options available. 
+
+## License
+
+Released under the MIT License.  See the LICENSE file for further details. 

data/vendor/bundle/ruby/1.9.1/gems/thor-0.14.6/Thorfile

@@ -0,0 +1,24 @@
+# enconding: utf-8
+require 'thor/rake_compat'
+
+class Default < Thor
+  include Thor::RakeCompat
+
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+
+  require 'rdoc/task'
+  if defined?(RDoc)
+    RDoc::Task.new do |rdoc|
+      rdoc.main     = 'README.md'
+      rdoc.rdoc_dir = 'rdoc'
+      rdoc.title    = 'thor'
+      rdoc.rdoc_files.include('README.md', 'LICENSE', 'CHANGELOG.rdoc', 'Thorfile')
+      rdoc.rdoc_files.include('lib/**/*.rb')
+      rdoc.options << '--line-numbers' << '--inline-source'
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/thor-0.14.6/bin/rake2thor

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+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/vendor/bundle/ruby/1.9.1/gems/thor-0.14.6/bin/thor

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+require 'thor/runner'
+$thor_runner = true
+Thor::Runner.start

data/vendor/bundle/ruby/1.9.1/gems/thor-0.14.6/lib/thor.rb

@@ -0,0 +1,334 @@
+require 'thor/base'
+
+class Thor
+  class << self
+    # Sets the default task when thor is executed without an explicit task to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the defaut task
+    #
+    def default_task(meth=nil)
+      case meth
+        when :none
+          @default_task = 'help'
+        when nil
+          @default_task ||= from_superclass(:default_task, 'help')
+        else
+          @default_task = meth.to_s
+      end
+    end
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options={})
+      if klass <= Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { invoke klass }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    def desc(usage, description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.usage = usage             if usage
+        task.description = description if description
+      else
+        @usage, @desc, @hide = usage, description, options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next task.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.long_description = long_description if long_description
+      else
+        @long_desc = long_description
+      end
+    end
+
+    # Maps an input to a task. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list task.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
+    #
+    def map(mappings=nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each {|subkey| @map[subkey] = value}
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next task to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options=nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined task.
+    #
+    #   def previous_task
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_task
+    #
+    #   def next_task
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    #
+    def method_option(name, options={})
+      scope = if options[:for]
+        find_and_refresh_task(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+
+    # Prints help information for the given task.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      meth = normalize_task_name(task_name)
+      task = all_tasks[meth]
+      handle_no_task_error(meth) unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      if task.long_description
+        shell.say "Description:"
+        shell.print_wrapped(task.long_description, :ident => 2)
+      else
+        shell.say task.description
+      end
+    end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell, subcommand = false)
+      list = printable_tasks(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_tasks(false)
+      end
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      shell.say "Tasks:"
+      shell.print_table(list, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(all = true, subcommand = false)
+      (all ? all_tasks : tasks).map do |_, task|
+        next if task.hidden?
+        item = []
+        item << banner(task, false, subcommand)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
+      end.compact
+    end
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      self.subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      define_method(subcommand) { |*args| invoke subcommand_class, args }
+    end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options={})
+      @check_unknown_options ||= Hash.new
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      task = config[:current_task]
+      return true unless task
+
+      name = task.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    protected
+
+      # The method responsible for dispatching given the args.
+      def dispatch(meth, given_args, given_opts, config) #:nodoc:
+        meth ||= retrieve_task_name(given_args)
+        task = all_tasks[normalize_task_name(meth)]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+        else
+          args, opts = given_args, nil
+          task = Thor::DynamicTask.new(meth)
+        end
+
+        opts = given_opts || opts || []
+        config.merge!(:current_task => task, :task_options => task.options)
+
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke_task(task, trailing || [])
+      end
+
+      # The banner for this class. You can customize it if you are invoking the
+      # thor class by another ways which is not the Thor::Runner. It receives
+      # the task that is going to be invoked and a boolean which indicates if
+      # the namespace should be displayed as arguments.
+      #
+      def banner(task, namespace = nil, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, $thor_runner, subcommand)}"
+      end
+
+      def baseclass #:nodoc:
+        Thor
+      end
+
+      def create_task(meth) #:nodoc:
+        if @usage && @desc
+          base_class = @hide ? Thor::HiddenTask : Thor::Task
+          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          @usage, @desc, @long_desc, @method_options, @hide = nil
+          true
+        elsif self.all_tasks[meth] || meth == "method_missing"
+          true
+        else
+          puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
+               "Call desc if you want this method to be available as task or declare it inside a " <<
+               "no_tasks{} block. Invoked from #{caller[1].inspect}."
+          false
+        end
+      end
+
+      def initialize_added #:nodoc:
+        class_options.merge!(method_options)
+        @method_options = nil
+      end
+
+      # Retrieve the task name from given args.
+      def retrieve_task_name(args) #:nodoc:
+        meth = args.first.to_s unless args.empty?
+
+        if meth && (map[meth] || meth !~ /^\-/)
+          args.shift
+        else
+          nil
+        end
+      end
+
+      # Receives a task name (can be nil), and try to get a map from it.
+      # If a map can't be found use the sent name or the default task.
+      def normalize_task_name(meth) #:nodoc:
+        meth = map[meth.to_s] || meth || default_task
+        meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
+      end
+
+      def subcommand_help(cmd)
+        desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+        class_eval <<-RUBY
+          def help(task = nil, subcommand = true); super; end
+        RUBY
+      end
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [TASK]", "Describe available tasks or one specific task"
+  def help(task = nil, subcommand = false)
+    task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
+  end
+end