M/e> dZddlZddlZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z dd l m Z ejeZd Zd egZGddZGddeZde edeefdZGddeZGddeZdedefdZdedefdZd#dededefdZdededefdZd$d edeed!edefd"Zy)%zx This file contains parsing routines and object classes to help derive meaning from raw lists of tokens from pyparsing. N)Any)Callable)Iterator)List)Optional)Sequence)Tuple)Type)errorsz managed by Certbot#c eZdZdZej ZddedfdZe de e de de dffd Z e ejd edefd Zejdd eed eddfdZej ddedeedgefdeefdZejdefdZejddeddfdZddedeefdZy)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 Nparentc.g|_d|_||_yN)_data_tabsr)selfrs D/usr/lib/python3/dist-packages/certbot_nginx/_internal/parser_obj.py__init__zParsable.__init__"s "   returnBlockSentence Statementsc$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: )rrr)clss r parsing_hookszParsable.parsing_hooks'sh **rlistsct)z Returns whether the contents of `lists` can be parsed into this object. :returns: Whether `lists` can be parsed as this object. :rtype bool: NotImplementedErrorrs r should_parsezParsable.should_parse1 "##rraw_list add_spacesct)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. r!rr&r's rparsezParsable.parse;s "##rexpandedmatchct)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. r!rr+r,s riteratezParsable.iterateJs "##rct)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: r!rs rget_tabszParsable.get_tabsXs "##rtabsct)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). r!rr3s rset_tabszParsable.set_tabser%rinclude_spacesc^|jDcgc]}|j|c}Scc}w)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: )rdump)rr7elems rr9z Parsable.dumpos%7;jjAd .)AAAs*rFFN )__name__ __module__ __qualname____doc__abcABCMeta __metaclass__rr classmethodr r r staticmethodabstractmethodrboolr$rr*rrr/strr2r6r9rrrrsk KKMx 3 +eDM4 3CT,EW$WX++$C$D$$  $d3i $T $d $ $ ',@D $ $*t); <= $IQRU $ $  $# $ $ $S$d$$ B4 BDI BrrceZdZdZddeeffd Zedede fdZ dde ddfd Z dd e ed e ddfd Zde fd Zdde de effd Z dde deedge fdeefdZxZS)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. Nrc2t||d|_yr)superr_trailing_whitespacerr __class__s rrzStatements.__init__s  $(!rrrc"t|tSr) isinstancelistr#s rr$zStatements.should_parses%&&rr3c|jD]}|j||j#d|jjz|_yy)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 )rr6rr2rO)rr3 statements rr6zStatements.set_tabssN %I   t $ % ;; "(,t{{/C/C/E(ED % #rr&r'ct|tstjd|r5t|dtr"|dj r|d|_|dd}|Dcgc]}t|||c}|_ycc}w)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!N) rSrTr MisconfigurationErrorrJisspacerO parse_rawr)rr&r'r:s rr*zStatements.parsest (D)../ST T  8B<5(2,:N:N:P(0 D %}HDLMDidJ7M Ms!A>cV|jr|jdjSy)zs Takes a guess at the tabbing of all contained Statements by retrieving the tabbing of the first Statement.r)rr2r1s rr2zStatements.get_tabss% ::::a=))+ +rr7cbt||}|r|j||jgzS|S)z Dumps this object by first dumping each statement, then appending its trailing whitespace (if `include_spaces` is set) )rNr9rO)rr7datarQs rr9zStatements.dumps:w|N+ d77C44455 5 rr+r,rc#dK|jD]}|j||D]}|yw)z& Combines each statement's iterator. N)rr/)rr+r,r:sub_elems rr/zStatements.iterates:JJ D LL59   s.0rr=r;r<)r?r@rArBrrrrGrrIr$rJr6rr*r2r9rrr/ __classcell__rQs@rrr~s )x1) 'C'D'' FS Fd F Nd3i NT Nd N#4DI(-@D*t); <=IQRUrrlist_rcg}ttt|D]Z}|jd|||dkDs||j r2||dz j rI|jdd\|S)z< Inserts whitespace between adjacent non-whitespace tokens. r )reversedrangeleninsertr[)respaced_statementis r _space_listrosz"$ eCJ' (,58, q5q))+E!A#J4F4F4H  # #As +, rceZdZdZededefdZddeededdfdZ dd ed e e e gefde efd Zdd eddfd ZddedeefdZdefdZedeefdZdedefdZdedefdZy)rzW A list of words. Non-whitespace words are typically separated with whitespace tokens. rrcjt|txr"t|dkDxrtd|DS)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`. rc3<K|]}t|tywrrSrJ.0r:s r z(Sentence.should_parse..srr&r'Nc|r t|}t|trtd|Drt j d||_y)z Parses a list of string types into this object. If add_spaces is set, adds whitespace tokens between adjacent non-whitespace tokens.c3>K|]}t|t ywrrsrts rrvz!Sentence.parse..sFT:dC00Fsz0Sentence parsing expects a list of string types.N)rorSrTanyr rZrr)s rr*zSentence.parsesB "8,H8T*FXFF../ab b rr+r,c#*K|||r|yyw)z Simply yields itself. NrKr.s rr/zSentence.iterates =E$KJ(sr3c~|jdjry|jjdd|zy)zk Sets the tabbing on this sentence. Inserts a newline and `tabs` at the beginning of `self._data`. rNrV)rr[rlr5s rr6zSentence.set_tabss3 ::a= "  !TD[)rr7c6|s |jS|jS)zK Dumps this sentence. If include_spaces is set, includes whitespace tokens.)wordsr)rr7s rr9z Sentence.dumps:: zzrct|jd}|jsy|jd}||dzdS)z Guesses at the tabbing of this sentence. If the first element is whitespace, returns the whitespace after the rightmost newline in the string. rr^rVrgN)rr[rfind)rfirstrindexs rr2zSentence.get_tabss< 1 }}T"VAXYrc|jDcgc]$}|jr|jd&c}Scc}w)z> Iterates over words, but without spaces. Like Unspaced List. z"')rr[striprwords rr~zSentence.wordss-04zzPt 6"PPPs;;indexc |j|Srr~)rrs r __getitem__zSentence.__getitem__ szz%  rrc||jvSrrrs r __contains__zSentence.__contains__ stzz!!rr;r<r=)r?r@rArBrGrrIr$rr*rrrrr/rJr6r9r2propertyr~intrrrKrrrrsa >C >D > >d3iTd(->B(T)9 :;GOPS} *S*d*4DI  # QtCyQQ!!!"""rrceZdZdZddeeddffd Zedede fdZ dde ddfd Z dd e d ee ege fdeefd Zdd eede ddfdZde fdZxZS)ras Any sort of block, 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"], " "] Nrrc@t||d|_d|_yr)rNrnamescontentsrPs rrzBlock.__init__s  )- )- rrct|txr=t|dk(xr-tj |dxrt|dtS)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`. rrg)rSrTrkrr$r#s rr$zBlock.should_parse!sP%&N3u:?N$$U1X.N3=eAh3M Nrr3cv|jj||jj|dzy)z[ Sets tabs by setting equivalent tabbing on names, then adding tabbing to contents.r>N)rr6rr5s rr6zBlock.set_tabs-s, D! tf}-rr+r,c#xK|||r||r&|jj||D]}|yyw)z@ Iterator over self, and if expanded is set, over its contents. N)rr/)rr+r,r:s rr/z Block.iterate3sE =E$KJ  --h>    s8:r&r'cztj|stjdt ||_|r|dj d|j j|d|t||_ |jj|d||j |jg|_ y)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). zBlock parsing expects a list of length 2. First element should be a list of string types (the block names), and second should be another list of statements (the block content).rrhrgN) rr$r rZrrappendr*rrrr)s rr*z Block.parse<s!!(+..0WX Xd^  QK  s # !j1"4(  HQK4jj$--0 rc6|jjS)z< Guesses tabbing by retrieving tabbing guess of self.names. )rr2r1s rr2zBlock.get_tabsRszz""$$rrr=r<r;)r?r@rArBrrrrGrrIr$rJr6rrr/rr*r2rcrds@rrrs .x1.T.  NC ND N N.S.d. (->B(T)9 :;GOPS}1d3i1T1d1,%#%rr parsed_objcHt|tsy|jddk(S)z Checks whether parsed_obj is a comment. :param .Parsable parsed_obj: :returns: whether parsed_obj represents a comment sentence. :rtype bool: Frr )rSrr~)rs r _is_commentrWs' j( +   A # %%rct|syt|jttk7ryt |jD]\}}|t|k7syy)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)rrkr~ COMMENT_BLOCK enumerate)rrnrs r_is_certbot_commentrds] z " :  M 22Z--.4 =# # rrpreceding_spacescTt|}|jd|zgtz|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 rh)rr*r)rrresults r_certbot_commentrvs-f F LL#(()M9: Mrctj}|rt|j}|D]}|j|s||cSt j d)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.)rrtyper$r rZ)rrehookstype_s r_choose_parserrsh  " " $E V **,!   e $= !  & &_ aarlists_r'cBt||}|j|||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. )rr*)rrr'parsers rr\r\s#FF +F LL$ Mr))NF) rBrCloggingtypingrrrrrrr r certbotr getLoggerr?loggerCOMMENTrrrrJrorrrIrrrrrr\rKrrrs'(    8 $ g bBbBJ??Hx}cB"xB"JC%HC%L &H & &H$ X  X  a8 aC aH ac8H#5$[cr