Metadata-Version: 2.1
Name: re_assert
Version: 1.1.0
Summary: show where your regex match assertion failed!
Home-page: https://github.com/asottile/re-assert
Author: Anthony Sottile
Author-email: asottile@umich.edu
License: MIT
Description: [![Build Status](https://dev.azure.com/asottile/asottile/_apis/build/status/asottile.re-assert?branchName=master)](https://dev.azure.com/asottile/asottile/_build/latest?definitionId=31&branchName=master)
        [![Azure DevOps coverage](https://img.shields.io/azure-devops/coverage/asottile/asottile/31/master.svg)](https://dev.azure.com/asottile/asottile/_build/latest?definitionId=31&branchName=master)
        
        re-assert
        =========
        
        show where your regex match assertion failed!
        
        ## installation
        
        `pip install re-assert`
        
        ## usage
        
        `re-assert` provides a helper class to make assertions of regexes simpler.
        
        ### `re_assert.Matches(pattern: str, *args, **kwargs)`
        
        construct a `Matches` object.
        
        _note_: under the hood, `re-assert` uses the [`regex`] library for matching,
        any `*args` / `**kwargs` that `regex.compile` supports will work.  in general,
         the `regex` library is 100% compatible with the `re` library (and will even
        accept its flags, etc.)
        
        [`regex`]: https://pypi.org/project/regex/
        
        ### `re_assert.Matches.from_pattern(pattern: Pattern[str]) -> Matches`
        
        construct a `Matches` object from an already-compiled regex.
        
        this is useful (for instance) if you're testing an existing compiled regex.
        
        ```pycon
        >>> import re
        >>> reg = re.compile('foo')
        >>> Matches.from_pattern(reg) == 'fork'
        False
        >>> Matches.from_pattern(reg) == 'food'
        True
        ```
        
        ### `Matches.__eq__(other)` (`==`)
        
        the equality operator is overridden for use with assertion frameworks such
        as pytest
        
        ```pycon
        >>> pat = Matches('foo')
        >>> pat == 'bar'
        False
        >>> pat == 'food'
        True
        ```
        
        ### `Matches.__repr__()` (`repr(...)`)
        
        a side-effect of an equality failure changes the `repr(...)` of a `Matches`
        object.  this allows for useful pytest assertion messages:
        
        ```pytest
        >       assert Matches('foo') == 'fork'
        E       AssertionError: assert Matches('foo'...ork\n    #    ^ == 'fork'
        E         -Matches('foo')\n
        E         -    # regex failed to match at:\n
        E         -    #\n
        E         -    #> fork\n
        E         -    #    ^
        E         +'fork'
        ```
        
        ### `Matches.assert_matches(s: str)`
        
        if you're using some other test framework, this method is useful for producing
        a readable traceback
        
        ```pycon
        >>> Matches('foo').assert_matches('food')
        >>> Matches('foo').assert_matches('fork')
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
          File "/home/asottile/workspace/re-assert/re_assert.py", line 63, in assert_matches
            assert self == s, self._fail
        AssertionError:  regex failed to match at:
        
        > fork
            ^
        ```
        
Platform: UNKNOWN
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Requires-Python: >=3.6.1
Description-Content-Type: text/markdown
