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

engineyard-serverside 1.5.21 → 1.5.23.ruby19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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