a 4j7@sFdZddlmZmZmZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZmZmZGdddeZGd d d eZGd d d eZGd ddeZGdddeZGdddeZGdddeZddZGdddeZGdddeZGdddeZeeeedZ ea!ddZ"d d!Z#d"d#Z$dS)$z This module provides the step matchers functionality that matches a step definition (as text) with step-functions that implement this step. )absolute_importprint_functionwith_statementN)cfparse)ChainedExceptionUtil ExceptionUtil)Argument FileLocation Replayablec@seZdZdZdddZdS)StepParseErrorzException class, used when step matching fails before a step is run. This is normally the case when an error occurs during the type conversion of step parameters. NcCsX|s|rt|}|r8tjr8tj|ddd}|d|7}t|||rTt||dS)NTz CAUSED-BY: )Z use_tracebackprefix ) six text_typePY2rdescribe ValueError__init__rZ set_cause)selftext exc_causeZ cause_textr5E:\soccer\ml_env\Lib\site-packages\behave/matchers.pyrs    zStepParseError.__init__)NN__name__ __module__ __qualname____doc__rrrrrr sr csReZdZdZdZdfdd ZddZdd Zd d Zd d Z e ddZ Z S)MatchaWAn parameter-matched *feature file* step name extracted using step decorator `parameters`_. .. attribute:: func The step function that this match will be applied to. .. attribute:: arguments A list of :class:`~behave.model_core.Argument` instances containing the matched parameters from the step name. matchNcs4tt|||_||_d|_|r0|||_dSN)superrrfunc argumentslocation make_location)rr"r# __class__rrr?s zMatch.__init__cCs"|jr|jj}nd}d||jfS)Nz z)r"rr$)r func_namerrr__repr__Gs zMatch.__repr__cCs&t|tsdS|j|jf|j|jfkS)NF) isinstancerr"r$)rotherrrr__eq__Ns z Match.__eq__cCst|}||_|Sr )copyr#)rr#rrrrwith_argumentsSs zMatch.with_argumentscCs|g}i}|jD](}|jdur*|j||j<q||jq|(|j|g|Ri|Wdn1sn0YdSr )r#namevalueappendZuse_with_user_moder")rcontextargskwargsargrrrrunXs   z Match.runcCs t|S)aExtracts the location information from the step function and builds a FileLocation object with (filename, line_number) info. :param step_function: Function whose location should be determined. :return: FileLocation object for step function. )r Z for_function)Z step_functionrrrr%dszMatch.make_location)N) rrrrtyperr)r,r.r6 staticmethodr% __classcell__rrr&rr0s  rc@seZdZdZddZdS)NoMatchzXUsed for an "undefined step" when it can not be matched with a step definition. cCs$tj|ddd|_g|_d|_dSN)r")rrr"r#r$rrrrrtszNoMatch.__init__Nrrrrrr:osr:c@s eZdZdZddZddZdS)MatchWithErrorzvMatch class when error occur during step-matching REASON: * Type conversion error occured. * ... cCs,t|st|tj||d||_dSr;)rZ has_tracebackZ set_tracebackrr stored_error)rr"errorrrrrs  zMatchWithError.__init__cCst|jddS)z?Raises stored error from step matching phase (type conversion).)rN)r r>)rr2rrrr6szMatchWithError.runN)rrrrrr6rrrrr={sr=c@sdeZdZdZdZdddZeddZedd Zed d Z dd d Z ddZ ddZ ddZ dS)MatcherzPull parameters out of step names. .. attribute:: pattern The match pattern attached to the step function. .. attribute:: func The step function the pattern is being attached to. z @%s('%s')NcCs||_||_||_d|_dSr )r"pattern step_type _locationrr"rArBrrrrszMatcher.__init__cCstdt|jS)Nz!deprecated: Use 'pattern' instead)warningswarnDeprecationWarningrAr<rrrstrings zMatcher.stringcCs|jdurt|j|_|jSr )rCrr%r"r<rrrr$s zMatcher.locationcCs|jS)z&Return the used textual regex pattern.)rAr<rrr regex_patternszMatcher.regex_patterncCs"|jpd}|s|j}|||jfS)zProvide a textual description of the step function/matcher object. :param schema: Text schema to use. :return: Textual description of this step definition (matcher). step)rBschemarA)rrKrBrrrrs zMatcher.describecCstdS)a<Match me against the "step" name supplied. Return None, if I don't match otherwise return a list of matches as :class:`~behave.model_core.Argument` instances. The return value from this function will be converted into a :class:`~behave.matchers.Match` instance by *behave*. N)NotImplementedError)rrJrrr check_matchs zMatcher.check_matchc CsXz||}Wn0ty>}zt|j|WYd}~Sd}~00|durLdSt|j|Sr )rM Exceptionr=r"r)rrJresulterrrrs"z Matcher.matchcCsd|jj|jfS)Nz<%s: %r>)r'rrAr<rrrr)szMatcher.__repr__)N)N)rrrrrKrpropertyrHr$rIrrMrr)rrrrr@s        r@cs@eZdZdZiZejZd fdd Ze ddZ ddZ Z S) ParseMatcherz~Uses :class:`~parse.Parser` class to be able to use simpler parse expressions compared to normal regular expressions. Ncs(tt|||||||j|_dSr )r!rRr parser_class custom_typesparserrDr&rrrszParseMatcher.__init__cCs|jjSr )rUZ _expressionr<rrrrIszParseMatcher.regex_patternc Cs|j|}|sdSg}t|jD]2\}}|j|\}}|t||||||q"|jD]4\}}|j|\}}|t|||||||q`|j ddd|S)NcSs|jSr )start)xrrrz*ParseMatcher.check_match..)key) rUparse enumeratefixedspansr1rnameditemssort) rrJrOr3indexr0rVendr/rrrrMs  zParseMatcher.check_match)N) rrrrrTr[ParserrSrrQrIrMr9rrr&rrRs rRc@seZdZdZejZdS)CFParseMatcherzUses :class:`~parse_type.cfparse.Parser` instead of "parse.Parser". Provides support for automatic generation of type variants for fields with CardinalityField part. N)rrrrrrdrSrrrrresrecKstj|dS)aRegisters a custom type that will be available to "parse" for type conversion during step matching. Converters should be supplied as ``name=callable`` arguments (or as dict). A type converter should follow :pypi:`parse` module rules. In general, a type converter is a function that converts text (as string) into a value-type (type converted value). EXAMPLE: .. code-block:: python from behave import register_type, given import parse # -- TYPE CONVERTER: For a simple, positive integer number. @parse.with_pattern(r"\d+") def parse_number(text): return int(text) # -- REGISTER TYPE-CONVERTER: With behave register_type(Number=parse_number) # -- STEP DEFINITIONS: Use type converter. @given('{amount:Number} vehicles') def step_impl(context, amount): assert isinstance(amount, int) N)rRrTupdate)kwrrr register_types rhcs&eZdZdfdd ZddZZS) RegexMatcherNcs&tt||||t|j|_dSr )r!rirrecompilerAregexrDr&rrr,szRegexMatcher.__init__c Cs|j|}|sdStdd|jjD}g}t|D]>\}}|d7}||d}|t | || ||||q>|S)Ncss|]\}}||fVqdSr r).0rWyrrr 5rYz+RegexMatcher.check_match..) rlrdict groupindexr`r\groupsgetr1rrVrc)rrJmrrr3rbgroupr/rrrrM0s  zRegexMatcher.check_match)N)rrrrrMr9rrr&rri+srics"eZdZdZdfdd ZZS)SimplifiedRegexMatcheraSimplified regular expression step-matcher that automatically adds start-of-line/end-of-line matcher symbols to string: .. code-block:: python @when(u'a step passes') # re.pattern = "^a step passes$" def step_impl(context): pass NcsF|ds|dr Jd|d|}tt||||||_dS)N^$z5Regular expression should not use begin/end-markers: z^%s$) startswithendswithr!rwrrA)rr"rArB expressionr&rrrIs zSimplifiedRegexMatcher.__init__)N)rrrrrr9rrr&rrw?s rwc@seZdZdZdS)CucumberRegexMatcheraCompatible to (old) Cucumber style regular expressions. Text must contain start-of-line/end-of-line matcher symbols to string: .. code-block:: python @when(u'^a step passes$') # re.pattern = "^a step passes$" def step_impl(context): pass N)rrrrrrrrr}Qsr})r[rrjZre0cCs t|adS)aChange the parameter matcher used in parsing step text. The change is immediate and may be performed between step definitions in your step implementation modules - allowing adjacent steps to use different matchers if necessary. There are several parsers available in *behave* (by default): **parse** (the default, based on: :pypi:`parse`) Provides a simple parser that replaces regular expressions for step parameters with a readable syntax like ``{param:Type}``. The syntax is inspired by the Python builtin ``string.format()`` function. Step parameters must use the named fields syntax of :pypi:`parse` in step definitions. The named fields are extracted, optionally type converted and then used as step function arguments. Supports type conversions by using type converters (see :func:`~behave.register_type()`). **cfparse** (extends: :pypi:`parse`, requires: :pypi:`parse_type`) Provides an extended parser with "Cardinality Field" (CF) support. Automatically creates missing type converters for related cardinality as long as a type converter for cardinality=1 is provided. Supports parse expressions like: * ``{values:Type+}`` (cardinality=1..N, many) * ``{values:Type*}`` (cardinality=0..N, many0) * ``{value:Type?}`` (cardinality=0..1, optional) Supports type conversions (as above). **re** This uses full regular expressions to parse the clause text. You will need to use named groups "(?P...)" to define the variables pulled from the text and passed to your ``step()`` function. Type conversion is **not supported**. A step function writer may implement type conversion inside the step function (implementation). You may `define your own matcher`_. .. _`define your own matcher`: api.html#step-parameters N)matcher_mappingcurrent_matcherr/rrruse_step_matcherks/rcCstjdtddt|dS)z= DEPRECATED, use :func:`use_step_matcher()` instead. z,deprecated: Use 'use_step_matcher()' instead) stacklevelN)rErFrGrrrrr step_matchersrcCs t||Sr )r)r"rArrr get_matchersr)%r __future__rrrr-rjrEr[rZ parse_typerZ behave._typesrrZbehave.model_corerr r rr rr:r=objectr@rRrerhrirwr}r~rrrrrrrrs: ? L"#  1