U ÔZj«:ã@sÂdZddlZddlZddlZddlmZddlmZe e ¡Z dZ de gZ Gdd„de ƒZGd d „d eƒZd d „ZGd d„deƒZGdd„deƒZdd„Zdd„Zddd„Zdd„Zddd„ZdS)zx This file contains parsing routines and object classes to help derive meaning from raw lists of tokens from pyparsing. éN)Úerrors)ÚListz managed by Certbotú#c@s†eZdZdZejZddd„Zedd„ƒZ e ej dd„ƒƒZ ej dd d „ƒZ ej dd d „ƒZej dd„ƒZej ddd„ƒZddd„ZdS)ÚParsablez® Abstract base class for "Parsable" objects whose underlying representation is a tree of lists. :param .Parsable parent: This object's parsed parent in the tree NcCsg|_d|_||_dS©N)Ú_dataZ_tabsÚparent©Úselfr©r ú[/var/www/html/TRUCKING_PROJECT/venv/lib/python3.8/site-packages/certbot_nginx/parser_obj.pyÚ__init__szParsable.__init__cCs tttfS)a Returns object types that this class should be able to `parse` recusrively. The order of the objects indicates the order in which the parser should try to parse each subitem. :returns: A list of Parsable classes. :rtype list: )ÚBlockÚSentenceÚ Statements)Úclsr r r Ú parsing_hooksszParsable.parsing_hookscCs tƒ‚dS)z§ Returns whether the contents of `lists` can be parsed into this object. :returns: Whether `lists` can be parsed as this object. :rtype bool: N©ÚNotImplementedError©Úlistsr r r Ú should_parse)szParsable.should_parseFcCs tƒ‚dS)aZ Loads information into this object from underlying raw_list structure. Each Parsable object might make different assumptions about the structure of raw_list. :param list raw_list: A list or sublist of tokens from pyparsing, containing whitespace as separate tokens. :param bool add_spaces: If set, the method can and should manipulate and insert spacing between non-whitespace tokens and lists to delimit them. :raises .errors.MisconfigurationError: when the assumptions about the structure of raw_list are not met. Nr©r Zraw_listÚ add_spacesr r r Úparse3s zParsable.parsecCs tƒ‚dS)a Iterates across this object. If this object is a leaf object, only yields itself. If it contains references other parsing objects, and `expanded` is set, this function should first yield itself, then recursively iterate across all of them. :param bool expanded: Whether to recursively iterate on possible children. :param callable match: If provided, an object is only iterated if this callable returns True when called on that object. :returns: Iterator over desired objects. Nr©r ÚexpandedÚmatchr r r ÚiterateBs zParsable.iteratecCs tƒ‚dS)a” Guess at the tabbing style of this parsed object, based on whitespace. If this object is a leaf, it deducts the tabbing based on its own contents. Other objects may guess by calling `get_tabs` recursively on child objects. :returns: Guess at tabbing for this object. Should only return whitespace strings that does not contain newlines. :rtype str: Nr©r r r r Úget_tabsOs zParsable.get_tabsú cCs tƒ‚dS)a!This tries to set and alter the tabbing of the current object to a desired whitespace string. Primarily meant for objects that were constructed, so they can conform to surrounding whitespace. :param str tabs: A whitespace string (not containing newlines). Nr©r Útabsr r r Úset_tabs\szParsable.set_tabscs‡fdd„|jDƒS)a— Dumps back to pyparsing-like list tree. The opposite of `parse`. Note: if this object has not been modified, `dump` with `include_spaces=True` should always return the original input of `parse`. :param bool include_spaces: If set to False, magically hides whitespace tokens from dumped output. :returns: Pyparsing-like list tree. :rtype list: csg|]}| ˆ¡‘qSr )Údump©Ú.0Úelem©Úinclude_spacesr r Ú rsz!Parsable.dump..©r©r r*r r)r r%fs z Parsable.dump)N)F)FN)r!)F)Ú__name__Ú __module__Ú __qualname__Ú__doc__ÚabcÚABCMetaZ __metaclass__r Ú classmethodrÚ staticmethodÚabstractmethodrrrr r$r%r r r r rs"       rcsbeZdZdZd‡fdd„ Zedd„ƒZddd „Zdd d „Zd d„Z d‡fdd„ Z ddd„Z ‡Z S)ra" A group or list of "Statements". A Statement is either a Block or a Sentence. The underlying representation is simply a list of these Statement objects, with an extra `_trailing_whitespace` string to keep track of the whitespace that does not precede any more statements. Ncstt|ƒ |¡d|_dSr)Úsuperrr Ú_trailing_whitespacer ©Ú __class__r r r |szStatements.__init__cCs t|tƒSr)Ú isinstanceÚlistrr r r r‚szStatements.should_parser!cCs4|jD]}| |¡q|jdk r0d|j ¡|_dS)aE Sets the tabbing for this set of statements. Does this by calling `set_tabs` on each of the child statements. Then, if a parent is present, sets trailing whitespace to parent tabbing. This is so that the trailing } of any Block that contains Statements lines up with parent tabbing. NÚ )rr$rr r8)r r#Z statementr r r r$†s   zStatements.set_tabsFcsdt|tƒst d¡‚|rJt|dtjƒrJ|d ¡rJ|dˆ_|dd…}‡‡fdd„|Dƒˆ_dS)zÌ Parses a list of statements. Expects all elements in `raw_list` to be parseable by `type(self).parsing_hooks`, with an optional whitespace string at the last index of `raw_list`. z"Statements parsing expects a list!éÿÿÿÿNcsg|]}t|ˆˆƒ‘qSr )Ú parse_rawr&©rr r r r+žsz$Statements.parse..) r;r<rÚMisconfigurationErrorÚsixÚ string_typesÚisspacer8rrr r@r r“s      zStatements.parsecCs|jr|jd ¡SdS)zs Takes a guess at the tabbing of all contained Statements by retrieving the tabbing of the first Statement.rÚ)rr rr r r r  szStatements.get_tabscs.tt|ƒ |¡}|r*|jdk r*||jgS|S)z€ Dumps this object by first dumping each statement, then appending its trailing whitespace (if `include_spaces` is set) N)r7rr%r8)r r*Údatar9r r r%§s zStatements.dumpccs(|jD]}| ||¡D] }|VqqdS)z& Combines each statement's iterator. N)rr)r rrr(Zsub_elemr r r r¯s zStatements.iterate)N)r!)F)F)FN) r.r/r0r1r r5rr$rr r%rÚ __classcell__r r r9r rus  rcCsbg}ttj t|ƒ¡ƒD]D}| d||¡|dkr|| ¡s||d ¡s| dd¡q|S)z< Inserts whitespace between adjacent non-whitespace tokens. réú )ÚreversedrBÚmovesÚxrangeÚlenÚinsertrD)Úlist_Zspaced_statementÚir r r Ú _space_list¸s $rQc@sheZdZdZedd„ƒZddd„Zddd „Zdd d „Zdd d„Z dd„Z e dd„ƒZ dd„Z dd„ZdS)rzW A list of words. Non-whitespace words are typically separated with whitespace tokens. cCs(t|tƒo&t|ƒdko&tdd„|DƒƒS)zó Returns True if `lists` can be parseable as a `Sentence`-- that is, every element is a string type. :param list lists: The raw unparsed list to check. :returns: whether this lists is parseable by `Sentence`. rcSsg|]}t|tjƒ‘qSr ©r;rBrCr&r r r r+Ñsz)Sentence.should_parse..)r;r<rMÚallrr r r rÇs ÿzSentence.should_parseFcCs<|r t|ƒ}t|tƒr(tdd„|Dƒƒr2t d¡‚||_dS)z Parses a list of string types into this object. If add_spaces is set, adds whitespace tokens between adjacent non-whitespace tokens.cSsg|]}t|tjƒ ‘qSr rRr&r r r r+Ùsz"Sentence.parse..z0Sentence parsing expects a list of string types.N)rQr;r<ÚanyrrArrr r r rÓs ÿ zSentence.parseNccs|dks||ƒr|VdS)z Simply yields itself. Nr rr r r rÝszSentence.iterater!cCs(|jd ¡rdS|j dd|¡dS)zk Sets the tabbing on this sentence. Inserts a newline and `tabs` at the beginning of `self._data`. rNr=)rrDrNr"r r r r$âszSentence.set_tabscCs|s |jS|jS)zK Dumps this sentence. If include_spaces is set, includes whitespace tokens.)Úwordsrr-r r r r%ész Sentence.dumpcCs0|jd}| ¡sdS| d¡}||dd…S)z˜ Guesses at the tabbing of this sentence. If the first element is whitespace, returns the whitespace after the rightmost newline in the string. rrEr=rHN)rrDÚrfind)r ÚfirstÚrindexr r r r ïs   zSentence.get_tabscCsdd„|jDƒS)z> Iterates over words, but without spaces. Like Unspaced List. cSsg|]}| ¡s| d¡‘qS)z"')rDÚstrip)r'Úwordr r r r+ýsz"Sentence.words..r,rr r r rUúszSentence.wordscCs |j|Sr©rU)r Úindexr r r Ú __getitem__ÿszSentence.__getitem__cCs ||jkSrr[)r rZr r r Ú __contains__szSentence.__contains__)F)FN)r!)F)r.r/r0r1r5rrrr$r%r ÚpropertyrUr]r^r r r r rÂs     rcsTeZdZdZd‡fdd„ Zedd„ƒZddd „Zdd d „Zdd d„Z dd„Z ‡Z S)rar Any sort of bloc, denoted by a block name and curly braces, like so: The parsed block: block name { content 1; content 2; } might be represented with the list [names, contents], where names = ["block", " ", "name", " "] contents = [[" ", "content", " ", "1"], [" ", "content", " ", "2"], " "] Ncs tt|ƒ |¡d|_d|_dSr)r7rr ÚnamesÚcontentsr r9r r r szBlock.__init__cCs2t|tƒo0t|ƒdko0t |d¡o0t|dtƒS)a- Returns True if `lists` can be parseable as a `Block`-- that is, it's got a length of 2, the first element is a `Sentence` and the second can be a `Statements`. :param list lists: The raw unparsed list to check. :returns: whether this lists is parseable by `Block`. érrH)r;r<rMrrrr r r rs  ÿ ÿzBlock.should_parser!cCs |j |¡|j |d¡dS)z[ Sets tabs by setting equivalent tabbing on names, then adding tabbing to contents.r!N)r`r$rar"r r r r$"s zBlock.set_tabsFccs8|dks||ƒr|V|r4|j ||¡D] }|Vq(dS)z@ Iterator over self, and if expanded is set, over its contents. N)rar)r rrr(r r r r(s z Block.iteratecCspt |¡st d¡‚t|ƒ|_|r0|d d¡|j |d|¡t|ƒ|_ |j  |d|¡|j|j g|_ dS)a¸ Parses a list that resembles a block. The assumptions that this routine makes are: 1. the first element of `raw_list` is a valid Sentence. 2. the second element of `raw_list` is a valid Statement. If add_spaces is set, we call it recursively on `names` and `contents`, and add an extra trailing space to `names` (to separate the block's opening bracket and the block name). z®Block parsing expects a list of length 2. First element should be a list of string types (the bloc names), and second should be another list of statements (the bloc content).rrIrHN) rrrrArr`Úappendrrrarrr r r r0s    z Block.parsecCs |j ¡S)z< Guesses tabbing by retrieving tabbing guess of self.names. )r`r rr r r r FszBlock.get_tabs)N)r!)FN)F) r.r/r0r1r r5rr$rrr rGr r r9r rs    rcCst|tƒsdS|jddkS)z¡ Checks whether parsed_obj is a comment. :param .Parsable parsed_obj: :returns: whether parsed_obj represents a comment sentence. :rtype bool: Frr)r;rrU)Ú parsed_objr r r Ú _is_commentJs recCsLt|ƒs dSt|jƒttƒkr"dSt|jƒD]\}}|t|kr,dSq,dS)zº Checks whether parsed_obj is a "managed by Certbot" comment. :param .Parsable parsed_obj: :returns: whether parsed_obj is a "managed by Certbot" comment. :rtype bool: FT)rerMrUÚ COMMENT_BLOCKÚ enumerate)rdrPrZr r r Ú_is_certbot_commentVs rhécCs t|ƒ}| d|gt¡|S)zß A "Managed by Certbot" comment. :param int preceding_spaces: Number of spaces between the end of the previous statement and the comment. :returns: Sentence containing the comment. :rtype: .Sentence rI)rrrf)rZpreceding_spacesÚresultr r r Ú_certbot_commentgsrkcCsFt ¡}|rt|ƒ ¡}|D]}| |¡r||ƒSqt d¡‚dS)zf Choose a parser from type(parent).parsing_hooks, depending on whichever hook returns True first. zUNone of the parsing hooks succeeded, so we don't know how to parse this set of lists.N)rrÚtyperrrA)rrOÚhooksÚtype_r r r Ú_choose_parserrs  ÿroFcCst||ƒ}| ||¡|S)a  Primary parsing factory function. :param list lists_: raw lists from pyparsing to parse. :param .Parent parent: The parent containing this object. :param bool add_spaces: Whether to pass add_spaces to the parser. :returns .Parsable: The parsed object. :raises errors.MisconfigurationError: If no parsing hook passes, and we can't determine which type to parse the raw lists into. )ror)Zlists_rrÚparserr r r r?~s  r?)ri)NF)r1r2ÚloggingrBZcertbotrZacme.magic_typingrÚ getLoggerr.ÚloggerÚCOMMENTrfÚobjectrrrQrrrerhrkror?r r r r Ús$   dC DD