python-pyparsing/python-pyparsing.changes

-------------------------------------------------------------------
Mon Feb  1 11:11:39 UTC 2016 - toddrme2178@gmail.com

- update to version 2.0.7:
  * Simplified string representation of Forward class, to avoid memory
    and performance errors while building ParseException
    messages. Thanks, Will McGugan, Andrea Censi, and Martijn Vermaat
    for the bug reports and test code.
  * Cleaned up additional issues from enhancing the error messages for
    Or and MatchFirst, handling Unicode values in expressions. Fixes
    Unicode encoding issues in Python 2, thanks to Evan Hubinger for
    the bug report.
  * Fixed implementation of dir() for ParseResults - was leaving out
    all the defined methods and just adding the custom results names.
  * Fixed bug in ignore() that was introduced in pyparsing 1.5.3, that
    would not accept a string literal as the ignore expression.
  * Added new example parseTabularData.py to illustrate parsing of
    data formatted in columns, with detection of empty cells.
  * Updated a number of examples to more current Python and pyparsing
    forms.
- update to version 2.0.6:
  * Fixed a bug in Each when multiple Optional elements are present.
    Thanks for reporting this, whereswalden on SO.
  * Fixed another bug in Each, when Optional elements have results
    names or parse actions, reported by Max Rothman - thank you, Max!
  * Added optional parseAll argument to runTests, whether tests should
    require the entire input string to be parsed or not (similar to
    parseAll argument to parseString). Plus a little neaten-up of the
    output on Python 2 (no stray ()'s).
  * Modified exception messages from MatchFirst and Or
    expressions. These were formerly misleading as they would only
    give the first or longest exception mismatch error message. Now
    the error message includes all the alternatives that were possible
    matches. Originally proposed by a pyparsing user, but I've lost
    the email thread - finally figured out a fairly clean way to do
    this.
  * Fixed a bug in Or, when a parse action on an alternative raises an
    exception, other potentially matching alternatives were not always
    tried.  Reported by TheVeryOmni on the pyparsing wiki, thanks!
  * Fixed a bug to dump() introduced in 2.0.4, where list values were
    shown in duplicate.
- update to version 2.0.5:
  * (&$(@#&$(@!!!!  Some "print" statements snuck into pyparsing
    v2.0.4, breaking Python 3 compatibility! Fixed. Reported by
    jenshn, thanks!
- changes from Version 2.0.4:
  * Added ParserElement.addCondition, to simplify adding parse actions
    that act primarily as filters. If the given condition evaluates
    False, pyparsing will raise a ParseException. The condition should
    be a method with the same method signature as a parse action, but
    should return a boolean. Suggested by Victor Porton, nice idea
    Victor, thanks!
  * Slight mod to srange to accept unicode literals for the input
    string, such as "[а-яА-Я]" instead of
    "[\u0430-\u044f\u0410-\u042f]". Thanks to Alexandr Suchkov for the
    patch!
  * Enhanced implementation of replaceWith.
  * Fixed enhanced ParseResults.dump() method when the results
    consists only of an unnamed array of sub-structure
    results. Reported by Robin Siebler, thanks for your patience and
    persistence, Robin!
  * Fixed bug in fourFn.py example code, where pi and e were defined
    using CaselessLiteral instead of CaselessKeyword. This was not a
    problem until adding a new function 'exp', and the leading 'e' of
    'exp' was accidentally parsed as the mathematical constant
    'e'. Nice catch, Tom Grydeland - thanks!
  * Adopt new-fangled Python features, like decorators and ternary
    expressions, per suggestions from Williamzjc - thanks William! (Oh
    yeah, I'm not supporting Python 2.3 with this code any more...)
    Plus, some additional code fixes/cleanup - thanks again!
  * Added ParserElement.runTests, a little test bench for quickly
    running an expression against a list of sample input
    strings. Basically, I got tired of writing the same test code over
    and over, and finally added it as a test point method on
    ParserElement.
  * Added withClass helper method, a simplified version of
    withAttribute for the common but annoying case when defining a
    filter on a div's class - made difficult because 'class' is a
    Python reserved word.

-------------------------------------------------------------------
Mon May 11 17:40:24 UTC 2015 - benoit.monin@gmx.fr

- update to version 2.0.3:
  * Fixed escaping behavior in QuotedString. Formerly, only
    quotation marks (or characters designated as quotation marks in
    the QuotedString constructor) would be escaped. Now all escaped
    characters will be escaped, and the escaping backslashes will
    be removed.
  * Fixed regression in ParseResults.pop() - pop() was pretty much
    broken after I added *improvements* in 2.0.2. Reported by Iain
    Shelvington, thanks Iain!
  * Fixed bug in And class when initializing using a generator.
  * Enhanced ParseResults.dump() method to list out nested
    ParseResults that are unnamed arrays of sub-structures.
  * Fixed UnboundLocalError under Python 3.4 in oneOf method,
    reported on Sourceforge by aldanor, thanks!
  * Fixed bug in ParseResults __init__ method, when returning
    non-ParseResults types from parse actions that implement
    __eq__. Raised during discussion on the pyparsing wiki with
    cyrfer.
- fix end of line encoding of every file in examples

-------------------------------------------------------------------
Tue Nov 11 17:34:18 UTC 2014 - Greg.Freemyer@gmail.com

- update to v2.0.2
	- Extended "expr(name)" shortcut (same as "expr.setResultsName(name)")
	  to accept "expr()" as a shortcut for "expr.copy()".

	- Added "locatedExpr(expr)" helper, to decorate any returned tokens
	  with their location within the input string. Adds the results names
	  locn_start and locn_end to the output parse results.

	- Added "pprint()" method to ParseResults, to simplify troubleshooting
	  and prettified output. Now instead of importing the pprint module
	  and then writing "pprint.pprint(result)", you can just write
	  "result.pprint()".  This method also accepts addtional positional and
	  keyword arguments (such as indent, width, etc.), which get passed 
	  through directly to the pprint method 
	  (see http://docs.python.org/2/library/pprint.html#pprint.pprint).

	- Removed deprecation warnings when using '<<' for Forward expression
	  assignment. '<<=' is still preferred, but '<<' will be retained
	  for cases whre '<<=' operator is not suitable (such as in defining
	  lambda expressions).

	- Expanded argument compatibility for classes and functions that
	  take list arguments, to now accept generators as well.

	- Extended list-like behavior of ParseResults, adding support for
	  append and extend. NOTE: if you have existing applications using
	  these names as results names, you will have to access them using
	  dict-style syntax: res["append"] and res["extend"]

	- ParseResults emulates the change in list vs. iterator semantics for
	  methods like keys(), values(), and items(). Under Python 2.x, these
	  methods will return lists, under Python 3.x, these methods will 
	  return iterators.

	- ParseResults now has a method haskeys() which returns True or False
	  depending on whether any results names have been defined. This simplifies
	  testing for the existence of results names under Python 3.x, which 
	  returns keys() as an iterator, not a list.

	- ParseResults now supports both list and dict semantics for pop().
	  If passed no argument or an integer argument, it will use list semantics
	  and pop tokens from the list of parsed tokens. If passed a non-integer
	  argument (most likely a string), it will use dict semantics and 
	  pop the corresponding value from any defined results names. A
	  second default return value argument is supported, just as in 
	  dict.pop().

	- Fixed bug in markInputline, thanks for reporting this, Matt Grant!

	- Cleaned up my unit test environment, now runs with Python 2.6 and 
	  3.3.

-------------------------------------------------------------------
Mon Sep 23 08:45:12 UTC 2013 - hpj@urpla.net

- include examples in -doc package

-------------------------------------------------------------------
Tue Sep 17 13:15:51 UTC 2013 - speilicke@suse.com

- Update to version 2.0.1:
  - Removed use of "nonlocal" that prevented using this version of 
    pyparsing with Python 2.6 and 2.7. This will make it easier to 
    install for packages that depend on pyparsing, under Python 
    versions 2.6 and later. Those using older versions of Python
    will have to manually install pyparsing 1.5.7.
  - Fixed implementation of <<= operator to return self; reported by
    Luc J. Bourhis, with patch fix by Mathias Mamsch - thanks, Luc
    and Mathias!
- Changes from version 2.0.0:
  - Rather than release another combined Python 2.x/3.x release
    I've decided to start a new major version that is only 
    compatible with Python 3.x (and consequently Python 2.7 as
    well due to backporting of key features). This version will
    be the main development path from now on, with little follow-on
    development on the 1.5.x path.
  - Operator '<<' is now deprecated, in favor of operator '<<=' for
    attaching parsing expressions to Forward() expressions. This is
    being done to address precedence of operations problems with '<<'.
    Operator '<<' will be removed in a future version of pyparsing.

-------------------------------------------------------------------
Tue Sep 17 12:45:24 UTC 2013 - dmueller@suse.com

- remove nonsensical tarball 

-------------------------------------------------------------------
Wed Mar 13 09:04:46 UTC 2013 - dmueller@suse.com

- update to 1.5.7:
 * NOTE: This is the last release of pyparsing that will try to 
   maintain compatibility with Python versions < 2.6. The next
   release of pyparsing will be version 2.0.0, using new Python
   syntax that will not be compatible for Python version 2.5 or
   older.
 * An awesome new example is included in this release, submitted
   by Luca DellOlio, for parsing ANTLR grammar definitions, nice
   work Luca!
 * Fixed implementation of ParseResults.__str__ to use Pythonic
   ''.join() instead of repeated string concatenation. This
   purportedly has been a performance issue under PyPy.
 * Fixed bug in ParseResults.__dir__ under Python 3, reported by
   Thomas Kluyver, thank you Thomas!
 * Added ParserElement.inlineLiteralsUsing static method, to 
   override pyparsing's default behavior of converting string
   literals to Literal instances, to use other classes (such
   as Suppress or CaselessLiteral).
 * Added new operator '<<=', which will eventually replace '<<' for 
   storing the contents of a Forward(). '<<=' does not have the same
   operator precedence problems that '<<' does.
 * 'operatorPrecedence' is being renamed 'infixNotation' as a better
   description of what this helper function creates. 'operatorPrecedence'
   is deprecated, and will be dropped entirely in a future release.
 * Added optional arguments lpar and rpar to operatorPrecedence, so that 
   expressions that use it can override the default suppression of the
   grouping characters.
 * Added support for using single argument builtin functions as parse 
   actions.  Now you can write 'expr.setParseAction(len)' and get back
   the length of the list of matched tokens.  Supported builtins are:
   sum, len, sorted, reversed, list, tuple, set, any, all, min, and max.
   A script demonstrating this feature is included in the examples
   directory.
 * Fixed a bug in the definition of 'alphas', which was based on the 
   string.uppercase and string.lowercase "constants", which in fact 
   *aren't* constant, but vary with locale settings. This could make 
   parsers locale-sensitive in a subtle way. Thanks to Kef Schecter for
   his diligence in following through on reporting and monitoring 
   this bugfix!
 * Fixed a bug in the Py3 version of pyparsing, during exception
   handling with packrat parsing enabled, reported by Catherine 
   Devlin - thanks Catherine!
 * Fixed typo in ParseBaseException.__dir__, reported anonymously on 
   the SourceForge bug tracker, thank you Pyparsing User With No Name.
 * Fixed bug in srange when using '\x###' hex character codes.
 * Addeed optional 'intExpr' argument to countedArray, so that you 
   can define your own expression that will evaluate to an integer,
   to be used as the count for the following elements. Allows you 
   to define a countedArray with the count given in hex, for example,
   by defining intExpr as "Word(hexnums).setParseAction(int(t[0],16))".

-------------------------------------------------------------------
Mon Jan 14 11:56:55 UTC 2013 - saschpe@suse.de

- Fix license (MIT and GPL-2.0+ and GPL-3.0+)

-------------------------------------------------------------------
Wed Jan  9 08:27:28 UTC 2013 - saschpe@suse.de

- Don't ship examples twice

-------------------------------------------------------------------
Mon Jan  7 20:03:30 UTC 2013 - p.drouand@gmail.com

- Initial support of python3

-------------------------------------------------------------------
Fri Nov 23 14:06:29 UTC 2012 - saschpe@suse.de

- Package examples
- Spec file cleanup

-------------------------------------------------------------------
Sun Jul  3 09:40:58 UTC 2011 - saschpe@gmx.de

- Add Provides/Obsoletes for python-parsing

-------------------------------------------------------------------
Thu Jun 30 08:33:22 UTC 2011 - saschpe@suse.de

- Update to version 1.5.6:
  * Cleanup of parse action normalizing code, to be more version-tolerant,
    and robust in the face of future Python versions
  * Removal of exception cacheing, addressing a memory leak condition
    in Python 3.
  * Fixed bug when using packrat parsing, where a previously parsed
    expression would duplicate subsequent tokens
  * Fixed bug in srange, which accepted escaped hex characters of the 
    form '\0x##', but should be '\x##'.  Both forms will be supported
    for backwards compatibility.
  * Added the Verilog parser to the provided set of examples, under the
    MIT license.
  * Added the excludeChars argument to the Word class, to simplify defining
    a word composed of all characters in a large range except for one or two.
  * Added optional overlap parameter to scanString, to return overlapping
    matches found in the source text.
  * Updated oneOf internal regular expression generation, with improved
    parse time performance.
  * Slight performance improvement in transformString, removing empty
    strings from the list of string fragments built while scanning the
    source text, before calling ''.join. Especially useful when using 
    transformString to strip out selected text.
  * Enhanced form of using the "expr('name')" style of results naming,
    in lieu of calling setResultsName.  If name ends with an '*', then
    this is equivalent to expr.setResultsName('name',listAllMatches=True).
  * Fixed up internal list flattener to use iteration instead of recursion,
    to avoid stack overflow when transforming large files.
- Changes from version 1.5.5:
  * Typo in Python3 version of pyparsing, "builtin" should be "builtins".
- Changes from version 1.5.4:
  * Fixed __builtins__ and file references in Python 3 code, thanks to 
    Greg Watson, saulspatz, sminos, and Mark Summerfield for reporting 
    their Python 3 experiences.
- Spec file cleanup:
  * Regenerated with py2pack, much simpler spec file
  * Fixed license to MIT, it's not GPLv2+

-------------------------------------------------------------------
Wed Jul  7 00:32:17 UTC 2010 - pascal.bleser@opensuse.org

- Initial package (1.5.3)