rails-rfc6570 3.1.0 → 3.2.0

data/vendor/bundle/ruby/3.3.0/gems/benchmark-ips-2.13.0/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Evan Phoenix
+
+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/benchmark-ips-2.13.0/README.md

@@ -0,0 +1,279 @@
+# benchmark-ips
+
+* rdoc :: http://rubydoc.info/gems/benchmark-ips
+* home :: https://github.com/evanphx/benchmark-ips
+
+[![Gem Version](https://badge.fury.io/rb/benchmark-ips.svg)](http://badge.fury.io/rb/benchmark-ips)
+[![Build Status](https://secure.travis-ci.org/evanphx/benchmark-ips.svg)](http://travis-ci.org/evanphx/benchmark-ips)
+[![Inline docs](http://inch-ci.org/github/evanphx/benchmark-ips.svg)](http://inch-ci.org/github/evanphx/benchmark-ips)
+
+* https://github.com/evanphx/benchmark-ips
+
+## DESCRIPTION:
+
+An iterations per second enhancement to Benchmark.
+
+## FEATURES/PROBLEMS:
+
+ * benchmark/ips - benchmarks a blocks iterations/second. For short snippits
+   of code, ips automatically figures out how many times to run the code
+   to get interesting data. No more guessing at random iteration counts!
+
+## SYNOPSIS:
+
+```ruby
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  # Configure the number of seconds used during
+  # the warmup phase (default 2) and calculation phase (default 5)
+  x.config(:time => 5, :warmup => 2)
+
+  # These parameters can also be configured this way
+  x.time = 5
+  x.warmup = 2
+
+  # Typical mode, runs the block as many times as it can
+  x.report("addition") { 1 + 2 }
+
+  # To reduce overhead, the number of iterations is passed in
+  # and the block must run the code the specific number of times.
+  # Used for when the workload is very small and any overhead
+  # introduces incorrectable errors.
+  x.report("addition2") do |times|
+    i = 0
+    while i < times
+      1 + 2
+      i += 1
+    end
+  end
+
+  # To reduce overhead even more, grafts the code given into
+  # the loop that performs the iterations internally to reduce
+  # overhead. Typically not needed, use the |times| form instead.
+  x.report("addition3", "1 + 2")
+
+  # Really long labels should be formatted correctly
+  x.report("addition-test-long-label") { 1 + 2 }
+
+  # Compare the iterations per second of the various reports!
+  x.compare!
+end
+```
+
+This will generate the following report:
+
+```
+Calculating -------------------------------------
+            addition    71.254k i/100ms
+           addition2    68.658k i/100ms
+           addition3    83.079k i/100ms
+addition-test-long-label
+                        70.129k i/100ms
+-------------------------------------------------
+            addition     4.955M (± 8.7%) i/s -     24.155M
+           addition2    24.011M (± 9.5%) i/s -    114.246M
+           addition3    23.958M (±10.1%) i/s -    115.064M
+addition-test-long-label
+                         5.014M (± 9.1%) i/s -     24.545M
+
+Comparison:
+           addition2: 24011974.8 i/s
+           addition3: 23958619.8 i/s - 1.00x slower
+addition-test-long-label:  5014756.0 i/s - 4.79x slower
+            addition:  4955278.9 i/s - 4.85x slower
+```
+
+Benchmark/ips will report the number of iterations per second for a given block
+of code. When analyzing the results, notice the percent of [standard
+deviation](http://en.wikipedia.org/wiki/Standard\_deviation) which tells us how
+spread out our measurements are from the average. A high standard deviation
+could indicate the results having too much variability.
+
+One benefit to using this method is benchmark-ips automatically determines the
+data points for testing our code, so we can focus on the results instead of
+guessing iteration counts as we do with the traditional Benchmark library.
+
+### Custom Suite
+
+Pass a custom suite to disable garbage collection during benchmark:
+
+```ruby
+require 'benchmark/ips'
+
+# Enable and start GC before each job run. Disable GC afterwards.
+#
+# Inspired by https://www.omniref.com/ruby/2.2.1/symbols/Benchmark/bm?#annotation=4095926&line=182
+class GCSuite
+  def warming(*)
+    run_gc
+  end
+
+  def running(*)
+    run_gc
+  end
+
+  def warmup_stats(*)
+  end
+
+  def add_report(*)
+  end
+
+  private
+
+  def run_gc
+    GC.enable
+    GC.start
+    GC.disable
+  end
+end
+
+suite = GCSuite.new
+
+Benchmark.ips do |x|
+  x.config(:suite => suite)
+  x.report("job1") { ... }
+  x.report("job2") { ... }
+end
+```
+
+### Independent benchmarking
+
+If you are comparing multiple implementations of a piece of code you may want
+to benchmark them in separate invocations of Ruby so that the measurements
+are independent of each other. You can do this with the `hold!` command.
+
+```ruby
+Benchmark.ips do |x|
+
+  # Hold results between multiple invocations of Ruby
+  x.hold! 'filename'
+
+end
+```
+
+This will run only one benchmarks each time you run the command, storing
+results in the specified file. The file is deleted when all results have been
+gathered and the report is shown.
+
+Alternatively, if you prefer a different approach, the `save!` command is
+available. Examples for [hold!](examples/hold.rb) and [save!](examples/save.rb) are available in
+the `examples/` directory.
+
+
+### Multiple iterations
+
+In some cases you may want to run multiple iterations of the warmup and
+calculation stages and take only the last result for comparison. This is useful
+if you are benchmarking with an implementation of Ruby that optimizes using
+tracing or on-stack-replacement, because to those implementations the
+calculation phase may appear as new, unoptimized code.
+
+You can do this with the `iterations` option, which by default is `1`. The
+total time spent will then be `iterations * warmup + iterations * time` seconds.
+
+```ruby
+Benchmark.ips do |x|
+
+  x.config(:iterations => 3)
+
+    # or
+
+  x.iterations = 3
+
+end
+```
+
+### Online sharing
+
+If you want to quickly share your benchmark result with others, run you benchmark
+with `SHARE=1` argument. For example: `SHARE=1 ruby my_benchmark.rb`.
+
+Result will be sent to [benchmark.fyi](https://ips.fastruby.io/) and benchmark-ips
+will display the link to share the benchmark's result.
+
+If you want to run your own instance of [benchmark.fyi](https://github.com/evanphx/benchmark.fyi)
+and share it to that instance, you can do this: `SHARE_URL=https://ips.example.com ruby my_benchmark.rb`
+
+### Advanced Statistics
+
+By default, the margin of error shown is plus-minus one standard deviation. If
+a more advanced statistical test is wanted, a bootstrap confidence interval
+can be calculated instead. A bootstrap confidence interval has the advantages of
+arguably being more mathematically sound for this application than a standard
+deviation, it additionally produces an error for relative slowdowns, which the
+standard deviation does not, and it is arguably more intuitive and actionable.
+
+When a bootstrap confidence interval is used, a median of the interval is used
+rather than the mean of the samples, which is what you get with the default
+standard deviation.
+
+The bootstrap confidence interval used is the one described by Tomas Kalibera.
+Note that for this technique to be valid your benchmark should have reached a
+non-periodic steady state with statistically independent samples (it should
+have warmed up) by the time measurements start.
+
+Using a bootstrap confidence internal requires that the 'kalibera' gem is
+installed separately. This gem is not a formal dependency, as by default it is
+not needed.
+
+```
+gem install kalibera
+```
+
+```ruby
+Benchmark.ips do |x|
+
+  # The default is :stats => :sd, which doesn't have a configurable confidence
+  x.config(:stats => :bootstrap, :confidence => 95)
+
+    # or
+
+  x.stats = :bootstrap
+  x.confidence = 95
+
+  # confidence is 95% by default, so it can be omitted
+
+end
+```
+
+### Output as JSON
+
+You can generate output in JSON. If you want to write JSON to a file, pass filename to `json!` method:
+
+```ruby
+Benchmark.ips do |x|
+  x.report("some report") {  }
+  x.json! 'filename.json'
+end
+```
+
+If you want to write JSON to STDOUT, pass `STDOUT` to `json!` method and set `quiet = true` before `json!`:
+
+```ruby
+Benchmark.ips do |x|
+  x.report("some report") {  }
+  x.quiet = true
+  x.json! STDOUT
+end
+```
+
+This is useful when the output from `benchmark-ips` becomes an input of other tools via stdin.
+
+## REQUIREMENTS:
+
+* None!
+
+## INSTALL:
+
+    $ gem install benchmark-ips
+
+## DEVELOPERS:
+
+After checking out the source, run:
+
+    $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+

data/vendor/bundle/ruby/3.3.0/gems/bigdecimal-3.1.8/LICENSE

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. 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.

data/vendor/bundle/ruby/3.3.0/gems/bigdecimal-3.1.8/bigdecimal.gemspec

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+name = File.basename(__FILE__, '.*')
+source_version = ["", "ext/#{name}/"].find do |dir|
+  begin
+    break File.foreach(File.join(__dir__, "#{dir}#{name}.c")) {|line|
+      break $1.sub("-", ".") if /^#define\s+#{name.upcase}_VERSION\s+"(.+)"/o =~ line
+    }
+  rescue Errno::ENOENT
+  end
+end or raise "can't find #{name.upcase}_VERSION"
+
+Gem::Specification.new do |s|
+  s.name          = name
+  s.version       = source_version
+  s.authors       = ["Kenta Murata", "Zachary Scott", "Shigeo Kobayashi"]
+  s.email         = ["mrkn@mrkn.jp"]
+
+  s.summary       = "Arbitrary-precision decimal floating-point number library."
+  s.description   = "This library provides arbitrary-precision decimal floating-point number class."
+  s.homepage      = "https://github.com/ruby/bigdecimal"
+  s.licenses       = ["Ruby", "BSD-2-Clause"]
+
+  s.require_paths = %w[lib]
+  s.files         = %w[
+    LICENSE
+    bigdecimal.gemspec
+    lib/bigdecimal.rb
+    lib/bigdecimal/jacobian.rb
+    lib/bigdecimal/ludcmp.rb
+    lib/bigdecimal/math.rb
+    lib/bigdecimal/newton.rb
+    lib/bigdecimal/util.rb
+    sample/linear.rb
+    sample/nlsolve.rb
+    sample/pi.rb
+  ]
+  if Gem::Platform === s.platform and s.platform =~ 'java' or RUBY_ENGINE == 'jruby'
+    s.platform      = 'java'
+  else
+    s.extensions    = %w[ext/bigdecimal/extconf.rb]
+    s.files += %w[
+      ext/bigdecimal/bigdecimal.c
+      ext/bigdecimal/bigdecimal.h
+      ext/bigdecimal/bits.h
+      ext/bigdecimal/feature.h
+      ext/bigdecimal/missing.c
+      ext/bigdecimal/missing.h
+      ext/bigdecimal/missing/dtoa.c
+      ext/bigdecimal/static_assert.h
+    ]
+  end
+
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  s.metadata["changelog_uri"] = s.homepage + "/blob/master/CHANGES.md"
+end

data/vendor/bundle/ruby/3.3.0/gems/builder-3.3.0/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2003-2012 Jim Weirich (jim.weirich@gmail.com)
+
+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/builder-3.3.0/README.md

@@ -0,0 +1,258 @@
+# Project: Builder
+
+## Goal
+
+Provide a simple way to create XML markup and data structures.
+
+## Classes
+
+Builder::XmlMarkup:: Generate XML markup notation
+Builder::XmlEvents:: Generate XML events (i.e. SAX-like)
+
+**Notes:**
+
+* An <tt>Builder::XmlTree</tt> class to generate XML tree
+  (i.e. DOM-like) structures is also planned, but not yet implemented.
+  Also, the events builder is currently lagging the markup builder in
+  features.
+
+## Usage
+
+```ruby
+  require 'rubygems'
+  require_gem 'builder', '~> 2.0'
+
+  builder = Builder::XmlMarkup.new
+  xml = builder.person { |b| b.name("Jim"); b.phone("555-1234") }
+  xml #=> <person><name>Jim</name><phone>555-1234</phone></person>
+```
+
+or
+
+```ruby
+  require 'rubygems'
+  require_gem 'builder'
+
+  builder = Builder::XmlMarkup.new(:target=>STDOUT, :indent=>2)
+  builder.person { |b| b.name("Jim"); b.phone("555-1234") }
+  #
+  # Prints:
+  # <person>
+  #   <name>Jim</name>
+  #   <phone>555-1234</phone>
+  # </person>
+```
+
+## Compatibility
+
+### Version 2.0.0 Compatibility Changes
+
+Version 2.0.0 introduces automatically escaped attribute values for
+the first time.  Versions prior to 2.0.0 did not insert escape
+characters into attribute values in the XML markup.  This allowed
+attribute values to explicitly reference entities, which was
+occasionally used by a small number of developers.  Since strings
+could always be explicitly escaped by hand, this was not a major
+restriction in functionality.
+
+However, it did surprise most users of builder.  Since the body text is
+normally escaped, everybody expected the attribute values to be
+escaped as well.  Escaped attribute values were the number one support
+request on the 1.x Builder series.
+
+Starting with Builder version 2.0.0, all attribute values expressed as
+strings will be processed and the appropriate characters will be
+escaped (e.g. "&" will be translated to "&amp;amp;").  Attribute values
+that are expressed as Symbol values will not be processed for escaped
+characters and will be unchanged in output. (Yes, this probably counts
+as Symbol abuse, but the convention is convenient and flexible).
+
+Example:
+
+```ruby
+  xml = Builder::XmlMarkup.new
+  xml.sample(:escaped=>"This&That", :unescaped=>:"Here&amp;There")
+  xml.target!  =>
+    <sample escaped="This&amp;That" unescaped="Here&amp;There"/>
+```
+
+### Version 1.0.0 Compatibility Changes
+
+Version 1.0.0 introduces some changes that are not backwards
+compatible with earlier releases of builder.  The main areas of
+incompatibility are:
+
+* Keyword based arguments to +new+ (rather than positional based).  It
+  was found that a developer would often like to specify indentation
+  without providing an explicit target, or specify a target without
+  indentation.  Keyword based arguments handle this situation nicely.
+
+* Builder must now be an explicit target for markup tags.  Instead of
+  writing
+
+```ruby
+    xml_markup = Builder::XmlMarkup.new
+    xml_markup.div { strong("text") }
+```
+
+  you need to write
+
+```ruby
+    xml_markup = Builder::XmlMarkup.new
+    xml_markup.div { xml_markup.strong("text") }
+```
+
+* The builder object is passed as a parameter to all nested markup
+  blocks.  This allows you to create a short alias for the builder
+  object that can be used within the block.  For example, the previous
+  example can be written as:
+
+```ruby
+    xml_markup = Builder::XmlMarkup.new
+    xml_markup.div { |xml| xml.strong("text") }
+```
+
+* If you have both a pre-1.0 and a post-1.0 gem of builder installed,
+  you can choose which version to use through the RubyGems
+  +require_gem+ facility.
+
+```ruby
+    require_gem 'builder', "~> 0.0"   # Gets the old version
+    require_gem 'builder', "~> 1.0"   # Gets the new version
+```
+
+## Features
+
+* XML Comments are supported ...
+
+```ruby
+    xml_markup.comment! "This is a comment"
+      #=>  <!-- This is a comment -->
+```
+
+* XML processing instructions are supported ...
+
+```ruby
+    xml_markup.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      #=>  <?xml version="1.0" encoding="UTF-8"?>
+```
+
+  If the processing instruction is omitted, it defaults to "xml".
+  When the processing instruction is "xml", the defaults attributes
+  are:
+
+  <b>version</b>: 1.0
+  <b>encoding</b>: "UTF-8"
+
+  (NOTE: if the encoding is set to "UTF-8" and $KCODE is set to
+  "UTF8", then Builder will emit UTF-8 encoded strings rather than
+  encoding non-ASCII characters as entities.)
+
+* XML entity declarations are now supported to a small degree.
+
+```ruby
+    xml_markup.declare! :DOCTYPE, :chapter, :SYSTEM, "../dtds/chapter.dtd"
+      #=>  <!DOCTYPE chapter SYSTEM "../dtds/chapter.dtd">
+```
+
+  The parameters to a declare! method must be either symbols or
+  strings. Symbols are inserted without quotes, and strings are
+  inserted with double quotes.  Attribute-like arguments in hashes are
+  not allowed.
+
+  If you need to have an argument to declare! be inserted without
+  quotes, but the argument does not conform to the typical Ruby
+  syntax for symbols, then use the :"string" form to specify a symbol.
+
+  For example:
+
+```ruby
+    xml_markup.declare! :ELEMENT, :chapter, :"(title,para+)"
+      #=>  <!ELEMENT chapter (title,para+)>
+```
+
+  Nested entity declarations are allowed.  For example:
+
+```ruby
+    @xml_markup.declare! :DOCTYPE, :chapter do |x|
+      x.declare! :ELEMENT, :chapter, :"(title,para+)"
+      x.declare! :ELEMENT, :title, :"(#PCDATA)"
+      x.declare! :ELEMENT, :para, :"(#PCDATA)"
+    end
+
+    #=>
+
+    <!DOCTYPE chapter [
+      <!ELEMENT chapter (title,para+)>
+      <!ELEMENT title (#PCDATA)>
+      <!ELEMENT para (#PCDATA)>
+    ]>
+```
+
+* Some support for XML namespaces is now available.  If the first
+  argument to a tag call is a symbol, it will be joined to the tag to
+  produce a namespace:tag combination.  It is easier to show this than
+  describe it.
+
+```ruby
+   xml.SOAP :Envelope do ... end
+```
+
+  Just put a space before the colon in a namespace to produce the
+  right form for builder (e.g. "<tt>SOAP:Envelope</tt>" =>
+  "<tt>xml.SOAP :Envelope</tt>")
+
+* String attribute values are <em>now</em> escaped by default by
+  Builder (<b>NOTE:</b> this is _new_ behavior as of version 2.0).
+
+  However, occasionally you need to use entities in attribute values.
+  Using a symbol (rather than a string) for an attribute value will
+  cause Builder to not run its quoting/escaping algorithm on that
+  particular value.
+
+  (<b>Note:</b> The +escape_attrs+ option for builder is now
+  obsolete).
+
+  Example:
+
+```ruby
+    xml = Builder::XmlMarkup.new
+    xml.sample(:escaped=>"This&That", :unescaped=>:"Here&amp;There")
+    xml.target!  =>
+      <sample escaped="This&amp;That" unescaped="Here&amp;There"/>
+```
+
+* UTF-8 Support
+
+  Builder correctly translates UTF-8 characters into valid XML.  (New
+  in version 2.0.0).  Thanks to Sam Ruby for the translation code.
+
+  You can get UTF-8 encoded output by making sure that the XML
+  encoding is set to "UTF-8" and that the $KCODE variable is set to
+  "UTF8".
+
+```ruby
+    $KCODE = 'UTF8'
+    xml = Builder::Markup.new
+    xml.instruct!(:xml, :encoding => "UTF-8")
+    xml.sample("Iñtërnâtiônàl")
+    xml.target!  =>
+      "<sample>Iñtërnâtiônàl</sample>"
+```
+
+## Links
+
+| Description | Link |
+| :----: | :----: |
+| Documents           | http://builder.rubyforge.org/ |
+| Github Clone        | git://github.com/rails/builder.git |
+| Issue / Bug Reports | https://github.com/rails/builder/issues?state=open |
+
+## Contact
+
+| Description | Value                  |
+| :----:      | :----:                 |
+| Author      | Jim Weirich            |
+| Email       | jim.weirich@gmail.com  |
+| Home Page   | http://onestepback.org |
+| License     | MIT Licence (http://www.opensource.org/licenses/mit-license.html) |