rails-rfc6570 3.1.0 → 3.2.0

data/vendor/bundle/ruby/3.3.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.3.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.3.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.3.0/gems/docile-1.4.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2024 Marc Siegel
+
+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.