← Back
Editing: parser_obj.cpython-38.pyc
U �]�: � @ s� d Z ddlZddlZddlZddlmZ ddlmZ e�e �Z dZ de gZ G dd� de �ZG d d � d e�Zd d � ZG d d� de�ZG dd� de�Zdd� Zdd� Zd dd�Zdd� Zd dd �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� e Zd ZdZejZddd�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 Nc C s g | _ d | _|| _d S �N)�_dataZ_tabs�parent��selfr � r �:/usr/lib/python3/dist-packages/certbot_nginx/parser_obj.py�__init__ s zParsable.__init__c C s t ttfS )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_hooks s zParsable.parsing_hooksc C s 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�Zlistsr r r � should_parse) s zParsable.should_parseFc C s 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 �parse3 s zParsable.parsec C s 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 �iterateB s zParsable.iteratec C s 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_tabsO s zParsable.get_tabs� c C s 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\ s zParsable.set_tabsc s � fdd�| j D �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: c s g | ]}|� � ��qS r )�dump��.0�elem��include_spacesr r � <listcomp>r s z!Parsable.dump.<locals>.<listcomp>�r �r r) r r( r r$ f s z Parsable.dump)N)F)FN)r )F)�__name__� __module__� __qualname__�__doc__�abc�ABCMetaZ __metaclass__r � classmethodr � staticmethod�abstractmethodr r r r r# r$ r r r r r s" r c sb e Zd ZdZd� fdd� Zedd� �Zddd �Zdd d �Zd d� Z d� fdd� Z ddd�Z � Z S )r a" 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. Nc s t t| ��|� d | _d S r )�superr r �_trailing_whitespacer �� __class__r r r | s zStatements.__init__c C s t | t�S r )� isinstance�listr r r r r � s zStatements.should_parser c C s4 | j D ]}|�|� 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� )r r# r r r7 )r r" Z statementr r r r# � s zStatements.set_tabsFc sd t |t�st�d��|rJt |d tj�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!���Nc s g | ]}t |�� ��qS r )� parse_rawr% �r r r r r* � s z$Statements.parse.<locals>.<listcomp>) r: r; r �MisconfigurationError�six� string_types�isspacer7 r r r r? r r � s zStatements.parsec C s | j r| j d �� S dS )zs Takes a guess at the tabbing of all contained Statements by retrieving the tabbing of the first Statement.r � )r r r r r r r � s zStatements.get_tabsc s. t t| ��|�}|r*| jdk r*|| jg S |S )z� Dumps this object by first dumping each statement, then appending its trailing whitespace (if `include_spaces` is set) N)r6 r r$ r7 )r r) �datar8 r r r$ � s zStatements.dumpc c s( | j D ] }|�||�D ] }|V qqdS )z& Combines each statement's iterator. N)r r )r r r r' Zsub_elemr r r r � s zStatements.iterate)N)r )F)F)FN) r- r. r/ r0 r r4 r r# r r r$ r � __classcell__r r r8 r r u s r c C sb g }t tj�t| ���D ]D}|�d| | � |dkr| | �� s| |d �� s|�dd� q|S )z< Inserts whitespace between adjacent non-whitespace tokens. r � � )�reversedrA ZmovesZxrange�len�insertrC )�list_Zspaced_statement�ir r r � _space_list� s $rN c @ sh e Zd ZdZedd� �Zddd�Zddd �Zdd d �Zdd d�Z dd� Z e dd� �Z dd� Z dd� ZdS )r zW A list of words. Non-whitespace words are typically separated with whitespace tokens. c C s( 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`. r c S s g | ]}t |tj��qS r �r: rA rB r% r r r r* � s z)Sentence.should_parse.<locals>.<listcomp>)r: r; rJ �allr r r r r � s �zSentence.should_parseFc C s< |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.c S s g | ]}t |tj� �qS r rO r% r r r r* � s z"Sentence.parse.<locals>.<listcomp>z0Sentence parsing expects a list of string types.N)rN r: r; �anyr r@ r r r r r r � s � zSentence.parseNc c s |dks|| �r| V dS )z Simply yields itself. Nr r r r r r � s zSentence.iterater c C s( | j d �� rdS | j �dd| � dS )zk Sets the tabbing on this sentence. Inserts a newline and `tabs` at the beginning of `self._data`. r Nr< )r rC rK r! r r r r# � s zSentence.set_tabsc C s |s | j S | jS )zK Dumps this sentence. If include_spaces is set, includes whitespace tokens.)�wordsr r, r r r r$ � s z Sentence.dumpc C s0 | j d }|�� sdS |�d�}||d d� 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. r rD r< rG N)r rC �rfind)r �first�rindexr r r r � s zSentence.get_tabsc C s dd� | j D �S )z> Iterates over words, but without spaces. Like Unspaced List. c S s g | ]}|� � s|�d ��qS )z"')rC �strip)r& �wordr r r r* � s z"Sentence.words.<locals>.<listcomp>r+ r r r r rR � s zSentence.wordsc C s | j | S r �rR )r �indexr r r � __getitem__� s zSentence.__getitem__c C s || j kS r rX )r rW r r r � __contains__ s zSentence.__contains__)F)FN)r )F)r- r. r/ r0 r4 r r r r# r$ r �propertyrR rZ r[ r r r r r � s r c sT e Zd ZdZd� fdd� Zedd� �Zddd �Zdd d �Zdd d�Z dd� Z � Z S )r ar 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"], " "] Nc s t t| ��|� d | _d | _d S r )r6 r r �names�contentsr r8 r r r s zBlock.__init__c C s2 t | t�o0t| �dko0t�| d �o0t | d t�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`. � r rG )r: r; rJ r r r r r r r s � �zBlock.should_parser c C s | j �|� | j�|d � dS )z[ Sets tabs by setting equivalent tabbing on names, then adding tabbing to contents.r N)r] r# r^ r! r r r r# " s zBlock.set_tabsFc c s8 |dks|| �r| V |r4| j �||�D ] }|V q(dS )z@ Iterator over self, and if expanded is set, over its contents. N)r^ r )r r r r' r r r r ( s z Block.iteratec C sp t �|�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).r rH rG N) r r r r@ r r] �appendr r r^ r r r r r r 0 s z Block.parsec C s | j �� S )z< Guesses tabbing by retrieving tabbing guess of self.names. )r] r r r r r r F s zBlock.get_tabs)N)r )FN)F) r- r. r/ r0 r r4 r r# r r r rF r r r8 r r s r c C s t | t�sdS | jd dkS )z� Checks whether parsed_obj is a comment. :param .Parsable parsed_obj: :returns: whether parsed_obj represents a comment sentence. :rtype bool: Fr r )r: r rR )� parsed_objr r r � _is_commentJ s rb c C sL t | �s dS t| j�tt�kr"dS t| j�D ]\}}|t| kr, dS q,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)rb rJ rR � COMMENT_BLOCK� enumerate)ra rM rW r r r �_is_certbot_commentV s re � c C s 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 rH )r r rc )r Zpreceding_spaces�resultr r r �_certbot_commentg s rh c C sF t �� }| rt| ��� }|D ]}|�|�r || � S q t�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)r r �typer r r@ )r rL ZhooksZtype_r r r �_choose_parserr s �rj Fc C s t || �}|�| |� |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. )rj r )Zlists_r r �parserr r r r> ~ s r> )rf )NF)r0 r1 ZloggingrA Zcertbotr Zacme.magic_typingr Z getLoggerr- Zlogger�COMMENTrc �objectr r rN r r rb re rh rj r> r r r r �<module> s$ dC DD
Save File
Cancel