pool/python-pyparsing
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Add nose_to_unittest.patch to avoid nose BR and rewrite tests

Browse Source 
to work (gh#pyparsing/pyparsing#64)

OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-pyparsing?expand=0&rev=52
This commit is contained in:
Matej Cepl 2019-01-07 14:16:05 +00:00 committed by Git OBS Bridge
parent 02825dedbb
commit 0a12b50e88
3 changed files with 395 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

378
nose_to_unittest.patch Normal file
View File

@ -0,0 +1,378 @@
--- a/examples/test_bibparse.py
+++ b/examples/test_bibparse.py
@@ -1,195 +1,193 @@
""" Test for bibparse grammar """
+import unittest
from os.path import join as pjoin, dirname
from pyparsing import ParseException
from .btpyparse import Macro
from . import btpyparse as bp
-from nose.tools import assert_true, assert_false, assert_equal, assert_raises
+class TestBibparse(unittest.TestCase):
+ def test_names(self):
+ # check various types of names
+ # All names can contains alphas, but not some special chars
+ bad_chars = '"#%\'(),={}'
+ for name_type, dig1f in ((bp.macro_def, False),
+ (bp.field_name, False),
+ (bp.entry_type, False),
+ (bp.cite_key, True)):
+ if dig1f: # can start with digit
+ self.assertEqual(name_type.parseString('2t')[0], '2t')
+ else:
+ self.assertRaises(ParseException, name_type.parseString, '2t')
+ # All of the names cannot contain some characters
+ for char in bad_chars:
+ self.assertRaises(ParseException, name_type.parseString, char)
+ # standard strings all OK
+ self.assertEqual(name_type.parseString('simple_test')[0], 'simple_test')
+ # Test macro ref
+ mr = bp.macro_ref
+ # can't start with digit
+ self.assertRaises(ParseException, mr.parseString, '2t')
+ for char in bad_chars:
+ self.assertRaises(ParseException, mr.parseString, char)
+ self.assertEqual(mr.parseString('simple_test')[0].name, 'simple_test')
-def test_names():
- # check various types of names
- # All names can contains alphas, but not some special chars
- bad_chars = '"#%\'(),={}'
- for name_type, dig1f in ((bp.macro_def, False),
- (bp.field_name, False),
- (bp.entry_type, False),
- (bp.cite_key, True)):
- if dig1f: # can start with digit
- assert_equal(name_type.parseString('2t')[0], '2t')
- else:
- assert_raises(ParseException, name_type.parseString, '2t')
- # All of the names cannot contain some characters
- for char in bad_chars:
- assert_raises(ParseException, name_type.parseString, char)
- # standard strings all OK
- assert_equal(name_type.parseString('simple_test')[0], 'simple_test')
- # Test macro ref
- mr = bp.macro_ref
- # can't start with digit
- assert_raises(ParseException, mr.parseString, '2t')
- for char in bad_chars:
- assert_raises(ParseException, mr.parseString, char)
- assert_equal(mr.parseString('simple_test')[0].name, 'simple_test')
-
-
-def test_numbers():
- assert_equal(bp.number.parseString('1066')[0], '1066')
- assert_equal(bp.number.parseString('0')[0], '0')
- assert_raises(ParseException, bp.number.parseString, '-4')
- assert_raises(ParseException, bp.number.parseString, '+4')
- assert_raises(ParseException, bp.number.parseString, '.4')
- # something point something leaves a trailing .4 unmatched
- assert_equal(bp.number.parseString('0.4')[0], '0')
-
-
-def test_parse_string():
- # test string building blocks
- assert_equal(bp.chars_no_quotecurly.parseString('x')[0], 'x')
- assert_equal(bp.chars_no_quotecurly.parseString("a string")[0], 'a string')
- assert_equal(bp.chars_no_quotecurly.parseString('a "string')[0], 'a ')
- assert_equal(bp.chars_no_curly.parseString('x')[0], 'x')
- assert_equal(bp.chars_no_curly.parseString("a string")[0], 'a string')
- assert_equal(bp.chars_no_curly.parseString('a {string')[0], 'a ')
- assert_equal(bp.chars_no_curly.parseString('a }string')[0], 'a ')
- # test more general strings together
- for obj in (bp.curly_string, bp.string, bp.field_value):
- assert_equal(obj.parseString('{}').asList(), [])
- assert_equal(obj.parseString('{a "string}')[0], 'a "string')
- assert_equal(obj.parseString('{a {nested} string}').asList(),
- ['a ', ['nested'], ' string'])
- assert_equal(obj.parseString('{a {double {nested}} string}').asList(),
- ['a ', ['double ', ['nested']], ' string'])
- for obj in (bp.quoted_string, bp.string, bp.field_value):
- assert_equal(obj.parseString('""').asList(), [])
- assert_equal(obj.parseString('"a string"')[0], 'a string')
- assert_equal(obj.parseString('"a {nested} string"').asList(),
- ['a ', ['nested'], ' string'])
- assert_equal(obj.parseString('"a {double {nested}} string"').asList(),
- ['a ', ['double ', ['nested']], ' string'])
- # check macro def in string
- assert_equal(bp.string.parseString('someascii')[0], Macro('someascii'))
- assert_raises(ParseException, bp.string.parseString, '%#= validstring')
- # check number in string
- assert_equal(bp.string.parseString('1994')[0], '1994')
-
-
-def test_parse_field():
- # test field value - hashes included
- fv = bp.field_value
- # Macro
- assert_equal(fv.parseString('aname')[0], Macro('aname'))
- assert_equal(fv.parseString('ANAME')[0], Macro('aname'))
- # String and macro
- assert_equal(fv.parseString('aname # "some string"').asList(),
- [Macro('aname'), 'some string'])
- # Nested string
- assert_equal(fv.parseString('aname # {some {string}}').asList(),
- [Macro('aname'), 'some ', ['string']])
- # String and number
- assert_equal(fv.parseString('"a string" # 1994').asList(),
- ['a string', '1994'])
- # String and number and macro
- assert_equal(fv.parseString('"a string" # 1994 # a_macro').asList(),
- ['a string', '1994', Macro('a_macro')])
-
-
-def test_comments():
- res = bp.comment.parseString('@Comment{about something}')
- assert_equal(res.asList(), ['comment', '{about something}'])
- assert_equal(
- bp.comment.parseString('@COMMENT{about something').asList(),
- ['comment', '{about something'])
- assert_equal(
- bp.comment.parseString('@comment(about something').asList(),
- ['comment', '(about something'])
- assert_equal(
- bp.comment.parseString('@COMment about something').asList(),
- ['comment', ' about something'])
- assert_raises(ParseException, bp.comment.parseString,
- '@commentabout something')
- assert_raises(ParseException, bp.comment.parseString,
- '@comment+about something')
- assert_raises(ParseException, bp.comment.parseString,
- '@comment"about something')
-
-
-def test_preamble():
- res = bp.preamble.parseString('@preamble{"about something"}')
- assert_equal(res.asList(), ['preamble', 'about something'])
- assert_equal(bp.preamble.parseString(
- '@PREamble{{about something}}').asList(),
- ['preamble', 'about something'])
- assert_equal(bp.preamble.parseString("""@PREamble{
- {about something}
- }""").asList(),
- ['preamble', 'about something'])
-
-
-def test_macro():
- res = bp.macro.parseString('@string{ANAME = "about something"}')
- assert_equal(res.asList(), ['string', 'aname', 'about something'])
- assert_equal(
- bp.macro.parseString('@string{aname = {about something}}').asList(),
- ['string', 'aname', 'about something'])
-
-
-def test_entry():
- txt = """@some_entry{akey, aname = "about something",
- another={something else}}"""
- res = bp.entry.parseString(txt)
- assert_equal(res.asList(),
- ['some_entry', 'akey',
- ['aname', 'about something'], ['another', 'something else']])
- # Case conversion
- txt = """@SOME_ENTRY{akey, ANAME = "about something",
- another={something else}}"""
- res = bp.entry.parseString(txt)
- assert_equal(res.asList(),
- ['some_entry', 'akey',
- ['aname', 'about something'], ['another', 'something else']])
-
-
-def test_bibfile():
- txt = """@some_entry{akey, aname = "about something",
- another={something else}}"""
- res = bp.bibfile.parseString(txt)
- assert_equal(res.asList(),
- [['some_entry', 'akey',
- ['aname', 'about something'],
- ['another', 'something else']]])
-
-
-def test_bib1():
- # First pass whole bib-like tests
- txt = """
-Some introductory text
-(implicit comment)
-
- @ARTICLE{Brett2002marsbar,
- author = {Matthew Brett and Jean-Luc Anton and Romain Valabregue and Jean-Baptise
- Poline},
- title = {{Region of interest analysis using an SPM toolbox}},
- journal = {Neuroimage},
- year = {2002},
- volume = {16},
- pages = {1140--1141},
- number = {2}
-}
-
-@some_entry{akey, aname = "about something",
-another={something else}}
-"""
- res = bp.bibfile.parseString(txt)
- assert_equal(len(res), 3)
- res2 = bp.parse_str(txt)
- assert_equal(res.asList(), res2.asList())
- res3 = [r.asList()[0] for r, start, end in bp.definitions.scanString(txt)]
- assert_equal(res.asList(), res3)
+ def test_numbers(self):
+ self.assertEqual(bp.number.parseString('1066')[0], '1066')
+ self.assertEqual(bp.number.parseString('0')[0], '0')
+ self.assertRaises(ParseException, bp.number.parseString, '-4')
+ self.assertRaises(ParseException, bp.number.parseString, '+4')
+ self.assertRaises(ParseException, bp.number.parseString, '.4')
+ # something point something leaves a trailing .4 unmatched
+ self.assertEqual(bp.number.parseString('0.4')[0], '0')
+
+
+ def test_parse_string(self):
+ # test string building blocks
+ self.assertEqual(bp.chars_no_quotecurly.parseString('x')[0], 'x')
+ self.assertEqual(bp.chars_no_quotecurly.parseString("a string")[0], 'a string')
+ self.assertEqual(bp.chars_no_quotecurly.parseString('a "string')[0], 'a ')
+ self.assertEqual(bp.chars_no_curly.parseString('x')[0], 'x')
+ self.assertEqual(bp.chars_no_curly.parseString("a string")[0], 'a string')
+ self.assertEqual(bp.chars_no_curly.parseString('a {string')[0], 'a ')
+ self.assertEqual(bp.chars_no_curly.parseString('a }string')[0], 'a ')
+ # test more general strings together
+ for obj in (bp.curly_string, bp.string, bp.field_value):
+ self.assertEqual(obj.parseString('{}').asList(), [])
+ self.assertEqual(obj.parseString('{a "string}')[0], 'a "string')
+ self.assertEqual(obj.parseString('{a {nested} string}').asList(),
+ ['a ', ['nested'], ' string'])
+ self.assertEqual(obj.parseString('{a {double {nested}} string}').asList(),
+ ['a ', ['double ', ['nested']], ' string'])
+ for obj in (bp.quoted_string, bp.string, bp.field_value):
+ self.assertEqual(obj.parseString('""').asList(), [])
+ self.assertEqual(obj.parseString('"a string"')[0], 'a string')
+ self.assertEqual(obj.parseString('"a {nested} string"').asList(),
+ ['a ', ['nested'], ' string'])
+ self.assertEqual(obj.parseString('"a {double {nested}} string"').asList(),
+ ['a ', ['double ', ['nested']], ' string'])
+ # check macro def in string
+ self.assertEqual(bp.string.parseString('someascii')[0], Macro('someascii'))
+ self.assertRaises(ParseException, bp.string.parseString, '%#= validstring')
+ # check number in string
+ self.assertEqual(bp.string.parseString('1994')[0], '1994')
+
+
+ def test_parse_field(self):
+ # test field value - hashes included
+ fv = bp.field_value
+ # Macro
+ self.assertEqual(fv.parseString('aname')[0], Macro('aname'))
+ self.assertEqual(fv.parseString('ANAME')[0], Macro('aname'))
+ # String and macro
+ self.assertEqual(fv.parseString('aname # "some string"').asList(),
+ [Macro('aname'), 'some string'])
+ # Nested string
+ self.assertEqual(fv.parseString('aname # {some {string}}').asList(),
+ [Macro('aname'), 'some ', ['string']])
+ # String and number
+ self.assertEqual(fv.parseString('"a string" # 1994').asList(),
+ ['a string', '1994'])
+ # String and number and macro
+ self.assertEqual(fv.parseString('"a string" # 1994 # a_macro').asList(),
+ ['a string', '1994', Macro('a_macro')])
+
+
+ def test_comments(self):
+ res = bp.comment.parseString('@Comment{about something}')
+ self.assertEqual(res.asList(), ['comment', '{about something}'])
+ self.assertEqual(
+ bp.comment.parseString('@COMMENT{about something').asList(),
+ ['comment', '{about something'])
+ self.assertEqual(
+ bp.comment.parseString('@comment(about something').asList(),
+ ['comment', '(about something'])
+ self.assertEqual(
+ bp.comment.parseString('@COMment about something').asList(),
+ ['comment', ' about something'])
+ self.assertRaises(ParseException, bp.comment.parseString,
+ '@commentabout something')
+ self.assertRaises(ParseException, bp.comment.parseString,
+ '@comment+about something')
+ self.assertRaises(ParseException, bp.comment.parseString,
+ '@comment"about something')
+
+
+ def test_preamble(self):
+ res = bp.preamble.parseString('@preamble{"about something"}')
+ self.assertEqual(res.asList(), ['preamble', 'about something'])
+ self.assertEqual(bp.preamble.parseString(
+ '@PREamble{{about something}}').asList(),
+ ['preamble', 'about something'])
+ self.assertEqual(bp.preamble.parseString("""@PREamble{
+ {about something}
+ }""").asList(),
+ ['preamble', 'about something'])
+
+
+ def test_macro(self):
+ res = bp.macro.parseString('@string{ANAME = "about something"}')
+ self.assertEqual(res.asList(), ['string', 'aname', 'about something'])
+ self.assertEqual(
+ bp.macro.parseString('@string{aname = {about something}}').asList(),
+ ['string', 'aname', 'about something'])
+
+
+ def test_entry(self):
+ txt = """@some_entry{akey, aname = "about something",
+ another={something else}}"""
+ res = bp.entry.parseString(txt)
+ self.assertEqual(res.asList(),
+ ['some_entry', 'akey',
+ ['aname', 'about something'], ['another', 'something else']])
+ # Case conversion
+ txt = """@SOME_ENTRY{akey, ANAME = "about something",
+ another={something else}}"""
+ res = bp.entry.parseString(txt)
+ self.assertEqual(res.asList(),
+ ['some_entry', 'akey',
+ ['aname', 'about something'], ['another', 'something else']])
+
+
+ def test_bibfile(self):
+ txt = """@some_entry{akey, aname = "about something",
+ another={something else}}"""
+ res = bp.bibfile.parseString(txt)
+ self.assertEqual(res.asList(),
+ [['some_entry', 'akey',
+ ['aname', 'about something'],
+ ['another', 'something else']]])
+
+
+ def test_bib1(self):
+ # First pass whole bib-like tests
+ txt = """
+ Some introductory text
+ (implicit comment)
+
+ @ARTICLE{Brett2002marsbar,
+ author = {Matthew Brett and Jean-Luc Anton and Romain Valabregue and Jean-Baptise
+ Poline},
+ title = {{Region of interest analysis using an SPM toolbox}},
+ journal = {Neuroimage},
+ year = {2002},
+ volume = {16},
+ pages = {1140--1141},
+ number = {2}
+ }
+
+ @some_entry{akey, aname = "about something",
+ another={something else}}
+ """
+ res = bp.bibfile.parseString(txt)
+ self.assertEqual(len(res), 3)
+ res2 = bp.parse_str(txt)
+ self.assertEqual(res.asList(), res2.asList())
+ res3 = [r.asList()[0] for r, start, end in bp.definitions.scanString(txt)]
+ self.assertEqual(res.asList(), res3)
if __name__ == '__main__':
- import nose
- nose.main()
+ unittest.main()

6
python-pyparsing.changes
View File

@ -1,3 +1,9 @@
-------------------------------------------------------------------
Mon Jan 7 12:36:20 UTC 2019 - Matěj Cepl <mcepl@suse.com>
- Add nose_to_unittest.patch to avoid nose BR and rewrite tests
to work (gh#pyparsing/pyparsing#64)
------------------------------------------------------------------- -------------------------------------------------------------------
Fri Dec 28 09:57:56 UTC 2018 - Martin Pluskal <mpluskal@suse.com> Fri Dec 28 09:57:56 UTC 2018 - Martin Pluskal <mpluskal@suse.com>

15
python-pyparsing.spec
View File

@ -1,7 +1,7 @@
# #
# spec file for package python-pyparsing # spec file for package python-pyparsing
# #
# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany. # Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany.
# #
# All modifications and additions to the file contributed by third parties # All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed # remain the property of their copyright owners, unless otherwise agreed
@ -16,6 +16,7 @@
# #
%define modname pyparsing
%define oldpython python %define oldpython python
%{?!python_module:%define python_module() python-%{**} python3-%{**}} %{?!python_module:%define python_module() python-%{**} python3-%{**}}
%global flavor @BUILD_FLAVOR@%{nil} %global flavor @BUILD_FLAVOR@%{nil}
@ -37,8 +38,9 @@ Group: Development/Languages/Python
URL: https://github.com/pyparsing/pyparsing/ URL: https://github.com/pyparsing/pyparsing/
# Upstream tarball from the master branch with gh#pyparsing/pyparsing#47 # Upstream tarball from the master branch with gh#pyparsing/pyparsing#47
Source: pyparsing-%{version}.tar.gz Source: pyparsing-%{version}.tar.gz
# Remove dependency on nose, gh#pyparsing/pyparsing#64
Patch: nose_to_unittest.patch
BuildRequires: %{python_module base} BuildRequires: %{python_module base}
BuildRequires: %{python_module nose}
# Source: https://files.pythonhosted.org/packages/source/p/pyparsing/pyparsing-%%{version}.tar.gz # Source: https://files.pythonhosted.org/packages/source/p/pyparsing/pyparsing-%%{version}.tar.gz
BuildRequires: fdupes BuildRequires: fdupes
BuildRequires: python-rpm-macros BuildRequires: python-rpm-macros
@ -61,7 +63,8 @@ expressions. The pyparsing module provides a library of classes that client
code uses to construct the grammar directly in Python code. code uses to construct the grammar directly in Python code.
%prep %prep
%setup -q -n pyparsing-2.3.1 %setup -q -n %{modname}-2.3.1
%autopatch -p1
%build %build
%python_build %python_build
@ -79,7 +82,11 @@ cp -r pyparsing.egg-info %{buildroot}%{$python_sitelib}/pyparsing-%{version}-py%
%check %check
%if %{with test} %if %{with test}
export PYTHONPATH=.:example export PYTHONPATH=.:example
%python_exec setup.py nosetests -v # unittest from Python 2.7 doesn't load tests correctly
python2 -munittest2 -v simple_unit_tests.py examples.test_bibparse examples.antlr_grammar_tests
python3 -munittest -v simple_unit_tests.py examples.test_bibparse examples.antlr_grammar_tests
# Fails with python2 gh#pyparsing/pyparsing#63
python3 unitTests.py
%endif %endif
%files %{python_files} %files %{python_files}