RubyGems - engineyard-serverside - Versions diffs - 1.5.21 → 1.5.23.ruby19 - Mend

engineyard-serverside 1.5.21 → 1.5.23.ruby19

Files changed (184) hide show

data/lib/vendor/thor/README.rdoc DELETED Viewed

@@ -1,297 +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 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 hould 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].
-== 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.camelize %>
-    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",
-"devise/test/devise_test.rb". The user will then be prompt (with the
-use of the method <tt>yes?</tt>) if he wants to copy the MITLICENSE. If you
-want to change the test framework, you can add the option:
-<tt>thor newgem devise --test-framework=rspec</tt>
-This will generate: "devise/lib/devise.rb" and
-"devise/spec/devise_spec.rb".
-== Further Reading
-Thor has 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 all the
-options Thor offers.
-== License
-See MIT LICENSE.

data/lib/vendor/thor/Thorfile DELETED Viewed

@@ -1,69 +0,0 @@
-# enconding: utf-8
-require File.join(File.dirname(__FILE__), "lib", "thor", "version")
-require 'rubygems'
-require 'thor/rake_compat'
-require 'spec/rake/spectask'
-begin
-  require 'rdoc/task'
-rescue LoadError
-end
-GEM_NAME = 'thor'
-EXTRA_RDOC_FILES = ["README.rdoc", "LICENSE", "CHANGELOG.rdoc", "VERSION", "Thorfile"]
-class Default < Thor
-  include Thor::RakeCompat
-  Spec::Rake::SpecTask.new(:spec) do |t|
-    t.libs << 'lib'
-    t.spec_opts = ['--options', "spec/spec.opts"]
-    t.spec_files = FileList['spec/**/*_spec.rb']
-  end
-  Spec::Rake::SpecTask.new(:rcov) do |t|
-    t.libs << 'lib'
-    t.spec_opts = ['--options', "spec/spec.opts"]
-    t.spec_files = FileList['spec/**/*_spec.rb']
-    t.rcov = true
-    t.rcov_dir = "rcov"
-  end
-  if defined?(RDoc)
-    RDoc::Task.new do |rdoc|
-      rdoc.main     = "README.rdoc"
-      rdoc.rdoc_dir = "rdoc"
-      rdoc.title    = GEM_NAME
-      rdoc.rdoc_files.include(*EXTRA_RDOC_FILES)
-      rdoc.rdoc_files.include('lib/**/*.rb')
-      rdoc.options << '--line-numbers' << '--inline-source'
-    end
-  end
-  begin
-    require 'jeweler'
-    Jeweler::Tasks.new do |s|
-      s.name = GEM_NAME
-      s.version = Thor::VERSION
-      s.rubyforge_project = "textmate"
-      s.platform = Gem::Platform::RUBY
-      s.summary = "A scripting framework that replaces rake, sake and rubigen"
-      s.email = "ruby-thor@googlegroups.com"
-      s.homepage = "http://yehudakatz.com"
-      s.description = "A scripting framework that replaces rake, sake and rubigen"
-      s.authors = ['Yehuda Katz', 'José Valim']
-      s.has_rdoc = true
-      s.extra_rdoc_files = EXTRA_RDOC_FILES
-      s.require_path = 'lib'
-      s.bindir = "bin"
-      s.executables = %w( thor rake2thor )
-      s.files = s.extra_rdoc_files + Dir.glob("{bin,lib}/**/*")
-      s.test_files.include 'spec/**/*'
-      s.test_files.exclude 'spec/sandbox/**/*'
-    end
-    Jeweler::GemcutterTasks.new
-  rescue LoadError
-    puts "Jeweler, or one of its dependencies, is not available. Install it with: gem install jeweler"
-  end
-end

data/lib/vendor/thor/bin/rake2thor DELETED Viewed

@@ -1,86 +0,0 @@
-#!/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/lib/vendor/thor/bin/thor DELETED Viewed

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

data/lib/vendor/thor/lib/thor/actions/create_file.rb DELETED Viewed

@@ -1,103 +0,0 @@
-require 'thor/actions/empty_directory'
-class Thor
-  module Actions
-    # Create a new file relative to the destination root with the given data,
-    # which is the return value of a block or a data string.
-    #
-    # ==== Parameters
-    # destination<String>:: the relative path to the destination root.
-    # data<String|NilClass>:: the data to append to the file.
-    # config<Hash>:: give :verbose => false to not log the status.
-    #
-    # ==== Examples
-    #
-    #   create_file "lib/fun_party.rb" do
-    #     hostname = ask("What is the virtual hostname I should use?")
-    #     "vhost.name = #{hostname}"
-    #   end
-    #
-    #   create_file "config/apach.conf", "your apache config"
-    #
-    def create_file(destination, data=nil, config={}, &block)
-      action CreateFile.new(self, destination, block || data.to_s, config)
-    end
-    alias :add_file :create_file
-    # AddFile is a subset of Template, which instead of rendering a file with
-    # ERB, it gets the content from the user.
-    #
-    class CreateFile < EmptyDirectory #:nodoc:
-      attr_reader :data
-      def initialize(base, destination, data, config={})
-        @data = data
-        super(base, destination, config)
-      end
-      # Checks if the content of the file at the destination is identical to the rendered result.
-      #
-      # ==== Returns
-      # Boolean:: true if it is identical, false otherwise.
-      #
-      def identical?
-        exists? && File.binread(destination) == render
-      end
-      # Holds the content to be added to the file.
-      #
-      def render
-        @render ||= if data.is_a?(Proc)
-          data.call
-        else
-          data
-        end
-      end
-      def invoke!
-        invoke_with_conflict_check do
-          FileUtils.mkdir_p(File.dirname(destination))
-          File.open(destination, 'wb') { |f| f.write render }
-        end
-        given_destination
-      end
-      protected
-        # Now on conflict we check if the file is identical or not.
-        #
-        def on_conflict_behavior(&block)
-          if identical?
-            say_status :identical, :blue
-          else
-            options = base.options.merge(config)
-            force_or_skip_or_conflict(options[:force], options[:skip], &block)
-          end
-        end
-        # If force is true, run the action, otherwise check if it's not being
-        # skipped. If both are false, show the file_collision menu, if the menu
-        # returns true, force it, otherwise skip.
-        #
-        def force_or_skip_or_conflict(force, skip, &block)
-          if force
-            say_status :force, :yellow
-            block.call unless pretend?
-          elsif skip
-            say_status :skip, :yellow
-          else
-            say_status :conflict, :red
-            force_or_skip_or_conflict(force_on_collision?, true, &block)
-          end
-        end
-        # Shows the file collision menu to the user and gets the result.
-        #
-        def force_on_collision?
-          base.shell.file_collision(destination){ render }
-        end
-    end
-  end
-end

data/lib/vendor/thor/lib/thor/actions/directory.rb DELETED Viewed

@@ -1,91 +0,0 @@
-require 'thor/actions/empty_directory'
-class Thor
-  module Actions
-    # Copies recursively the files from source directory to root directory.
-    # If any of the files finishes with .tt, it's considered to be a template
-    # and is placed in the destination without the extension .tt. If any
-    # empty directory is found, it's copied and all .empty_directory files are
-    # ignored. Remember that file paths can also be encoded, let's suppose a doc
-    # directory with the following files:
-    #
-    #   doc/
-    #     components/.empty_directory
-    #     README
-    #     rdoc.rb.tt
-    #     %app_name%.rb
-    #
-    # When invoked as:
-    #
-    #   directory "doc"
-    #
-    # It will create a doc directory in the destination with the following
-    # files (assuming that the app_name is "blog"):
-    #
-    #   doc/
-    #     components/
-    #     README
-    #     rdoc.rb
-    #     blog.rb
-    #
-    # ==== Parameters
-    # source<String>:: the relative path to the source root.
-    # destination<String>:: the relative path to the destination root.
-    # config<Hash>:: give :verbose => false to not log the status.
-    #                If :recursive => false, does not look for paths recursively.
-    #
-    # ==== Examples
-    #
-    #   directory "doc"
-    #   directory "doc", "docs", :recursive => false
-    #
-    def directory(source, destination=nil, config={}, &block)
-      action Directory.new(self, source, destination || source, config, &block)
-    end
-    class Directory < EmptyDirectory #:nodoc:
-      attr_reader :source
-      def initialize(base, source, destination=nil, config={}, &block)
-        @source = File.expand_path(base.find_in_source_paths(source.to_s))
-        @block  = block
-        super(base, destination, { :recursive => true }.merge(config))
-      end
-      def invoke!
-        base.empty_directory given_destination, config
-        execute!
-      end
-      def revoke!
-        execute!
-      end
-      protected
-        def execute!
-          lookup = config[:recursive] ? File.join(source, '**') : source
-          lookup = File.join(lookup, '{*,.[a-z]*}')
-          Dir[lookup].each do |file_source|
-            next if File.directory?(file_source)
-            file_destination = File.join(given_destination, file_source.gsub(source, '.'))
-            file_destination.gsub!('/./', '/')
-            case file_source
-              when /\.empty_directory$/
-                dirname = File.dirname(file_destination).gsub(/\/\.$/, '')
-                next if dirname == given_destination
-                base.empty_directory(dirname, config)
-              when /\.tt$/
-                destination = base.template(file_source, file_destination[0..-4], config, &@block)
-              else
-                destination = base.copy_file(file_source, file_destination, config, &@block)
-            end
-          end
-        end
-    end
-  end
-end