getargv 0.3.0-universal-darwin → 0.3.3-universal-darwin

data/vendor/bundle/ruby/3.3.0/gems/rake-13.1.0/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Jim Weirich
+
+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/vendor/bundle/ruby/3.3.0/gems/rake-13.1.0/README.rdoc

@@ -0,0 +1,155 @@
+= RAKE -- Ruby Make
+
+home :: https://github.com/ruby/rake
+bugs :: https://github.com/ruby/rake/issues
+docs :: https://ruby.github.io/rake
+
+== Description
+
+Rake is a Make-like program implemented in Ruby. Tasks and dependencies are
+specified in standard Ruby syntax.
+
+Rake has the following features:
+
+* Rakefiles (rake's version of Makefiles) are completely defined in
+  standard Ruby syntax.  No XML files to edit.  No quirky Makefile
+  syntax to worry about (is that a tab or a space?)
+
+* Users can specify tasks with prerequisites.
+
+* Rake supports rule patterns to synthesize implicit tasks.
+
+* Flexible FileLists that act like arrays but know about manipulating
+  file names and paths.
+
+* A library of prepackaged tasks to make building rakefiles easier. For example,
+  tasks for building tarballs. (Formerly
+  tasks for building RDoc, Gems, and publishing to FTP were included in rake but they're now
+  available in RDoc, RubyGems, and rake-contrib respectively.)
+
+* Supports parallel execution of tasks.
+
+== Installation
+
+=== Gem Installation
+
+Download and install rake with the following.
+
+  gem install rake
+
+== Usage
+
+=== Simple Example
+
+First, you must write a "Rakefile" file which contains the build rules. Here's
+a simple example:
+
+  task default: %w[test]
+
+  task :test do
+    ruby "test/unittest.rb"
+  end
+
+This Rakefile has two tasks:
+
+* A task named "test", which -- upon invocation -- will run a unit test file
+  in Ruby.
+* A task named "default". This task does nothing by itself, but it has exactly
+  one dependency, namely the "test" task. Invoking the "default" task will
+  cause Rake to invoke the "test" task as well.
+
+Running the "rake" command without any options will cause it to run the
+"default" task in the Rakefile:
+
+  % ls
+  Rakefile     test/
+  % rake
+  (in /home/some_user/Projects/rake)
+  ruby test/unittest.rb
+  ....unit test output here...
+
+Type "rake --help" for all available options.
+
+== Resources
+
+=== Rake Information
+
+* {Rake command-line}[link:doc/command_line_usage.rdoc]
+* {Writing Rakefiles}[link:doc/rakefile.rdoc]
+* The original {Rake announcement}[link:doc/rational.rdoc]
+* Rake {glossary}[link:doc/glossary.rdoc]
+
+=== Presentations and Articles about Rake
+
+* Avdi Grimm's rake series:
+  1. {Rake Basics}[https://avdi.codes/rake-part-1-basics/]
+  2. {Rake File Lists}[https://avdi.codes/rake-part-2-file-lists-2/]
+  3. {Rake Rules}[https://avdi.codes/rake-part-3-rules/]
+  4. {Rake Pathmap}[https://avdi.codes/rake-part-4-pathmap/]
+  5. {File Operations}[https://avdi.codes/rake-part-5-file-operations/]
+  6. {Clean and Clobber}[https://avdi.codes/rake-part-6-clean-and-clobber/]
+  7. {MultiTask}[https://avdi.codes/rake-part-7-multitask/]
+* {Jim Weirich's 2003 RubyConf presentation}[https://web.archive.org/web/20140221123354/http://onestepback.org/articles/buildingwithrake/]
+* Martin Fowler's article on Rake: https://martinfowler.com/articles/rake.html
+
+== Other Make Re-envisionings ...
+
+Rake is a late entry in the make replacement field.  Here are links to
+other projects with similar (and not so similar) goals.
+
+* https://directory.fsf.org/wiki/Bras -- Bras, one of earliest
+  implementations of "make in a scripting language".
+* http://www.a-a-p.org -- Make in Python
+* https://ant.apache.org -- The Ant project
+* https://search.cpan.org/search?query=PerlBuildSystem -- The Perl Build System
+* https://www.rubydoc.info/gems/rant/0.5.7/frames -- Rant, another Ruby make tool.
+
+== Credits
+
+[<b>Jim Weirich</b>] Who originally created Rake.
+
+[<b>Ryan Dlugosz</b>] For the initial conversation that sparked Rake.
+
+[<b>Nobuyoshi Nakada <nobu@ruby-lang.org></b>] For the initial patch for rule support.
+
+[<b>Tilman Sauerbeck <tilman@code-monkey.de></b>] For the recursive rule patch.
+
+[<b>Eric Hodel</b>] For aid in maintaining rake.
+
+[<b>Hiroshi SHIBATA</b>] Maintainer of Rake 10 and later
+
+== License
+
+Rake is available under an MIT-style license.
+
+:include: MIT-LICENSE
+
+---
+
+= Other stuff
+
+Author::   Jim Weirich <jim.weirich@gmail.com>
+Requires:: Ruby 2.0.0 or later
+License::  Copyright Jim Weirich.
+           Released under an MIT-style license.  See the MIT-LICENSE
+           file included in the distribution.
+
+== Warranty
+
+This software is provided "as is" and without any express or implied
+warranties, including, without limitation, the implied warranties of
+merchantability and fitness for a particular purpose.
+
+== Historical
+
+Rake was originally created by Jim Weirich, who unfortunately passed away in
+February 2014. This repository was originally hosted at
+{github.com/jimweirich/rake}[https://github.com/jimweirich/rake/], however
+with his passing, has been moved to {ruby/rake}[https://github.com/ruby/rake].
+
+You can view Jim's last commit here:
+https://github.com/jimweirich/rake/tree/336559f28f55bce418e2ebcc0a57548dcbac4025
+
+You can {read more about Jim}[https://en.wikipedia.org/wiki/Jim_Weirich] at Wikipedia.
+
+Thank you for this great tool, Jim. We'll remember you.

data/vendor/bundle/ruby/3.3.0/gems/rake-13.1.0/doc/command_line_usage.rdoc

@@ -0,0 +1,158 @@
+= 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
+    standard 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 maximum number of concurrent threads allowed. Rake
+    will allocate threads as needed up to this maximum number.
+
+    If omitted, Rake will attempt to estimate the number of CPUs on
+    the system and add 4 to that number.
+
+    The concurrent threads 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)   : Allow up to (# of CPUs + 4) number of threads
+       --jobs    : Allow unlimited number of threads
+       --jobs=1  : Allow only one thread (the main thread)
+       --jobs=16 : Allow up to 16 concurrent threads
+
+[<tt>--job-stats</tt> _level_]
+
+    Display job statistics at the completion of the run. By default,
+    this will display the requested number of active threads (from the
+    -j options) and the maximum number of threads 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 standard 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/vendor/bundle/ruby/3.3.0/gems/rake-13.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/vendor/bundle/ruby/3.3.0/gems/rake-13.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/vendor/bundle/ruby/3.3.0/gems/rake-13.1.0/doc/example/a.c

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

data/vendor/bundle/ruby/3.3.0/gems/rake-13.1.0/doc/example/b.c

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

data/vendor/bundle/ruby/3.3.0/gems/rake-13.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/vendor/bundle/ruby/3.3.0/gems/rake-13.1.0/doc/glossary.rdoc

@@ -0,0 +1,42 @@
+= Glossary
+
+action ::
+  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.)
+
+execute ::
+  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).
+
+file task (Rake::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.
+
+invoke ::
+  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 it has
+  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
+  Rake::Task#needed?.  If the task is needed, we execute its actions.
+
+  NOTE: Prerequisites are still invoked even if the task is not needed.
+
+prerequisites ::
+  Every task has a (possibly empty) set of prerequisites.  A prerequisite P to
+  Task T is itself a task that must be invoked before Task T.
+
+rule ::
+  A rule is a recipe for synthesizing a task when no task is explicitly
+  defined.  Rules generally synthesize file tasks.
+
+task (Rake::Task) ::
+  The basic unit of work in a Rakefile.  A task has a name, a set of 
+  prerequisites, and a list of actions to be performed.