rails-rfc6570 3.3.0 → 3.4.0

data/vendor/bundle/ruby/3.4.0/gems/crass-1.0.6/README.md

@@ -0,0 +1,192 @@
+Crass
+=====
+
+Crass is a Ruby CSS parser that's fully compliant with the
+[CSS Syntax Level 3][css] specification.
+
+* [Home](https://github.com/rgrove/crass/)
+* [API Docs](http://rubydoc.info/github/rgrove/crass/master)
+
+[![Build Status](https://travis-ci.org/rgrove/crass.svg?branch=master)](https://travis-ci.org/rgrove/crass)
+[![Gem Version](https://badge.fury.io/rb/crass.svg)](http://badge.fury.io/rb/crass)
+
+Features
+--------
+
+* Pure Ruby, with no runtime dependencies other than Ruby 1.9.x or higher.
+
+* Tokenizes and parses CSS according to the rules defined in the 14 November
+  2014 editor's draft of the [CSS Syntax Level 3][css] specification.
+
+* Extremely tolerant of broken or invalid CSS. If a browser can handle it, Crass
+  should be able to handle it too.
+
+* Optionally includes comments in the token stream.
+
+* Optionally preserves certain CSS hacks, such as the IE "*" hack, which would
+  otherwise be discarded according to CSS3 tokenizing rules.
+
+* Capable of serializing the parse tree back to CSS while maintaining all
+  original whitespace, comments, and indentation.
+
+[css]: http://dev.w3.org/csswg/css-syntax/
+
+Problems
+--------
+
+* Crass isn't terribly fast. I mean, it's Ruby, and it's not really slow by Ruby
+  standards. But compared to the CSS parser in your average browser? Yeah, it's
+  slow.
+
+* Crass only parses the CSS syntax; it doesn't understand what any of it means,
+  doesn't coalesce selectors, etc. You can do this yourself by consuming the
+  parse tree, though.
+
+* While any node in the parse tree (or the parse tree as a whole) can be
+  serialized back to CSS with perfect fidelity, changes made to those nodes
+  (except for wholesale removal of nodes) are not reflected in the serialized
+  output.
+
+* Crass only supports UTF-8 input and doesn't respect `@charset` rules. Input in
+  any other encoding will be converted to UTF-8.
+
+Installing
+----------
+
+```
+gem install crass
+```
+
+Examples
+--------
+
+Say you have a string containing some CSS:
+
+```css
+/* Comment! */
+a:hover {
+  color: #0d8bfa;
+  text-decoration: underline;
+}
+```
+
+Parsing it is simple:
+
+```ruby
+tree = Crass.parse(css, :preserve_comments => true)
+```
+
+This returns a big fat beautiful parse tree, which looks like this:
+
+```ruby
+[{:node=>:comment, :pos=>0, :raw=>"/* Comment! */", :value=>" Comment! "},
+ {:node=>:whitespace, :pos=>14, :raw=>"\n"},
+ {:node=>:style_rule,
+  :selector=>
+   {:node=>:selector,
+    :value=>"a:hover",
+    :tokens=>
+     [{:node=>:ident, :pos=>15, :raw=>"a", :value=>"a"},
+      {:node=>:colon, :pos=>16, :raw=>":"},
+      {:node=>:ident, :pos=>17, :raw=>"hover", :value=>"hover"},
+      {:node=>:whitespace, :pos=>22, :raw=>" "}]},
+  :children=>
+   [{:node=>:whitespace, :pos=>24, :raw=>"\n  "},
+    {:node=>:property,
+     :name=>"color",
+     :value=>"#0d8bfa",
+     :children=>
+      [{:node=>:whitespace, :pos=>33, :raw=>" "},
+       {:node=>:hash,
+        :pos=>34,
+        :raw=>"#0d8bfa",
+        :type=>:unrestricted,
+        :value=>"0d8bfa"}],
+     :important=>false,
+     :tokens=>
+      [{:node=>:ident, :pos=>27, :raw=>"color", :value=>"color"},
+       {:node=>:colon, :pos=>32, :raw=>":"},
+       {:node=>:whitespace, :pos=>33, :raw=>" "},
+       {:node=>:hash,
+        :pos=>34,
+        :raw=>"#0d8bfa",
+        :type=>:unrestricted,
+        :value=>"0d8bfa"}]},
+    {:node=>:semicolon, :pos=>41, :raw=>";"},
+    {:node=>:whitespace, :pos=>42, :raw=>"\n  "},
+    {:node=>:property,
+     :name=>"text-decoration",
+     :value=>"underline",
+     :children=>
+      [{:node=>:whitespace, :pos=>61, :raw=>" "},
+       {:node=>:ident, :pos=>62, :raw=>"underline", :value=>"underline"}],
+     :important=>false,
+     :tokens=>
+      [{:node=>:ident,
+        :pos=>45,
+        :raw=>"text-decoration",
+        :value=>"text-decoration"},
+       {:node=>:colon, :pos=>60, :raw=>":"},
+       {:node=>:whitespace, :pos=>61, :raw=>" "},
+       {:node=>:ident, :pos=>62, :raw=>"underline", :value=>"underline"}]},
+    {:node=>:semicolon, :pos=>71, :raw=>";"},
+    {:node=>:whitespace, :pos=>72, :raw=>"\n"}]}]
+```
+
+If you want, you can stringify the parse tree:
+
+```ruby
+css = Crass::Parser.stringify(tree)
+```
+
+...which gives you back exactly what you put in!
+
+```css
+/* Comment! */
+a:hover {
+  color: #0d8bfa;
+  text-decoration: underline;
+}
+```
+
+Wasn't that exciting?
+
+A Note on Versioning
+--------------------
+
+As of version 1.0.0, Crass adheres strictly to [SemVer 2.0][semver].
+
+[semver]:http://semver.org/spec/v2.0.0.html
+
+Contributing
+------------
+
+The best way to contribute is to use Crass and [create issues][issue] when you
+run into problems.
+
+Pull requests that fix bugs are more than welcome as long as they include tests.
+Please adhere to the style and format of the surrounding code, or I might ask
+you to change things.
+
+If you want to add a feature or refactor something, please get in touch first to
+make sure I'm on board with your idea and approach; I'm pretty picky, and I'd
+hate to have to turn down a pull request you spent a lot of time on.
+
+[issue]: https://github.com/rgrove/crass/issues/new
+
+Acknowledgments
+---------------
+
+I'm deeply, deeply grateful to [Simon Sapin][simon] for his wonderfully
+comprehensive [CSS parsing tests][css-tests], which I adapted to create many of
+Crass's tests. They've been invaluable in helping me fix bugs and handle weird
+edge cases, and Crass would be much crappier without them.
+
+I'm also grateful to [Tab Atkins Jr.][tab] and Simon Sapin (again!) for their
+work on the [CSS Syntax Level 3][spec] specification, which defines the
+tokenizing and parsing rules that Crass implements.
+
+[css-tests]:https://github.com/SimonSapin/css-parsing-tests/
+[simon]:http://exyr.org/about/
+[spec]:http://www.w3.org/TR/css-syntax-3/
+[tab]:http://www.xanthir.com/contact/

data/vendor/bundle/ruby/3.4.0/gems/crass-1.0.6/crass.gemspec

@@ -0,0 +1,31 @@
+# encoding: utf-8
+require './lib/crass/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'crass'
+  s.summary     = 'CSS parser based on the CSS Syntax Level 3 spec.'
+  s.description = 'Crass is a pure Ruby CSS parser based on the CSS Syntax Level 3 spec.'
+  s.version     = Crass::VERSION
+  s.authors     = ['Ryan Grove']
+  s.email       = ['ryan@wonko.com']
+  s.homepage    = 'https://github.com/rgrove/crass/'
+  s.license     = 'MIT'
+
+  s.metadata = {
+    'bug_tracker_uri'   => 'https://github.com/rgrove/crass/issues',
+    'changelog_uri'     => "https://github.com/rgrove/crass/blob/v#{s.version}/HISTORY.md",
+    'documentation_uri' => "https://www.rubydoc.info/gems/crass/#{s.version}",
+    'source_code_uri'   => "https://github.com/rgrove/crass/tree/v#{s.version}",
+  }
+
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = Gem::Requirement.new('>= 1.9.2')
+
+  s.require_paths = ['lib']
+
+  s.files = `git ls-files -z`.split("\x0").grep_v(%r{^test/})
+
+  # Development dependencies.
+  s.add_development_dependency 'minitest', '~> 5.0.8'
+  s.add_development_dependency 'rake',     '~> 10.1.0'
+end

data/vendor/bundle/ruby/3.4.0/gems/diff-lcs-1.5.1/README.rdoc

@@ -0,0 +1,84 @@
+= Diff::LCS
+
+home :: https://github.com/halostatue/diff-lcs
+code :: https://github.com/halostatue/diff-lcs
+bugs :: https://github.com/halostatue/diff-lcs/issues
+rdoc :: http://rubydoc.info/github/halostatue/diff-lcs
+continuous integration :: {<img src="https://github.com/halostatue/diff-lcs/workflows/CI/badge.svg" />}[https://github.com/halostatue/diff-lcs/actions]
+
+== Description
+
+Diff::LCS computes the difference between two Enumerable sequences using the
+McIlroy-Hunt longest common subsequence (LCS) algorithm. It includes utilities
+to create a simple HTML diff output format and a standard diff-like tool.
+
+This is release 1.4.3, providing a simple extension that allows for
+Diff::LCS::Change objects to be treated implicitly as arrays and fixes a
+number of formatting issues.
+
+Ruby versions below 2.5 are soft-deprecated, which means that older versions
+are no longer part of the CI test suite. If any changes have been introduced
+that break those versions, bug reports and patches will be accepted, but it
+will be up to the reporter to verify any fixes prior to release. The next
+major release will completely break compatibility.
+
+== Synopsis
+
+Using this module is quite simple. By default, Diff::LCS does not extend
+objects with the Diff::LCS interface, but will be called as if it were a
+function:
+
+  require 'diff/lcs'
+
+  seq1 = %w(a b c e h j l m n p)
+  seq2 = %w(b c d e f j k l m r s t)
+
+  lcs = Diff::LCS.LCS(seq1, seq2)
+  diffs = Diff::LCS.diff(seq1, seq2)
+  sdiff = Diff::LCS.sdiff(seq1, seq2)
+  seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
+  bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
+  seq2 == Diff::LCS.patch!(seq1, diffs)
+  seq1 == Diff::LCS.unpatch!(seq2, diffs)
+  seq2 == Diff::LCS.patch!(seq1, sdiff)
+  seq1 == Diff::LCS.unpatch!(seq2, sdiff)
+
+Objects can be extended with Diff::LCS:
+
+  seq1.extend(Diff::LCS)
+  lcs = seq1.lcs(seq2)
+  diffs = seq1.diff(seq2)
+  sdiff = seq1.sdiff(seq2)
+  seq = seq1.traverse_sequences(seq2, callback_obj)
+  bal = seq1.traverse_balanced(seq2, callback_obj)
+  seq2 == seq1.patch!(diffs)
+  seq1 == seq2.unpatch!(diffs)
+  seq2 == seq1.patch!(sdiff)
+  seq1 == seq2.unpatch!(sdiff)
+
+By requiring 'diff/lcs/array' or 'diff/lcs/string', Array or String will be
+extended for use this way.
+
+Note that Diff::LCS requires a sequenced enumerable container, which means that
+the order of enumeration is both predictable and consistent for the same set of
+data. While it is theoretically possible to generate a diff for an unordered
+hash, it will only be meaningful if the enumeration of the hashes is
+consistent. In general, this will mean that containers that behave like String
+or Array will perform best.
+
+== History
+
+Diff::LCS is a port of Perl's Algorithm::Diff that uses the McIlroy-Hunt
+longest common subsequence (LCS) algorithm to compute intelligent differences
+between two sequenced enumerable containers. The implementation is based on
+Mario I. Wolczko's
+{Smalltalk version 1.2}[ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st]
+(1993) and Ned Konz's Perl version
+{Algorithm::Diff 1.15}[http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/].
+Diff::LCS#sdiff and Diff::LCS#traverse_balanced were originally written for the
+Perl version by Mike Schilli.
+
+The algorithm is described in <em>A Fast Algorithm for Computing Longest Common
+Subsequences</em>, CACM, vol.20, no.5, pp.350-353, May 1977, with a few minor
+improvements to improve the speed. A simplified description of the algorithm,
+originally written for the Perl version, was written by Mark-Jason Dominus.

data/vendor/bundle/ruby/3.4.0/gems/drb-2.2.1/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/bundle/ruby/3.4.0/gems/drb-2.2.1/drb.gemspec

@@ -0,0 +1,41 @@
+begin
+  require_relative "lib/drb/version"
+rescue LoadError # Fallback to load version file in ruby core repository
+  require_relative "version"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "drb"
+  spec.version       = DRb::VERSION
+  spec.authors       = ["Masatoshi SEKI"]
+  spec.email         = ["seki@ruby-lang.org"]
+
+  spec.summary       = %q{Distributed object system for Ruby}
+  spec.description   = %q{Distributed object system for Ruby}
+  spec.homepage      = "https://github.com/ruby/drb"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files         = %w[
+    LICENSE.txt
+    drb.gemspec
+    lib/drb.rb
+    lib/drb/acl.rb
+    lib/drb/drb.rb
+    lib/drb/eq.rb
+    lib/drb/extserv.rb
+    lib/drb/extservm.rb
+    lib/drb/gw.rb
+    lib/drb/invokemethod.rb
+    lib/drb/observer.rb
+    lib/drb/ssl.rb
+    lib/drb/timeridconv.rb
+    lib/drb/unix.rb
+    lib/drb/version.rb
+    lib/drb/weakidconv.rb
+  ]
+  spec.require_paths = ["lib"]
+end

data/vendor/bundle/ruby/3.4.0/gems/erubi-1.13.1/CHANGELOG

@@ -0,0 +1,111 @@
+=== 1.13.1 (2024-12-19)
+
+* Avoid spurious frozen string literal warnings for chilled strings when using Ruby 3.4 (jeremyevans)
+
+=== 1.13.0 (2024-06-13)
+
+* Define Erubi.h as a module function (jeremyevans)
+
+* Add erubi/capture_block, supporting capturing block output via standard <%= and <%== tags (jeremyevans)
+
+=== 1.12.0 (2022-12-22)
+
+* Use erb/escape for faster html escaping if available (jeremyevans)
+
+* Default :freeze_template_literals option to false if running with --enable-frozen-string-literal (casperisfine) (#35)
+
+=== 1.11.0 (2022-08-02)
+
+* Support :freeze_template_literals option for configuring whether to add .freeze to template literal strings (casperisfine) (#33)
+
+* Support :chain_appends option for chaining appends to the buffer variable (casperisfine, jeremyevans) (#32)
+
+* Avoid unnecessary defined? usage on Ruby 3+ when using the :ensure option (jeremyevans)
+
+=== 1.10.0 (2020-11-13)
+
+* Improve template parsing, mostly by reducing allocations (jeremyevans)
+
+* Do not ship tests in the gem, reducing gem size about 20% (jeremyevans)
+
+* Support :literal_prefix and :literal_postfix options for how to output literal tags (e.g. <%% code %>) (jaredcwhite) (#26, #27)
+
+=== 1.9.0 (2019-09-25)
+
+* Change default :bufvar from 'String.new' to '::String.new' to work with BasicObject (jeremyevans)
+
+=== 1.8.0 (2018-12-18)
+
+* Support :yield_returns_buffer option in capture_end for always returning the (potentially modified) buffer in <%|= tags (evanleck) (#15)
+
+=== 1.7.1 (2018-03-05)
+
+* Make whitespace handling for <%# %> tags more compatible with Erubis (jeremyevans) (#14)
+
+=== 1.7.0 (2017-10-09)
+
+* Fix escaping in erubi/capture_end, the setting was previously inverted (jeremyevans) (#10)
+
+=== 1.6.1 (2017-06-27)
+
+* Fix usage on newer versions of JRuby 9.1 (jeremyevans)
+
+=== 1.6.0 (2017-02-27)
+
+* Use cgi/escape if available for 6x faster HTML escaping (k0kubun, jeremyevans) (#4)
+
+=== 1.5.0 (2017-01-26)
+
+* Drop tilt/erubi file, as tilt now ships with Erubi support (jeremyevans)
+
+* Drop erubi/capture file, Erubi::CaptureEngine support (jeremyevans)
+
+=== 1.4.0 (2017-01-20)
+
+* Allow postambles to depend on internal state of engine (jeremyevans)
+
+* Allow overriding of behavior for <%= and <%== tags to depend on which indicator was used (jeremyevans)
+
+* Make whitespace handling for <% %> tags more compatible with Erubis for subclasses overriding add_text (jeremyevans)
+
+=== 1.3.0 (2016-12-29)
+
+* Support :capture=>:explicit option in tilt support to use Erubi::CaptureEndEngine (jeremyevans)
+
+* Add erubi/capture_end containing Erubi::CaptureEndEngine, allowing <%|= and <%|== for opening capture tags, and <%| for closing capture tags (jeremyevans)
+
+=== 1.2.1 (2016-11-21)
+
+* Don't automatically freeze template text strings on ruby 1.9 or 2.0 (jeremyevans)
+
+=== 1.2.0 (2016-11-21)
+
+* Engine#src now returns a frozen string (jeremyevans)
+
+* Automatically freeze template text strings on ruby 2.1+, reducing garbage generated (jeremyevans)
+
+* Allow overriding of behavior for <%= and <%== tags (ujifgc) (#1)
+
+=== 1.1.0 (2016-11-14)
+
+* Add :ensure option to supporting restoring bufvar to original value (jeremyevans)
+
+* Don't have tilt support require erb (jeremyevans)
+
+* Support :engine_class option in tilt support to override engine class used (jeremyevans)
+
+* Support :capture option in tilt support to use Erubi::CaptureEngine (jeremyevans)
+
+* Add erubi/capture file containing Erubi::CaptureEngine, allowing <%|= and <%|== for capture (and escaping) blocks in templates (jeremyevans)
+
+* Raise ArgumentError if template source code contains indicators matched by regexp but not handled (jeremyevans)
+
+* Add :bufval option to support arbitrary buffer values (jeremyevans)
+
+* Add :regexp option to specify regexp used for scanning (jeremyevans)
+
+* Add :src option to specify initial template source (jeremyevans)
+
+=== 1.0.0 (2016-11-10)
+
+* Initial Public Release

data/vendor/bundle/ruby/3.4.0/gems/erubi-1.13.1/MIT-LICENSE

@@ -0,0 +1,21 @@
+copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
+copyright(c) 2016-2021 Jeremy Evans
+
+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.4.0/gems/erubi-1.13.1/README.rdoc

@@ -0,0 +1,151 @@
+= Erubi
+
+Erubi is a ERB template engine for ruby. It is a simplified fork of Erubis, using
+the same basic algorithm, with the following differences:
+
+* Handles postfix conditionals when using escaping (e.g. <tt><%= foo if bar %></tt>)
+* Supports frozen_string_literal: true in templates via :freeze option
+* Works with ruby's <tt>--enable-frozen-string-literal</tt> option
+* Automatically freezes strings for template text when ruby optimizes it (on ruby 2.1+)
+* Escapes <tt>'</tt> (apostrophe) when escaping for better XSS protection 
+* Has 15x-6x faster escaping by using erb/escape or cgi/escape
+* Has 81% smaller memory footprint (calculated using +ObjectSpace.memsize_of_all+)
+* Does no monkey patching (Erubis adds a method to Kernel)
+* Uses an immutable design (all options passed to the constructor, which returns a frozen object)
+* Has simpler internals (1 file, <150 lines of code)
+* Is not dead (Erubis hasn't been updated since 2011)
+
+It is not designed with Erubis API compatibility in mind, though most Erubis
+ERB syntax works, with the following exceptions:
+
+* No support for <tt><%===</tt> for debug output
+
+= Installation
+
+  gem install erubi
+
+= Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/erubi
+
+= Usage
+
+Erubi only has built in support for retrieving the generated source for a
+file:
+
+  require 'erubi'
+  eval(Erubi::Engine.new(File.read('filename.erb')).src)
+
+Most users will probably use Erubi via Rails or Tilt.  Erubi is the default
+erb template handler in Tilt 2.0.6+ and Rails 5.1+.
+
+== Capturing
+
+Erubi does not support capturing block output into the template by default.
+It currently ships with two implementations that allow it.
+
+=== Erubi::CaptureBlockEngine
+
+The recommended implementation can be required via +erubi/capture_block+,
+which allows capturing to work with normal <tt><%=</tt> and <tt><%==</tt>
+tags.
+
+  <%= form do %>
+    <input>
+  <% end %>
+
+When using the capture_block support, capture methods should just return
+the text it emit into the template, and call +capture+ on the buffer value.
+Since the buffer variable is a local variable and not an instance variable
+by default, you'll probably want to set the +:bufvar+ variable when using
+the capture_block support to an instance variable, and have any methods
+used call capture on that instance variable.  Example:
+
+  def form(&block)
+    "<form>#{@_buf.capture(&block)}</form>"
+  end
+
+  puts eval(Erubi::CaptureBlockEngine.new(<<-END, bufvar: '@_buf', trim: false).src)
+  before
+  <%= form do %>
+  inside
+  <% end %>
+  after
+  END
+
+  # Output:
+  # before
+  # <form>
+  # inside
+  # </form>
+  # after
+
+To use the capture_block support with tilt:
+
+  require 'tilt'
+  require 'erubi/capture_block'
+  Tilt.new("filename.erb", :engine_class=>Erubi::CaptureBlockEngine).render
+
+Note that the capture_block support, while very compatible with the default
+support, is not 100% compatible.  One area where behavior differs is when
+using multiple statements inside <tt><%=</tt> and <tt><%==</tt> tags:
+
+  <%= 1; 2 %>
+
+The default support will output 2, but the capture_block support will output
+1.
+
+=== Erubi::CaptureEndEngine
+
+An alternative capture implementation can be required via +erubi/capture_end+,
+which supports it via <tt><%|=</tt> and <tt><%|==</tt> tags which are
+closed with a <tt><%|</tt> tag:
+
+  <%|= form do %>
+    <input>
+  <%| end %>
+
+It is only recommended to use +erubi/capture_end+ for backwards
+compatibilty.
+
+When using the capture_end support, capture methods (such as +form+ in the example
+above) should return the (potentially modified) buffer. Similar to the
+capture_block support, using an instance variable is recommended. Example:
+
+  def form
+    @_buf << "<form>"
+    yield
+    @_buf << "</form>"
+    @_buf
+  end
+
+  puts eval(Erubi::CaptureEndEngine.new(<<-END, bufvar: '@_buf').src)
+  before
+  <%|= form do %>
+  inside
+  <%| end %>
+  after
+  END
+
+  # Output:
+  # before
+  # <form>
+  # inside
+  # </form>
+  # after
+
+Alternatively, passing the option <tt>:yield_returns_buffer => true</tt> will return the
+buffer captured by the block instead of the last expression in the block.
+
+= Reporting Bugs
+
+The bug tracker is located at https://github.com/jeremyevans/erubi/issues
+
+= License
+
+MIT
+
+= Authors
+
+Jeremy Evans <code@jeremyevans.net>
+kuwata-lab.com

data/vendor/bundle/ruby/3.4.0/gems/i18n-1.14.7/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 The Ruby I18n team
+
+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.