bundle_depot 0.0.1

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/command_line_usage.rdoc

@@ -0,0 +1,152 @@
+= Rake Command Line Usage
+
+Rake is invoked from the command line using:
+
+    % rake [options ...]  [VAR=VALUE ...]  [targets ...]
+
+Options are:
+
+[<tt><em>name</em>=<em>value</em></tt>]
+    Set the environment variable <em>name</em> to <em>value</em>
+    during the execution of the <b>rake</b> command.  You can access
+    the value by using ENV['<em>name</em>'].
+
+[<tt>--all</tt> (-A)]
+    Used in combination with the -T and -D options, will force
+    those options to show all the tasks, even the ones without comments.
+
+[<tt>--backtrace</tt>{=_output_} (-n)]
+    Enable a full backtrace (i.e. like --trace, but without the task
+    tracing details). The _output_ parameter is optional, but if
+    specified it controls where the backtrace output is sent. If
+    _output_ is <tt>stdout</tt>, then backtrace output is directed to
+    stardard output. If _output_ is <tt>stderr</tt>, or if it is
+    missing, then the backtrace output is sent to standard error.
+
+[<tt>--comments</tt>]
+    Used in combination with the -W options to force the output to
+    contain commented options only. This is the reverse of
+    <tt>--all</tt>.
+
+[<tt>--describe</tt> _pattern_ (-D)]
+    Describe the tasks (matching optional PATTERN), then exit.
+
+[<tt>--dry-run</tt> (-n)]
+    Do a dry run.  Print the tasks invoked and executed, but do not
+    actually execute any of the actions.
+
+[<tt>--execute</tt> _code_ (-e)]
+    Execute some Ruby code and exit.
+
+[<tt>--execute-print</tt> _code_ (-p)]
+    Execute some Ruby code, print the result, and exit.
+
+[<tt>--execute-continue</tt> _code_ (-E)]
+    Execute some Ruby code, then continue with normal task processing.
+
+[<tt>--help</tt>  (-H)]
+    Display some help text and exit.
+
+[<tt>--jobs</tt> _number_  (-j)]
+    Specifies the number of active concurrent tasks used. The
+    suggested value is equal to the number of CPUs. The concurrent
+    tasks are used to execute the <tt>multitask</tt> prerequisites.
+    Also see the <tt>-m</tt> option which turns all tasks into
+    multitasks.
+
+    Sample values:
+     (no -j) : unlimited concurrent tasks (standard rake behavior)
+     -j      : 2 concurrent tasks (exact number may change)
+     -j 16   : 16 concurrent tasks
+
+[<tt>--job-stats</tt> _level_]
+
+    Display job statistics at the completion of the run. By default,
+    this will display the requested number of active tasks (from the
+    -j options) and the maximum number of tasks in play at any given
+    time.
+
+    If the optional _level_ is <tt>history</tt>, then a complete trace
+    of task history will be displayed on standard output.
+
+[<tt>--libdir</tt> _directory_  (-I)]
+    Add _directory_ to the list of directories searched for require.
+
+[<tt>--multitask</tt> (-m)]
+    Treat all tasks as multitasks. ('make/drake' semantics)
+
+[<tt>--nosearch</tt>  (-N)]
+    Do not search for a Rakefile in parent directories.
+
+[<tt>--prereqs</tt>  (-P)]
+    Display a list of all tasks and their immediate prerequisites.
+
+[<tt>--quiet</tt> (-q)]
+    Do not echo commands from FileUtils.
+
+[<tt>--rakefile</tt> _filename_ (-f)]
+    Use _filename_ as the name of the rakefile. The default rakefile
+    names are +rakefile+ and +Rakefile+ (with +rakefile+ taking
+    precedence). If the rakefile is not found in the current
+    directory, +rake+ will search parent directories for a match. The
+    directory where the Rakefile is found will become the current
+    directory for the actions executed in the Rakefile.
+
+[<tt>--rakelibdir</tt> _rakelibdir_ (-R)]
+    Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib')
+
+[<tt>--require</tt> _name_ (-r)]
+    Require _name_ before executing the Rakefile.
+
+[<tt>--rules</tt>]
+    Trace the rules resolution.
+
+[<tt>--silent (-s)</tt>]
+    Like --quiet, but also suppresses the 'in directory' announcement.
+
+[<tt>--suppress-backtrace _pattern_ </tt>]
+    Line matching the regular expression _pattern_ will be removed
+    from the backtrace output. Note that the --backtrace option is the
+    full backtrace without these lines suppressed.
+
+[<tt>--system</tt> (-g)]
+    Use the system wide (global) rakefiles. The project Rakefile is
+    ignored. By default, the system wide rakefiles are used only if no
+    project Rakefile is found. On Unix-like system, the system wide
+    rake files are located in $HOME/.rake. On a windows system they
+    are stored in $APPDATA/Rake.
+
+[<tt>--no-system</tt> (-G)]
+    Use the project level Rakefile, ignoring the system-wide (global)
+    rakefiles.
+
+[<tt>--tasks</tt> <em>pattern</em> (-T)]
+    Display a list of the major tasks and their comments.  Comments
+    are defined using the "desc" command.  If a pattern is given, then
+    only tasks matching the pattern are displayed.
+
+[<tt>--trace</tt>{=_output_} (-t)]
+    Turn on invoke/execute tracing. Also enable full backtrace on
+    errors. The _output_ parameter is optional, but if specified it
+    controls where the trace output is sent. If _output_ is
+    <tt>stdout</tt>, then trace output is directed to stardard output.
+    If _output_ is <tt>stderr</tt>, or if it is missing, then trace
+    output is sent to standard error.
+
+[<tt>--verbose</tt> (-v)]
+    Echo the Sys commands to standard output.
+
+[<tt>--version</tt> (-V)]
+    Display the program version and exit.
+
+[<tt>--where</tt> <em>pattern</em> (-W)]
+    Display tasks that match <em>pattern</em> and the file and line
+    number where the task is defined. By default this option will
+    display all tasks, not just the tasks that have descriptions.
+
+[<tt>--no-deprecation-warnings</tt> (-X)]
+    Do not display the deprecation warnings.
+
+In addition, any command line option of the form
+<em>VAR</em>=<em>VALUE</em> will be added to the environment hash
+<tt>ENV</tt> and may be tested in the Rakefile.

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/example/Rakefile1

@@ -0,0 +1,38 @@
+# Example Rakefile -*- ruby -*-
+
+task :default => [:main]
+
+file "a.o" => ["a.c"] do |t|
+  src = t.name.sub(/\.o$/, '.c')
+  sh "gcc #{src} -c -o #{t.name}"
+end
+
+file "b.o" => ["b.c"] do |t|
+  src = t.name.sub(/\.o$/, '.c')
+  sh "gcc #{src} -c -o #{t.name}"
+end
+
+file "main.o" => ["main.c"] do |t|
+  src = t.name.sub(/\.o$/, '.c')
+  sh "gcc #{src} -c -o #{t.name}"
+end
+
+OBJFILES = ["a.o", "b.o", "main.o"]
+task :obj => OBJFILES
+
+file "main" => OBJFILES do |t|
+  sh "gcc -o #{t.name} main.o a.o b.o"
+end
+
+task :clean do
+  rm_f FileList['*.o']
+  Dir['*~'].each { |fn| rm_f fn }
+end
+
+task :clobber => [:clean] do
+  rm_f "main"
+end
+
+task :run => ["main"] do
+  sh "./main"
+end

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/example/Rakefile2

@@ -0,0 +1,35 @@
+# Example Rakefile -*- ruby -*-
+# Using the power of Ruby
+
+task :default => [:main]
+
+def ext(fn, newext)
+  fn.sub(/\.[^.]+$/, newext)
+end
+
+SRCFILES = Dir['*.c']
+OBJFILES = SRCFILES.collect { |fn| ext(fn,".o") }
+
+OBJFILES.each do |objfile|
+  srcfile = ext(objfile, ".c")
+  file objfile => [srcfile] do |t|
+    sh "gcc #{srcfile} -c -o #{t.name}"
+  end
+end
+
+file "main" => OBJFILES do |t|
+  sh "gcc -o #{t.name} main.o a.o b.o"
+end
+
+task :clean do
+  rm_f FileList['*.o']
+  Dir['*~'].each { |fn| rm_f fn }
+end
+
+task :clobber => [:clean] do
+  rm_f "main"
+end
+
+task :run => ["main"] do
+  sh "./main"
+end

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/example/a.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+void a()
+{
+    printf ("In function a\n");
+}

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/example/b.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+void b()
+{
+    printf ("In function b\n");
+}

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/example/main.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+extern void a();
+extern void b();
+
+int main ()
+{
+    a();
+    b();
+    return 0;
+}

data/fixtures/bundle/rake/4c3a94088cd7bd0ac6b190c7f40a19c809356cda7fbd7dd8860ed3155b8e5c3d/ruby/2.0.0/gems/rake-10.1.0/doc/glossary.rdoc

@@ -0,0 +1,51 @@
+= Glossary
+
+[<b>action</b>]
+	Code to be executed in order to perform a task.  Actions in a
+	rakefile are specified in a code block (usually delimited by
+	+do+/+end+ pairs.
+
+[<b>execute</b>]
+	When a task is executed, all of its actions are performed, in
+	the order they were defined.  Note that unlike
+	<tt>invoke</tt>, <tt>execute</tt> always executes the actions
+	(without invoking or executing the prerequisites).
+
+[<b>file task</b> (FileTask)]
+	 A file task is a task whose purpose is to create a file
+	 (which has the same name as the task).  When invoked, a file
+	 task will only execute if one or more of the following
+	 conditions are true.
+
+         1. The associated file does not exist.
+	 2. A prerequisite has a later time stamp than the existing file.
+
+	 Because normal Tasks always have the current time as
+	 timestamp, a FileTask that has a normal Task prerequisite
+	 will always execute.
+
+[<b>invoke</b>]
+	When a task is invoked, first we check to see if it has been
+	invoked before.  if it has been, then nothing else is done.
+	If this is the first time its been invoked, then we invoke
+	each of its prerequisites.  Finally, we check to see if we
+	need to execute the actions of this task by calling
+	<tt>needed?</tt>.  Finally, if the task is needed, we execute
+	its actions.
+
+	NOTE: Currently prerequisites are invoked even if the task is
+	not needed.  This may change in the future.
+
+[<b>prerequisites</b>]
+	Every task has a set (possibly empty) of prerequisites.  A
+	prerequisite P to Task T is itself a task that must be invoked
+	before Task T.
+
+[<b>rule</b>]
+	A rule is a recipe for synthesizing a task when no task is
+	explicitly defined.  Rules generally synthesize file tasks.
+
+[<b>task</b> (Task)]
+	Basic unit of work in a rakefile.  A task has a name, a set of
+	prerequisites and a list of actions to be performed.
+