Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:Factory:Rebuild
rubygem-regexp_parser
rubygem-regexp_parser.changes
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File rubygem-regexp_parser.changes of Package rubygem-regexp_parser
------------------------------------------------------------------- Mon Jan 29 14:27:55 UTC 2024 - Dan Čermák <dan.cermak@posteo.net> - New upstream release 2.9.0, no changelog found ------------------------------------------------------------------- Tue Nov 14 18:35:56 UTC 2023 - Dan Čermák <dan.cermak@posteo.net> - New upstream release 2.8.2, no changelog found ------------------------------------------------------------------- Wed Dec 7 11:32:31 UTC 2022 - Stephan Kulow <coolo@suse.com> updated to version 2.6.1 see installed CHANGELOG.md ## [2.6.1] - 2022-11-16 - [Janosch Müller](mailto:janosch84@gmail.com) ### Fixed - fixed scanning of two negative lookbehind edge cases * `(?<!x)y>` used to raise a ScannerError * `(?<!x>)y` used to be misinterpreted as a named group * thanks to [Sergio Medina](https://github.com/serch) for the report ------------------------------------------------------------------- Mon Oct 10 13:18:09 UTC 2022 - Stephan Kulow <coolo@suse.com> updated to version 2.6.0 see installed CHANGELOG.md # Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ------------------------------------------------------------------- Mon Jun 13 17:10:18 UTC 2022 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 2.5.0 ### Added - `Regexp::Expression::Base.construct` and `.token_class` methods * see the [wiki](https://github.com/ammar/regexp_parser/wiki) for details ------------------------------------------------------------------- Mon May 16 07:51:38 UTC 2022 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 2.4.0 ### 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](https://github.com/ammar/regexp_parser/issues/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 `type, text, min, max, mode` with `::Regexp::Token.new(:quantifier, type, text)`. min, max, and mode will be derived automatically. This is consistent with how Expression::Base instances are created. ------------------------------------------------------------------- Thu Apr 28 05:45:28 UTC 2022 - Stephan Kulow <coolo@suse.com> updated to version 2.3.1 see installed CHANGELOG.md ## [Unreleased] ## [2.3.1] - 2022-04-24 - [Janosch Müller](mailto:janosch84@gmail.com) ### Fixed - removed five inexistent unicode properties from `Syntax#features` - these were never supported by Ruby but incorrectly accepted by the parser - thanks to [Markus Schirp](https://github.com/mbj) for the report ## [2.3.0] - 2022-04-08 - [Janosch Müller](mailto:janosch84@gmail.com) ### 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 ------------------------------------------------------------------- Tue Feb 15 07:39:10 UTC 2022 - Stephan Kulow <coolo@suse.com> updated to version 2.2.1 see installed CHANGELOG.md ------------------------------------------------------------------- Sat Dec 25 21:37:11 UTC 2021 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 2.2.0 ### Added - Added support for 13 new unicode properties introduced in Ruby 3.1.0-dev ------------------------------------------------------------------- Tue Mar 16 04:04:24 UTC 2021 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 2.1.1 ## [2.1.1] - 2021-02-23 - [Janosch Müller](mailto:janosch84@gmail.com) ### Fixed - fixed `NameError` when requiring only `'regexp_parser/scanner'` in v2.1.0 * thanks to [Jared White and Sam Ruby](https://github.com/ruby2js/ruby2js) for the report ## [2.1.0] - 2021-02-22 - [Janosch Müller](mailto:janosch84@gmail.com) ### Added - common ancestor for all scanning/parsing/lexing errors * `Regexp::Parser::Error` can now be rescued as a catch-all * the following errors (and their many descendants) now inherit from it: - `Regexp::Expression::Conditional::TooManyBranches` - `Regexp::Parser::ParserError` - `Regexp::Scanner::ScannerError` - `Regexp::Scanner::ValidationError` - `Regexp::Syntax::SyntaxError` * it replaces `ArgumentError` in some rare cases (`Regexp::Parser.parse('?')`) * thanks to [sandstrom](https://github.com/sandstrom) for the cue ### Fixed - fixed scanning of whole-pattern recursion calls `\g<0>` and `\g'0'` * a regression in v2.0.1 had caused them to be scanned as literals - fixed scanning of some backreference and subexpression call edge cases * e.g. `\k<+1>`, `\g<x-1>` - fixed tokenization of some escapes in character sets * `.`, `|`, `{`, `}`, `(`, `)`, `^`, `$`, `?`, `+`, `*` * all of these correctly emitted `#type` `:literal` and `#token` `:literal` if *not* escaped * if escaped, they emitted e.g. `#type` `:escape` and `#token` `:group_open` for `[\(]` * the escaped versions now correctly emit `#type` `:escape` and `#token` `:literal` - fixed handling of control/metacontrol escapes in character sets * e.g. `[\cX]`, `[\M-\C-X]` * they were misread as bunch of individual literals, escapes, and ranges - fixed some cases where calling `#dup`/`#clone` on expressions led to shared state ------------------------------------------------------------------- Wed Jan 20 13:12:49 UTC 2021 - Stephan Kulow <coolo@suse.com> updated to version 2.0.3 see installed CHANGELOG.md ## [2.0.3] - 2020-12-28 - [Janosch Müller](mailto:janosch84@gmail.com) ### Fixed - fixed error when scanning some unlikely and redundant but valid charset patterns - e.g. `/[[.a-b.]]/`, `/[[=e=]]/`, - fixed ancestry of some error classes related to syntax version lookup - `NotImplementedError`, `InvalidVersionNameError`, `UnknownSyntaxNameError` - they now correctly inherit from `Regexp::Syntax::SyntaxError` instead of Rubys `::SyntaxError` ## [2.0.2] - 2020-12-25 - [Janosch Müller](mailto:janosch84@gmail.com) ### Fixed - fixed `FrozenError` when calling `#to_s` on a frozen `Group::Passive` * thanks to [Daniel Gollahon](https://github.com/dgollahon) ## [2.0.1] - 2020-12-20 - [Janosch Müller](mailto:janosch84@gmail.com) ### Fixed - fixed error when scanning some group names * this affected names containing hyphens, digits or multibyte chars, e.g. `/(?<a1>a)/` * thanks to [Daniel Gollahon](https://github.com/dgollahon) for the report - fixed error when scanning hex escapes with just one hex digit * e.g. `/\x0A/` was scanned correctly, but the equivalent `/\xA/` was not * thanks to [Daniel Gollahon](https://github.com/dgollahon) for the report ## [2.0.0] - 2020-11-25 - [Janosch Müller](mailto:janosch84@gmail.com) ### Changed - some methods that used to return byte-based indices now return char-based indices * the returned values have only changed for Regexps that contain multibyte chars * this is only a breaking change if you used such methods directly AND relied on them pointing to bytes * affected methods: * `Regexp::Token` `#length`, `#offset`, `#te`, `#ts` * `Regexp::Expression::Base` `#full_length`, `#offset`, `#starts_at`, `#te`, `#ts` * thanks to [Akinori MUSHA](https://github.com/knu) for the report - removed some deprecated methods/signatures * these are rarely used and have been showing deprecation warnings for a long time * `Regexp::Expression::Subexpression.new` with 3 arguments * `Regexp::Expression::Root.new` without a token argument * `Regexp::Expression.parsed` ### Added - `Regexp::Expression::Base#base_length` * returns the character count of an expression body, ignoring any quantifier - pragmatic, experimental support for chained quantifiers * e.g.: `/^a{10}{4,6}$/` matches exactly 40, 50 or 60 `a`s * successive quantifiers used to be silently dropped by the parser * they are now wrapped with passive groups as if they were written `(?:a{10}){4,6}` * thanks to [calfeld](https://github.com/calfeld) for reporting this a while back ### Fixed - incorrect encoding output for non-ascii comments * this led to a crash when calling `#to_s` on parse results containing such comments * thanks to [Michael Glass](https://github.com/michaelglass) for the report - some crashes when scanning contrived patterns such as `'\😋'` ------------------------------------------------------------------- Tue Nov 10 21:43:06 UTC 2020 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 1.8.2 ### Fixed - fix `FrozenError` in `Expression::Base#repetitions` on Ruby 3.0 * thanks to [Thomas Walpole](https://github.com/twalpole) - removed "unknown future version" warning on Ruby 3.0 ------------------------------------------------------------------- Fri Sep 25 14:47:43 UTC 2020 - Stephan Kulow <coolo@suse.com> updated to version 1.8.0 see installed CHANGELOG.md ### [1.8.0] - 2020-09-20 - [Janosch Müller](mailto:janosch84@gmail.com) ### Changed - dropped support for running on Ruby 1.9.x ### Added - regexp flags can now be passed when parsing a `String` as regexp body * see the [README](/README.md#usage) for details * thanks to [Owen Stephens](https://github.com/owst) - bare occurrences of `\g` and `\k` are now allowed and scanned as literal escapes * matches Onigmo behavior * thanks for the report to [Marc-André Lafortune](https://github.com/marcandre) ### Fixed - fixed parsing comments without preceding space or trailing newline in x-mode * thanks to [Owen Stephens](https://github.com/owst) ------------------------------------------------------------------- Mon Jun 8 09:52:37 UTC 2020 - Dan Čermák <dcermak@suse.com> - New upstream release 1.7.1 ### Fixed - Support for literals that include the unescaped delimiters `{`, `}`, and `]`. These delimiters are informally supported by various regexp engines. ------------------------------------------------------------------- Tue Mar 3 10:35:34 UTC 2020 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 1.7.0 ### Added - `Expression#each_expression` and `#traverse` can now be called without a block * this returns an `Enumerator` and allows chaining, e.g. `each_expression.select` * thanks to [Masataka Kuwabara](https://github.com/pocke) ### Fixed - `MatchLength#each` no longer ignores the given `limit:` when called without a block ------------------------------------------------------------------- Fri Jul 19 07:28:44 UTC 2019 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 1.6.0 ### Added - Added support for 16 new unicode properties introduced in Ruby 2.6.2 and 2.6.3 ------------------------------------------------------------------- Mon Jul 8 08:21:50 UTC 2019 - Manuel Schnitzer <mschnitzer@suse.com> - updated to version 1.5.1 ### Fixed - Fixed `#options` (and thus `#i?`, `#u?` etc.) not being set for some expressions: * this affected posix classes as well as alternation, conditional, and intersection branches * `#options` was already correct for all child expressions of such branches * this only made an operational difference for posix classes as they respect encoding flags - Fixed `#options` not respecting all negative options in weird cases like '(?u-m-x)' - Fixed `Group#option_changes` not accounting for indirectly disabled (overridden) encoding flags - Fixed `Scanner` allowing negative encoding options if there were no positive options, e.g. '(?-u)' - Fixed `ScannerError` for some valid meta/control sequences such as '\\C-\\\\' - Fixed `Expression#match` and `#=~` not working with a single argument ------------------------------------------------------------------- Fri May 17 11:50:20 UTC 2019 - Lukas Krause <lukas.krause@suse.com> - update to version 1.5.0 see installed CHANGELOG.md ### [1.5.0] - 2019-05-14 - Janosch Müller ### Added - Added #referenced_expression for backrefs, subexp calls and conditionals * returns the Group expression that is being referenced via name or number - Added Expression#repetitions * returns a Range of allowed repetitions (1..1 if there is no quantifier) * like #quantity but with a more uniform interface - Added Expression#match_length * allows to inspect and iterate over String lengths matched by the Expression ### Fixed - Fixed Expression#clone "direction" * it used to dup ivars onto the callee, leaving only the clone referencing the original objects * this will affect you if you call #eql?/#equal? on expressions or use them as Hash keys - Fixed #clone results for Sequences, e.g. alternations and conditionals * the inner #text was cloned onto the Sequence and thus duplicated * e.g. Regexp::Parser.parse(/(a|bc)/).clone.to_s # => (aa|bcbc) - Fixed inconsistent #to_s output for Sequences * it used to return only the "specific" text, e.g. "|" for an alternation * now it includes nested expressions as it does for all other Subexpressions - Fixed quantification of codepoint lists with more than one entry (\u{62 63 64}+) * quantifiers apply only to the last entry, so this token is now split up if quantified ------------------------------------------------------------------- Sun May 5 09:41:53 UTC 2019 - Stephan Kulow <coolo@suse.com> - updated to version 1.4.0 see installed CHANGELOG.md ### [1.4.0] - 2019-04-02 - [Janosch Müller](mailto:janosch84@gmail.com) ### Added - Added support for 19 new unicode properties introduced in Ruby 2.6.0 ------------------------------------------------------------------- Tue Nov 20 07:47:16 UTC 2018 - mschnitzer@suse.com - updated to version 1.3.0 ### Added - `Syntax#features` returns a `Hash` of all types and tokens supported by a given `Syntax` ### Fixed - Thanks to [Akira Matsuda](https://github.com/amatsuda) * eliminated warning "assigned but unused variable - testEof" ------------------------------------------------------------------- Tue Nov 6 10:39:36 UTC 2018 - mschnitzer@suse.com - initial package release
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
