Log message:
devel/ruby-regexp_parser: update to 2.9.0

2.9.0 (2024-01-07)

Added

* all expressions now respond to #negative? / #negated?

    - previously only sets, props, and posix classes did

* implemented #negative? / #negated? for more applicable expressions

    - \B, \D, \H, \S, \W, (?!...), (?<!...)

Fixed

* fixed missing support for grapheme cluster break unicode properties

    - e.g. /\p{Grapheme_Cluster_Break=Extend}/

Log message:
devel/ruby-regexp_parser: update to 2.8.3

2.8.3 (2023-12-04)

Fixed

* fixed scanner errors for insignificant leading zeros in numerical group
  refs
  - e.g. (a)\k<01>, (a)\g<-01>, (a)?(?(01)b|c)
  - thanks to Markus Schirp for the report

Log message:
devel/ruby-regexp_parser: update to 2.8.2

2.8.2 (2023-10-10)

Fixed

* handle a corner case where parsing redundant number escapes raised an error

   - e.g. parse(/\99/), which in Ruby is a valid Regexp that matches 99
   - thanks to Markus Schirp for the report

Log message:
devel/ruby-regexp_parser: update to 2.8.1

2.8.1] (2023-06-10)

Fixed

* support for extpict unicode property, added in Ruby 2.6
* support for 10 unicode script/block properties added in Ruby 3.2

Log message:
devel/ruby-regexp_parser: update to 2.8.0

2.8.0 (2023-04-17)

Added

o Regexp::Expression::Shared#ends_at
  * e.g. parse(/a +/x)[0].ends_at # => 3
  * e.g. parse(/a +/x)[0].ends_at(include_quantifier = false) # => 1
o Regexp::Expression::Shared#{capturing?,comment?}
  * previously only available on capturing and comment groups
o Regexp::Expression::Shared#{decorative?}
  * true for decorations: comment groups as well as comments and whitespace
    in x-mode
o Regexp::Expression::Shared#parent
o new format argument :original for Regexp::Expression::Base#to_s
  * includes decorative elements between node and its quantifier
  * e.g. parse(/a (?#comment) +/x)[0].to_s(:original) # => "a \ 
(?#comment) +"
  * using it is not needed when calling Root#to_s as Root can't be
    quantified

o support calling Subexpression#{each_expression,flat_map} with a
  one-argument block
  * in this case, only the expressions are passed to the block, no indices
o support calling test methods at Expression class level
  * capturing?, comment?, decorative?, referential?, terminal?
  * e.g. Regexp::Expression::CharacterSet.terminal? # => false

Fixed

o Regexp::Expression::Shared#full_length with whitespace before quantifier
  * e.g. parse(/a +/x)[0].full_length used to yield 2, now it yields 3
o Subexpression#to_s output with children with whitespace before their
  quantifier
  * e.g. parse(/a + /x).to_s used to yield "a+  ", now it yields \ 
"a + "
  * calling #to_s on sub-nodes still omits such decorative interludes by
    default
      - use new #to_s format :original to include it
      - e.g. parse(/a + /x)[0].to_s(:original) # => "a +"
o fixed Subexpression#te behaving differently from other expressions
  * only Subexpression#te used to include the quantifier
  * now #te is the end index without quantifier, as for other expressions
o fixed NoMethodError when calling #starts_at or #ts on empty sequences
  * e.g. Regexp::Parser.parse(/|/)[0].starts_at
  * e.g. Regexp::Parser.parse(/[&&]/)[0][0].starts_at
o fixed nested comment groups breaking local x-options
  * e.g. in /(?x:(?#hello)) /, the x-option wrongly applied to the
    whitespace
o fixed nested comment groups breaking conditionals
  * e.g. in /(a)(?(1)b|c(?#hello)d)e/, the 2nd conditional branch included
    "e"
o fixed quantifiers after comment groups being mis-assigned to that group
  * e.g. in /a(?#foo){3}/ (matches 'aaa')
o fixed Scanner accepting two cases of invalid Regexp syntax
  * unmatched closing parentheses ()) and k-backrefs with number 0 (\k<0>)
  * these are a SyntaxError in Ruby, so could only be passed as a String
  * they now raise a Regexp::Scanner::ScannerError
o fixed some scanner errors not inheriting from
  Regexp::Scanner::ScannerError
o reduced verbosity of inspect / pretty print output

Log message:
devel/ruby-regexp_parser: update to 2.7.0

2.7.0 (2023-02-08)

Added

* Regexp::Lexer.lex now streams tokens when called with a block
  - it can now take arbitrarily large input, just like Regexp::Scanner
  - this also slightly improves Regexp::Parser.parse performance
  - note: Regexp::Parser.parse still does not and will not support streaming
* improved performance of Subexpression#each_expression
* minor improvements to Regexp::Scanner performance
* overall improvement of parse performance: about 10% for large Regexps

Fixed

* parsing of octal escape sequences in sets, e.g. [\141]
  - thanks to Randy Stauner for the report

Log message:
devel/ruby-regexp_parser: update to 2.6.2

2.6.2 (2023-01-19)

Fixed

* fixed SystemStackError when cloning recursive subexpression calls

	- e.g. Regexp::Parser.parse(/a|b\g<0>/).dup

Log message:
devel/ruby-regexp_parser: update to 2.6.1

2.6.1 (2022-11-16)

Fixed

* fixed scanning of two negative lookbehind edge cases

	o (?<!x)y> used to raise a ScannerError
	o (?<!x>)y used to be misinterpreted as a named group
	o thanks to Sergio Medina for the report

Log message:
devel/ruby-regexp_parser: update to 2.6.0

2.6.0 (2022-09-26)

Fixed

* fixed #referenced_expression for \g<0> (was nil, is now the Root exp)

* fixed #reference, #referenced_expression for recursion level backrefs

	- e.g. (a)(b)\k<-1+1>
	- #referenced_expression was nil, now it is the correct Group exp

* detect and raise for two more syntax errors when parsing String input

	- quantification of option switches (e.g. (?i)+)
	- invalid references (e.g. /\k<1>/)
	- these are a SyntaxError in Ruby, so could only be passed as a
          String

Added

* Regexp::Expression::Base#human_name

	- returns a nice, human-readable description of the expression

* Regexp::Expression::Base#optional?

	- returns true if the expression is quantified accordingly
          (e.g. with *, {,n})

* added a deprecation warning when calling #to_re on set members

Log message:
devel/ruby-regexp_parser: update to 2.5.0

[2.5.0] - 2022-05-27 - Janosch Müller

Added
* Regexp::Expression::Base.construct and .token_class methods
  o see the wiki for details

[2.4.0] - 2022-05-09 - Janosch Müller

Fixed
* fixed interpretation of + and ? after interval quantifiers ({n,n})
  - they used to be treated as reluctant or possessive mode indicators
  - however, Ruby does not support these modes for interval quantifiers
  - they are now treated as chained quantifiers instead, as Ruby does it
  - c.f. #3
* fixed Expression::Base#nesting_level for some tree rewrite cases
  - e.g. the alternatives in /a|[b]/ had an inconsistent nesting_level
* fixed Scanner accepting invalid posix classes, e.g. [[:foo:]]
  - they raise a SyntaxError when used in a Regexp, so could only be
    passed as String
  - they now raise a Regexp::Scanner::ValidationError in the Scanner

Added
* added Expression::Base#== for (deep) comparison of expressions
* added Expression::Base#parts
  - returns the text elements and subexpressions of an expression
  - e.g. parse(/(a)/)[0].parts # => ["(", #<Literal \ 
@text="a"...>, ")"]
* added Expression::Base#te (a.k.a. token end index)
  - Expression::Subexpression always had #te, only terminal nodes
    lacked it so far

* made some Expression::Base methods available on Quantifier instances, too
  - #type, #type?, #is?, #one_of?, #options, #terminal?
  - #base_length, #full_length, #starts_at, #te, #ts, #offset
  - #conditional_level, #level, #nesting_level , #set_level
  - this allows a more unified handling with Expression::Base instances

* allowed Quantifier#initialize to take a token and options Hash like
  other nodes

* added a deprecation warning for initializing Quantifiers with 4+ arguments:

  Calling Expression::Base#quantify or Quantifier.new with 4+
  arguments is deprecated.

  It will no longer be supported in regexp_parser v3.0.0.

  Please pass a Regexp::Token instead, e.g. replace token, text, min,
  max, mode with ::Regexp::Token.new(:quantifier, token, text).  min,
  max, and mode will be derived automatically.

  Or do exp.quantifier = Quantifier.construct(token: token, text: str).

  This is consistent with how Expression::Base instances are created.

[2.3.1] - 2022-04-24 - Janosch Müller

Fixed
* removed five inexistent unicode properties from Syntax#features
  - these were never supported by Ruby or the Regexp::Scanner
  - thanks to Markus Schirp for the report

[2.3.0] - 2022-04-08 - Janosch Müller

Added

* improved parsing performance through Syntax refactoring
  - instead of fresh Syntax instances, pre-loaded constants are now re-used
  - this approximately doubles the parsing speed for simple regexps
* added methods to Syntax classes to show relative feature sets
  - e.g. Regexp::Syntax::V3_2_0.added_features

* support for new unicode properties of Ruby 3.2 / Unicode 14.0