yapf-0.15.1/000077500000000000000000000000001304174360200125355ustar00rootroot00000000000000yapf-0.15.1/.coveragerc000066400000000000000000000001251304174360200146540ustar00rootroot00000000000000[report] # Verifier is used for testing only. omit = */__main__.py */verifier.py yapf-0.15.1/.editorconfig000066400000000000000000000004111304174360200152060ustar00rootroot00000000000000# EditorConfig is awesome: http://EditorConfig.org # top-most EditorConfig file root = true # Unix-style newlines with a newline ending every file [*] end_of_line = lf insert_final_newline = true # 2 space indentation [*.py] indent_style = space indent_size = 2 yapf-0.15.1/.flake8000066400000000000000000000002571304174360200137140ustar00rootroot00000000000000[flake8] ignore = # indentation is not a multiple of four, E111,E114, # visually indented line with same indent as next logical line, E129 max-line-length=80 yapf-0.15.1/.gitignore000066400000000000000000000022631304174360200145300ustar00rootroot00000000000000#==============================================================================# # This file specifies intentionally untracked files that git should ignore. # See: http://www.kernel.org/pub/software/scm/git/docs/gitignore.html # # This file is intentionally different from the output of `git svn show-ignore`, # as most of those are useless. #==============================================================================# #==============================================================================# # File extensions to be ignored anywhere in the tree. #==============================================================================# # Temp files created by most text editors. *~ # Merge files created by git. *.orig # Byte compiled python modules. *.pyc # vim swap files .*.sw? .sw? # OS X specific files. .DS_store #==============================================================================# # Files to ignore #==============================================================================# /.coverage # Directories to ignore (do not add trailing '/'s, they skip symlinks). #==============================================================================# /build /dist /.tox /yapf.egg-info yapf-0.15.1/.style.yapf000066400000000000000000000001011304174360200146240ustar00rootroot00000000000000[style] # YAPF uses the chromium style based_on_style = chromium yapf-0.15.1/.travis.yml000066400000000000000000000011021304174360200146400ustar00rootroot00000000000000language: python python: - 2.7 - 3.4 - 3.5 - 3.6 - nightly matrix: allow_failures: - python: nightly include: - python: 2.7 env: SCA=true - python: 3.5 env: SCA=true install: - if [ -z "$SCA" ]; then pip install --quiet coveralls; else echo skip; fi - if [ -n "$SCA" ]; then python setup.py develop; else echo skip; fi script: - if [ -n "$SCA" ]; then yapf --diff --recursive . || exit; else echo skip; fi - if [ -z "$SCA" ]; then nosetests --with-coverage --cover-package=yapf; else echo skip; fi after_success: - coveralls yapf-0.15.1/.vimrc000066400000000000000000000002471304174360200136610ustar00rootroot00000000000000" Force indentation styles for this directory autocmd FileType python set shiftwidth=2 autocmd FileType python set tabstop=2 autocmd FileType python set softtabstop=2 yapf-0.15.1/AUTHORS000066400000000000000000000004631304174360200136100ustar00rootroot00000000000000# This is the official list of YAPF authors for copyright purposes. # This file is distinct from the CONTRIBUTORS files. # See the latter for an explanation. # Names should be added to this file as: # Name or Organization # The email address is not required for organizations. Google Inc. yapf-0.15.1/CHANGELOG000066400000000000000000000342631304174360200137570ustar00rootroot00000000000000# Change Log # All notable changes to this project will be documented in this file. # This project adheres to [Semantic Versioning](http://semver.org/). ## [0.15.1] 2017-01-21 ### Fixed - Don't insert a space between a type hint and the '=' sign. - The '@' operator can be used in Python 3 for matrix multiplication. Give the '@' in the decorator a DECORATOR subtype to distinguish it. - Encourage the formatter to split at the beginning of an argument list instead of in the middle. Especially if the middle is an empty parameter list. This adjusts the affinity of binary and comparison operators. In particular, the "not in" and other such operators don't want to have a split after it (or before it) if at all possible. ## [0.15.0] 2017-01-12 ### Added - Keep type annotations intact as much as possible. Don't try to split the over mutliple lines. ### Fixed - When determining if each element in a dictionary can fit on a single line, we are skipping dictionary entries. However, we need to ignore comments in our calculations and implicitly concatenated strings, which are already placed on separate lines. - Allow text before a "pylint" comment. - Also allow text before a "yapf: (disable|enable)" comment. ## [0.14.0] 2016-11-21 ### Added - formatting can be run in parallel using the "-p" / "--parallel" flags. ### Fixed - "not in" and "is not" should be subtyped as binary operators. - A non-Node dictionary value may have a comment before it. In those cases, we want to avoid encompassing only the comment in pseudo parens. So we include the actual value as well. - Adjust calculation so that pseudo-parentheses don't count towards the total line length. - Don't count a dictionary entry as not fitting on a single line in a dictionary. - Don't count pseudo-parentheses in the length of the line. ## [0.13.2] 2016-10-22 ### Fixed - REGRESSION: A comment may have a prefix with newlines in it. When calculating the prefix indent, we cannot take the newlines into account. Otherwise, the comment will be misplaced causing the code to fail. ## [0.13.1] 2016-10-17 ### Fixed - Correct emitting a diff that was accidentally removed. ## [0.13.0] 2016-10-16 ### Added - Added support to retain the original line endings of the source code. ### Fixed - Functions or classes with comments before them were reformatting the comments even if the code was supposed to be ignored by the formatter. We now don't adjust the whitespace before a function's comment if the comment is a "disabled" line. We also don't count "# yapf: {disable|enable}" as a disabled line, which seems logical. - It's not really more readable to split before a dictionary value if it's part of a dictionary comprehension. - Enforce two blank lines after a function or class definition, even before a comment. (But not between a decorator and a comment.) This is related to PEP8 error E305. - Remove O(n^2) algorithm from the line disabling logic. ## [0.12.2] 2016-10-09 ### Fixed - If `style.SetGlobalStyle()` was called and then `yapf_api.FormatCode` was called, the style set by the first call would be lost, because it would return the style created by `DEFAULT_STYLE_FACTORY`, which is set to PEP8 by default. Fix this by making the first call set which factory we call as the "default" style. - Don't force a split before non-function call arguments. - A dictionary being used as an argument to a function call and which can exist on a single line shouldn't be split. - Don't rely upon the original line break to determine if we should split before the elements in a container. Especially split if there's a comment in the container. - Don't add spaces between star and args in a lambda expression. - If a nested data structure terminates in a comma, then split before the first element, but only if there's more than one element in the list. ## [0.12.1] 2016-10-02 ### Changed - Dictionary values will be placed on the same line as the key if *all* of the elements in the dictionary can be placed on one line. Otherwise, the dictionary values will be placed on the next line. ### Fixed - Prefer to split before a terminating r-paren in an argument list if the line would otherwise go over the column limit. - Split before the first key in a dictionary if the dictionary cannot fit on a single line. - Don't count "pylint" comments when determining if the line goes over the column limit. - Don't count the argument list of a lambda as a named assign in a function call. ## [0.12.0] 2016-09-25 ### Added - Support formatting of typed names. Typed names are formatted a similar way to how named arguments are formatted, except that there's a space after the colon. - Add a knob, 'SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN', to allow adding spaces around the assign operator on default or named assigns. ## Changed - Turn "verification" off by default for external APIs. - If a function call in an argument list won't fit on the current line but will fit on a line by itself, then split before the call so that it won't be split up unnecessarily. ## Fixed - Don't add space after power operator if the next operator's a unary operator. ## [0.11.1] 2016-08-17 ### Changed - Issue #228: Return exit code 0 on success, regardless of whether files were changed. (Previously, 0 meant success with no files modified, and 2 meant success with at least one file modified.) ### Fixed - Enforce splitting each element in a dictionary if comma terminated. - It's okay to split in the middle of a dotted name if the whole expression is going to go over the column limit. - Asynchronous functions were going missing if they were preceded by a comment (a what? exactly). The asynchronous function processing wasn't taking the comment into account and thus skipping the whole function. - The splitting of arguments when comma terminated had a conflict. The split penalty of the closing bracket was set to the maximum, but it shouldn't be if the closing bracket is preceded by a comma. ## [0.11.0] 2016-07-17 ### Added - The COALESCE_BRACKETS knob prevents splitting consecutive brackets when DEDENT_CLOSING_BRACKETS is set. - Don't count "pylint" directives as exceeding the column limit. ### Changed - We split all of the arguments to a function call if there's a named argument. In this case, we want to split after the opening bracket too. This makes things look a bit better. ### Fixed - When retaining format of a multiline string with Chromium style, make sure that the multiline string doesn't mess up where the following comma ends up. - Correct for when 'lib2to3' smooshes comments together into the same DEDENT node. ## [0.10.0] 2016-06-14 ### Added - Add a knob, 'USE_TABS', to allow using tabs for indentation. ### Changed - Performance enhancements. ### Fixed - Don't split an import list if it's not surrounded by parentheses. ## [0.9.0] 2016-05-29 ### Added - Added a knob (SPLIT_PENALTY_BEFORE_IF_EXPR) to adjust the split penalty before an if expression. This allows the user to place a list comprehension all on one line. - Added a knob (SPLIT_BEFORE_FIRST_ARGUMENT) that encourages splitting before the first element of a list of arguments or parameters if they are going to be split anyway. - Added a knob (SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED) splits arguments to a function if the list is terminated by a comma. ### Fixed - Don't split before a first element list argument as we would before a first element function call. - Don't penalize when we must split a line. - Allow splitting before the single argument in a function call. ## [0.8.2] 2016-05-21 ### Fixed - Prefer not to split after the opening of a subscript. - Don't add space before the 'await' keyword if it's preceded by an opening paren. - When we're setting the split penalty for a continuous list, we don't want to mistake a comment at the end of that list as part of the list. - When calculating blank lines, don't assume the last seen object was a class or function when we're in a class or function. - Don't count the closing scope when determining if the current scope is the last scope on the line. ## [0.8.1] 2016-05-18 ### Fixed - 'SPLIT_BEFORE_LOGICAL_OPERATOR' wasn't working correctly. The penalty was being set incorrectly when it was part of a larger construct. - Don't separate a keyword, like "await", from a left paren. - Don't rely upon the original tokens' line number to determine if we should perform splitting in Facebook mode. The line number isn't the line number of the reformatted token, but the line number where it was in the original code. Instead, we need to carefully determine if the line is liabel to be split and act accordingly. ## [0.8.0] 2016-05-10 ### Added - Add a knob, 'SPACES_AROUND_POWER_OPERATOR', to allow adding spaces around the power operator. ### Fixed - There shouldn't be a space between a decorator and an intervening comment. - If we split before a bitwise operator, then we assume that the programmer knows what they're doing, more or less, and so we enforce a split before said operator if one exists in the original program. - Strengthen the bond between a keyword and value argument. - Don't add a blank line after a multiline string. - If the "for" part of a list comprehension can exist on the starting line without going over the column limit, then let it remain there. ## [0.7.1] 2016-04-21 ### Fixed - Don't rewrite the file if there are no changes. - Ensure the proper number of blank lines before an async function. - Split after a bitwise operator when in PEP 8 mode. - Retain the splitting within a dictionary data literal between the key and value. - Try to keep short function calls all on one line even if they're part of a larger series of tokens. This stops us from splitting too much. ## [0.7.0] 2016-04-09 ### Added - Support for Python 3.5. - Add 'ALLOW_MULTILINE_LAMBDAS' which allows lambdas to be formatted onto multiple lines. ### Fixed - Lessen penalty for splitting before a dictionary keyword. - Formatting of trailing comments on disabled formatting lines. - Disable / enable formatting at end of multi-line comment. ## [0.6.3] 2016-03-06 ### Changed - Documentation updated. ### Fixed - Fix spacing of multiline comments when formatting is disabled. ## [0.6.2] 2015-11-01 ### Changed - Look at the 'setup.cfg' file to see if it contains style information for YAPF. - Look at the '~/.config/yapf/style' file to see if it contains global style information for YAPF. ### Fixed - Make lists that can fit on one line more likely to stay together. - Correct formatting of '*args' and '**kwargs' when there are default values in the argument list. ## [0.6.1] 2015-10-24 ### Fixed - Make sure to align comments in data literals correctly. Also make sure we don't count a "#." in a string as an i18n comment. - Retain proper vertical spacing before comments in a data literal. - Make sure that continuations from a compound statement are distinguished from the succeeding line. - Ignore preceding comments when calculating what is a "dictonary maker". - Add a small penalty for splitting before a closing bracket. - Ensure that a space is enforced after we remove a pseudo-paren that's between two names, keywords, numbers, etc. - Increase the penalty for splitting after a pseudo-paren. This could lead to less readable code in some circumstances. ## [0.6.0] 2015-10-18 ### Added - Add knob to indent the dictionary value if there is a split before it. ### Changed - No longer check that a file is a "Python" file unless the '--recursive' flag is specified. - No longer allow the user to specify a directory unless the '--recursive' flag is specified. ### Fixed - When determining if we should split a dictionary's value to a new line, use the longest entry instead of the total dictionary's length. This allows the formatter to reformat the dictionary in a more consistent manner. - Improve how list comprehensions are formatted. Make splitting dependent upon whether the "comp_for" or "comp_if" goes over the column limit. - Don't over indent if expression hanging indents if we expect to dedent the closing bracket. - Improve splitting heuristic when the first argument to a function call is itself a function call with arguments. In cases like this, the remaining arguments to the function call would look badly aligned, even though they are techincally correct (the best kind of correct!). - Improve splitting heuristic more so that if the first argument to a function call is a data literal that will go over the column limit, then we want to split before it. - Remove spaces around '**' operator. - Retain formatting of comments in the middle of an expression. - Don't add a newline to an empty file. - Over indent a function's parameter list if it's not distinguished from the body of the function. ## [0.5.0] 2015-10-11 ### Added - Add option to exclude files/directories from formatting. - Add a knob to control whether import names are split after the first '('. ### Fixed - Indent the continuation of an if-then statement when it's not distinguished from the body of the if-then. - Allow for sensible splitting of array indices where appropriate. - Prefer to not split before the ending bracket of an atom. This produces better code in most cases. - Corrected how horizontal spaces were presevered in a disabled region. ## [0.4.0] 2015-10-07 ### Added - Support for dedenting closing brackets, "facebook" style. ### Fixed - Formatting of tokens after a multiline string didn't retain their horizontal spacing. ## [0.3.1] 2015-09-30 ### Fixed - Format closing scope bracket correctly when indentation size changes. ## [0.3.0] 2015-09-20 ### Added - Return a 2 if the source changed, 1 on error, and 0 for no change. ### Fixed - Make sure we format if the "lines" specified are in the middle of a statement. ## [0.2.9] - 2015-09-13 ### Fixed - Formatting of multiple files. It was halting after formatting the first file. ## [0.2.8] - 2015-09-12 ### Added - Return a non-zero exit code if the source was changed. - Add bitwise operator splitting penalty and prefer to split before bitwise operators. ### Fixed - Retain vertical spacing between disabled and enabled lines. - Split only at start of named assign. - Retain comment position when formatting is disabled. - Honor splitting before or after logical ops. yapf-0.15.1/CONTRIBUTING.rst000066400000000000000000000035771304174360200152120ustar00rootroot00000000000000Want to contribute? Great! First, read this page (including the small print at the end). Before you contribute --------------------- Before we can use your code, you must sign the `Google Individual Contributor License Agreement `_ (CLA), which you can do online. The CLA is necessary mainly because you own the copyright to your changes, even after your contribution becomes part of our codebase, so we need your permission to use and distribute your code. We also need to be sure of various other things—for instance that you'll tell us if you know that your code infringes on other people's patents. You don't have to sign the CLA until after you've submitted your code for review and a member has approved it, but you must do it before we can put your code into our codebase. Before you start working on a larger contribution, you should get in touch with us first through the issue tracker with your idea so that we can help out and possibly guide you. Coordinating up front makes it much easier to avoid frustration later on. Code reviews ------------ All submissions, including submissions by project members, require review. We use Github pull requests for this purpose. YAPF coding style ----------------- YAPF follows the `Chromium Python Style Guide `_. It's the same as the Google Python Style guide with two exceptions: - 2 spaces for indentation rather than 4. - CamelCase for function and method names rather than words_with_underscores. The rationale for this is that YAPF was initially developed at Google where these two exceptions are still part of the internal Python style guide. Small print ----------- Contributions made by corporations are covered by a different agreement than the one above, the Software Grant and Corporate Contributor License Agreement. yapf-0.15.1/CONTRIBUTORS000066400000000000000000000010631304174360200144150ustar00rootroot00000000000000# People who have agreed to one of the CLAs and can contribute patches. # The AUTHORS file lists the copyright holders; this file # lists people. For example, Google employees are listed here # but not in AUTHORS, because Google holds the copyright. # # https://developers.google.com/open-source/cla/individual # https://developers.google.com/open-source/cla/corporate # # Names should be added to this file as: # Name Bill Wendling Eli Bendersky Sam Clegg Łukasz Langa yapf-0.15.1/HACKING.rst000066400000000000000000000015301304174360200143320ustar00rootroot00000000000000Running YAPF on itself ---------------------- To run YAPF on all of YAPF:: $ PYTHONPATH=$PWD/yapf python -m yapf -i -r . To run YAPF on just the files changed in the curent git branch:: $ PYTHONPATH=$PWD/yapf python -m yapf -i $(git diff --name-only @{upstream}) Releasing a new version ----------------------- * Run tests: python setup.py test [don't forget to run with Python 2.7 and 3.4] * Bump version in yapf/__init__.py * Build source distribution: python setup.py sdist * Check it looks OK, install it onto a virtualenv, run tests, run yapf as a tool * Push to PyPI: python setup.py sdist bdist_wheel upload * Test in a clean virtualenv that 'pip install yapf' works with the new version * Commit the version bump; add tag with git tag v; git push --tags TODO: discuss how to use tox to make virtualenv testing easier. yapf-0.15.1/LICENSE000066400000000000000000000261361304174360200135520ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. yapf-0.15.1/README.rst000066400000000000000000000445001304174360200142270ustar00rootroot00000000000000==== YAPF ==== .. image:: https://badge.fury.io/py/yapf.svg :target: http://badge.fury.io/py/yapf :alt: PyPI version .. image:: https://travis-ci.org/google/yapf.svg?branch=master :target: https://travis-ci.org/google/yapf :alt: Build status .. image:: https://coveralls.io/repos/google/yapf/badge.svg?branch=master :target: https://coveralls.io/r/google/yapf?branch=master :alt: Coverage status Introduction ============ Most of the current formatters for Python --- e.g., autopep8, and pep8ify --- are made to remove lint errors from code. This has some obvious limitations. For instance, code that conforms to the PEP 8 guidelines may not be reformatted. But it doesn't mean that the code looks good. YAPF takes a different approach. It's based off of 'clang-format', developed by Daniel Jasper. In essence, the algorithm takes the code and reformats it to the best formatting that conforms to the style guide, even if the original code didn't violate the style guide. The idea is also similar to the 'gofmt' tool for the Go programming language: end all holy wars about formatting - if the whole codebase of a project is simply piped through YAPF whenever modifications are made, the style remains consistent throughout the project and there's no point arguing about style in every code review. The ultimate goal is that the code YAPF produces is as good as the code that a programmer would write if they were following the style guide. It takes away some of the drudgery of maintaining your code. .. footer:: YAPF is not an official Google product (experimental or otherwise), it is just code that happens to be owned by Google. .. contents:: Installation ============ To install YAPF from PyPI: .. code-block:: $ pip install yapf (optional) If you are using Python 2.7 and want to enable multiprocessing: .. code-block:: $ pip install futures YAPF is still considered in "alpha" stage, and the released version may change often; therefore, the best way to keep up-to-date with the latest development is to clone this repository. Note that if you intend to use YAPF as a command-line tool rather than as a library, installation is not necessary. YAPF supports being run as a directory by the Python interpreter. If you cloned/unzipped YAPF into ``DIR``, it's possible to run: .. code-block:: $ PYTHONPATH=DIR python DIR/yapf [options] ... Python versions =============== YAPF supports Python 2.7 and 3.4.1+. YAPF requires the code it formats to be valid Python for the version YAPF itself runs under. Therefore, if you format Python 3 code with YAPF, run YAPF itself under Python 3 (and similarly for Python 2). Usage ===== Options:: usage: yapf [-h] [-v] [-d | -i] [-r | -l START-END] [-e PATTERN] [--style STYLE] [--style-help] [--no-local-style] [-p] [files [files ...]] Formatter for Python code. positional arguments: files optional arguments: -h, --help show this help message and exit -v, --version show version number and exit -d, --diff print the diff for the fixed source -i, --in-place make changes to files in place -r, --recursive run recursively over directories -l START-END, --lines START-END range of lines to reformat, one-based -e PATTERN, --exclude PATTERN patterns for files to exclude from formatting --style STYLE specify formatting style: either a style name (for example "pep8" or "google"), or the name of a file with style settings. The default is pep8 unless a .style.yapf or setup.cfg file located in one of the parent directories of the source file (or current directory for stdin) --style-help show style settings and exit --no-local-style don't search for local style definition (.style.yapf) -p, --parallel Run yapf in parallel when formatting multiple files. Requires concurrent.futures in Python 2.X Formatting style ================ The formatting style used by YAPF is configurable and there are many "knobs" that can be used to tune how YAPF does formatting. See the ``style.py`` module for the full list. To control the style, run YAPF with the ``--style`` argument. It accepts one of the predefined styles (e.g., ``pep8`` or ``google``), a path to a configuration file that specifies the desired style, or a dictionary of key/value pairs. The config file is a simple listing of (case-insensitive) ``key = value`` pairs with a ``[style]`` heading. For example: .. code-block:: [style] based_on_style = pep8 spaces_before_comment = 4 split_before_logical_operator = true The ``based_on_style`` setting determines which of the predefined styles this custom style is based on (think of it like subclassing). It's also possible to do the same on the command line with a dictionary. For example: .. code-block:: --style='{based_on_style: chromium, indent_width: 4}' This will take the ``chromium`` base style and modify it to have four space indentations. YAPF will search for the formatting style in the following manner: 1. Specified on the command line 2. In the `[style]` section of a `.style.yapf` file in either the current directory or one of its parent directories. 3. In the `[yapf]` section of a `setup.cfg` file in either the current directory or one of its parent directories. 4. In the `~/.config/yapf/style` file in your home directory. If none of those files are found, the default style is used (PEP8). Example ======= An example of the type of formatting that YAPF can do, it will take this ugly code: .. code-block:: python x = { 'a':37,'b':42, 'c':927} y = 'hello ''world' z = 'hello '+'world' a = 'hello {}'.format('world') class foo ( object ): def f (self ): return 37*-+2 def g(self, x,y=42): return y def f ( a ) : return 37+-+a[42-x : y**3] and reformat it into: .. code-block:: python x = {'a': 37, 'b': 42, 'c': 927} y = 'hello ' 'world' z = 'hello ' + 'world' a = 'hello {}'.format('world') class foo(object): def f(self): return 37 * -+2 def g(self, x, y=42): return y def f(a): return 37 + -+a[42 - x:y**3] Example as a module =================== The two main APIs for calling yapf are ``FormatCode`` and ``FormatFile``, these share several arguments which are described below: .. code-block:: python >>> from yapf.yapf_api import FormatCode # reformat a string of code >>> FormatCode("f ( a = 1, b = 2 )") 'f(a=1, b=2)\n' A ``style_config`` argument: Either a style name or a path to a file that contains formatting style settings. If None is specified, use the default style as set in ``style.DEFAULT_STYLE_FACTORY``. .. code-block:: python >>> FormatCode("def g():\n return True", style_config='pep8') 'def g():\n return True\n' A ``lines`` argument: A list of tuples of lines (ints), [start, end], that we want to format. The lines are 1-based indexed. It can be used by third-party code (e.g., IDEs) when reformatting a snippet of code rather than a whole file. .. code-block:: python >>> FormatCode("def g( ):\n a=1\n b = 2\n return a==b", lines=[(1, 1), (2, 3)]) 'def g():\n a = 1\n b = 2\n return a==b\n' A ``print_diff`` (bool): Instead of returning the reformatted source, return a diff that turns the formatted source into reformatter source. .. code-block:: python >>> print(FormatCode("a==b", filename="foo.py", print_diff=True)) --- foo.py (original) +++ foo.py (reformatted) @@ -1 +1 @@ -a==b +a == b Note: the ``filename`` argument for ``FormatCode`` is what is inserted into the diff, the default is ````. ``FormatFile`` returns reformatted code from the passed file along with its encoding: .. code-block:: python >>> from yapf.yapf_api import FormatFile # reformat a file >>> print(open("foo.py").read()) # contents of file a==b >>> FormatFile("foo.py") ('a == b\n', 'utf-8') The ``in-place`` argument saves the reformatted code back to the file: .. code-block:: python >>> FormatFile("foo.py", in_place=True) (None, 'utf-8') >>> print(open("foo.py").read()) # contents of file (now fixed) a == b Knobs ===== ``ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT`` Align closing bracket with visual indentation. ``ALLOW_MULTILINE_LAMBDAS`` Allow lambdas to be formatted on more than one line. ``BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF`` Insert a blank line before a ``def`` or ``class`` immediately nested within another ``def`` or ``class``. For example: .. code-block:: python class Foo: # <------ this blank line def method(): pass ``COALESCE_BRACKETS`` Do not split consecutive brackets. Only relevant when ``DEDENT_CLOSING_BRACKETS`` is set. For example: .. code-block:: python call_func_that_takes_a_dict( { 'key1': 'value1', 'key2': 'value2', } ) would reformat to: .. code-block:: python call_func_that_takes_a_dict({ 'key1': 'value1', 'key2': 'value2', }) ``COLUMN_LIMIT`` The column limit (or max line-length) ``CONTINUATION_INDENT_WIDTH`` Indent width used for line continuations. ``DEDENT_CLOSING_BRACKETS`` Put closing brackets on a separate line, dedented, if the bracketed expression can't fit in a single line. Applies to all kinds of brackets, including function definitions and calls. For example: .. code-block:: python config = { 'key1': 'value1', 'key2': 'value2', } # <--- this bracket is dedented and on a separate line time_series = self.remote_client.query_entity_counters( entity='dev3246.region1', key='dns.query_latency_tcp', transform=Transformation.AVERAGE(window=timedelta(seconds=60)), start_ts=now()-timedelta(days=3), end_ts=now(), ) # <--- this bracket is dedented and on a separate line ``I18N_COMMENT`` The regex for an internationalization comment. The presence of this comment stops reformatting of that line, because the comments are required to be next to the string they translate. ``I18N_FUNCTION_CALL`` The internationalization function call names. The presence of this function stops reformatting on that line, because the string it has cannot be moved away from the i18n comment. ``INDENT_DICTIONARY_VALUE`` Indent the dictionary value if it cannot fit on the same line as the dictionary key. For example: .. code-block:: python config = { 'key1': 'value1', 'key2': value1 + value2, } ``INDENT_WIDTH`` The number of columns to use for indentation. ``JOIN_MULTIPLE_LINES`` Join short lines into one line. E.g., single line ``if`` statements. ``SPACES_AROUND_POWER_OPERATOR`` Set to ``True`` to prefer using spaces around ``**``. ``SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN`` Set to ``True`` to prefer spaces around the assignment operator for default or keyword arguments. ``SPACES_BEFORE_COMMENT`` The number of spaces required before a trailing comment. ``SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET`` Insert a space between the ending comma and closing bracket of a list, etc. ``SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED`` Split before arguments if the argument list is terminated by a comma. ``SPLIT_BEFORE_BITWISE_OPERATOR`` Set to ``True`` to prefer splitting before ``&``, ``|`` or ``^`` rather than after. ``SPLIT_BEFORE_FIRST_ARGUMENT`` If an argument / parameter list is going to be split, then split before the first argument. ``SPLIT_BEFORE_LOGICAL_OPERATOR`` Set to ``True`` to prefer splitting before ``and`` or ``or`` rather than after. ``SPLIT_BEFORE_NAMED_ASSIGNS`` Split named assignments onto individual lines. ``SPLIT_PENALTY_AFTER_OPENING_BRACKET`` The penalty for splitting right after the opening bracket. ``SPLIT_PENALTY_AFTER_UNARY_OPERATOR`` The penalty for splitting the line after a unary operator. ``SPLIT_PENALTY_BEFORE_IF_EXPR`` The penalty for splitting right before an ``if`` expression. ``SPLIT_PENALTY_BITWISE_OPERATOR`` The penalty of splitting the line around the ``&``, ``|``, and ``^`` operators. ``SPLIT_PENALTY_EXCESS_CHARACTER`` The penalty for characters over the column limit. ``SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT`` The penalty incurred by adding a line split to the unwrapped line. The more line splits added the higher the penalty. ``SPLIT_PENALTY_IMPORT_NAMES`` The penalty of splitting a list of ``import as`` names. For example: .. code-block:: python from a_very_long_or_indented_module_name_yada_yad import (long_argument_1, long_argument_2, long_argument_3) would reformat to something like: .. code-block:: python from a_very_long_or_indented_module_name_yada_yad import ( long_argument_1, long_argument_2, long_argument_3) ``SPLIT_PENALTY_LOGICAL_OPERATOR`` The penalty of splitting the line around the ``and`` and ``or`` operators. ``USE_TABS`` Use the Tab character for indentation. (Potentially) Frequently Asked Questions ======================================== Why does YAPF destroy my awesome formatting? -------------------------------------------- YAPF tries very hard to get the formatting correct. But for some code, it won't be as good as hand-formatting. In particular, large data literals may become horribly disfigured under YAPF. The reason for this is many-fold. But in essence YAPF is simply a tool to help with development. It will format things to coincide with the style guide, but that may not equate with readability. What can be done to alleviate this situation is to indicate regions YAPF should ignore when reformatting something: .. code-block:: python # yapf: disable FOO = { # ... some very large, complex data literal. } BAR = [ # ... another large data literal. ] # yapf: enable You can also disable formatting for a single literal like this: .. code-block:: python BAZ = { (1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12), } # yapf: disable To preserve the nice dedented closing brackets, use the ``dedent_closing_brackets`` in your style. Note that in this case all brackets, including function definitions and calls, are going to use that style. This provides consistency across the formatted codebase. Why Not Improve Existing Tools? ------------------------------- We wanted to use clang-format's reformatting algorithm. It's very powerful and designed to come up with the best formatting possible. Existing tools were created with different goals in mind, and would require extensive modifications to convert to using clang-format's algorithm. Can I Use YAPF In My Program? ----------------------------- Please do! YAPF was designed to be used as a library as well as a command line tool. This means that a tool or IDE plugin is free to use YAPF. Gory Details ============ Algorithm Design ---------------- The main data structure in YAPF is the ``UnwrappedLine`` object. It holds a list of ``FormatToken``\s, that we would want to place on a single line if there were no column limit. An exception being a comment in the middle of an expression statement will force the line to be formatted on more than one line. The formatter works on one ``UnwrappedLine`` object at a time. An ``UnwrappedLine`` typically won't affect the formatting of lines before or after it. There is a part of the algorithm that may join two or more ``UnwrappedLine``\s into one line. For instance, an if-then statement with a short body can be placed on a single line: .. code-block:: python if a == 42: continue YAPF's formatting algorithm creates a weighted tree that acts as the solution space for the algorithm. Each node in the tree represents the result of a formatting decision --- i.e., whether to split or not to split before a token. Each formatting decision has a cost associated with it. Therefore, the cost is realized on the edge between two nodes. (In reality, the weighted tree doesn't have separate edge objects, so the cost resides on the nodes themselves.) For example, take the following Python code snippet. For the sake of this example, assume that line (1) violates the column limit restriction and needs to be reformatted. .. code-block:: python def xxxxxxxxxxx(aaaaaaaaaaaa, bbbbbbbbb, cccccccc, dddddddd, eeeeee): # 1 pass # 2 For line (1), the algorithm will build a tree where each node (a ``FormattingDecisionState`` object) is the state of the line at that token given the decision to split before the token or not. Note: the ``FormatDecisionState`` objects are copied by value so each node in the graph is unique and a change in one doesn't affect other nodes. Heuristics are used to determine the costs of splitting or not splitting. Because a node holds the state of the tree up to a token's insertion, it can easily determine if a splitting decision will violate one of the style requirements. For instance, the heuristic is able to apply an extra penalty to the edge when not splitting between the previous token and the one being added. There are some instances where we will never want to split the line, because doing so will always be detrimental (i.e., it will require a backslash-newline, which is very rarely desirable). For line (1), we will never want to split the first three tokens: ``def``, ``xxxxxxxxxxx``, and ``(``. Nor will we want to split between the ``)`` and the ``:`` at the end. These regions are said to be "unbreakable." This is reflected in the tree by there not being a "split" decision (left hand branch) within the unbreakable region. Now that we have the tree, we determine what the "best" formatting is by finding the path through the tree with the lowest cost. And that's it! yapf-0.15.1/plugins/000077500000000000000000000000001304174360200142165ustar00rootroot00000000000000yapf-0.15.1/plugins/README.rst000066400000000000000000000013531304174360200157070ustar00rootroot00000000000000=========== IDE Plugins =========== Emacs ===== The ``Emacs`` plugin is maintained separately. Installation directions can be found here: https://github.com/paetzke/py-yapf.el VIM === The ``vim`` plugin allows you to reformat a range of code. Place it into the ``.vim/autoload`` directory. You can add key bindings in the ``.vimrc`` file: .. code-block:: vim map :call yapf#YAPF() imap :call yapf#YAPF() Sublime Text ============ The ``Sublime Text`` plugin is also maintained separately. It is compatible with both Sublime Text 2 and 3. The plugin can be easily installed by using *Sublime Package Control*. Check the project page of the plugin for more information: https://github.com/jason-kane/PyYapf yapf-0.15.1/plugins/yapf.vim000066400000000000000000000025541304174360200157000ustar00rootroot00000000000000" Copyright 2015 Google Inc. All Rights Reserved. " " Licensed under the Apache License, Version 2.0 (the "License"); " you may not use this file except in compliance with the License. " You may obtain a copy of the License at " " http://www.apache.org/licenses/LICENSE-2.0 " " Unless required by applicable law or agreed to in writing, software " distributed under the License is distributed on an "AS IS" BASIS, " WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. " See the License for the specific language governing permissions and " limitations under the License. """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" " VIM Autoload script for YAPF support " " Place this script in your ~/.vim/autoload directory. You can add accessors to " ~/.vimrc, e.g.: " " map :call yapf#YAPF() " imap :call yapf#YAPF() " function! yapf#YAPF() range " Determine range to format. let l:line_ranges = a:firstline . '-' . a:lastline let l:cmd = 'yapf --lines=' . l:line_ranges " Call YAPF with the current buffer let l:formatted_text = system(l:cmd, join(getline(1, '$'), "\n") . "\n") " Update the buffer. execute '1,' . string(line('$')) . 'delete' call setline(1, split(l:formatted_text, "\n")) " Reset cursor to first line of the formatted range. call cursor(a:firstline, 1) endfunction yapf-0.15.1/pylintrc000066400000000000000000000315201304174360200143250ustar00rootroot00000000000000[MASTER] # Specify a configuration file. #rcfile= # Python code to execute, usually for sys.path manipulation such as # pygtk.require(). #init-hook= # Add files or directories to the blacklist. They should be base names, not # paths. ignore=CVS # Pickle collected data for later comparisons. persistent=yes # List of plugins (as comma separated values of python modules names) to load, # usually to register additional checkers. load-plugins= # Use multiple processes to speed up Pylint. jobs=1 # Allow loading of arbitrary C extensions. Extensions are imported into the # active Python interpreter and may run arbitrary code. unsafe-load-any-extension=no # A comma-separated list of package or module names from where C extensions may # be loaded. Extensions are loading into the active Python interpreter and may # run arbitrary code extension-pkg-whitelist= # Allow optimization of some AST trees. This will activate a peephole AST # optimizer, which will apply various small optimizations. For instance, it can # be used to obtain the result of joining multiple strings with the addition # operator. Joining a lot of strings can lead to a maximum recursion error in # Pylint and this flag can prevent that. It has one side effect, the resulting # AST will be different than the one from reality. optimize-ast=no [MESSAGES CONTROL] # Only show warnings with the listed confidence levels. Leave empty to show # all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED confidence= # Enable the message, report, category or checker with the given id(s). You can # either give multiple identifier separated by comma (,) or put this option # multiple time (only on the command line, not in the configuration file where # it should appear only once). See also the "--disable" option for examples. #enable= # Disable the message, report, category or checker with the given id(s). You # can either give multiple identifiers separated by comma (,) or put this # option multiple times (only on the command line, not in the configuration # file where it should appear only once).You can also use "--disable=all" to # disable everything first and then reenable specific checks. For example, if # you want to run only the similarities checker, you can use "--disable=all # --enable=similarities". If you want to run only the classes checker, but have # no Warning level messages displayed, use"--disable=all --enable=classes # --disable=W" disable= # disabled by me, locally-disabled, missing-docstring, fixme, # disabled by default, import-star-module-level, old-octal-literal, oct-method, print-statement, unpacking-in-except, parameter-unpacking, backtick, old-raise-syntax, old-ne-operator, long-suffix, dict-view-method, dict-iter-method, metaclass-assignment, next-method-called, raising-string, indexing-exception, raw_input-builtin, long-builtin, file-builtin, execfile-builtin, coerce-builtin, cmp-builtin, buffer-builtin, basestring-builtin, apply-builtin, filter-builtin-not-iterating, using-cmp-argument, useless-suppression, range-builtin-not-iterating, suppressed-message, no-absolute-import, old-division, cmp-method, reload-builtin, zip-builtin-not-iterating, intern-builtin, unichr-builtin, reduce-builtin, standarderror-builtin, unicode-builtin, xrange-builtin, coerce-method, delslice-method, getslice-method, setslice-method, input-builtin, round-builtin, hex-method, nonzero-method, map-builtin-not-iterating, [REPORTS] # Set the output format. Available formats are text, parseable, colorized, msvs # (visual studio) and html. You can also give a reporter class, eg # mypackage.mymodule.MyReporterClass. output-format=text # Put messages in a separate file for each module / package specified on the # command line instead of printing them on stdout. Reports (if any) will be # written in a file name "pylint_global.[txt|html]". files-output=no # Tells whether to display a full report or only the messages reports=yes # Python expression which should return a note less than 10 (10 is the highest # note). You have access to the variables errors warning, statement which # respectively contain the number of errors / warnings messages and the total # number of statements analyzed. This is used by the global evaluation report # (RP0004). evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) # Template used to display messages. This is a python new-style format string # used to format the message information. See doc for all details #msg-template= [FORMAT] # Maximum number of characters on a single line. max-line-length=100 # Regexp for a line that is allowed to be longer than the limit. ignore-long-lines=^\s*(# )??$ # Allow the body of an if to be on the same line as the test if there is no # else. single-line-if-stmt=no # List of optional constructs for which whitespace checking is disabled. `dict- # separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. # `trailing-comma` allows a space between comma and closing bracket: (a, ). # `empty-line` allows space-only lines. no-space-check=trailing-comma,dict-separator # Maximum number of lines in a module max-module-lines=1000 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 # tab). indent-string=' ' # Number of spaces of indent required inside a hanging or continued line. indent-after-paren=4 # Expected format of line ending, e.g. empty (any line ending), LF or CRLF. expected-line-ending-format= [SPELLING] # Spelling dictionary name. Available dictionaries: none. To make it working # install python-enchant package. spelling-dict= # List of comma separated words that should not be checked. spelling-ignore-words= # A path to a file that contains private dictionary; one word per line. spelling-private-dict-file= # Tells whether to store unknown words to indicated private dictionary in # --spelling-private-dict-file option instead of raising a message. spelling-store-unknown-words=no [LOGGING] # Logging modules to check that the string format arguments are in logging # function parameter format logging-modules=logging [BASIC] # List of builtins function names that should not be used, separated by a comma bad-functions=map,filter,input # Good variable names which should always be accepted, separated by a comma good-names=i,e,s,_,fd,fp # Bad variable names which should always be refused, separated by a comma bad-names=foo,bar,baz,toto,tutu,tata # Colon-delimited sets of names that determine each other's naming style when # the name regexes allow several styles. name-group= # Include a hint for the correct naming format with invalid-name include-naming-hint=no # Regular expression matching correct function names # original: #function-rgx=[a-z_][a-z0-9_]{2,30}$ function-rgx=[a-zA-Z_][a-zA-Z0-9_]{2,40}$ # Naming hint for function names function-name-hint=[a-z_][a-z0-9_]{2,30}$ # Regular expression matching correct variable names variable-rgx=[a-z_][a-z0-9_]{2,30}$ # Naming hint for variable names variable-name-hint=[a-z_][a-z0-9_]{2,30}$ # Regular expression matching correct constant names # original: #const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$ const-rgx=(([a-zA-Z_][a-zA-Z0-9_]*)|(__.*__))$ # Naming hint for constant names const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$ # Regular expression matching correct attribute names attr-rgx=[a-z_][a-z0-9_]{2,30}$ # Naming hint for attribute names attr-name-hint=[a-z_][a-z0-9_]{2,30}$ # Regular expression matching correct argument names argument-rgx=[a-z_][a-z0-9_]{2,30}$ # Naming hint for argument names argument-name-hint=[a-z_][a-z0-9_]{2,30}$ # Regular expression matching correct class attribute names # original: #class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,40}|(__.*__))$ # Naming hint for class attribute names class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ # Regular expression matching correct inline iteration names inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$ # Naming hint for inline iteration names inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$ # Regular expression matching correct class names # original: #class-rgx=[A-Z_][a-zA-Z0-9]+$ class-rgx=[a-zA-Z_][a-zA-Z0-9]+$ # Naming hint for class names class-name-hint=[A-Z_][a-zA-Z0-9]+$ # Regular expression matching correct module names module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ # Naming hint for module names module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ # Regular expression matching correct method names # original: #method-rgx=[a-z_][a-z0-9_]{2,30}$ method-rgx=[a-zA-Z_][a-zA-Z0-9_]{2,40}$ # Naming hint for method names method-name-hint=[a-z_][a-z0-9_]{2,30}$ # Regular expression which should only match function or class names that do # not require a docstring. no-docstring-rgx=^_ # Minimum line length for functions/classes that require docstrings, shorter # ones are exempt. docstring-min-length=-1 [ELIF] # Maximum number of nested blocks for function / method body max-nested-blocks=5 [SIMILARITIES] # Minimum lines number of a similarity. min-similarity-lines=4 # Ignore comments when computing similarities. ignore-comments=yes # Ignore docstrings when computing similarities. ignore-docstrings=yes # Ignore imports when computing similarities. ignore-imports=no [TYPECHECK] # Tells whether missing members accessed in mixin class should be ignored. A # mixin class is detected if its name ends with "mixin" (case insensitive). ignore-mixin-members=yes # List of module names for which member attributes should not be checked # (useful for modules/projects where namespaces are manipulated during runtime # and thus existing member attributes cannot be deduced by static analysis. It # supports qualified module names, as well as Unix pattern matching. ignored-modules= # List of classes names for which member attributes should not be checked # (useful for classes with attributes dynamically set). This supports can work # with qualified names. ignored-classes= # List of members which are set dynamically and missed by pylint inference # system, and so shouldn't trigger E1101 when accessed. Python regular # expressions are accepted. generated-members= [MISCELLANEOUS] # List of note tags to take in consideration, separated by a comma. notes=FIXME,XXX,TODO [VARIABLES] # Tells whether we should check for unused import in __init__ files. init-import=no # A regular expression matching the name of dummy variables (i.e. expectedly # not used). dummy-variables-rgx=_$|dummy # List of additional names supposed to be defined in builtins. Remember that # you should avoid to define new builtins when possible. additional-builtins= # List of strings which can identify a callback function by name. A callback # name must start or end with one of those strings. callbacks=cb_,_cb [CLASSES] # List of method names used to declare (i.e. assign) instance attributes. defining-attr-methods=__init__,__new__,setUp # List of valid names for the first argument in a class method. valid-classmethod-first-arg=cls # List of valid names for the first argument in a metaclass class method. valid-metaclass-classmethod-first-arg=mcs # List of member names, which should be excluded from the protected access # warning. exclude-protected=_asdict,_fields,_replace,_source,_make [DESIGN] # Maximum number of arguments for function / method max-args=5 # Argument names that match this expression will be ignored. Default to name # with leading underscore ignored-argument-names=_.* # Maximum number of locals for function / method body max-locals=15 # Maximum number of return / yield for function / method body max-returns=6 # Maximum number of branch for function / method body max-branches=12 # Maximum number of statements in function / method body max-statements=50 # Maximum number of parents for a class (see R0901). max-parents=7 # Maximum number of attributes for a class (see R0902). max-attributes=7 # Minimum number of public methods for a class (see R0903). min-public-methods=2 # Maximum number of public methods for a class (see R0904). max-public-methods=20 # Maximum number of boolean expressions in a if statement max-bool-expr=5 [IMPORTS] # Deprecated modules which should not be used, separated by a comma deprecated-modules=regsub,TERMIOS,Bastion,rexec # Create a graph of every (i.e. internal and external) dependencies in the # given file (report RP0402 must not be disabled) import-graph= # Create a graph of external dependencies in the given file (report RP0402 must # not be disabled) ext-import-graph= # Create a graph of internal dependencies in the given file (report RP0402 must # not be disabled) int-import-graph= [EXCEPTIONS] # Exceptions that will emit a warning when being caught. Defaults to # "Exception" overgeneral-exceptions=Exception yapf-0.15.1/setup.cfg000066400000000000000000000000341304174360200143530ustar00rootroot00000000000000[bdist_wheel] universal = 1 yapf-0.15.1/setup.py000066400000000000000000000044011304174360200142460ustar00rootroot00000000000000#!/usr/bin/env python # Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import codecs import unittest from setuptools import setup, Command import sys import yapf class RunTests(Command): user_options = [] def initialize_options(self): pass def finalize_options(self): pass def run(self): loader = unittest.TestLoader() tests = loader.discover('yapftests', pattern='*_test.py', top_level_dir='.') runner = unittest.TextTestRunner() results = runner.run(tests) sys.exit(0 if results.wasSuccessful() else 1) with codecs.open('README.rst', 'r', 'utf-8') as fd: setup( name='yapf', version=yapf.__version__, description='A formatter for Python code.', long_description=fd.read(), license='Apache License, Version 2.0', author='Google Inc.', maintainer='Bill Wendling', maintainer_email='morbo@google.com', packages=['yapf', 'yapf.yapflib', 'yapftests'], classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Software Development :: Quality Assurance', ], entry_points={'console_scripts': ['yapf = yapf:run_main'],}, cmdclass={'test': RunTests,},) yapf-0.15.1/tox.ini000066400000000000000000000001201304174360200140410ustar00rootroot00000000000000[tox] envlist=py27,py34,py35,py36 [testenv] commands= python setup.py test yapf-0.15.1/yapf/000077500000000000000000000000001304174360200134745ustar00rootroot00000000000000yapf-0.15.1/yapf/__init__.py000066400000000000000000000241241304174360200156100ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """YAPF. YAPF uses the algorithm in clang-format to figure out the "best" formatting for Python code. It looks at the program as a series of "unwrappable lines" --- i.e., lines which, if there were no column limit, we would place all tokens on that line. It then uses a priority queue to figure out what the best formatting is --- i.e., the formatting with the least penalty. It differs from tools like autopep8 and pep8ify in that it doesn't just look for violations of the style guide, but looks at the module as a whole, making formatting decisions based on what's the best format for each line. If no filenames are specified, YAPF reads the code from stdin. """ from __future__ import print_function import argparse import logging import os import sys from yapf.yapflib import errors from yapf.yapflib import file_resources from yapf.yapflib import py3compat from yapf.yapflib import style from yapf.yapflib import yapf_api __version__ = '0.15.1' def main(argv): """Main program. Arguments: argv: command-line arguments, such as sys.argv (including the program name in argv[0]). Returns: 0 if there were no changes, non-zero otherwise. Raises: YapfError: if none of the supplied files were Python files. """ parser = argparse.ArgumentParser(description='Formatter for Python code.') parser.add_argument( '-v', '--version', action='store_true', help='show version number and exit') diff_inplace_group = parser.add_mutually_exclusive_group() diff_inplace_group.add_argument( '-d', '--diff', action='store_true', help='print the diff for the fixed source') diff_inplace_group.add_argument( '-i', '--in-place', action='store_true', help='make changes to files in place') lines_recursive_group = parser.add_mutually_exclusive_group() lines_recursive_group.add_argument( '-r', '--recursive', action='store_true', help='run recursively over directories') lines_recursive_group.add_argument( '-l', '--lines', metavar='START-END', action='append', default=None, help='range of lines to reformat, one-based') parser.add_argument( '-e', '--exclude', metavar='PATTERN', action='append', default=None, help='patterns for files to exclude from formatting') parser.add_argument( '--style', action='store', help=('specify formatting style: either a style name (for example "pep8" ' 'or "google"), or the name of a file with style settings. The ' 'default is pep8 unless a %s or %s file located in one of the ' 'parent directories of the source file (or current directory for ' 'stdin)' % (style.LOCAL_STYLE, style.SETUP_CONFIG))) parser.add_argument( '--style-help', action='store_true', help=('show style settings and exit; this output can be ' 'saved to .style.yapf to make your settings ' 'permanent')) parser.add_argument( '--no-local-style', action='store_true', help="don't search for local style definition") parser.add_argument('--verify', action='store_true', help=argparse.SUPPRESS) parser.add_argument( '-p', '--parallel', action='store_true', help=('Run yapf in parallel when formatting multiple files. Requires ' 'concurrent.futures in Python 2.X')) parser.add_argument('files', nargs='*') args = parser.parse_args(argv[1:]) if args.version: print('yapf {}'.format(__version__)) return 0 if args.style_help: style.SetGlobalStyle(style.CreateStyleFromConfig(args.style)) print('[style]') for option, docstring in sorted(style.Help().items()): for line in docstring.splitlines(): print('#', line) print(option.lower(), '=', style.Get(option), sep='') print() return 0 if args.lines and len(args.files) > 1: parser.error('cannot use -l/--lines with more than one file') lines = _GetLines(args.lines) if args.lines is not None else None if not args.files: # No arguments specified. Read code from stdin. if args.in_place or args.diff: parser.error('cannot use --in-place or --diff flags when reading ' 'from stdin') original_source = [] while True: try: # Use 'raw_input' instead of 'sys.stdin.read', because otherwise the # user will need to hit 'Ctrl-D' more than once if they're inputting # the program by hand. 'raw_input' throws an EOFError exception if # 'Ctrl-D' is pressed, which makes it easy to bail out of this loop. original_source.append(py3compat.raw_input()) except EOFError: break style_config = args.style if style_config is None and not args.no_local_style: style_config = file_resources.GetDefaultStyleForDir(os.getcwd()) source = [line.rstrip() for line in original_source] reformatted_source, changed = yapf_api.FormatCode( py3compat.unicode('\n'.join(source) + '\n'), filename='', style_config=style_config, lines=lines, verify=args.verify) file_resources.WriteReformattedCode('', reformatted_source) return 0 files = file_resources.GetCommandLineFiles(args.files, args.recursive, args.exclude) if not files: raise errors.YapfError('Input filenames did not match any python files') FormatFiles( files, lines, style_config=args.style, no_local_style=args.no_local_style, in_place=args.in_place, print_diff=args.diff, verify=args.verify, parallel=args.parallel) return 0 def FormatFiles(filenames, lines, style_config=None, no_local_style=False, in_place=False, print_diff=False, verify=True, parallel=False): """Format a list of files. Arguments: filenames: (list of unicode) A list of files to reformat. lines: (list of tuples of integers) A list of tuples of lines, [start, end], that we want to format. The lines are 1-based indexed. This argument overrides the 'args.lines'. It can be used by third-party code (e.g., IDEs) when reformatting a snippet of code. style_config: (string) Style name or file path. no_local_style: (string) If style_config is None don't search for directory-local style configuration. in_place: (bool) Modify the files in place. print_diff: (bool) Instead of returning the reformatted source, return a diff that turns the formatted source into reformatter source. verify: (bool) True if reformatted code should be verified for syntax. parallel: (bool) True if should format multiple files in parallel. Returns: True if the source code changed in any of the files being formatted. """ changed = False if parallel: import multiprocessing # pylint: disable=g-import-not-at-top import concurrent.futures # pylint: disable=g-import-not-at-top workers = min(multiprocessing.cpu_count(), len(filenames)) with concurrent.futures.ProcessPoolExecutor(workers) as executor: future_formats = [ executor.submit(_FormatFile, filename, lines, style_config, no_local_style, in_place, print_diff, verify) for filename in filenames ] for future in concurrent.futures.as_completed(future_formats): changed |= future.result() else: for filename in filenames: changed |= _FormatFile(filename, lines, style_config, no_local_style, in_place, print_diff, verify) return changed def _FormatFile(filename, lines, style_config=None, no_local_style=False, in_place=False, print_diff=False, verify=True): logging.info('Reformatting %s', filename) if style_config is None and not no_local_style: style_config = ( file_resources.GetDefaultStyleForDir(os.path.dirname(filename))) try: reformatted_code, encoding, has_change = yapf_api.FormatFile( filename, in_place=in_place, style_config=style_config, lines=lines, print_diff=print_diff, verify=verify, logger=logging.warning) if not in_place and reformatted_code: file_resources.WriteReformattedCode(filename, reformatted_code, in_place, encoding) return has_change except SyntaxError as e: e.filename = filename raise def _GetLines(line_strings): """Parses the start and end lines from a line string like 'start-end'. Arguments: line_strings: (array of string) A list of strings representing a line range like 'start-end'. Returns: A list of tuples of the start and end line numbers. Raises: ValueError: If the line string failed to parse or was an invalid line range. """ lines = [] for line_string in line_strings: # The 'list' here is needed by Python 3. line = list(map(int, line_string.split('-', 1))) if line[0] < 1: raise errors.YapfError('invalid start of line range: %r' % line) if line[0] > line[1]: raise errors.YapfError('end comes before start in line range: %r', line) lines.append(tuple(line)) return lines def run_main(): # pylint: disable=invalid-name try: sys.exit(main(sys.argv)) except errors.YapfError as e: sys.stderr.write('yapf: ' + str(e) + '\n') sys.exit(1) if __name__ == '__main__': run_main() yapf-0.15.1/yapf/__main__.py000066400000000000000000000011661304174360200155720ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import yapf yapf.run_main() yapf-0.15.1/yapf/yapflib/000077500000000000000000000000001304174360200151225ustar00rootroot00000000000000yapf-0.15.1/yapf/yapflib/__init__.py000066400000000000000000000011311304174360200172270ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. yapf-0.15.1/yapf/yapflib/blank_line_calculator.py000066400000000000000000000144231304174360200220070ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Calculate the number of blank lines between top-level entities. Calculates how many blank lines we need between classes, functions, and other entities at the same level. CalculateBlankLines(): the main function exported by this module. Annotations: newlines: The number of newlines required before the node. """ from lib2to3 import pytree from yapf.yapflib import py3compat from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor _NO_BLANK_LINES = 1 _ONE_BLANK_LINE = 2 _TWO_BLANK_LINES = 3 _PYTHON_STATEMENTS = frozenset({ 'small_stmt', 'expr_stmt', 'print_stmt', 'del_stmt', 'pass_stmt', 'break_stmt', 'continue_stmt', 'return_stmt', 'raise_stmt', 'yield_stmt', 'import_stmt', 'global_stmt', 'exec_stmt', 'assert_stmt', 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', 'nonlocal_stmt', 'async_stmt', 'simple_stmt' }) def CalculateBlankLines(tree): """Run the blank line calculator visitor over the tree. This modifies the tree in place. Arguments: tree: the top-level pytree node to annotate with subtypes. """ blank_line_calculator = _BlankLineCalculator() blank_line_calculator.Visit(tree) class _BlankLineCalculator(pytree_visitor.PyTreeVisitor): """_BlankLineCalculator - see file-level docstring for a description.""" def __init__(self): self.class_level = 0 self.function_level = 0 self.last_comment_lineno = 0 self.last_was_decorator = False self.last_was_class_or_function = False def Visit_simple_stmt(self, node): # pylint: disable=invalid-name self.DefaultNodeVisit(node) if pytree_utils.NodeName(node.children[0]) == 'COMMENT': self.last_comment_lineno = node.children[0].lineno def Visit_decorator(self, node): # pylint: disable=invalid-name if (self.last_comment_lineno and self.last_comment_lineno == node.children[0].lineno - 1): self._SetNumNewlines(node.children[0], _NO_BLANK_LINES) else: self._SetNumNewlines(node.children[0], self._GetNumNewlines(node)) for child in node.children: self.Visit(child) self.last_was_decorator = True def Visit_classdef(self, node): # pylint: disable=invalid-name self.last_was_class_or_function = False index = self._SetBlankLinesBetweenCommentAndClassFunc(node) self.last_was_decorator = False self.class_level += 1 for child in node.children[index:]: self.Visit(child) self.class_level -= 1 self.last_was_class_or_function = True def Visit_funcdef(self, node): # pylint: disable=invalid-name self.last_was_class_or_function = False index = self._SetBlankLinesBetweenCommentAndClassFunc(node) if _AsyncFunction(node): index = self._SetBlankLinesBetweenCommentAndClassFunc( node.prev_sibling.parent) self._SetNumNewlines(node.children[0], None) else: index = self._SetBlankLinesBetweenCommentAndClassFunc(node) self.last_was_decorator = False self.function_level += 1 for child in node.children[index:]: self.Visit(child) self.function_level -= 1 self.last_was_class_or_function = True def DefaultNodeVisit(self, node): """Override the default visitor for Node. This will set the blank lines required if the last entity was a class or function. Arguments: node: (pytree.Node) The node to visit. """ if self.last_was_class_or_function: if pytree_utils.NodeName(node) in _PYTHON_STATEMENTS: leaf = _GetFirstChildLeaf(node) self._SetNumNewlines(leaf, self._GetNumNewlines(leaf)) self.last_was_class_or_function = False super(_BlankLineCalculator, self).DefaultNodeVisit(node) def _SetBlankLinesBetweenCommentAndClassFunc(self, node): """Set the number of blanks between a comment and class or func definition. Class and function definitions have leading comments as children of the classdef and functdef nodes. Arguments: node: (pytree.Node) The classdef or funcdef node. Returns: The index of the first child past the comment nodes. """ index = 0 while pytree_utils.IsCommentStatement(node.children[index]): # Standalone comments are wrapped in a simple_stmt node with the comment # node as its only child. self.Visit(node.children[index].children[0]) if not self.last_was_decorator: self._SetNumNewlines(node.children[index].children[0], _ONE_BLANK_LINE) index += 1 if (index and node.children[index].lineno - 1 == node.children[index - 1].children[0].lineno): self._SetNumNewlines(node.children[index], _NO_BLANK_LINES) else: if self.last_comment_lineno + 1 == node.children[index].lineno: num_newlines = _NO_BLANK_LINES else: num_newlines = self._GetNumNewlines(node) self._SetNumNewlines(node.children[index], num_newlines) return index def _GetNumNewlines(self, node): if self.last_was_decorator: return _NO_BLANK_LINES elif self._IsTopLevel(node): return _TWO_BLANK_LINES return _ONE_BLANK_LINE def _SetNumNewlines(self, node, num_newlines): pytree_utils.SetNodeAnnotation(node, pytree_utils.Annotation.NEWLINES, num_newlines) def _IsTopLevel(self, node): return (not (self.class_level or self.function_level) and _StartsInZerothColumn(node)) def _StartsInZerothColumn(node): return (_GetFirstChildLeaf(node).column == 0 or (_AsyncFunction(node) and node.prev_sibling.column == 0)) def _AsyncFunction(node): return (py3compat.PY3 and node.prev_sibling and pytree_utils.NodeName(node.prev_sibling) == 'ASYNC') def _GetFirstChildLeaf(node): if isinstance(node, pytree.Leaf): return node return _GetFirstChildLeaf(node.children[0]) yapf-0.15.1/yapf/yapflib/comment_splicer.py000066400000000000000000000356221304174360200206670ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Comment splicer for lib2to3 trees. The lib2to3 syntax tree produced by the parser holds comments and whitespace in prefix attributes of nodes, rather than nodes themselves. This module provides functionality to splice comments out of prefixes and into nodes of their own, making them easier to process. SpliceComments(): the main function exported by this module. """ from lib2to3 import pygram from lib2to3 import pytree from lib2to3.pgen2 import token from yapf.yapflib import pytree_utils def SpliceComments(tree): """Given a pytree, splice comments into nodes of their own right. Extract comments from the prefixes where they are housed after parsing. The prefixes that previously housed the comments become empty. Args: tree: a pytree.Node - the tree to work on. The tree is modified by this function. """ # The previous leaf node encountered in the traversal. # This is a list because Python 2.x doesn't have 'nonlocal' :) prev_leaf = [None] _AnnotateIndents(tree) def _VisitNodeRec(node): # This loop may insert into node.children, so we'll iterate over a copy. for child in node.children[:]: if isinstance(child, pytree.Node): # Nodes don't have prefixes. _VisitNodeRec(child) else: if child.prefix.lstrip().startswith('#'): # We have a comment prefix in this child, so splicing is needed. comment_prefix = child.prefix comment_lineno = child.lineno - comment_prefix.count('\n') comment_column = child.column # Remember the leading indentation of this prefix and clear it. # Mopping up the prefix is important because we may go over this same # child in the next iteration... child_prefix = child.prefix.lstrip('\n') prefix_indent = child_prefix[:child_prefix.find('#')] if '\n' in prefix_indent: prefix_indent = prefix_indent[prefix_indent.rfind('\n') + 1:] child.prefix = '' if child.type == token.NEWLINE: # If the prefix was on a NEWLINE leaf, it's part of the line so it # will be inserted after the previously encountered leaf. # We can't just insert it before the NEWLINE node, because as a # result of the way pytrees are organized, this node can be under # an inappropriate parent. comment_column -= len(comment_prefix) comment_column += len(comment_prefix) - len(comment_prefix.lstrip()) pytree_utils.InsertNodesAfter( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=False), prev_leaf[0]) elif child.type == token.DEDENT: # Comment prefixes on DEDENT nodes also deserve special treatment, # because their final placement depends on their prefix. # We'll look for an ancestor of this child with a matching # indentation, and insert the comment after it. ancestor_at_indent = _FindAncestorAtIndent(child, prefix_indent) if ancestor_at_indent.type == token.DEDENT: comments = comment_prefix.split('\n') # lib2to3 places comments that should be separated into the same # DEDENT node. For example, "comment 1" and "comment 2" will be # combined. # # def _(): # for x in y: # pass # # comment 1 # # # comment 2 # pass # # In this case, we need to split them up ourselves. before = [] after = [] after_lineno = comment_lineno index = 0 while index < len(comments): cmt = comments[index] if not cmt.strip() or cmt.startswith(prefix_indent + '#'): before.append(cmt) else: after_lineno += index after.extend(comments[index:]) break index += 1 # Special case where the comment is inserted in the same # indentation level as the DEDENT it was originally attached to. pytree_utils.InsertNodesBefore( _CreateCommentsFromPrefix( '\n'.join(before) + '\n', comment_lineno, comment_column, standalone=True), ancestor_at_indent) if after: after_column = len(after[0]) - len(after[0].lstrip()) comment_column -= comment_column - after_column pytree_utils.InsertNodesAfter( _CreateCommentsFromPrefix( '\n'.join(after) + '\n', after_lineno, comment_column, standalone=True), _FindNextAncestor(ancestor_at_indent)) else: pytree_utils.InsertNodesAfter( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True), ancestor_at_indent) else: # Otherwise there are two cases. # # 1. The comment is on its own line # 2. The comment is part of an expression. # # Unfortunately, it's fairly difficult to distinguish between the # two in lib2to3 trees. The algorithm here is to determine whether # child is the first leaf in the statement it belongs to. If it is, # then the comment (which is a prefix) belongs on a separate line. # If it is not, it means the comment is buried deep in the statement # and is part of some expression. stmt_parent = _FindStmtParent(child) for leaf_in_parent in stmt_parent.leaves(): if leaf_in_parent.type == token.NEWLINE: continue elif id(leaf_in_parent) == id(child): # This comment stands on its own line, and it has to be inserted # into the appropriate parent. We'll have to find a suitable # parent to insert into. See comments above # _STANDALONE_LINE_NODES for more details. node_with_line_parent = _FindNodeWithStandaloneLineParent(child) pytree_utils.InsertNodesBefore( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, 0, standalone=True), node_with_line_parent) break else: if comment_lineno == prev_leaf[0].lineno: comment_lines = comment_prefix.splitlines() value = comment_lines[0].lstrip() if value.rstrip('\n'): comment_column = prev_leaf[0].column comment_column += len(prev_leaf[0].value) comment_column += ( len(comment_lines[0]) - len(comment_lines[0].lstrip())) comment_leaf = pytree.Leaf( type=token.COMMENT, value=value.rstrip('\n'), context=('', (comment_lineno, comment_column))) pytree_utils.InsertNodesAfter([comment_leaf], prev_leaf[0]) comment_prefix = '\n'.join(comment_lines[1:]) comment_lineno += 1 rindex = (0 if '\n' not in comment_prefix.rstrip() else comment_prefix.rstrip().rindex('\n') + 1) comment_column = (len(comment_prefix[rindex:]) - len(comment_prefix[rindex:].lstrip())) comments = _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=False) pytree_utils.InsertNodesBefore(comments, child) break prev_leaf[0] = child _VisitNodeRec(tree) def _CreateCommentsFromPrefix(comment_prefix, comment_lineno, comment_column, standalone=False): """Create pytree nodes to represent the given comment prefix. Args: comment_prefix: (unicode) the text of the comment from the node's prefix. comment_lineno: (int) the line number for the start of the comment. comment_column: (int) the column for the start of the comment. standalone: (bool) determines if the comment is standalone or not. Returns: The simple_stmt nodes if this is a standalone comment, otherwise a list of new COMMENT leafs. The prefix may consist of multiple comment blocks, separated by blank lines. Each block gets its own leaf. """ # The comment is stored in the prefix attribute, with no lineno of its # own. So we only know at which line it ends. To find out at which line it # starts, look at how many newlines the comment itself contains. comments = [] lines = comment_prefix.split('\n') index = 0 while index < len(lines): comment_block = [] while index < len(lines) and lines[index].lstrip().startswith('#'): comment_block.append(lines[index]) index += 1 if comment_block: new_lineno = comment_lineno + index - 1 comment_block[0] = comment_block[0].lstrip() comment_block[-1] = comment_block[-1].rstrip('\n') comment_leaf = pytree.Leaf( type=token.COMMENT, value='\n'.join(comment_block), context=('', (new_lineno, comment_column))) comment_node = comment_leaf if not standalone else pytree.Node( pygram.python_symbols.simple_stmt, [comment_leaf]) comments.append(comment_node) while index < len(lines) and not lines[index].lstrip(): index += 1 return comments # "Standalone line nodes" are tree nodes that have to start a new line in Python # code (and cannot follow a ';' or ':'). Other nodes, like 'expr_stmt', serve as # parents of other nodes but can come later in a line. This is a list of # standalone line nodes in the grammar. It is meant to be exhaustive # *eventually*, and we'll modify it with time as we discover more corner cases # in the parse tree. # # When splicing a standalone comment (i.e. a comment that appears on its own # line, not on the same line with other code), it's important to insert it into # an appropriate parent of the node it's attached to. An appropriate parent # is the first "standaline line node" in the parent chain of a node. _STANDALONE_LINE_NODES = frozenset([ 'suite', 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', 'funcdef', 'classdef', 'decorated', 'file_input' ]) def _FindNodeWithStandaloneLineParent(node): """Find a node whose parent is a 'standalone line' node. See the comment above _STANDALONE_LINE_NODES for more details. Arguments: node: node to start from Returns: Suitable node that's either the node itself or one of its ancestors. """ if pytree_utils.NodeName(node.parent) in _STANDALONE_LINE_NODES: return node else: # This is guaranteed to terminate because 'file_input' is the root node of # any pytree. return _FindNodeWithStandaloneLineParent(node.parent) # "Statement nodes" are standalone statements. The don't have to start a new # line. _STATEMENT_NODES = frozenset(['simple_stmt']) | _STANDALONE_LINE_NODES def _FindStmtParent(node): """Find the nearest parent of node that is a statement node. Arguments: node: node to start from Returns: Nearest parent (or node itself, if suitable). """ if pytree_utils.NodeName(node) in _STATEMENT_NODES: return node else: return _FindStmtParent(node.parent) def _FindAncestorAtIndent(node, indent): """Find an ancestor of node with the given indentation. Arguments: node: node to start from. This must not be the tree root. indent: indentation string for the ancestor we're looking for. See _AnnotateIndents for more details. Returns: An ancestor node with suitable indentation. If no suitable ancestor is found, the closest ancestor to the tree root is returned. """ if node.parent.parent is None: # Our parent is the tree root, so there's nowhere else to go. return node # If the parent has an indent annotation, and it's shorter than node's # indent, this is a suitable ancestor. # The reason for "shorter" rather than "equal" is that comments may be # improperly indented (i.e. by three spaces, where surrounding statements # have either zero or two or four), and we don't want to propagate them all # the way to the root. parent_indent = pytree_utils.GetNodeAnnotation( node.parent, pytree_utils.Annotation.CHILD_INDENT) if parent_indent is not None and indent.startswith(parent_indent): return node else: # Keep looking up the tree. return _FindAncestorAtIndent(node.parent, indent) def _FindNextAncestor(node): if node.parent is None: return node if node.parent.next_sibling is not None: return node.parent.next_sibling return _FindNextAncestor(node.parent) def _AnnotateIndents(tree): """Annotate the tree with child_indent annotations. A child_indent annotation on a node specifies the indentation (as a string, like " ") of its children. It is inferred from the INDENT child of a node. Arguments: tree: root of a pytree. The pytree is modified to add annotations to nodes. Raises: RuntimeError: if the tree is malformed. """ # Annotate the root of the tree with zero indent. if tree.parent is None: pytree_utils.SetNodeAnnotation(tree, pytree_utils.Annotation.CHILD_INDENT, '') for child in tree.children: if child.type == token.INDENT: child_indent = pytree_utils.GetNodeAnnotation( tree, pytree_utils.Annotation.CHILD_INDENT) if child_indent is not None and child_indent != child.value: raise RuntimeError('inconsistent indentation for child', (tree, child)) pytree_utils.SetNodeAnnotation(tree, pytree_utils.Annotation.CHILD_INDENT, child.value) _AnnotateIndents(child) yapf-0.15.1/yapf/yapflib/continuation_splicer.py000066400000000000000000000033651304174360200217360ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Insert "continuation" nodes into lib2to3 tree. The "backslash-newline" continuation marker is shoved into the node's prefix. Pull them out and make it into nodes of their own. SpliceContinuations(): the main funciton exported by this module. """ from lib2to3 import pytree from yapf.yapflib import format_token def SpliceContinuations(tree): """Given a pytree, splice the continuation marker into nodes. Arguments: tree: (pytree.Node) The tree to work on. The tree is modified by this function. """ def RecSplicer(node): """Inserts a continuation marker into the node.""" if isinstance(node, pytree.Leaf): if node.prefix.lstrip().startswith('\\\n'): new_lineno = node.lineno - node.prefix.count('\n') return pytree.Leaf( type=format_token.CONTINUATION, value=node.prefix, context=('', (new_lineno, 0))) return None num_inserted = 0 for index, child in enumerate(node.children[:]): continuation_node = RecSplicer(child) if continuation_node: node.children.insert(index + num_inserted, continuation_node) num_inserted += 1 RecSplicer(tree) yapf-0.15.1/yapf/yapflib/errors.py000066400000000000000000000014671304174360200170200ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. class YapfError(Exception): """Parent class for user errors or input errors. Exceptions of this type are handled by the command line tool and result in clear error messages, as opposed to backtraces. """ pass yapf-0.15.1/yapf/yapflib/file_resources.py000066400000000000000000000120041304174360200205020ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Interface to file resources. This module provides functions for interfacing with files: opening, writing, and querying. """ import fnmatch import os import re from lib2to3.pgen2 import tokenize from yapf.yapflib import errors from yapf.yapflib import py3compat from yapf.yapflib import style CR = '\r' LF = '\n' CRLF = '\r\n' def GetDefaultStyleForDir(dirname): """Return default style name for a given directory. Looks for .style.yapf or setup.cfg in the parent directories. Arguments: dirname: (unicode) The name of the directory. Returns: The filename if found, otherwise return the global default (pep8). """ dirname = os.path.abspath(dirname) while True: # See if we have a .style.yapf file. style_file = os.path.join(dirname, style.LOCAL_STYLE) if os.path.exists(style_file): return style_file # See if we have a setup.cfg file with a '[yapf]' section. config_file = os.path.join(dirname, style.SETUP_CONFIG) if os.path.exists(config_file): with open(config_file) as fd: config = py3compat.ConfigParser() config.read_file(fd) if config.has_section('yapf'): return config_file dirname = os.path.dirname(dirname) if (not dirname or not os.path.basename(dirname) or dirname == os.path.abspath(os.path.sep)): break global_file = os.path.expanduser(style.GLOBAL_STYLE) if os.path.exists(global_file): return global_file return style.DEFAULT_STYLE def GetCommandLineFiles(command_line_file_list, recursive, exclude): """Return the list of files specified on the command line.""" return _FindPythonFiles(command_line_file_list, recursive, exclude) def WriteReformattedCode(filename, reformatted_code, in_place=False, encoding=''): """Emit the reformatted code. Write the reformatted code into the file, if in_place is True. Otherwise, write to stdout. Arguments: filename: (unicode) The name of the unformatted file. reformatted_code: (unicode) The reformatted code. in_place: (bool) If True, then write the reformatted code to the file. encoding: (unicode) The encoding of the file. """ if in_place: with py3compat.open_with_encoding( filename, mode='w', encoding=encoding) as fd: fd.write(reformatted_code) else: py3compat.EncodeAndWriteToStdout(reformatted_code) def LineEnding(lines): """Retrieve the line ending of the original source.""" endings = {CRLF: 0, CR: 0, LF: 0} for line in lines: if line.endswith(CRLF): endings[CRLF] += 1 elif line.endswith(CR): endings[CR] += 1 elif line.endswith(LF): endings[LF] += 1 return (sorted(endings, key=endings.get, reverse=True) or [LF])[0] def _FindPythonFiles(filenames, recursive, exclude): """Find all Python files.""" python_files = [] for filename in filenames: if os.path.isdir(filename): if recursive: # TODO(morbo): Look into a version of os.walk that can handle recursion. python_files.extend( os.path.join(dirpath, f) for dirpath, _, filelist in os.walk(filename) for f in filelist if IsPythonFile(os.path.join(dirpath, f))) else: raise errors.YapfError( "directory specified without '--recursive' flag: %s" % filename) elif os.path.isfile(filename): python_files.append(filename) if exclude: return [ f for f in python_files if not any(fnmatch.fnmatch(f, p) for p in exclude) ] return python_files def IsPythonFile(filename): """Return True if filename is a Python file.""" if os.path.splitext(filename)[1] == '.py': return True try: with open(filename, 'rb') as fd: encoding = tokenize.detect_encoding(fd.readline)[0] # Check for correctness of encoding. with py3compat.open_with_encoding( filename, mode='r', encoding=encoding) as fd: fd.read() except UnicodeDecodeError: encoding = 'latin-1' except (IOError, SyntaxError): # If we fail to detect encoding (or the encoding cookie is incorrect - which # will make detect_encoding raise SyntaxError), assume it's not a Python # file. return False try: with py3compat.open_with_encoding( filename, mode='r', encoding=encoding) as fd: first_line = fd.readlines()[0] except (IOError, IndexError): return False return re.match(r'^#!.*\bpython[23]?\b', first_line) yapf-0.15.1/yapf/yapflib/format_decision_state.py000066400000000000000000000641741304174360200220550ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Implements a format decision state object that manages whitespace decisions. Each token is processed one at a time, at which point its whitespace formatting decisions are made. A graph of potential whitespace formattings is created, where each node in the graph is a format decision state object. The heuristic tries formatting the token with and without a newline before it to determine which one has the least penalty. Therefore, the format decision state object for each decision needs to be its own unique copy. Once the heuristic determines the best formatting, it makes a non-dry run pass through the code to commit the whitespace formatting. FormatDecisionState: main class exported by this module. """ import copy from yapf.yapflib import format_token from yapf.yapflib import split_penalty from yapf.yapflib import style from yapf.yapflib import unwrapped_line _COMPOUND_STMTS = frozenset( {'for', 'while', 'if', 'elif', 'with', 'except', 'def', 'class'}) class FormatDecisionState(object): """The current state when indenting an unwrapped line. The FormatDecisionState object is meant to be copied instead of referenced. Attributes: first_indent: The indent of the first token. column: The number of used columns in the current line. next_token: The next token to be formatted. paren_level: The level of nesting inside (), [], and {}. start_of_line_level: The paren_level at the start of this line. lowest_level_on_line: The lowest paren_level on the current line. newline: Indicates if a newline is added along the edge to this format decision state node. previous: The previous format decision state in the decision tree. stack: A stack (of _ParenState) keeping track of properties applying to parenthesis levels. ignore_stack_for_comparison: Ignore the stack of _ParenState for state comparison. """ def __init__(self, line, first_indent): """Initializer. Initializes to the state after placing the first token from 'line' at 'first_indent'. Arguments: line: (UnwrappedLine) The unwrapped line we're currently processing. first_indent: (int) The indent of the first token. """ self.next_token = line.first self.column = first_indent self.line = line self.paren_level = 0 self.start_of_line_level = 0 self.lowest_level_on_line = 0 self.ignore_stack_for_comparison = False self.stack = [_ParenState(first_indent, first_indent)] self.first_indent = first_indent self.newline = False self.previous = None self.column_limit = style.Get('COLUMN_LIMIT') self._MoveStateToNextToken() def Clone(self): new = copy.copy(self) new.stack = [copy.copy(state) for state in self.stack] return new def __eq__(self, other): # Note: 'first_indent' is implicit in the stack. Also, we ignore 'previous', # because it shouldn't have a bearing on this comparison. (I.e., it will # report equal if 'next_token' does.) return (self.next_token == other.next_token and self.column == other.column and self.paren_level == other.paren_level and self.start_of_line_level == other.start_of_line_level and self.lowest_level_on_line == other.lowest_level_on_line and ( self.ignore_stack_for_comparison or other.ignore_stack_for_comparison or self.stack == other.stack)) def __ne__(self, other): return not self == other def __hash__(self): return hash((self.next_token, self.column, self.paren_level, self.start_of_line_level, self.lowest_level_on_line)) def __repr__(self): return ('column::%d, next_token::%s, paren_level::%d, stack::[\n\t%s' % (self.column, repr(self.next_token), self.paren_level, '\n\t'.join(repr(s) for s in self.stack) + ']')) def CanSplit(self): """Returns True if the line can be split before the next token.""" current = self.next_token if current.is_pseudo_paren: return False return current.can_break_before def MustSplit(self): """Returns True if the line must split before the next token.""" current = self.next_token previous = current.previous_token if current.is_pseudo_paren: return False if current.must_break_before: return True if (previous and (style.Get('DEDENT_CLOSING_BRACKETS') or style.Get('SPLIT_BEFORE_FIRST_ARGUMENT'))): bracket = current if current.ClosesScope() else previous if format_token.Subtype.SUBSCRIPT_BRACKET not in bracket.subtypes: if bracket.OpensScope(): if style.Get('COALESCE_BRACKETS'): if current.OpensScope(): return False if (not _IsLastScopeInLine(bracket) or unwrapped_line.IsSurroundedByBrackets(bracket)): last_token = bracket.matching_bracket else: last_token = _LastTokenInLine(bracket.matching_bracket) if not self._FitsOnLine(bracket, last_token): self.stack[-1].split_before_closing_bracket = True return True elif style.Get('DEDENT_CLOSING_BRACKETS') and current.ClosesScope(): return self.stack[-1].split_before_closing_bracket if self.stack[-1].split_before_closing_bracket and current.value in '}]': # Split if we need to split before the closing bracket. return current.node_split_penalty != split_penalty.UNBREAKABLE if not previous: return False # TODO(morbo): This should be controlled with a knob. if (format_token.Subtype.DICTIONARY_KEY in current.subtypes and not current.is_comment): # Place each dictionary entry on its own line. if previous.value == '{' and previous.previous_token: opening = _GetOpeningBracket(previous.previous_token) if (opening and opening.value == '(' and opening.previous_token and opening.previous_token.is_name): # This is a dictionary that's an argument to a function. if self._FitsOnLine(previous, previous.matching_bracket): return False return True # TODO(morbo): This should be controlled with a knob. if format_token.Subtype.DICT_SET_GENERATOR in current.subtypes: return True if (style.Get('SPLIT_BEFORE_NAMED_ASSIGNS') and not current.is_comment and format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in current.subtypes): if (previous.value not in {'=', ':', '*', '**'} and current.value not in ':=,)'): # If we're going to split the lines because of named arguments, then we # want to split after the opening bracket as well. But not when this is # part of function definition. if not _IsFunctionDefinition(previous): # Make sure we don't split after the opening bracket if the # continuation indent is greater than the opening bracket: # # a( # b=1, # c=2) indent_amt = self.stack[-1].indent * style.Get('INDENT_WIDTH') pptoken = previous.previous_token opening_column = len(pptoken.value) if pptoken else 0 - indent_amt - 1 if previous.value == '(': return opening_column >= style.Get('CONTINUATION_INDENT_WIDTH') opening = _GetOpeningBracket(current) if opening: arglist_length = (opening.matching_bracket.total_length - opening.total_length + self.stack[-1].indent) return arglist_length > self.column_limit if style.Get('SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED'): # Split before arguments in a function call or definition if the # arguments are terminated by a comma. opening = _GetOpeningBracket(current) if opening and opening.previous_token and opening.previous_token.is_name: if previous.value in '(,': if opening.matching_bracket.previous_token.value == ',': return True if (format_token.Subtype.DICTIONARY_VALUE in current.subtypes or (previous.is_pseudo_paren and previous.value == '(')): if not current.OpensScope(): opening = _GetOpeningBracket(current) if previous.is_pseudo_paren: # Split before the dictionary value if we can't fit the whole # dictionary on one line. if not self._EachDictEntryFitsOnOneLine(opening): return True if (previous.OpensScope() and not current.OpensScope() and format_token.Subtype.SUBSCRIPT_BRACKET not in previous.subtypes): if not current.is_comment: pprevious = previous.previous_token if pprevious and not pprevious.is_keyword and not pprevious.is_name: # We want to split if there's a comment in the container. token = current while token != previous.matching_bracket: if token.is_comment: return True token = token.next_token if previous.value == '(': pptoken = previous.previous_token if not pptoken or not pptoken.is_name: # Split after the opening of a tuple if it doesn't fit on the current # line and it's not a function call. if self._FitsOnLine(previous, previous.matching_bracket): return False else: # Split after the opening of a container if it doesn't fit on the # current line or if it has a comment. if not self._FitsOnLine(previous, previous.matching_bracket): return True if previous.value == '{': closing = previous.matching_bracket if (not self._FitsOnLine(previous, closing) and closing.previous_token.value == ','): self.stack[-1].split_before_closing_bracket = True return True if (format_token.Subtype.COMP_FOR in current.subtypes and format_token.Subtype.COMP_FOR not in previous.subtypes): # Split at the beginning of a list comprehension. length = _GetLengthOfSubtype(current, format_token.Subtype.COMP_FOR, format_token.Subtype.COMP_IF) if length + self.column > self.column_limit: return True if (format_token.Subtype.COMP_IF in current.subtypes and format_token.Subtype.COMP_IF not in previous.subtypes): # Split at the beginning of an if expression. length = _GetLengthOfSubtype(current, format_token.Subtype.COMP_IF) if length + self.column > self.column_limit: return True previous_previous_token = previous.previous_token if (current.is_name and previous_previous_token and previous_previous_token.is_name and previous.value == '('): if not self._FitsOnLine(previous, previous.matching_bracket): if _IsFunctionCallWithArguments(current): # There is a function call, with more than 1 argument, where # the first argument is itself a function call with arguments. # In this specific case, if we split after the first argument's # opening '(', then the formatting will look bad for the rest # of the arguments. Instead, enforce a split before that # argument to keep things looking good. return True elif current.OpensScope(): if not self._FitsOnLine(current, current.matching_bracket): # There is a data literal that will need to be split and could mess # up the formatting. return True if (style.Get('SPLIT_BEFORE_BITWISE_OPERATOR') and current.value in '&|' and previous.lineno < current.lineno): # Retain the split before a bitwise operator. return True if (current.is_comment and previous.lineno < current.lineno - current.value.count('\n')): # If a comment comes in the middle of an unwrapped line (like an if # conditional with comments interspersed), then we want to split if the # original comments were on a separate line. return True if current.is_name and previous.value == ',': # If we have a function call within an argument list and it won't fit on # the remaining line, but it will fit on a line by itself, then go ahead # and split before the call. opening = _GetOpeningBracket(current) if (opening and opening.value == '(' and opening.previous_token and opening.previous_token.is_name): is_func_call = False token = current while token: if token.value == '(': is_func_call = True break if not token.is_name and token.value != '.': break token = token.next_token if is_func_call: if not self._FitsOnLine(current, opening.matching_bracket): return True return False def AddTokenToState(self, newline, dry_run, must_split=False): """Add a token to the format decision state. Allow the heuristic to try out adding the token with and without a newline. Later on, the algorithm will determine which one has the lowest penalty. Arguments: newline: (bool) Add the token on a new line if True. dry_run: (bool) Don't commit whitespace changes to the FormatToken if True. must_split: (bool) A newline was required before this token. Returns: The penalty of splitting after the current token. """ penalty = 0 if newline: penalty = self._AddTokenOnNewline(dry_run, must_split) else: self._AddTokenOnCurrentLine(dry_run) return self._MoveStateToNextToken() + penalty def _AddTokenOnCurrentLine(self, dry_run): """Puts the token on the current line. Appends the next token to the state and updates information necessary for indentation. Arguments: dry_run: (bool) Commit whitespace changes to the FormatToken if True. """ current = self.next_token previous = current.previous_token spaces = current.spaces_required_before if not dry_run: current.AddWhitespacePrefix(newlines_before=0, spaces=spaces) if previous.OpensScope(): if not current.is_comment: # Align closing scopes that are on a newline with the opening scope: # # foo = [a, # b, # ] self.stack[-1].closing_scope_indent = self.column - 1 if style.Get('ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'): self.stack[-1].closing_scope_indent += 1 self.stack[-1].indent = self.column + spaces else: self.stack[-1].closing_scope_indent = ( self.stack[-1].indent - style.Get('CONTINUATION_INDENT_WIDTH')) self.column += spaces def _AddTokenOnNewline(self, dry_run, must_split): """Adds a line break and necessary indentation. Appends the next token to the state and updates information necessary for indentation. Arguments: dry_run: (bool) Don't commit whitespace changes to the FormatToken if True. must_split: (bool) A newline was required before this token. Returns: The split penalty for splitting after the current state. """ current = self.next_token previous = current.previous_token self.column = self._GetNewlineColumn() if not dry_run: current.AddWhitespacePrefix(newlines_before=1, spaces=self.column) if not current.is_comment: self.stack[-1].last_space = self.column self.start_of_line_level = self.paren_level self.lowest_level_on_line = self.paren_level if (previous.OpensScope() or (previous.is_comment and previous.previous_token is not None and previous.previous_token.OpensScope())): self.stack[-1].closing_scope_indent = max( 0, self.stack[-1].indent - style.Get('CONTINUATION_INDENT_WIDTH')) self.stack[-1].split_before_closing_bracket = True # Calculate the split penalty. penalty = current.split_penalty if must_split: # Don't penalize for a must split. return penalty if previous.is_pseudo_paren and previous.value == '(': # Small penalty for splitting after a pseudo paren. penalty += 50 # Add a penalty for each increasing newline we add, but don't penalize for # splitting before an if-expression or list comprehension. if not must_split and current.value not in {'if', 'for'}: last = self.stack[-1] last.num_line_splits += 1 penalty += (style.Get('SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT') * last.num_line_splits) return penalty + 10 def _GetNewlineColumn(self): """Return the new column on the newline.""" current = self.next_token previous = current.previous_token top_of_stack = self.stack[-1] if current.spaces_required_before > 2 or self.line.disable: return current.spaces_required_before if current.OpensScope(): return top_of_stack.indent if self.paren_level else self.first_indent if current.ClosesScope(): if (previous.OpensScope() or (previous.is_comment and previous.previous_token is not None and previous.previous_token.OpensScope())): return max(0, top_of_stack.indent - style.Get('CONTINUATION_INDENT_WIDTH')) return top_of_stack.closing_scope_indent if (previous and previous.is_string and current.is_string and format_token.Subtype.DICTIONARY_VALUE in current.subtypes): return previous.column if style.Get('INDENT_DICTIONARY_VALUE'): if previous and (previous.value == ':' or previous.is_pseudo_paren): if format_token.Subtype.DICTIONARY_VALUE in current.subtypes: return top_of_stack.indent if (self.line.first.value in _COMPOUND_STMTS and (not style.Get('DEDENT_CLOSING_BRACKETS') or style.Get('SPLIT_BEFORE_FIRST_ARGUMENT'))): token_indent = (len(self.line.first.whitespace_prefix.split('\n')[-1]) + style.Get('INDENT_WIDTH')) if token_indent == top_of_stack.indent: return top_of_stack.indent + style.Get('CONTINUATION_INDENT_WIDTH') return top_of_stack.indent def _MoveStateToNextToken(self): """Calculate format decision state information and move onto the next token. Before moving onto the next token, we first calculate the format decision state given the current token and its formatting decisions. Then the format decision state is set up so that the next token can be added. Returns: The penalty for the number of characters over the column limit. """ current = self.next_token if not current.OpensScope() and not current.ClosesScope(): self.lowest_level_on_line = min(self.lowest_level_on_line, self.paren_level) # If we encounter an opening bracket, we add a level to our stack to prepare # for the subsequent tokens. if current.OpensScope(): last = self.stack[-1] new_indent = style.Get('CONTINUATION_INDENT_WIDTH') + last.last_space self.stack.append(_ParenState(new_indent, self.stack[-1].last_space)) self.paren_level += 1 # If we encounter a closing bracket, we can remove a level from our # parenthesis stack. if len(self.stack) > 1 and current.ClosesScope(): self.stack[-2].last_space = self.stack[-1].last_space self.stack.pop() self.paren_level -= 1 is_multiline_string = current.is_string and '\n' in current.value if is_multiline_string: # This is a multiline string. Only look at the first line. self.column += len(current.value.split('\n')[0]) elif not current.is_pseudo_paren: self.column += len(current.value) self.next_token = self.next_token.next_token # Calculate the penalty for overflowing the column limit. penalty = 0 if not current.is_pylint_comment and self.column > self.column_limit: excess_characters = self.column - self.column_limit penalty += style.Get('SPLIT_PENALTY_EXCESS_CHARACTER') * excess_characters if is_multiline_string: # If this is a multiline string, the column is actually the # end of the last line in the string. self.column = len(current.value.split('\n')[-1]) return penalty def _FitsOnLine(self, start, end): """Determines if line between start and end can fit on the current line.""" length = end.total_length - start.total_length if not start.is_pseudo_paren: length += len(start.value) return length + self.column <= self.column_limit def _EachDictEntryFitsOnOneLine(self, opening): """Determine if each dict elems can fit on one line.""" def PreviousNonCommentToken(tok): tok = tok.previous_token while tok.is_comment: tok = tok.previous_token return tok def ImplicitStringConcatenation(tok): num_strings = 0 if tok.is_pseudo_paren: tok = tok.next_token while tok.is_string: num_strings += 1 tok = tok.next_token return num_strings > 1 closing = opening.matching_bracket entry_start = opening.next_token current = opening.next_token.next_token while current and current != closing: if format_token.Subtype.DICTIONARY_KEY in current.subtypes: prev = PreviousNonCommentToken(current) length = prev.total_length - entry_start.total_length length += len(entry_start.value) if length + self.stack[-2].indent >= self.column_limit: return False entry_start = current if current.OpensScope(): if ((current.value == '{' or (current.is_pseudo_paren and current.next_token.value == '{') and format_token.Subtype.DICTIONARY_VALUE in current.subtypes) or ImplicitStringConcatenation(current)): # A dictionary entry that cannot fit on a single line shouldn't matter # to this calcuation. If it can't fit on a single line, then the # opening should be on the same line as the key and the rest on # newlines after it. But the other entries should be on single lines # if possible. if current.matching_bracket: current = current.matching_bracket while current: if current == closing: return True if format_token.Subtype.DICTIONARY_KEY in current.subtypes: entry_start = current break current = current.next_token else: current = current.matching_bracket else: current = current.next_token # At this point, current is the closing bracket. Go back one to get the the # end of the dictionary entry. current = PreviousNonCommentToken(current) length = current.total_length - entry_start.total_length length += len(entry_start.value) return length + self.stack[-2].indent <= self.column_limit def _IsFunctionCallWithArguments(token): while token: if token.value == '(': token = token.next_token return token and token.value != ')' elif token.name not in {'NAME', 'DOT'}: break token = token.next_token return False def _GetLengthOfSubtype(token, subtype, exclude=None): current = token while (current.next_token and subtype in current.subtypes and (exclude is None or exclude not in current.subtypes)): current = current.next_token return current.total_length - token.total_length + 1 def _GetOpeningBracket(current): if current.matching_bracket and not current.is_pseudo_paren: return current.matching_bracket while current: if current.ClosesScope(): current = current.matching_bracket elif current.is_pseudo_paren: current = current.previous_token elif current.OpensScope(): return current current = current.previous_token return None def _LastTokenInLine(current): while not current.is_comment and current.next_token: current = current.next_token return current def _IsFunctionDefinition(current): prev = current.previous_token return (current.value == '(' and prev and format_token.Subtype.FUNC_DEF in prev.subtypes) def _IsLastScopeInLine(current): while current: current = current.next_token if current and current.OpensScope(): return False return True class _ParenState(object): """Maintains the state of the bracket enclosures. A stack of _ParenState objects are kept so that we know how to indent relative to the brackets. Attributes: indent: The column position to which a specified parenthesis level needs to be indented. last_space: The column position of the last space on each level. split_before_closing_bracket: Whether a newline needs to be inserted before the closing bracket. We only want to insert a newline before the closing bracket if there also was a newline after the beginning left bracket. num_line_splits: Number of line splits this _ParenState contains already. Each subsequent line split gets an increasing penalty. """ # TODO(morbo): This doesn't track "bin packing." def __init__(self, indent, last_space): self.indent = indent self.last_space = last_space self.closing_scope_indent = 0 self.split_before_closing_bracket = False self.num_line_splits = 0 def __copy__(self): state = _ParenState(self.indent, self.last_space) state.closing_scope_indent = self.closing_scope_indent state.split_before_closing_bracket = self.split_before_closing_bracket state.num_line_splits = self.num_line_splits return state def __repr__(self): return '[indent::%d, last_space::%d, closing_scope_indent::%d]' % ( self.indent, self.last_space, self.closing_scope_indent) def __eq__(self, other): return hash(self) == hash(other) def __ne__(self, other): return not self == other def __hash__(self, *args, **kwargs): return hash((self.indent, self.last_space, self.closing_scope_indent, self.split_before_closing_bracket, self.num_line_splits)) yapf-0.15.1/yapf/yapflib/format_token.py000066400000000000000000000214401304174360200201650ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Pytree nodes with extra formatting information. This is a thin wrapper around a pytree.Leaf node. """ import keyword import re from lib2to3 import pytree from lib2to3.pgen2 import token from yapf.yapflib import py3compat from yapf.yapflib import pytree_utils from yapf.yapflib import style CONTINUATION = token.N_TOKENS token.N_TOKENS += 1 class Subtype(object): """Subtype information about tokens. Gleaned from parsing the code. Helps determine the best formatting. """ NONE = 0 UNARY_OPERATOR = 1 BINARY_OPERATOR = 2 SUBSCRIPT_COLON = 3 SUBSCRIPT_BRACKET = 4 DEFAULT_OR_NAMED_ASSIGN = 5 DEFAULT_OR_NAMED_ASSIGN_ARG_LIST = 6 VARARGS_LIST = 7 VARARGS_STAR = 8 KWARGS_STAR_STAR = 9 ASSIGN_OPERATOR = 10 DICTIONARY_KEY = 11 DICTIONARY_VALUE = 12 DICT_SET_GENERATOR = 13 COMP_FOR = 14 COMP_IF = 15 FUNC_DEF = 16 DECORATOR = 17 class FormatToken(object): """A wrapper around pytree Leaf nodes. This represents the token plus additional information useful for reformatting the code. Attributes: next_token: The token in the unwrapped line after this token or None if this is the last token in the unwrapped line. previous_token: The token in the unwrapped line before this token or None if this is the first token in the unwrapped line. matching_bracket: If a bracket token ('[', '{', or '(') the matching bracket. whitespace_prefix: The prefix for the whitespace. spaces_required_before: The number of spaces required before a token. This is a lower-bound for the formatter and not a hard requirement. For instance, a comment may have n required spaces before it. But the formatter won't place n spaces before all comments. Only those that are moved to the end of a line of code. The formatter may use different spacing when appropriate. can_break_before: True if we're allowed to break before this token. must_break_before: True if we're required to break before this token. total_length: The total length of the unwrapped line up to and including whitespace and this token. However, this doesn't include the initial indentation amount. split_penalty: The penalty for splitting the line before this token. """ def __init__(self, node): """Constructor. Arguments: node: (pytree.Leaf) The node that's being wrapped. """ self.node = node self.next_token = None self.previous_token = None self.matching_bracket = None self.whitespace_prefix = '' self.can_break_before = False self.must_break_before = False self.total_length = 0 # TODO(morbo): Think up a better name. self.split_penalty = 0 if self.is_comment: self.spaces_required_before = style.Get('SPACES_BEFORE_COMMENT') else: self.spaces_required_before = 0 if self.is_continuation: self.value = self.node.value.rstrip() else: self.value = self.node.value def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): """Register a token's whitespace prefix. This is the whitespace that will be output before a token's string. Arguments: newlines_before: (int) The number of newlines to place before the token. spaces: (int) The number of spaces to place before the token. indent_level: (int) The indentation level. """ indent_char = '\t' if style.Get('USE_TABS') else ' ' indent_before = ( indent_char * indent_level * style.Get('INDENT_WIDTH') + ' ' * spaces) if self.is_comment: comment_lines = [s.lstrip() for s in self.value.splitlines()] self.node.value = ('\n' + indent_before).join(comment_lines) # Update our own value since we are changing node value self.value = self.node.value if not self.whitespace_prefix: self.whitespace_prefix = ( '\n' * (self.newlines or newlines_before) + indent_before) else: self.whitespace_prefix += indent_before def AdjustNewlinesBefore(self, newlines_before): """Change the number of newlines before this token.""" self.whitespace_prefix = ( '\n' * newlines_before + self.whitespace_prefix.lstrip('\n')) def RetainHorizontalSpacing(self, first_column, depth): """Retains a token's horizontal spacing.""" previous = self.previous_token if previous is None: return cur_lineno = self.lineno prev_lineno = previous.lineno if previous.is_multiline_string: prev_lineno += previous.value.count('\n') if (cur_lineno != prev_lineno or (previous.is_pseudo_paren and previous.value != ')' and cur_lineno != previous.previous_token.lineno)): self.spaces_required_before = ( self.column - first_column + depth * style.Get('INDENT_WIDTH')) return cur_column = self.node.column prev_column = previous.node.column prev_len = len(previous.value) if previous.is_pseudo_paren and previous.value == ')': prev_column -= 1 prev_len = 0 if previous.is_multiline_string: prev_len = len(previous.value.split('\n')[-1]) if '\n' in previous.value: prev_column = 0 # Last line starts in column 0. self.spaces_required_before = cur_column - (prev_column + prev_len) def OpensScope(self): return self.value in pytree_utils.OPENING_BRACKETS def ClosesScope(self): return self.value in pytree_utils.CLOSING_BRACKETS def __repr__(self): msg = 'FormatToken(name={0}, value={1}'.format(self.name, self.value) msg += ', pseudo)' if self.is_pseudo_paren else ')' return msg @property @py3compat.lru_cache() def node_split_penalty(self): """Split penalty attached to the pytree node of this token.""" return pytree_utils.GetNodeAnnotation( self.node, pytree_utils.Annotation.SPLIT_PENALTY, default=0) @property def newlines(self): """The number of newlines needed before this token.""" return pytree_utils.GetNodeAnnotation(self.node, pytree_utils.Annotation.NEWLINES) @property def must_split(self): """Return true if the token requires a split before it.""" return pytree_utils.GetNodeAnnotation(self.node, pytree_utils.Annotation.MUST_SPLIT) @property def column(self): """The original column number of the node in the source.""" return self.node.column @property def lineno(self): """The original line number of the node in the source.""" return self.node.lineno @property @py3compat.lru_cache() def subtypes(self): """Extra type information for directing formatting.""" value = pytree_utils.GetNodeAnnotation(self.node, pytree_utils.Annotation.SUBTYPE) return [Subtype.NONE] if value is None else value @property @py3compat.lru_cache() def is_binary_op(self): """Token is a binary operator.""" return Subtype.BINARY_OPERATOR in self.subtypes @property @py3compat.lru_cache() def name(self): """A string representation of the node's name.""" return pytree_utils.NodeName(self.node) @property def is_comment(self): return self.node.type == token.COMMENT @property def is_continuation(self): return self.node.type == CONTINUATION @property @py3compat.lru_cache() def is_keyword(self): return keyword.iskeyword(self.value) @property @py3compat.lru_cache() def is_name(self): return self.node.type == token.NAME and not self.is_keyword @property def is_number(self): return self.node.type == token.NUMBER @property def is_string(self): return self.node.type == token.STRING @property @py3compat.lru_cache() def is_multiline_string(self): return (self.is_string and re.match(r'^[uUbB]?[rR]?(?P"""|\'\'\').*(?P=delim)$', self.value, re.DOTALL) is not None) @property @py3compat.lru_cache() def is_docstring(self): return self.is_multiline_string and not self.node.prev_sibling @property @py3compat.lru_cache() def is_pseudo_paren(self): return hasattr(self.node, 'is_pseudo') and self.node.is_pseudo @property def is_pylint_comment(self): return self.is_comment and re.match(r'#.*\bpylint:\s*(disable|enable)=', self.value) yapf-0.15.1/yapf/yapflib/line_joiner.py000066400000000000000000000075311304174360200177770ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Join unwrapped lines together. Determine how many lines can be joined into one line. For instance, we could join these statements into one line: if a == 42: continue like this: if a == 42: continue There are a few restrictions: 1. The lines should have been joined in the original source. 2. The joined lines must not go over the column boundary if placed on the same line. 3. They need to be very simple statements. Note: Because we don't allow the use of a semicolon to separate statements, it follows that there can only be at most two lines to join. """ from yapf.yapflib import style _CLASS_OR_FUNC = frozenset({'def', 'class'}) def CanMergeMultipleLines(lines, last_was_merged=False): """Determine if multiple lines can be joined into one. Arguments: lines: (list of UnwrappedLine) This is a splice of UnwrappedLines from the full code base. last_was_merged: (bool) The last line was merged. Returns: True if two consecutive lines can be joined together. In reality, this will only happen if two consecutive lines can be joined, due to the style guide. """ # The indentation amount for the starting line (number of spaces). indent_amt = lines[0].depth * style.Get('INDENT_WIDTH') if len(lines) == 1 or indent_amt > style.Get('COLUMN_LIMIT'): return False if (len(lines) >= 3 and lines[2].depth >= lines[1].depth and lines[0].depth != lines[2].depth): # If lines[2]'s depth is greater than or equal to line[1]'s depth, we're not # looking at a single statement (e.g., if-then, while, etc.). A following # line with the same depth as the first line isn't part of the lines we # would want to combine. return False # Don't merge more than two lines together. if lines[0].first.value in _CLASS_OR_FUNC: # Don't join lines onto the starting line of a class or function. return False limit = style.Get('COLUMN_LIMIT') - indent_amt if lines[0].last.total_length < limit: limit -= lines[0].last.total_length if lines[0].first.value == 'if': return _CanMergeLineIntoIfStatement(lines, limit) if last_was_merged and lines[0].first.value in {'elif', 'else'}: return _CanMergeLineIntoIfStatement(lines, limit) # TODO(morbo): Other control statements? return False def _CanMergeLineIntoIfStatement(lines, limit): """Determine if we can merge a short if-then statement into one line. Two lines of an if-then statement can be merged if they were that way in the original source, fit on the line without going over the column limit, and are considered "simple" statements --- typically statements like 'pass', 'continue', and 'break'. Arguments: lines: (list of UnwrappedLine) The lines we are wanting to merge. limit: (int) The amount of space remaining on the line. Returns: True if the lines can be merged, False otherwise. """ if len(lines[1].tokens) == 1 and lines[1].last.is_multiline_string: # This might be part of a multiline shebang. return True if lines[0].lineno != lines[1].lineno: # Don't merge lines if the original lines weren't merged. return False if lines[1].last.total_length >= limit: # Don't merge lines if the result goes over the column limit. return False return style.Get('JOIN_MULTIPLE_LINES') yapf-0.15.1/yapf/yapflib/py3compat.py000066400000000000000000000054511304174360200174200ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Utilities for Python2 / Python3 compatibility.""" import io import sys PY3 = sys.version_info[0] == 3 PY36 = sys.version_info[0] == 3 and sys.version_info[1] >= 6 if PY3: StringIO = io.StringIO BytesIO = io.BytesIO import codecs def open_with_encoding(filename, mode, encoding, newline=''): # pylint: disable=unused-argument return codecs.open(filename, mode=mode, encoding=encoding) import functools lru_cache = functools.lru_cache range = range ifilter = filter raw_input = input import configparser # Mappings from strings to booleans (such as '1' to True, 'false' to False, # etc.) CONFIGPARSER_BOOLEAN_STATES = configparser.ConfigParser.BOOLEAN_STATES else: import __builtin__ import cStringIO StringIO = BytesIO = cStringIO.StringIO open_with_encoding = io.open # Python 2.7 doesn't have a native LRU cache, so do nothing. def lru_cache(maxsize=128, typed=False): def fake_wrapper(user_function): return user_function return fake_wrapper range = xrange from itertools import ifilter raw_input = raw_input import ConfigParser as configparser CONFIGPARSER_BOOLEAN_STATES = configparser.ConfigParser._boolean_states # pylint: disable=protected-access def EncodeAndWriteToStdout(s, encoding='utf-8'): """Encode the given string and emit to stdout. The string may contain non-ascii characters. This is a problem when stdout is redirected, because then Python doesn't know the encoding and we may get a UnicodeEncodeError. Arguments: s: (string) The string to encode. encoding: (string) The encoding of the string. """ if PY3: sys.stdout.buffer.write(codecs.encode(s, encoding)) else: sys.stdout.write(s.encode(encoding)) def unicode(s): """Force conversion of s to unicode.""" if PY3: return s else: return __builtin__.unicode(s, 'utf-8') # In Python 3.2+, readfp is deprecated in favor of read_file, which doesn't # exist in Python 2 yet. To avoid deprecation warnings, subclass ConfigParser to # fix this - now read_file works across all Python versions we care about. class ConfigParser(configparser.ConfigParser): if not PY3: def read_file(self, fp, source=None): self.readfp(fp, filename=source) yapf-0.15.1/yapf/yapflib/pytree_unwrapper.py000066400000000000000000000317261304174360200211200ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """PyTreeUnwrapper - produces a list of unwrapped lines from a pytree. [for a description of what an unwrapped line is, see unwrapped_line.py] This is a pytree visitor that goes over a parse tree and produces a list of UnwrappedLine containers from it, each with its own depth and containing all the tokens that could fit on the line if there were no maximal line-length limitations. Note: a precondition to running this visitor and obtaining correct results is for the tree to have its comments spliced in as nodes. Prefixes are ignored. For most uses, the convenience function UnwrapPyTree should be sufficient. """ # The word "token" is overloaded within this module, so for clarity rename # the imported pgen2.token module. from lib2to3 import pytree from lib2to3.pgen2 import token as grammar_token from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor from yapf.yapflib import split_penalty from yapf.yapflib import unwrapped_line def UnwrapPyTree(tree): """Create and return a list of unwrapped lines from the given pytree. Arguments: tree: the top-level pytree node to unwrap. Returns: A list of UnwrappedLine objects. """ unwrapper = PyTreeUnwrapper() unwrapper.Visit(tree) uwlines = unwrapper.GetUnwrappedLines() uwlines.sort(key=lambda x: x.lineno) return uwlines # Grammar tokens considered as whitespace for the purpose of unwrapping. _WHITESPACE_TOKENS = frozenset([ grammar_token.NEWLINE, grammar_token.DEDENT, grammar_token.INDENT, grammar_token.ENDMARKER ]) class PyTreeUnwrapper(pytree_visitor.PyTreeVisitor): """PyTreeUnwrapper - see file-level docstring for detailed description. Note: since this implements PyTreeVisitor and node names in lib2to3 are underscore_separated, the visiting methods of this class are named as Visit_node_name. invalid-name pragmas are added to each such method to silence a style warning. This is forced on us by the usage of lib2to3, and re-munging method names to make them different from actual node names sounded like a confusing and brittle affair that wasn't worth it for this small & controlled deviation from the style guide. To understand the connection between visitor methods in this class, some familiarity with the Python grammar is required. """ def __init__(self): # A list of all unwrapped lines finished visiting so far. self._unwrapped_lines = [] # Builds up a "current" unwrapped line while visiting pytree nodes. Some # nodes will finish a line and start a new one. self._cur_unwrapped_line = unwrapped_line.UnwrappedLine(0) # Current indentation depth. self._cur_depth = 0 def GetUnwrappedLines(self): """Fetch the result of the tree walk. Note: only call this after visiting the whole tree. Returns: A list of UnwrappedLine objects. """ # Make sure the last line that was being populated is flushed. self._StartNewLine() return self._unwrapped_lines def _StartNewLine(self): """Finish current line and start a new one. Place the currently accumulated line into the _unwrapped_lines list and start a new one. """ if self._cur_unwrapped_line.tokens: self._unwrapped_lines.append(self._cur_unwrapped_line) _MatchBrackets(self._cur_unwrapped_line) _AdjustSplitPenalty(self._cur_unwrapped_line) self._cur_unwrapped_line = unwrapped_line.UnwrappedLine(self._cur_depth) _STMT_TYPES = frozenset({ 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'expect_clause', 'with_stmt', 'funcdef', 'classdef', }) # pylint: disable=invalid-name,missing-docstring def Visit_simple_stmt(self, node): # A 'simple_stmt' conveniently represents a non-compound Python statement, # i.e. a statement that does not contain other statements. # When compound nodes have a single statement as their suite, the parser # can leave it in the tree directly without creating a suite. But we have # to increase depth in these cases as well. However, don't increase the # depth of we have a simple_stmt that's a comment node. This represents a # standalone comment and in the case of it coming directly after the # funcdef, it is a "top" comment for the whole function. # TODO(eliben): add more relevant compound statements here. single_stmt_suite = (node.parent and pytree_utils.NodeName(node.parent) in self._STMT_TYPES) is_comment_stmt = pytree_utils.IsCommentStatement(node) if single_stmt_suite and not is_comment_stmt: self._cur_depth += 1 self._StartNewLine() self.DefaultNodeVisit(node) if single_stmt_suite and not is_comment_stmt: self._cur_depth -= 1 def _VisitCompoundStatement(self, node, substatement_names): """Helper for visiting compound statements. Python compound statements serve as containers for other statements. Thus, when we encounter a new compound statement we start a new unwrapped line. Arguments: node: the node to visit. substatement_names: set of node names. A compound statement will be recognized as a NAME node with a name in this set. """ for child in node.children: # A pytree is structured in such a way that a single 'if_stmt' node will # contain all the 'if', 'elif' and 'else' nodes as children (similar # structure applies to 'while' statements, 'try' blocks, etc). Therefore, # we visit all children here and create a new line before the requested # set of nodes. if (child.type == grammar_token.NAME and child.value in substatement_names): self._StartNewLine() self.Visit(child) _IF_STMT_ELEMS = frozenset({'if', 'else', 'elif'}) def Visit_if_stmt(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._IF_STMT_ELEMS) _WHILE_STMT_ELEMS = frozenset({'while', 'else'}) def Visit_while_stmt(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._WHILE_STMT_ELEMS) _FOR_STMT_ELEMS = frozenset({'for', 'else'}) def Visit_for_stmt(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._FOR_STMT_ELEMS) _TRY_STMT_ELEMS = frozenset({'try', 'except', 'else', 'finally'}) def Visit_try_stmt(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._TRY_STMT_ELEMS) _EXCEPT_STMT_ELEMS = frozenset({'except'}) def Visit_except_clause(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._EXCEPT_STMT_ELEMS) _FUNC_DEF_ELEMS = frozenset({'def'}) def Visit_funcdef(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._FUNC_DEF_ELEMS) def Visit_async_funcdef(self, node): # pylint: disable=invalid-name self._StartNewLine() index = 0 for child in node.children: index += 1 self.Visit(child) if pytree_utils.NodeName(child) == 'ASYNC': break for child in node.children[index].children: self.Visit(child) _CLASS_DEF_ELEMS = frozenset({'class'}) def Visit_classdef(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._CLASS_DEF_ELEMS) def Visit_async_stmt(self, node): # pylint: disable=invalid-name self._StartNewLine() index = 0 for child in node.children: index += 1 self.Visit(child) if pytree_utils.NodeName(child) == 'ASYNC': break for child in node.children[index].children: self.Visit(child) def Visit_decorators(self, node): # pylint: disable=invalid-name for child in node.children: self._StartNewLine() self.Visit(child) def Visit_decorated(self, node): # pylint: disable=invalid-name for child in node.children: self._StartNewLine() self.Visit(child) _WITH_STMT_ELEMS = frozenset({'with'}) def Visit_with_stmt(self, node): # pylint: disable=invalid-name self._VisitCompoundStatement(node, self._WITH_STMT_ELEMS) def Visit_suite(self, node): # pylint: disable=invalid-name # A 'suite' starts a new indentation level in Python. self._cur_depth += 1 self._StartNewLine() self.DefaultNodeVisit(node) self._cur_depth -= 1 def Visit_listmaker(self, node): # pylint: disable=invalid-name _DetermineMustSplitAnnotation(node) self.DefaultNodeVisit(node) def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name _DetermineMustSplitAnnotation(node) self.DefaultNodeVisit(node) def Visit_import_as_names(self, node): # pylint: disable=invalid-name if node.prev_sibling.value == '(': _DetermineMustSplitAnnotation(node) self.DefaultNodeVisit(node) def Visit_testlist_gexp(self, node): # pylint: disable=invalid-name _DetermineMustSplitAnnotation(node) self.DefaultNodeVisit(node) def Visit_arglist(self, node): # pylint: disable=invalid-name _DetermineMustSplitAnnotation(node) self.DefaultNodeVisit(node) def Visit_typedargslist(self, node): # pylint: disable=invalid-name _DetermineMustSplitAnnotation(node) self.DefaultNodeVisit(node) def DefaultLeafVisit(self, leaf): """Default visitor for tree leaves. A tree leaf is always just gets appended to the current unwrapped line. Arguments: leaf: the leaf to visit. """ if leaf.type in _WHITESPACE_TOKENS: self._StartNewLine() elif leaf.type != grammar_token.COMMENT or leaf.value.strip(): if leaf.value == ';': # Split up multiple statements on one line. self._StartNewLine() else: # Add non-whitespace tokens and comments that aren't empty. self._cur_unwrapped_line.AppendNode(leaf) _BRACKET_MATCH = {')': '(', '}': '{', ']': '['} def _MatchBrackets(uwline): """Visit the node and match the brackets. For every open bracket ('[', '{', or '('), find the associated closing bracket and "match" them up. I.e., save in the token a pointer to its associated open or close bracket. Arguments: uwline: (UnwrappedLine) An unwrapped line. """ bracket_stack = [] for token in uwline.tokens: if token.value in pytree_utils.OPENING_BRACKETS: bracket_stack.append(token) elif token.value in pytree_utils.CLOSING_BRACKETS: bracket_stack[-1].matching_bracket = token token.matching_bracket = bracket_stack[-1] bracket_stack.pop() def _AdjustSplitPenalty(uwline): """Visit the node and adjust the split penalties if needed. A token shouldn't be split if it's not within a bracket pair. Mark any token that's not within a bracket pair as "unbreakable". Arguments: uwline: (UnwrappedLine) An unwrapped line. """ bracket_level = 0 for index, token in enumerate(uwline.tokens): if index and not bracket_level: pytree_utils.SetNodeAnnotation(token.node, pytree_utils.Annotation.SPLIT_PENALTY, split_penalty.UNBREAKABLE) if token.value in pytree_utils.OPENING_BRACKETS: bracket_level += 1 elif token.value in pytree_utils.CLOSING_BRACKETS: bracket_level -= 1 def _DetermineMustSplitAnnotation(node): """Enforce a split in the list if the list ends with a comma.""" if not _ContainsComments(node): if sum(1 for ch in node.children if pytree_utils.NodeName(ch) == 'COMMA') < 2: return if (not isinstance(node.children[-1], pytree.Leaf) or node.children[-1].value != ','): return num_children = len(node.children) index = 0 _SetMustSplitOnFirstLeaf(node.children[0]) while index < num_children - 1: child = node.children[index] if isinstance(child, pytree.Leaf) and child.value == ',': next_child = node.children[index + 1] if next_child.type == grammar_token.COMMENT: index += 1 if index >= num_children - 1: break _SetMustSplitOnFirstLeaf(node.children[index + 1]) index += 1 def _ContainsComments(node): """Return True if the list has a comment in it.""" if isinstance(node, pytree.Leaf): return node.type == grammar_token.COMMENT for child in node.children: if _ContainsComments(child): return True return False def _SetMustSplitOnFirstLeaf(node): """Set the "must split" annotation on the first leaf node.""" def FindFirstLeaf(node): if isinstance(node, pytree.Leaf): return node return FindFirstLeaf(node.children[0]) pytree_utils.SetNodeAnnotation( FindFirstLeaf(node), pytree_utils.Annotation.MUST_SPLIT, True) yapf-0.15.1/yapf/yapflib/pytree_utils.py000066400000000000000000000227251304174360200202340ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """pytree-related utilities. This module collects various utilities related to the parse trees produced by the lib2to3 library. NodeName(): produces a string name for pytree nodes. ParseCodeToTree(): convenience wrapper around lib2to3 interfaces to parse a given string with code to a pytree. InsertNodeBefore(): insert a node before another in a pytree. InsertNodeAfter(): insert a node after another in a pytree. {Get,Set}NodeAnnotation(): manage custom annotations on pytree nodes. """ import ast from lib2to3 import pygram from lib2to3 import pytree from lib2to3.pgen2 import driver from lib2to3.pgen2 import parse from lib2to3.pgen2 import token # TODO(eliben): We may want to get rid of this filtering at some point once we # have a better understanding of what information we need from the tree. Then, # these tokens may be filtered out from the tree before the tree gets to the # unwrapper. NONSEMANTIC_TOKENS = frozenset(['DEDENT', 'INDENT', 'NEWLINE', 'ENDMARKER']) OPENING_BRACKETS = frozenset({'(', '[', '{'}) CLOSING_BRACKETS = frozenset({')', ']', '}'}) class Annotation(object): """Annotation names associated with pytrees.""" CHILD_INDENT = 'child_indent' NEWLINES = 'newlines' MUST_SPLIT = 'must_split' SPLIT_PENALTY = 'split_penalty' SUBTYPE = 'subtype' def NodeName(node): """Produce a string name for a given node. For a Leaf this is the token name, and for a Node this is the type. Arguments: node: a tree node Returns: Name as a string. """ # Nodes with values < 256 are tokens. Values >= 256 are grammar symbols. if node.type < 256: return token.tok_name[node.type] else: return pygram.python_grammar.number2symbol[node.type] # lib2to3 thoughtfully provides pygram.python_grammar_no_print_statement for # parsing Python 3 code that wouldn't parse otherwise (when 'print' is used in a # context where a keyword is disallowed). # It forgets to do the same for 'exec' though. Luckily, Python is amenable to # monkey-patching. _GRAMMAR_FOR_PY3 = pygram.python_grammar_no_print_statement.copy() del _GRAMMAR_FOR_PY3.keywords['exec'] _GRAMMAR_FOR_PY2 = pygram.python_grammar.copy() del _GRAMMAR_FOR_PY2.keywords['nonlocal'] def ParseCodeToTree(code): """Parse the given code to a lib2to3 pytree. Arguments: code: a string with the code to parse. Raises: SyntaxError if the code is invalid syntax. parse.ParseError if some other parsing failure. Returns: The root node of the parsed tree. """ # This function is tiny, but the incantation for invoking the parser correctly # is sufficiently magical to be worth abstracting away. try: # Try to parse using a Python 3 grammar, which is more permissive (print and # exec are not keywords). parser_driver = driver.Driver(_GRAMMAR_FOR_PY3, convert=pytree.convert) tree = parser_driver.parse_string(code, debug=False) except parse.ParseError: # Now try to parse using a Python 2 grammar; If this fails, then # there's something else wrong with the code. try: parser_driver = driver.Driver(_GRAMMAR_FOR_PY2, convert=pytree.convert) tree = parser_driver.parse_string(code, debug=False) except parse.ParseError: # Raise a syntax error if the code is invalid python syntax. try: ast.parse(code) except SyntaxError as e: raise e else: raise return _WrapEndMarker(tree) def _WrapEndMarker(tree): """Wrap a single ENDMARKER token in a "file_input" node. Arguments: tree: (pytree.Node) The root node of the parsed tree. Returns: The root node of the parsed tree. If the tree is a single ENDMARKER node, then that node is wrapped in a "file_input" node. That will ensure we don't skip comments attached to that node. """ if isinstance(tree, pytree.Leaf) and tree.type == token.ENDMARKER: return pytree.Node(pygram.python_symbols.file_input, [tree]) return tree def InsertNodesBefore(new_nodes, target): """Insert new_nodes before the given target location in the tree. Arguments: new_nodes: a sequence of new nodes to insert (the nodes should not be in the tree). target: the target node before which the new node node will be inserted. Raises: RuntimeError: if the tree is corrupted, or the insertion would corrupt it. """ for node in new_nodes: _InsertNodeAt(node, target, after=False) def InsertNodesAfter(new_nodes, target): """Insert new_nodes after the given target location in the tree. Arguments: new_nodes: a sequence of new nodes to insert (the nodes should not be in the tree). target: the target node after which the new node node will be inserted. Raises: RuntimeError: if the tree is corrupted, or the insertion would corrupt it. """ for node in reversed(new_nodes): _InsertNodeAt(node, target, after=True) def _InsertNodeAt(new_node, target, after=False): """Underlying implementation for node insertion. Arguments: new_node: a new node to insert (this node should not be in the tree). target: the target node. after: if True, new_node is inserted after target. Otherwise, it's inserted before target. Returns: nothing Raises: RuntimeError: if the tree is corrupted, or the insertion would corrupt it. """ # Protect against attempts to insert nodes which already belong to some tree. if new_node.parent is not None: raise RuntimeError('inserting node which already has a parent', (new_node, new_node.parent)) # The code here is based on pytree.Base.next_sibling parent_of_target = target.parent if parent_of_target is None: raise RuntimeError('expected target node to have a parent', (target,)) for i, child in enumerate(parent_of_target.children): if child is target: insertion_index = i + 1 if after else i parent_of_target.insert_child(insertion_index, new_node) return raise RuntimeError('unable to find insertion point for target node', (target,)) # The following constant and functions implement a simple custom annotation # mechanism for pytree nodes. We attach new attributes to nodes. Each attribute # is prefixed with _NODE_ANNOTATION_PREFIX. These annotations should only be # managed through GetNodeAnnotation and SetNodeAnnotation. _NODE_ANNOTATION_PREFIX = '_yapf_annotation_' def GetNodeAnnotation(node, annotation, default=None): """Get annotation value from a node. Arguments: node: the node. annotation: annotation name - a string. default: the default value to return if there's no annotation. Returns: Value of the annotation in the given node. If the node doesn't have this particular annotation name yet, returns default. """ return getattr(node, _NODE_ANNOTATION_PREFIX + annotation, default) def SetNodeAnnotation(node, annotation, value): """Set annotation value on a node. Arguments: node: the node. annotation: annotation name - a string. value: annotation value to set. """ setattr(node, _NODE_ANNOTATION_PREFIX + annotation, value) def AppendNodeAnnotation(node, annotation, value): """Appends an annotation value to a list of annotations on the node. Arguments: node: the node. annotation: annotation name - a string. value: annotation value to set. """ attr = GetNodeAnnotation(node, annotation, set()) attr.add(value) SetNodeAnnotation(node, annotation, attr) def RemoveSubtypeAnnotation(node, value): """Removes an annotation value from the subtype annotations on the node. Arguments: node: the node. value: annotation value to remove. """ attr = GetNodeAnnotation(node, Annotation.SUBTYPE) if attr and value in attr: attr.remove(value) SetNodeAnnotation(node, Annotation.SUBTYPE, attr) def DumpNodeToString(node): """Dump a string representation of the given node. For debugging. Arguments: node: the node. Returns: The string representation. """ if isinstance(node, pytree.Leaf): fmt = '{name}({value}) [lineno={lineno}, column={column}, prefix={prefix}]' return fmt.format( name=NodeName(node), value=_PytreeNodeRepr(node), lineno=node.lineno, column=node.column, prefix=repr(node.prefix)) else: fmt = '{node} [{len} children] [child_indent="{indent}"]' return fmt.format( node=NodeName(node), len=len(node.children), indent=GetNodeAnnotation(node, Annotation.CHILD_INDENT)) def _PytreeNodeRepr(node): """Like pytree.Node.__repr__, but names instead of numbers for tokens.""" if isinstance(node, pytree.Node): return '%s(%s, %r)' % (node.__class__.__name__, NodeName(node), [_PytreeNodeRepr(c) for c in node.children]) if isinstance(node, pytree.Leaf): return '%s(%s, %r)' % (node.__class__.__name__, NodeName(node), node.value) def IsCommentStatement(node): return (NodeName(node) == 'simple_stmt' and node.children[0].type == token.COMMENT) yapf-0.15.1/yapf/yapflib/pytree_visitor.py000066400000000000000000000106651304174360200205730ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Generic visitor pattern for pytrees. The lib2to3 parser produces a "pytree" - syntax tree consisting of Node and Leaf types. This module implements a visitor pattern for such trees. It also exports a basic "dumping" visitor that dumps a textual representation of a pytree into a stream. PyTreeVisitor: a generic visitor pattern fo pytrees. PyTreeDumper: a configurable "dumper" for displaying pytrees. DumpPyTree(): a convenience function to dump a pytree. """ import sys from lib2to3 import pytree from yapf.yapflib import pytree_utils class PyTreeVisitor(object): """Visitor pattern for pytree trees. Methods named Visit_XXX will be invoked when a node with type XXX is encountered in the tree. The type is either a token type (for Leaf nodes) or grammar symbols (for Node nodes). The return value of Visit_XXX methods is ignored by the visitor. Visitors can modify node contents but must not change the tree structure (e.g. add/remove children and move nodes around). This is a very common visitor pattern in Python code; it's also used in the Python standard library ast module for providing AST visitors. Note: this makes names that aren't style conformant, so such visitor methods need to be marked with # pylint: disable=invalid-name We don't have a choice here, because lib2to3 nodes have under_separated names. For more complex behavior, the visit, DefaultNodeVisit and DefaultLeafVisit methods can be overridden. Don't forget to invoke DefaultNodeVisit for nodes that may have children - otherwise the children will not be visited. """ def Visit(self, node): """Visit a node.""" method = 'Visit_{0}'.format(pytree_utils.NodeName(node)) if hasattr(self, method): # Found a specific visitor for this node getattr(self, method)(node) else: if isinstance(node, pytree.Leaf): self.DefaultLeafVisit(node) else: self.DefaultNodeVisit(node) def DefaultNodeVisit(self, node): """Default visitor for Node: visits the node's children depth-first. This method is invoked when no specific visitor for the node is defined. Arguments: node: the node to visit """ for child in node.children: self.Visit(child) def DefaultLeafVisit(self, leaf): """Default visitor for Leaf: no-op. This method is invoked when no specific visitor for the leaf is defined. Arguments: leaf: the leaf to visit """ pass def DumpPyTree(tree, target_stream=sys.stdout): """Convenience function for dumping a given pytree. This function presents a very minimal interface. For more configurability (for example, controlling how specific node types are displayed), use PyTreeDumper directly. Arguments: tree: the tree to dump. target_stream: the stream to dump the tree to. A file-like object. By default will dump into stdout. """ dumper = PyTreeDumper(target_stream) dumper.Visit(tree) class PyTreeDumper(PyTreeVisitor): """Visitor that dumps the tree to a stream. Implements the PyTreeVisitor interface. """ def __init__(self, target_stream=sys.stdout): """Create a tree dumper. Arguments: target_stream: the stream to dump the tree to. A file-like object. By default will dump into stdout. """ self._target_stream = target_stream self._current_indent = 0 def _DumpString(self, s): self._target_stream.write('{0}{1}\n'.format(' ' * self._current_indent, s)) def DefaultNodeVisit(self, node): # Dump information about the current node, and then use the generic # DefaultNodeVisit visitor to dump each of its children. self._DumpString(pytree_utils.DumpNodeToString(node)) self._current_indent += 2 super(PyTreeDumper, self).DefaultNodeVisit(node) self._current_indent -= 2 def DefaultLeafVisit(self, leaf): self._DumpString(pytree_utils.DumpNodeToString(leaf)) yapf-0.15.1/yapf/yapflib/reformatter.py000066400000000000000000000501751304174360200200360ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Decide what the format for the code should be. The `unwrapped_line.UnwrappedLine`s are now ready to be formatted. UnwrappedLines that can be merged together are. The best formatting is returned as a string. Reformat(): the main function exported by this module. """ from __future__ import unicode_literals import collections import heapq import re from lib2to3 import pytree from lib2to3.pgen2 import token from yapf.yapflib import format_decision_state from yapf.yapflib import format_token from yapf.yapflib import line_joiner from yapf.yapflib import pytree_utils from yapf.yapflib import style from yapf.yapflib import verifier def Reformat(uwlines, verify=False): """Reformat the unwrapped lines. Arguments: uwlines: (list of unwrapped_line.UnwrappedLine) Lines we want to format. verify: (bool) True if reformatted code should be verified for syntax. Returns: A string representing the reformatted code. """ final_lines = [] prev_uwline = None # The previous line. indent_width = style.Get('INDENT_WIDTH') for uwline in _SingleOrMergedLines(uwlines): first_token = uwline.first _FormatFirstToken(first_token, uwline.depth, prev_uwline, final_lines) indent_amt = indent_width * uwline.depth state = format_decision_state.FormatDecisionState(uwline, indent_amt) if not uwline.disable: if uwline.first.is_comment: uwline.first.node.value = uwline.first.node.value.rstrip() elif uwline.last.is_comment: uwline.last.node.value = uwline.last.node.value.rstrip() if prev_uwline and prev_uwline.disable: # Keep the vertical spacing between a disabled and enabled formatting # region. _RetainVerticalSpacingBetweenTokens(uwline.first, prev_uwline.last) if any(tok.is_comment for tok in uwline.tokens): _RetainVerticalSpacingBeforeComments(uwline) if (_LineContainsI18n(uwline) or uwline.disable or _LineHasContinuationMarkers(uwline)): _RetainHorizontalSpacing(uwline) _RetainVerticalSpacing(uwline, prev_uwline) _EmitLineUnformatted(state) elif (_CanPlaceOnSingleLine(uwline) and not any(tok.must_split for tok in uwline.tokens)): # The unwrapped line fits on one line. while state.next_token: state.AddTokenToState(newline=False, dry_run=False) else: if not _AnalyzeSolutionSpace(state): # Failsafe mode. If there isn't a solution to the line, then just emit # it as is. state = format_decision_state.FormatDecisionState(uwline, indent_amt) _RetainHorizontalSpacing(uwline) _RetainVerticalSpacing(uwline, prev_uwline) _EmitLineUnformatted(state) final_lines.append(uwline) prev_uwline = uwline return _FormatFinalLines(final_lines, verify) def _RetainHorizontalSpacing(uwline): """Retain all horizontal spacing between tokens.""" for tok in uwline.tokens: tok.RetainHorizontalSpacing(uwline.first.column, uwline.depth) def _RetainVerticalSpacing(cur_uwline, prev_uwline): prev_tok = None if prev_uwline is not None: prev_tok = prev_uwline.last for cur_tok in cur_uwline.tokens: _RetainVerticalSpacingBetweenTokens(cur_tok, prev_tok) prev_tok = cur_tok def _RetainVerticalSpacingBetweenTokens(cur_tok, prev_tok): """Retain vertical spacing between two tokens.""" if prev_tok is None: return if prev_tok.is_string: prev_lineno = prev_tok.lineno + prev_tok.value.count('\n') elif prev_tok.is_pseudo_paren: if not prev_tok.previous_token.is_multiline_string: prev_lineno = prev_tok.previous_token.lineno else: prev_lineno = prev_tok.lineno else: prev_lineno = prev_tok.lineno if cur_tok.is_comment: cur_lineno = cur_tok.lineno - cur_tok.value.count('\n') else: cur_lineno = cur_tok.lineno cur_tok.AdjustNewlinesBefore(cur_lineno - prev_lineno) def _RetainVerticalSpacingBeforeComments(uwline): """Retain vertical spacing before comments.""" prev_token = None for tok in uwline.tokens: if tok.is_comment and prev_token: if tok.lineno - tok.value.count('\n') - prev_token.lineno > 1: tok.AdjustNewlinesBefore(ONE_BLANK_LINE) prev_token = tok def _EmitLineUnformatted(state): """Emit the line without formatting. The line contains code that if reformatted would break a non-syntactic convention. E.g., i18n comments and function calls are tightly bound by convention. Instead, we calculate when / if a newline should occur and honor that. But otherwise the code emitted will be the same as the original code. Arguments: state: (format_decision_state.FormatDecisionState) The format decision state. """ prev_lineno = None while state.next_token: previous_token = state.next_token.previous_token previous_lineno = previous_token.lineno if previous_token.is_multiline_string: previous_lineno += previous_token.value.count('\n') if previous_token.is_continuation: newline = False else: newline = (prev_lineno is not None and state.next_token.lineno > previous_lineno) prev_lineno = state.next_token.lineno state.AddTokenToState(newline=newline, dry_run=False) def _LineContainsI18n(uwline): """Return true if there are i18n comments or function calls in the line. I18n comments and pseudo-function calls are closely related. They cannot be moved apart without breaking i18n. Arguments: uwline: (unwrapped_line.UnwrappedLine) The line currently being formatted. Returns: True if the line contains i18n comments or function calls. False otherwise. """ if style.Get('I18N_COMMENT'): for tok in uwline.tokens: if tok.is_comment and re.match(style.Get('I18N_COMMENT'), tok.value): # Contains an i18n comment. return True if style.Get('I18N_FUNCTION_CALL'): length = len(uwline.tokens) index = 0 while index < length - 1: if (uwline.tokens[index + 1].value == '(' and uwline.tokens[index].value in style.Get('I18N_FUNCTION_CALL')): return True index += 1 return False def _LineHasContinuationMarkers(uwline): """Return true if the line has continuation markers in it.""" return any(tok.is_continuation for tok in uwline.tokens) def _CanPlaceOnSingleLine(uwline): """Determine if the unwrapped line can go on a single line. Arguments: uwline: (unwrapped_line.UnwrappedLine) The line currently being formatted. Returns: True if the line can or should be added to a single line. False otherwise. """ indent_amt = style.Get('INDENT_WIDTH') * uwline.depth last = uwline.last last_index = -1 if last.is_comment and re.search(r'^#+\s+pylint:', last.value.strip(), re.IGNORECASE): last = last.previous_token last_index = -2 if last is None: return True return (last.total_length + indent_amt <= style.Get('COLUMN_LIMIT') and not any(tok.is_comment for tok in uwline.tokens[:last_index])) def _FormatFinalLines(final_lines, verify): formatted_code = [] for line in final_lines: formatted_line = [] for tok in line.tokens: if not tok.is_pseudo_paren: formatted_line.append(tok.whitespace_prefix) formatted_line.append(tok.value) else: if (not tok.next_token.whitespace_prefix.startswith('\n') and not tok.next_token.whitespace_prefix.startswith(' ')): if (tok.previous_token.value == ':' or tok.next_token.value not in ',}])'): formatted_line.append(' ') formatted_code.append(''.join(formatted_line)) if verify: verifier.VerifyCode(formatted_code[-1]) return ''.join(formatted_code) + '\n' class _StateNode(object): """An edge in the solution space from 'previous.state' to 'state'. Attributes: state: (format_decision_state.FormatDecisionState) The format decision state for this node. newline: If True, then on the edge from 'previous.state' to 'state' a newline is inserted. previous: (_StateNode) The previous state node in the graph. """ # TODO(morbo): Add a '__cmp__' method. def __init__(self, state, newline, previous): self.state = state.Clone() self.newline = newline self.previous = previous def __repr__(self): # pragma: no cover return 'StateNode(state=[\n{0}\n], newline={1})'.format(self.state, self.newline) # A tuple of (penalty, count) that is used to prioritize the BFS. In case of # equal penalties, we prefer states that were inserted first. During state # generation, we make sure that we insert states first that break the line as # late as possible. _OrderedPenalty = collections.namedtuple('OrderedPenalty', ['penalty', 'count']) # An item in the prioritized BFS search queue. The 'StateNode's 'state' has # the given '_OrderedPenalty'. _QueueItem = collections.namedtuple('QueueItem', ['ordered_penalty', 'state_node']) def _AnalyzeSolutionSpace(initial_state): """Analyze the entire solution space starting from initial_state. This implements a variant of Dijkstra's algorithm on the graph that spans the solution space (LineStates are the nodes). The algorithm tries to find the shortest path (the one with the lowest penalty) from 'initial_state' to the state where all tokens are placed. Arguments: initial_state: (format_decision_state.FormatDecisionState) The initial state to start the search from. Returns: True if a formatting solution was found. False otherwise. """ count = 0 seen = set() p_queue = [] # Insert start element. node = _StateNode(initial_state, False, None) heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(0, count), node)) count += 1 prev_penalty = 0 while p_queue: item = p_queue[0] penalty = item.ordered_penalty.penalty node = item.state_node if not node.state.next_token: break heapq.heappop(p_queue) if count > 10000: node.state.ignore_stack_for_comparison = True if node.state in seen: continue prev_penalty = penalty seen.add(node.state) # FIXME(morbo): Add a 'decision' element? count = _AddNextStateToQueue(penalty, node, False, count, p_queue) count = _AddNextStateToQueue(penalty, node, True, count, p_queue) if not p_queue: # We weren't able to find a solution. Do nothing. return False _ReconstructPath(initial_state, heapq.heappop(p_queue).state_node) return True def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): """Add the following state to the analysis queue. Assume the current state is 'previous_node' and has been reached with a penalty of 'penalty'. Insert a line break if 'newline' is True. Arguments: penalty: (int) The penalty associated with the path up to this point. previous_node: (_StateNode) The last _StateNode inserted into the priority queue. newline: (bool) Add a newline if True. count: (int) The number of elements in the queue. p_queue: (heapq) The priority queue representing the solution space. Returns: The updated number of elements in the queue. """ if newline and not previous_node.state.CanSplit(): # Don't add a newline if the token cannot be split. return count must_split = previous_node.state.MustSplit() if not newline and must_split: # Don't add a token we must split but where we aren't splitting. return count node = _StateNode(previous_node.state, newline, previous_node) penalty += node.state.AddTokenToState( newline=newline, dry_run=True, must_split=must_split) heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(penalty, count), node)) return count + 1 def _ReconstructPath(initial_state, current): """Reconstruct the path through the queue with lowest penalty. Arguments: initial_state: (format_decision_state.FormatDecisionState) The initial state to start the search from. current: (_StateNode) The node in the decision graph that is the end point of the path with the least penalty. """ path = collections.deque() while current.previous: path.appendleft(current) current = current.previous for node in path: initial_state.AddTokenToState(newline=node.newline, dry_run=False) def _FormatFirstToken(first_token, indent_depth, prev_uwline, final_lines): """Format the first token in the unwrapped line. Add a newline and the required indent before the first token of the unwrapped line. Arguments: first_token: (format_token.FormatToken) The first token in the unwrapped line. indent_depth: (int) The line's indentation depth. prev_uwline: (list of unwrapped_line.UnwrappedLine) The unwrapped line previous to this line. final_lines: (list of unwrapped_line.UnwrappedLine) The unwrapped lines that have already been processed. """ first_token.AddWhitespacePrefix( _CalculateNumberOfNewlines(first_token, indent_depth, prev_uwline, final_lines), indent_level=indent_depth) NO_BLANK_LINES = 1 ONE_BLANK_LINE = 2 TWO_BLANK_LINES = 3 def _CalculateNumberOfNewlines(first_token, indent_depth, prev_uwline, final_lines): """Calculate the number of newlines we need to add. Arguments: first_token: (format_token.FormatToken) The first token in the unwrapped line. indent_depth: (int) The line's indentation depth. prev_uwline: (list of unwrapped_line.UnwrappedLine) The unwrapped line previous to this line. final_lines: (list of unwrapped_line.UnwrappedLine) The unwrapped lines that have already been processed. Returns: The number of newlines needed before the first token. """ # TODO(morbo): Special handling for imports. # TODO(morbo): Create a knob that can tune these. if prev_uwline is None: # The first line in the file. Don't add blank lines. # FIXME(morbo): Is this correct? if first_token.newlines is not None: pytree_utils.SetNodeAnnotation(first_token.node, pytree_utils.Annotation.NEWLINES, None) return 0 if first_token.is_docstring: # The docstring shouldn't have a newline before it. # TODO(morbo): Add a knob to adjust this. return NO_BLANK_LINES prev_last_token = prev_uwline.last if prev_last_token.is_docstring: if (not indent_depth and first_token.value in {'class', 'def', 'async'}): # Separate a class or function from the module-level docstring with two # blank lines. return TWO_BLANK_LINES if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, prev_last_token): return NO_BLANK_LINES else: return ONE_BLANK_LINE if first_token.value in {'class', 'def', 'async', '@'}: # TODO(morbo): This can go once the blank line calculator is more # sophisticated. if not indent_depth: # This is a top-level class or function. is_inline_comment = prev_last_token.whitespace_prefix.count('\n') == 0 if (not prev_uwline.disable and prev_last_token.is_comment and not is_inline_comment): # This token follows a non-inline comment. if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, prev_last_token): # Assume that the comment is "attached" to the current line. # Therefore, we want two blank lines before the comment. index = len(final_lines) - 1 while index > 0: if not final_lines[index - 1].is_comment: break index -= 1 if final_lines[index - 1].first.value == '@': final_lines[index].first.AdjustNewlinesBefore(NO_BLANK_LINES) else: prev_last_token.AdjustNewlinesBefore(TWO_BLANK_LINES) if first_token.newlines is not None: pytree_utils.SetNodeAnnotation( first_token.node, pytree_utils.Annotation.NEWLINES, None) return NO_BLANK_LINES elif prev_uwline.first.value in {'class', 'def', 'async'}: if not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'): pytree_utils.SetNodeAnnotation(first_token.node, pytree_utils.Annotation.NEWLINES, None) return NO_BLANK_LINES # Calculate how many newlines were between the original lines. We want to # retain that formatting if it doesn't violate one of the style guide rules. if first_token.is_comment: first_token_lineno = first_token.lineno - first_token.value.count('\n') else: first_token_lineno = first_token.lineno prev_last_token_lineno = prev_last_token.lineno if prev_last_token.is_multiline_string: prev_last_token_lineno += prev_last_token.value.count('\n') if first_token_lineno - prev_last_token_lineno > 1: return ONE_BLANK_LINE return NO_BLANK_LINES def _SingleOrMergedLines(uwlines): """Generate the lines we want to format. Arguments: uwlines: (list of unwrapped_line.UnwrappedLine) Lines we want to format. Yields: Either a single line, if the current line cannot be merged with the succeeding line, or the next two lines merged into one line. """ index = 0 last_was_merged = False while index < len(uwlines): if uwlines[index].disable: uwline = uwlines[index] index += 1 while index < len(uwlines): column = uwline.last.column + 2 if uwlines[index].lineno != uwline.lineno: break if uwline.last.value != ':': leaf = pytree.Leaf( type=token.SEMI, value=';', context=('', (uwline.lineno, column))) uwline.AppendToken(format_token.FormatToken(leaf)) for tok in uwlines[index].tokens: uwline.AppendToken(tok) index += 1 yield uwline elif line_joiner.CanMergeMultipleLines(uwlines[index:], last_was_merged): # TODO(morbo): This splice is potentially very slow. Come up with a more # performance-friendly way of determining if two lines can be merged. next_uwline = uwlines[index + 1] for tok in next_uwline.tokens: uwlines[index].AppendToken(tok) if (len(next_uwline.tokens) == 1 and next_uwline.first.is_multiline_string): # This may be a multiline shebang. In that case, we want to retain the # formatting. Otherwise, it could mess up the shell script's syntax. uwlines[index].disable = True yield uwlines[index] index += 2 last_was_merged = True else: yield uwlines[index] index += 1 last_was_merged = False def _NoBlankLinesBeforeCurrentToken(text, cur_token, prev_token): """Determine if there are no blank lines before the current token. The previous token is a docstring or comment. The prev_token_lineno is the start of the text of that token. Counting the number of newlines in its text gives us the extent and thus where the line number of the end of the docstring or comment. After that, we just compare it to the current token's line number to see if there are blank lines between them. Arguments: text: (unicode) The text of the docstring or comment before the current token. cur_token: (format_token.FormatToken) The current token in the unwrapped line. prev_token: (format_token.FormatToken) The previous token in the unwrapped line. Returns: True if there is no blank line before the current token. """ cur_token_lineno = cur_token.lineno if cur_token.is_comment: cur_token_lineno -= cur_token.value.count('\n') num_newlines = text.count('\n') if not prev_token.is_comment else 0 return prev_token.lineno + num_newlines == cur_token_lineno - 1 yapf-0.15.1/yapf/yapflib/split_penalty.py000066400000000000000000000433271304174360200203740ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Computation of split penalties before/between tokens.""" from lib2to3 import pytree from yapf.yapflib import format_token from yapf.yapflib import py3compat from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor from yapf.yapflib import style # TODO(morbo): Document the annotations in a centralized place. E.g., the # README file. UNBREAKABLE = 1000 * 1000 VERY_STRONGLY_CONNECTED = 3000 DOTTED_NAME = 2500 STRONGLY_CONNECTED = 2000 CONTIGUOUS_LIST = 500 NOT_TEST = 50 COMPARISON_EXPRESSION = 550 ARITHMETIC_EXPRESSION = 600 TERM_EXPRESSION = 650 ONE_ELEMENT_ARGUMENT = 650 def ComputeSplitPenalties(tree): """Compute split penalties on tokens in the given parse tree. Arguments: tree: the top-level pytree node to annotate with penalties. """ _TreePenaltyAssigner().Visit(tree) class _TreePenaltyAssigner(pytree_visitor.PyTreeVisitor): """Assigns split penalties to tokens, based on parse tree structure. Split penalties are attached as annotations to tokens. """ def Visit_import_as_names(self, node): # pyline: disable=invalid-name # import_as_names ::= import_as_name (',' import_as_name)* [','] self.DefaultNodeVisit(node) prev_child = None for child in node.children: if (prev_child and isinstance(prev_child, pytree.Leaf) and prev_child.value == ','): pytree_utils.SetNodeAnnotation(child, pytree_utils.Annotation.SPLIT_PENALTY, style.Get('SPLIT_PENALTY_IMPORT_NAMES')) prev_child = child def Visit_classdef(self, node): # pylint: disable=invalid-name # classdef ::= 'class' NAME ['(' [arglist] ')'] ':' suite # # NAME self._SetUnbreakable(node.children[1]) if len(node.children) > 4: # opening '(' self._SetUnbreakable(node.children[2]) # ':' self._SetUnbreakable(node.children[-2]) self.DefaultNodeVisit(node) def Visit_funcdef(self, node): # pylint: disable=invalid-name # funcdef ::= 'def' NAME parameters ['->' test] ':' suite # # Can't break before the function name and before the colon. The parameters # are handled by child iteration. colon_idx = 1 while pytree_utils.NodeName(node.children[colon_idx]) == 'simple_stmt': colon_idx += 1 self._SetUnbreakable(node.children[colon_idx]) arrow_idx = -1 while colon_idx < len(node.children): if isinstance(node.children[colon_idx], pytree.Leaf): if node.children[colon_idx].value == ':': break if node.children[colon_idx].value == '->': arrow_idx = colon_idx colon_idx += 1 self._SetUnbreakable(node.children[colon_idx]) self.DefaultNodeVisit(node) if arrow_idx > 0: pytree_utils.SetNodeAnnotation( _LastChildNode(node.children[arrow_idx - 1]), pytree_utils.Annotation.SPLIT_PENALTY, 0) self._SetUnbreakable(node.children[arrow_idx]) self._SetStronglyConnected(node.children[arrow_idx + 1]) def Visit_lambdef(self, node): # pylint: disable=invalid-name # lambdef ::= 'lambda' [varargslist] ':' test # Loop over the lambda up to and including the colon. if style.Get('ALLOW_MULTILINE_LAMBDAS'): self._SetStronglyConnected(node) else: self._SetUnbreakableOnChildren(node) def Visit_parameters(self, node): # pylint: disable=invalid-name # parameters ::= '(' [typedargslist] ')' self.DefaultNodeVisit(node) # Can't break before the opening paren of a parameter list. self._SetUnbreakable(node.children[0]) if not style.Get('DEDENT_CLOSING_BRACKETS'): self._SetStronglyConnected(node.children[-1]) def Visit_argument(self, node): # pylint: disable=invalid-name # argument ::= test [comp_for] | test '=' test # Really [keyword '='] test self.DefaultNodeVisit(node) index = 0 while index < len(node.children) - 1: next_child = node.children[index + 1] if isinstance(next_child, pytree.Leaf) and next_child.value == '=': self._SetUnbreakable(_FirstChildNode(node.children[index + 1])) self._SetUnbreakable(_FirstChildNode(node.children[index + 2])) index += 1 def Visit_dotted_name(self, node): # pylint: disable=invalid-name # dotted_name ::= NAME ('.' NAME)* self._SetUnbreakableOnChildren(node) def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name # dictsetmaker ::= ( (test ':' test # (comp_for | (',' test ':' test)* [','])) | # (test (comp_for | (',' test)* [','])) ) for child in node.children: self.Visit(child) if pytree_utils.NodeName(child) == 'COLON': # This is a key to a dictionary. We don't want to split the key if at # all possible. self._SetStronglyConnected(child) def Visit_trailer(self, node): # pylint: disable=invalid-name # trailer ::= '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME self.DefaultNodeVisit(node) if node.children[0].value == '.': self._SetUnbreakableOnChildren(node) pytree_utils.SetNodeAnnotation( node.children[1], pytree_utils.Annotation.SPLIT_PENALTY, DOTTED_NAME) elif len(node.children) == 2: # Don't split an empty argument list if at all possible. pytree_utils.SetNodeAnnotation(node.children[1], pytree_utils.Annotation.SPLIT_PENALTY, VERY_STRONGLY_CONNECTED) elif len(node.children) == 3: name = pytree_utils.NodeName(node.children[1]) if name == 'power': if pytree_utils.NodeName(node.children[1].children[0]) != 'atom': # Don't split an argument list with one element if at all possible. self._SetStronglyConnected(node.children[1], node.children[2]) pytree_utils.SetNodeAnnotation( _FirstChildNode(node.children[1]), pytree_utils.Annotation.SPLIT_PENALTY, ONE_ELEMENT_ARGUMENT) elif name not in { 'arglist', 'argument', 'term', 'or_test', 'and_test', 'comparison', 'atom' }: # Don't split an argument list with one element if at all possible. self._SetStronglyConnected(node.children[1], node.children[2]) if pytree_utils.NodeName(node.children[-1]) == 'RSQB': # Don't split the ending bracket of a subscript list. self._SetVeryStronglyConnected(*node.children) def Visit_power(self, node): # pylint: disable=invalid-name,missing-docstring # power ::= atom trailer* ['**' factor] self.DefaultNodeVisit(node) # When atom is followed by a trailer, we can not break between them. # E.g. arr[idx] - no break allowed between 'arr' and '['. if (len(node.children) > 1 and pytree_utils.NodeName(node.children[1]) == 'trailer'): # children[1] itself is a whole trailer: we don't want to # mark all of it as unbreakable, only its first token: (, [ or . self._SetUnbreakable(node.children[1].children[0]) # A special case when there are more trailers in the sequence. Given: # atom tr1 tr2 # The last token of tr1 and the first token of tr2 comprise an unbreakable # region. For example: foo.bar.baz(1) # We can't put breaks between either of the '.', '(', or '[' and the names # *preceding* them. prev_trailer_idx = 1 while prev_trailer_idx < len(node.children) - 1: cur_trailer_idx = prev_trailer_idx + 1 cur_trailer = node.children[cur_trailer_idx] if pytree_utils.NodeName(cur_trailer) == 'trailer': # Now we know we have two trailers one after the other prev_trailer = node.children[prev_trailer_idx] if prev_trailer.children[-1].value != ')': # Set the previous node unbreakable if it's not a function call: # atom tr1() tr2 # It may be necessary (though undesirable) to split up a previous # function call's parentheses to the next line. self._SetStronglyConnected(prev_trailer.children[-1]) self._SetStronglyConnected(cur_trailer.children[0]) prev_trailer_idx = cur_trailer_idx else: break # We don't want to split before the last ')' of a function call. This also # takes care of the special case of: # atom tr1 tr2 ... trn # where the 'tr#' are trailers that may end in a ')'. for trailer in node.children[1:]: if pytree_utils.NodeName(trailer) != 'trailer': break if trailer.children[0].value in '([': if len(trailer.children) > 2: subtypes = pytree_utils.GetNodeAnnotation( trailer.children[0], pytree_utils.Annotation.SUBTYPE) if subtypes and format_token.Subtype.SUBSCRIPT_BRACKET in subtypes: self._SetStronglyConnected(_FirstChildNode(trailer.children[1])) last_child_node = _LastChildNode(trailer) if last_child_node.value.strip().startswith('#'): last_child_node = last_child_node.prev_sibling if not style.Get('DEDENT_CLOSING_BRACKETS'): if _LastChildNode(last_child_node.prev_sibling).value != ',': if last_child_node.value == ']': self._SetUnbreakable(last_child_node) else: pytree_utils.SetNodeAnnotation( last_child_node, pytree_utils.Annotation.SPLIT_PENALTY, VERY_STRONGLY_CONNECTED) if _FirstChildNode(trailer).lineno == last_child_node.lineno: # If the trailer was originally on one line, then try to keep it # like that. self._SetExpressionPenalty(trailer, CONTIGUOUS_LIST) else: # If the trailer's children are '()', then make it a strongly # connected region. It's sometimes necessary, though undesirable, to # split the two. self._SetStronglyConnected(trailer.children[-1]) # If the original source has a "builder" style calls, then we should allow # the reformatter to retain that. _AllowBuilderStyleCalls(node) def Visit_subscript(self, node): # pylint: disable=invalid-name # subscript ::= test | [test] ':' [test] [sliceop] self._SetStronglyConnected(*node.children) self.DefaultNodeVisit(node) def Visit_comp_for(self, node): # pylint: disable=invalid-name # comp_for ::= 'for' exprlist 'in' testlist_safe [comp_iter] pytree_utils.SetNodeAnnotation( _FirstChildNode(node), pytree_utils.Annotation.SPLIT_PENALTY, 0) self._SetStronglyConnected(*node.children[1:]) self.DefaultNodeVisit(node) def Visit_comp_if(self, node): # pylint: disable=invalid-name # comp_if ::= 'if' old_test [comp_iter] pytree_utils.SetNodeAnnotation(node.children[0], pytree_utils.Annotation.SPLIT_PENALTY, style.Get('SPLIT_PENALTY_BEFORE_IF_EXPR')) self._SetStronglyConnected(*node.children[1:]) self.DefaultNodeVisit(node) def Visit_not_test(self, node): # pylint: disable=invalid-name # not_test ::= 'not' not_test | comparison self.DefaultNodeVisit(node) self._SetExpressionPenalty(node, NOT_TEST) def Visit_comparison(self, node): # pylint: disable=invalid-name # comparison ::= expr (comp_op expr)* self.DefaultNodeVisit(node) if len(node.children) == 3 and _StronglyConnectedCompOp(node): pytree_utils.SetNodeAnnotation( _FirstChildNode(node.children[1]), pytree_utils.Annotation.SPLIT_PENALTY, STRONGLY_CONNECTED) pytree_utils.SetNodeAnnotation( _FirstChildNode(node.children[2]), pytree_utils.Annotation.SPLIT_PENALTY, STRONGLY_CONNECTED) else: self._SetExpressionPenalty(node, COMPARISON_EXPRESSION) def Visit_arith_expr(self, node): # pylint: disable=invalid-name # arith_expr ::= term (('+'|'-') term)* self.DefaultNodeVisit(node) self._SetExpressionPenalty(node, ARITHMETIC_EXPRESSION) def Visit_term_expr(self, node): # pylint: disable=invalid-name # term ::= factor (('*'|'@'|'/'|'%'|'//') factor)* self.DefaultNodeVisit(node) self._SetExpressionPenalty(node, TERM_EXPRESSION) def Visit_atom(self, node): # pylint: disable=invalid-name # atom ::= ('(' [yield_expr|testlist_gexp] ')' # '[' [listmaker] ']' | # '{' [dictsetmaker] '}') self.DefaultNodeVisit(node) if node.children[0].value == '(': if node.children[0].lineno == node.children[-1].lineno: self._SetExpressionPenalty(node, CONTIGUOUS_LIST) if node.children[-1].value == ')': if pytree_utils.NodeName(node.parent) == 'if_stmt': pytree_utils.SetNodeAnnotation(node.children[-1], pytree_utils.Annotation.SPLIT_PENALTY, UNBREAKABLE) else: pytree_utils.SetNodeAnnotation(node.children[-1], pytree_utils.Annotation.SPLIT_PENALTY, COMPARISON_EXPRESSION) elif node.children[0].value in '[{': # Keep empty containers together if we can. lbracket = node.children[0] rbracket = node.children[-1] if len(node.children) == 2: self._SetUnbreakable(node.children[-1]) elif (rbracket.value in ']}' and lbracket.get_lineno() == rbracket.get_lineno() and rbracket.column - lbracket.column < style.Get('COLUMN_LIMIT')): self._SetStronglyConnected(*node.children[1:]) ############################################################################ # Helper methods that set the annotations. def _SetUnbreakable(self, node): """Set an UNBREAKABLE penalty annotation for the given node.""" _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY, UNBREAKABLE) def _SetVeryStronglyConnected(self, *nodes): """Set a STRONGLY_CONNECTED penalty annotation for the given nodes.""" for node in nodes: _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY, VERY_STRONGLY_CONNECTED) def _SetStronglyConnected(self, *nodes): """Set a STRONGLY_CONNECTED penalty annotation for the given nodes.""" for node in nodes: _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY, STRONGLY_CONNECTED) def _SetUnbreakableOnChildren(self, node): """Set an UNBREAKABLE penalty annotation on children of node.""" for child in node.children: self.Visit(child) start = 2 if hasattr(node.children[0], 'is_pseudo') else 1 for i in py3compat.range(start, len(node.children)): self._SetUnbreakable(node.children[i]) def _SetExpressionPenalty(self, node, penalty): """Set a penalty annotation on children nodes.""" def RecArithmeticExpression(node, first_child_leaf): if node is first_child_leaf: return if isinstance(node, pytree.Leaf): if node.value in {'(', 'for', 'if'}: return penalty_annotation = pytree_utils.GetNodeAnnotation( node, pytree_utils.Annotation.SPLIT_PENALTY, default=0) if penalty_annotation < penalty: pytree_utils.SetNodeAnnotation( node, pytree_utils.Annotation.SPLIT_PENALTY, penalty) else: for child in node.children: RecArithmeticExpression(child, first_child_leaf) RecArithmeticExpression(node, _FirstChildNode(node)) def _RecAnnotate(tree, annotate_name, annotate_value): """Recursively set the given annotation on all leafs of the subtree. Takes care to only increase the penalty. If the node already has a higher or equal penalty associated with it, this is a no-op. Args: tree: subtree to annotate annotate_name: name of the annotation to set annotate_value: value of the annotation to set """ for child in tree.children: _RecAnnotate(child, annotate_name, annotate_value) if isinstance(tree, pytree.Leaf): cur_annotate = pytree_utils.GetNodeAnnotation( tree, annotate_name, default=0) if cur_annotate < annotate_value: pytree_utils.SetNodeAnnotation(tree, annotate_name, annotate_value) def _AllowBuilderStyleCalls(node): """Allow splitting before '.' if it's a builder style function call.""" def RecGetLeaves(node): if isinstance(node, pytree.Leaf): return [node] children = [] for child in node.children: children += RecGetLeaves(child) return children list_of_children = RecGetLeaves(node) prev_child = None for child in list_of_children: if child.value == '.': if prev_child.lineno != child.lineno: pytree_utils.SetNodeAnnotation(child, pytree_utils.Annotation.SPLIT_PENALTY, 0) prev_child = child def _StronglyConnectedCompOp(op): if (len(op.children[1].children) == 2 and pytree_utils.NodeName(op.children[1]) == 'comp_op' and _FirstChildNode(op.children[1]).value == 'not' and _LastChildNode(op.children[1]).value == 'in'): return True if (isinstance(op.children[1], pytree.Leaf) and op.children[1].value in {'==', 'in'}): return True return False def _FirstChildNode(node): if isinstance(node, pytree.Leaf): return node return _FirstChildNode(node.children[0]) def _LastChildNode(node): if isinstance(node, pytree.Leaf): return node return _LastChildNode(node.children[-1]) yapf-0.15.1/yapf/yapflib/style.py000066400000000000000000000411151304174360200166360ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Python formatting style settings.""" import os import re import textwrap from yapf.yapflib import errors from yapf.yapflib import py3compat class StyleConfigError(errors.YapfError): """Raised when there's a problem reading the style configuration.""" pass def Get(setting_name): """Get a style setting.""" return _style[setting_name] def Help(): """Return dict mapping style names to help strings.""" return _STYLE_HELP def SetGlobalStyle(style): """Set a style dict.""" global _style global _GLOBAL_STYLE_FACTORY factory = _GetStyleFactory(style) if factory: _GLOBAL_STYLE_FACTORY = factory _style = style _STYLE_HELP = dict( ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=textwrap.dedent("""\ Align closing bracket with visual indentation."""), ALLOW_MULTILINE_LAMBDAS=textwrap.dedent("""\ Allow lambdas to be formatted on more than one line."""), BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=textwrap.dedent("""\ Insert a blank line before a 'def' or 'class' immediately nested within another 'def' or 'class'. For example: class Foo: # <------ this blank line def method(): ..."""), COALESCE_BRACKETS=textwrap.dedent("""\ Do not split consecutive brackets. Only relevant when dedent_closing_brackets is set. For example: call_func_that_takes_a_dict( { 'key1': 'value1', 'key2': 'value2', } ) would reformat to: call_func_that_takes_a_dict({ 'key1': 'value1', 'key2': 'value2', })"""), COLUMN_LIMIT=textwrap.dedent("""\ The column limit."""), CONTINUATION_INDENT_WIDTH=textwrap.dedent("""\ Indent width used for line continuations."""), DEDENT_CLOSING_BRACKETS=textwrap.dedent("""\ Put closing brackets on a separate line, dedented, if the bracketed expression can't fit in a single line. Applies to all kinds of brackets, including function definitions and calls. For example: config = { 'key1': 'value1', 'key2': 'value2', } # <--- this bracket is dedented and on a separate line time_series = self.remote_client.query_entity_counters( entity='dev3246.region1', key='dns.query_latency_tcp', transform=Transformation.AVERAGE(window=timedelta(seconds=60)), start_ts=now()-timedelta(days=3), end_ts=now(), ) # <--- this bracket is dedented and on a separate line"""), I18N_COMMENT=textwrap.dedent("""\ The regex for an i18n comment. The presence of this comment stops reformatting of that line, because the comments are required to be next to the string they translate."""), I18N_FUNCTION_CALL=textwrap.dedent("""\ The i18n function call names. The presence of this function stops reformattting on that line, because the string it has cannot be moved away from the i18n comment."""), INDENT_DICTIONARY_VALUE=textwrap.dedent("""\ Indent the dictionary value if it cannot fit on the same line as the dictionary key. For example: config = { 'key1': 'value1', 'key2': value1 + value2, }"""), INDENT_WIDTH=textwrap.dedent("""\ The number of columns to use for indentation."""), JOIN_MULTIPLE_LINES=textwrap.dedent("""\ Join short lines into one line. E.g., single line 'if' statements."""), SPACES_AROUND_POWER_OPERATOR=textwrap.dedent("""\ Use spaces around the power operator."""), SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=textwrap.dedent("""\ Use spaces around default or named assigns."""), SPACES_BEFORE_COMMENT=textwrap.dedent("""\ The number of spaces required before a trailing comment."""), SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=textwrap.dedent("""\ Insert a space between the ending comma and closing bracket of a list, etc."""), SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=textwrap.dedent("""\ Split before arguments if the argument list is terminated by a comma."""), SPLIT_BEFORE_BITWISE_OPERATOR=textwrap.dedent("""\ Set to True to prefer splitting before '&', '|' or '^' rather than after."""), SPLIT_BEFORE_FIRST_ARGUMENT=textwrap.dedent("""\ If an argument / parameter list is going to be split, then split before the first argument."""), SPLIT_BEFORE_LOGICAL_OPERATOR=textwrap.dedent("""\ Set to True to prefer splitting before 'and' or 'or' rather than after."""), SPLIT_BEFORE_NAMED_ASSIGNS=textwrap.dedent("""\ Split named assignments onto individual lines."""), SPLIT_PENALTY_AFTER_OPENING_BRACKET=textwrap.dedent("""\ The penalty for splitting right after the opening bracket."""), SPLIT_PENALTY_AFTER_UNARY_OPERATOR=textwrap.dedent("""\ The penalty for splitting the line after a unary operator."""), SPLIT_PENALTY_BEFORE_IF_EXPR=textwrap.dedent("""\ The penalty for splitting right before an if expression."""), SPLIT_PENALTY_BITWISE_OPERATOR=textwrap.dedent("""\ The penalty of splitting the line around the '&', '|', and '^' operators."""), SPLIT_PENALTY_EXCESS_CHARACTER=textwrap.dedent("""\ The penalty for characters over the column limit."""), SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=textwrap.dedent("""\ The penalty incurred by adding a line split to the unwrapped line. The more line splits added the higher the penalty."""), SPLIT_PENALTY_IMPORT_NAMES=textwrap.dedent("""\ The penalty of splitting a list of "import as" names. For example: from a_very_long_or_indented_module_name_yada_yad import (long_argument_1, long_argument_2, long_argument_3) would reformat to something like: from a_very_long_or_indented_module_name_yada_yad import ( long_argument_1, long_argument_2, long_argument_3) """), SPLIT_PENALTY_LOGICAL_OPERATOR=textwrap.dedent("""\ The penalty of splitting the line around the 'and' and 'or' operators."""), USE_TABS=textwrap.dedent("""\ Use the Tab character for indentation."""), # BASED_ON_STYLE='Which predefined style this style is based on', ) def CreatePEP8Style(): return dict( ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=True, ALLOW_MULTILINE_LAMBDAS=False, COLUMN_LIMIT=79, COALESCE_BRACKETS=False, DEDENT_CLOSING_BRACKETS=False, I18N_COMMENT='', I18N_FUNCTION_CALL='', INDENT_DICTIONARY_VALUE=False, INDENT_WIDTH=4, CONTINUATION_INDENT_WIDTH=4, BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=False, JOIN_MULTIPLE_LINES=True, SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=True, SPACES_AROUND_POWER_OPERATOR=False, SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=False, SPACES_BEFORE_COMMENT=2, SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=False, SPLIT_BEFORE_BITWISE_OPERATOR=False, SPLIT_BEFORE_FIRST_ARGUMENT=False, SPLIT_BEFORE_LOGICAL_OPERATOR=False, SPLIT_BEFORE_NAMED_ASSIGNS=True, SPLIT_PENALTY_AFTER_UNARY_OPERATOR=10000, SPLIT_PENALTY_EXCESS_CHARACTER=2600, SPLIT_PENALTY_BITWISE_OPERATOR=300, SPLIT_PENALTY_IMPORT_NAMES=0, SPLIT_PENALTY_LOGICAL_OPERATOR=300, SPLIT_PENALTY_AFTER_OPENING_BRACKET=30, SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=30, SPLIT_PENALTY_BEFORE_IF_EXPR=0, USE_TABS=False,) def CreateGoogleStyle(): style = CreatePEP8Style() style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False style['COLUMN_LIMIT'] = 80 style['INDENT_WIDTH'] = 4 style['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'] = True style['I18N_COMMENT'] = r'#\..*' style['I18N_FUNCTION_CALL'] = ['N_', '_'] style['SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET'] = False return style def CreateChromiumStyle(): style = CreateGoogleStyle() style['INDENT_DICTIONARY_VALUE'] = True style['INDENT_WIDTH'] = 2 style['JOIN_MULTIPLE_LINES'] = False style['SPLIT_BEFORE_BITWISE_OPERATOR'] = True return style def CreateFacebookStyle(): style = CreatePEP8Style() style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False style['COLUMN_LIMIT'] = 80 style['DEDENT_CLOSING_BRACKETS'] = True style['JOIN_MULTIPLE_LINES'] = False style['SPACES_BEFORE_COMMENT'] = 2 style['SPLIT_PENALTY_AFTER_OPENING_BRACKET'] = 0 style['SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT'] = 30 style['SPLIT_PENALTY_BEFORE_IF_EXPR'] = 30 return style _STYLE_NAME_TO_FACTORY = dict( pep8=CreatePEP8Style, chromium=CreateChromiumStyle, google=CreateGoogleStyle, facebook=CreateFacebookStyle,) _DEFAULT_STYLE_TO_FACTORY = [ (CreateChromiumStyle(), CreateChromiumStyle), (CreateFacebookStyle(), CreateFacebookStyle), (CreateGoogleStyle(), CreateGoogleStyle), (CreatePEP8Style(), CreatePEP8Style), ] def _GetStyleFactory(style): for def_style, factory in _DEFAULT_STYLE_TO_FACTORY: if style == def_style: return factory return None def _StringListConverter(s): """Option value converter for a comma-separated list of strings.""" return [part.strip() for part in s.split(',')] def _BoolConverter(s): """Option value converter for a boolean.""" return py3compat.CONFIGPARSER_BOOLEAN_STATES[s.lower()] # Different style options need to have their values interpreted differently when # read from the config file. This dict maps an option name to a "converter" # function that accepts the string read for the option's value from the file and # returns it wrapper in actual Python type that's going to be meaningful to # yapf. # # Note: this dict has to map all the supported style options. _STYLE_OPTION_VALUE_CONVERTER = dict( ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=_BoolConverter, ALLOW_MULTILINE_LAMBDAS=_BoolConverter, COALESCE_BRACKETS=_BoolConverter, COLUMN_LIMIT=int, DEDENT_CLOSING_BRACKETS=_BoolConverter, I18N_COMMENT=str, I18N_FUNCTION_CALL=_StringListConverter, INDENT_DICTIONARY_VALUE=_BoolConverter, INDENT_WIDTH=int, CONTINUATION_INDENT_WIDTH=int, BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=_BoolConverter, JOIN_MULTIPLE_LINES=_BoolConverter, SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=_BoolConverter, SPACES_AROUND_POWER_OPERATOR=_BoolConverter, SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=_BoolConverter, SPACES_BEFORE_COMMENT=int, SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=_BoolConverter, SPLIT_BEFORE_BITWISE_OPERATOR=_BoolConverter, SPLIT_BEFORE_FIRST_ARGUMENT=_BoolConverter, SPLIT_BEFORE_LOGICAL_OPERATOR=_BoolConverter, SPLIT_BEFORE_NAMED_ASSIGNS=_BoolConverter, SPLIT_PENALTY_AFTER_UNARY_OPERATOR=int, SPLIT_PENALTY_EXCESS_CHARACTER=int, SPLIT_PENALTY_BITWISE_OPERATOR=int, SPLIT_PENALTY_IMPORT_NAMES=int, SPLIT_PENALTY_LOGICAL_OPERATOR=int, SPLIT_PENALTY_AFTER_OPENING_BRACKET=int, SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=int, SPLIT_PENALTY_BEFORE_IF_EXPR=int, USE_TABS=_BoolConverter,) def CreateStyleFromConfig(style_config): """Create a style dict from the given config. Arguments: style_config: either a style name or a file name. The file is expected to contain settings. It can have a special BASED_ON_STYLE setting naming the style which it derives from. If no such setting is found, it derives from the default style. When style_config is None, the _GLOBAL_STYLE_FACTORY config is created. Returns: A style dict. Raises: StyleConfigError: if an unknown style option was encountered. """ def GlobalStyles(): for style, _ in _DEFAULT_STYLE_TO_FACTORY: yield style def_style = False if style_config is None: for style in GlobalStyles(): if _style == style: def_style = True break if not def_style: return _style return _GLOBAL_STYLE_FACTORY() style_factory = _STYLE_NAME_TO_FACTORY.get(style_config.lower()) if style_factory is not None: return style_factory() if style_config.startswith('{'): # Most likely a style specification from the command line. config = _CreateConfigParserFromConfigString(style_config) else: # Unknown config name: assume it's a file name then. config = _CreateConfigParserFromConfigFile(style_config) return _CreateStyleFromConfigParser(config) def _CreateConfigParserFromConfigString(config_string): """Given a config string from the command line, return a config parser.""" if config_string[0] != '{' or config_string[-1] != '}': raise StyleConfigError( "Invalid style dict syntax: '{}'.".format(config_string)) config = py3compat.ConfigParser() config.add_section('style') for key, value in re.findall(r'([a-zA-Z0-9_]+)\s*[:=]\s*([a-zA-Z0-9_]+)', config_string): config.set('style', key, value) return config def _CreateConfigParserFromConfigFile(config_filename): """Read the file and return a ConfigParser object.""" if not os.path.exists(config_filename): # Provide a more meaningful error here. raise StyleConfigError( '"{0}" is not a valid style or file path'.format(config_filename)) with open(config_filename) as style_file: config = py3compat.ConfigParser() config.read_file(style_file) if config_filename.endswith(SETUP_CONFIG): if not config.has_section('yapf'): raise StyleConfigError( 'Unable to find section [yapf] in {0}'.format(config_filename)) elif config_filename.endswith(LOCAL_STYLE): if not config.has_section('style'): raise StyleConfigError( 'Unable to find section [style] in {0}'.format(config_filename)) else: if not config.has_section('style'): raise StyleConfigError( 'Unable to find section [style] in {0}'.format(config_filename)) return config def _CreateStyleFromConfigParser(config): """Create a style dict from a configuration file. Arguments: config: a ConfigParser object. Returns: A style dict. Raises: StyleConfigError: if an unknown style option was encountered. """ # Initialize the base style. section = 'yapf' if config.has_section('yapf') else 'style' if config.has_option('style', 'based_on_style'): based_on = config.get('style', 'based_on_style').lower() base_style = _STYLE_NAME_TO_FACTORY[based_on]() elif config.has_option('yapf', 'based_on_style'): based_on = config.get('yapf', 'based_on_style').lower() base_style = _STYLE_NAME_TO_FACTORY[based_on]() else: base_style = _GLOBAL_STYLE_FACTORY() # Read all options specified in the file and update the style. for option, value in config.items(section): if option.lower() == 'based_on_style': # Now skip this one - we've already handled it and it's not one of the # recognized style options. continue option = option.upper() if option not in _STYLE_OPTION_VALUE_CONVERTER: raise StyleConfigError('Unknown style option "{0}"'.format(option)) try: base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) except ValueError: raise StyleConfigError( "'{}' is not a valid setting for {}.".format(value, option)) return base_style # The default style - used if yapf is not invoked without specifically # requesting a formatting style. DEFAULT_STYLE = 'pep8' DEFAULT_STYLE_FACTORY = CreatePEP8Style _GLOBAL_STYLE_FACTORY = CreatePEP8Style # The name of the file to use for global style definition. GLOBAL_STYLE = (os.path.join( os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'), 'yapf', 'style')) # The name of the file to use for directory-local style definition. LOCAL_STYLE = '.style.yapf' # Alternative place for directory-local style definition. Style should be # specified in the '[yapf]' section. SETUP_CONFIG = 'setup.cfg' # TODO(eliben): For now we're preserving the global presence of a style dict. # Refactor this so that the style is passed around through yapf rather than # being global. _style = None SetGlobalStyle(_GLOBAL_STYLE_FACTORY()) yapf-0.15.1/yapf/yapflib/subtype_assigner.py000066400000000000000000000371211304174360200210660ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Subtype assigner for lib2to3 trees. This module assigns extra type information to the lib2to3 trees. This information is more specific than whether something is an operator or an identifier. For instance, it can specify if a node in the tree is part of a subscript. AssignSubtypes(): the main function exported by this module. Annotations: subtype: The subtype of a pytree token. See 'format_token' module for a list of subtypes. """ from lib2to3 import pytree from lib2to3.pgen2 import token from lib2to3.pygram import python_symbols as syms from yapf.yapflib import format_token from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor from yapf.yapflib import style def AssignSubtypes(tree): """Run the subtype assigner visitor over the tree, modifying it in place. Arguments: tree: the top-level pytree node to annotate with subtypes. """ subtype_assigner = _SubtypeAssigner() subtype_assigner.Visit(tree) # Map tokens in argument lists to their respective subtype. _ARGLIST_TOKEN_TO_SUBTYPE = { '=': format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN, ':': format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN, '*': format_token.Subtype.VARARGS_STAR, '**': format_token.Subtype.KWARGS_STAR_STAR, } class _SubtypeAssigner(pytree_visitor.PyTreeVisitor): """_SubtypeAssigner - see file-level docstring for detailed description. The subtype is added as an annotation to the pytree token. """ def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name # dictsetmaker ::= (test ':' test (comp_for | # (',' test ':' test)* [','])) | # (test (comp_for | (',' test)* [','])) for child in node.children: self.Visit(child) comp_for = False dict_maker = False for child in node.children: if pytree_utils.NodeName(child) == 'comp_for': comp_for = True _AppendFirstLeafTokenSubtype(child, format_token.Subtype.DICT_SET_GENERATOR) elif pytree_utils.NodeName(child) in ('COLON', 'DOUBLESTAR'): dict_maker = True if not comp_for and dict_maker: last_was_colon = False for child in node.children: if dict_maker: if pytree_utils.NodeName(child) == 'DOUBLESTAR': _AppendFirstLeafTokenSubtype(child, format_token.Subtype.KWARGS_STAR_STAR) if last_was_colon: if style.Get('INDENT_DICTIONARY_VALUE'): _InsertPseudoParentheses(child) else: _AppendFirstLeafTokenSubtype( child, format_token.Subtype.DICTIONARY_VALUE) elif (child is not None and (isinstance(child, pytree.Node) or ( not child.value.startswith('#') and child.value not in '{:,'))): # Mark the first leaf of a key entry as a DICTIONARY_KEY. We # normally want to split before them if the dictionary cannot exist # on a single line. _AppendFirstLeafTokenSubtype(child, format_token.Subtype.DICTIONARY_KEY) last_was_colon = pytree_utils.NodeName(child) == 'COLON' def Visit_expr_stmt(self, node): # pylint: disable=invalid-name # expr_stmt ::= testlist_star_expr (augassign (yield_expr|testlist) # | ('=' (yield_expr|testlist_star_expr))*) for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '=': _AppendTokenSubtype(child, format_token.Subtype.ASSIGN_OPERATOR) def Visit_or_test(self, node): # pylint: disable=invalid-name # or_test ::= and_test ('or' and_test)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == 'or': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_and_test(self, node): # pylint: disable=invalid-name # and_test ::= not_test ('and' not_test)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == 'and': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_not_test(self, node): # pylint: disable=invalid-name # not_test ::= 'not' not_test | comparison for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == 'not': _AppendTokenSubtype(child, format_token.Subtype.UNARY_OPERATOR) def Visit_comparison(self, node): # pylint: disable=invalid-name # comparison ::= expr (comp_op expr)* # comp_op ::= '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not in'|'is'|'is not' for child in node.children: self.Visit(child) if (isinstance(child, pytree.Leaf) and child.value in {'<', '>', '==', '>=', '<=', '<>', '!=', 'in', 'is'}): _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) elif pytree_utils.NodeName(child) == 'comp_op': for grandchild in child.children: _AppendTokenSubtype(grandchild, format_token.Subtype.BINARY_OPERATOR) def Visit_star_expr(self, node): # pylint: disable=invalid-name # star_expr ::= '*' expr for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '*': _AppendTokenSubtype(child, format_token.Subtype.UNARY_OPERATOR) def Visit_expr(self, node): # pylint: disable=invalid-name # expr ::= xor_expr ('|' xor_expr)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '|': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_xor_expr(self, node): # pylint: disable=invalid-name # xor_expr ::= and_expr ('^' and_expr)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '^': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_and_expr(self, node): # pylint: disable=invalid-name # and_expr ::= shift_expr ('&' shift_expr)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '&': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_shift_expr(self, node): # pylint: disable=invalid-name # shift_expr ::= arith_expr (('<<'|'>>') arith_expr)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value in {'<<', '>>'}: _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_arith_expr(self, node): # pylint: disable=invalid-name # arith_expr ::= term (('+'|'-') term)* for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value in '+-': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_term(self, node): # pylint: disable=invalid-name # term ::= factor (('*'|'/'|'%'|'//') factor)* for child in node.children: self.Visit(child) if (isinstance(child, pytree.Leaf) and child.value in {'*', '/', '%', '//'}): _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_factor(self, node): # pylint: disable=invalid-name # factor ::= ('+'|'-'|'~') factor | power for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value in '+-~': _AppendTokenSubtype(child, format_token.Subtype.UNARY_OPERATOR) def Visit_power(self, node): # pylint: disable=invalid-name # power ::= atom trailer* ['**' factor] for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '**': _AppendTokenSubtype(child, format_token.Subtype.BINARY_OPERATOR) def Visit_trailer(self, node): # pylint: disable=invalid-name for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value in '[]': _AppendTokenSubtype(child, format_token.Subtype.SUBSCRIPT_BRACKET) def Visit_subscript(self, node): # pylint: disable=invalid-name # subscript ::= test | [test] ':' [test] [sliceop] for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == ':': _AppendTokenSubtype(child, format_token.Subtype.SUBSCRIPT_COLON) def Visit_sliceop(self, node): # pylint: disable=invalid-name # sliceop ::= ':' [test] for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == ':': _AppendTokenSubtype(child, format_token.Subtype.SUBSCRIPT_COLON) def Visit_argument(self, node): # pylint: disable=invalid-name # argument ::= # test [comp_for] | test '=' test self._ProcessArgLists(node) def Visit_arglist(self, node): # pylint: disable=invalid-name # arglist ::= # (argument ',')* (argument [','] # | '*' test (',' argument)* [',' '**' test] # | '**' test) self._ProcessArgLists(node) _SetDefaultOrNamedAssignArgListSubtype(node) def Visit_tname(self, node): # pylint: disable=invalid-name self._ProcessArgLists(node) _SetDefaultOrNamedAssignArgListSubtype(node) def Visit_decorator(self, node): # pylint: disable=invalid-name # decorator ::= # '@' dotted_name [ '(' [arglist] ')' ] NEWLINE for child in node.children: if isinstance(child, pytree.Leaf) and child.value == '@': _AppendTokenSubtype(child, subtype=format_token.Subtype.DECORATOR) self.Visit(child) def Visit_funcdef(self, node): # pylint: disable=invalid-name # funcdef ::= # 'def' NAME parameters ['->' test] ':' suite for child in node.children: if pytree_utils.NodeName(child) == 'NAME' and child.value != 'def': _AppendTokenSubtype(child, format_token.Subtype.FUNC_DEF) break for child in node.children: self.Visit(child) def Visit_typedargslist(self, node): # pylint: disable=invalid-name # typedargslist ::= # ((tfpdef ['=' test] ',')* # ('*' [tname] (',' tname ['=' test])* [',' '**' tname] # | '**' tname) # | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) self._ProcessArgLists(node) _SetDefaultOrNamedAssignArgListSubtype(node) def Visit_varargslist(self, node): # pylint: disable=invalid-name # varargslist ::= # ((vfpdef ['=' test] ',')* # ('*' [vname] (',' vname ['=' test])* [',' '**' vname] # | '**' vname) # | vfpdef ['=' test] (',' vfpdef ['=' test])* [',']) self._ProcessArgLists(node) for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf) and child.value == '=': _AppendTokenSubtype(child, format_token.Subtype.VARARGS_LIST) def Visit_comp_for(self, node): # pylint: disable=invalid-name # comp_for ::= 'for' exprlist 'in' testlist_safe [comp_iter] _AppendSubtypeRec(node, format_token.Subtype.COMP_FOR) self.DefaultNodeVisit(node) def Visit_comp_if(self, node): # pylint: disable=invalid-name # comp_if ::= 'if' old_test [comp_iter] _AppendSubtypeRec(node, format_token.Subtype.COMP_IF) self.DefaultNodeVisit(node) def _ProcessArgLists(self, node): """Common method for processing argument lists.""" for child in node.children: self.Visit(child) if isinstance(child, pytree.Leaf): _AppendTokenSubtype( child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get(child.value, format_token.Subtype.NONE)) def _SetDefaultOrNamedAssignArgListSubtype(node): def HasDefaultOrNamedAssignSubtype(node): if isinstance(node, pytree.Leaf): if (format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN in pytree_utils.GetNodeAnnotation(node, pytree_utils.Annotation.SUBTYPE, set())): return True return False has_subtype = False for child in node.children: has_subtype |= HasDefaultOrNamedAssignSubtype(child) return has_subtype if HasDefaultOrNamedAssignSubtype(node): for child in node.children: if pytree_utils.NodeName(child) != 'COMMA': _AppendFirstLeafTokenSubtype( child, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) def _AppendTokenSubtype(node, subtype): """Append the token's subtype only if it's not already set.""" pytree_utils.AppendNodeAnnotation(node, pytree_utils.Annotation.SUBTYPE, subtype) def _AppendFirstLeafTokenSubtype(node, subtype): """Append the first leaf token's subtypes.""" if isinstance(node, pytree.Leaf): _AppendTokenSubtype(node, subtype) return _AppendFirstLeafTokenSubtype(node.children[0], subtype) def _AppendSubtypeRec(node, subtype, force=True): """Append the leafs in the node to the given subtype.""" if isinstance(node, pytree.Leaf): _AppendTokenSubtype(node, subtype) return for child in node.children: _AppendSubtypeRec(child, subtype, force=force) def _InsertPseudoParentheses(node): """Insert pseudo parentheses so that dicts can be formatted correctly.""" comment_node = None if isinstance(node, pytree.Node): if node.children[-1].type == token.COMMENT: comment_node = node.children[-1].clone() node.children[-1].remove() first = _GetFirstLeafNode(node) last = _GetLastLeafNode(node) if first == last and first.type == token.COMMENT: # A comment was inserted before the value, which is a pytree.Leaf. # Encompass the dictionary's value into an ATOM node. last = first.next_sibling new_node = pytree.Node(syms.atom, [first.clone(), last.clone()]) node.replace(new_node) node = new_node last.remove() first = _GetFirstLeafNode(node) last = _GetLastLeafNode(node) lparen = pytree.Leaf( token.LPAR, u'(', context=('', (first.get_lineno(), first.column - 1))) last_lineno = last.get_lineno() if last.type == token.STRING and '\n' in last.value: last_lineno += last.value.count('\n') if last.type == token.STRING and '\n' in last.value: last_column = len(last.value.split('\n')[-1]) + 1 else: last_column = last.column + len(last.value) + 1 rparen = pytree.Leaf( token.RPAR, u')', context=('', (last_lineno, last_column))) lparen.is_pseudo = True rparen.is_pseudo = True if isinstance(node, pytree.Node): node.insert_child(0, lparen) node.append_child(rparen) if comment_node: node.append_child(comment_node) _AppendFirstLeafTokenSubtype(node, format_token.Subtype.DICTIONARY_VALUE) else: clone = node.clone() new_node = pytree.Node(syms.atom, [lparen, clone, rparen]) node.replace(new_node) _AppendFirstLeafTokenSubtype(clone, format_token.Subtype.DICTIONARY_VALUE) def _GetFirstLeafNode(node): if isinstance(node, pytree.Leaf): return node return _GetFirstLeafNode(node.children[0]) def _GetLastLeafNode(node): if isinstance(node, pytree.Leaf): return node return _GetLastLeafNode(node.children[-1]) yapf-0.15.1/yapf/yapflib/unwrapped_line.py000066400000000000000000000440711304174360200205160ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """UnwrappedLine primitive for formatting. An unwrapped line is the containing data structure produced by the parser. It collects all nodes (stored in FormatToken objects) that could appear on a single line if there were no line length restrictions. It's then used by the parser to perform the wrapping required to comply with the style guide. """ from yapf.yapflib import format_token from yapf.yapflib import py3compat from yapf.yapflib import pytree_utils from yapf.yapflib import split_penalty from yapf.yapflib import style class UnwrappedLine(object): """Represents a single unwrapped line in the output. Attributes: depth: indentation depth of this line. This is just a numeric value used to distinguish lines that are more deeply nested than others. It is not the actual amount of spaces, which is style-dependent. """ def __init__(self, depth, tokens=None): """Constructor. Creates a new unwrapped line with the given depth an initial list of tokens. Constructs the doubly-linked lists for format tokens using their built-in next_token and previous_token attributes. Arguments: depth: indentation depth of this line tokens: initial list of tokens """ self.depth = depth self._tokens = tokens or [] self.disable = False if self._tokens: # Set up a doubly linked list. for index, tok in enumerate(self._tokens[1:]): # Note, 'index' is the index to the previous token. tok.previous_token = self._tokens[index] self._tokens[index].next_token = tok def CalculateFormattingInformation(self): """Calculate the split penalty and total length for the tokens.""" # Say that the first token in the line should have a space before it. This # means only that if this unwrapped line is joined with a predecessor line, # then there will be a space between them. self.first.spaces_required_before = 1 self.first.total_length = len(self.first.value) prev_token = self.first prev_length = self.first.total_length for token in self._tokens[1:]: if (token.spaces_required_before == 0 and _SpaceRequiredBetween(prev_token, token)): token.spaces_required_before = 1 tok_len = len(token.value) if not token.is_pseudo_paren else 0 token.total_length = prev_length + tok_len + token.spaces_required_before # The split penalty has to be computed before {must|can}_break_before, # because these may use it for their decision. token.split_penalty += _SplitPenalty(prev_token, token) token.must_break_before = _MustBreakBefore(prev_token, token) token.can_break_before = (token.must_break_before or _CanBreakBefore(prev_token, token)) prev_length = token.total_length prev_token = token ############################################################################ # Token Access and Manipulation Methods # ############################################################################ def AppendToken(self, token): """Append a new FormatToken to the tokens contained in this line.""" if self._tokens: token.previous_token = self.last self.last.next_token = token self._tokens.append(token) def AppendNode(self, node): """Convenience method to append a pytree node directly. Wraps the node with a FormatToken. Arguments: node: the node to append """ self.AppendToken(format_token.FormatToken(node)) @property def first(self): """Returns the first non-whitespace token.""" return self._tokens[0] @property def last(self): """Returns the last non-whitespace token.""" return self._tokens[-1] ############################################################################ # Token -> String Methods # ############################################################################ def AsCode(self, indent_per_depth=2): """Return a "code" representation of this line. The code representation shows how the line would be printed out as code. TODO(eliben): for now this is rudimentary for debugging - once we add formatting capabilities, this method will have other uses (not all tokens have spaces around them, for example). Arguments: indent_per_depth: how much spaces to indend per depth level. Returns: A string representing the line as code. """ indent = ' ' * indent_per_depth * self.depth tokens_str = ' '.join(tok.value for tok in self._tokens) return indent + tokens_str def __str__(self): # pragma: no cover return self.AsCode() def __repr__(self): # pragma: no cover tokens_repr = ','.join( ['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens]) return 'UnwrappedLine(depth={0}, tokens=[{1}])'.format(self.depth, tokens_repr) ############################################################################ # Properties # ############################################################################ @property def tokens(self): """Access the tokens contained within this line. The caller must not modify the tokens list returned by this method. Returns: List of tokens in this line. """ return self._tokens @property def lineno(self): """Return the line number of this unwrapped line. Returns: The line number of the first token in this unwrapped line. """ return self.first.lineno @property def is_comment(self): return self.first.is_comment def _IsIdNumberStringToken(tok): return tok.is_keyword or tok.is_name or tok.is_number or tok.is_string def _IsUnaryOperator(tok): return format_token.Subtype.UNARY_OPERATOR in tok.subtypes def _SpaceRequiredBetween(left, right): """Return True if a space is required between the left and right token.""" lval = left.value rval = right.value if (left.is_pseudo_paren and _IsIdNumberStringToken(right) and left.previous_token and _IsIdNumberStringToken(left.previous_token)): # Space between keyword... tokens and pseudo parens. return True if left.is_pseudo_paren or right.is_pseudo_paren: # There should be a space after the ':' in a dictionary. if left.OpensScope(): return True # The closing pseudo-paren shouldn't affect spacing. return False if left.is_continuation or right.is_continuation: # The continuation node's value has all of the spaces it needs. return False if right.name in pytree_utils.NONSEMANTIC_TOKENS: # No space before a non-semantic token. return False if _IsIdNumberStringToken(left) and _IsIdNumberStringToken(right): # Spaces between keyword, string, number, and identifier tokens. return True if lval == ',' and rval == ':': # We do want a space between a comma and colon. return True if rval in ':,': # Otherwise, we never want a space before a colon or comma. return False if lval == ',' and rval in ']})': # Add a space between ending ',' and closing bracket if requested. return style.Get('SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET') if lval == ',': # We want a space after a comma. return True if lval == 'from' and rval == '.': # Space before the '.' in an import statement. return True if lval == '.' and rval == 'import': # Space after the '.' in an import statement. return True if ((right.is_keyword or right.is_name) and (left.is_keyword or left.is_name)): # Don't merge two keywords/identifiers. return True if left.is_string: if (rval == '=' and format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in right.subtypes): # If there is a type hint, then we don't want to add a space between the # equal sign and the hint. return False if rval not in '[)]}.': # A string followed by something other than a subscript, closing bracket, # or dot should have a space after it. return True if left.is_binary_op and lval != '**' and _IsUnaryOperator(right): # Space between the binary opertor and the unary operator. return True if _IsUnaryOperator(left) and _IsUnaryOperator(right): # No space between two unary operators. return False if left.is_binary_op or right.is_binary_op: if lval == '**' or rval == '**': # Space around the "power" operator. return style.Get('SPACES_AROUND_POWER_OPERATOR') # Enforce spaces around binary operators. return True if (_IsUnaryOperator(left) and lval != 'not' and (right.is_name or right.is_number or rval == '(')): # The previous token was a unary op. No space is desired between it and # the current token. return False if (format_token.Subtype.SUBSCRIPT_COLON in left.subtypes or format_token.Subtype.SUBSCRIPT_COLON in right.subtypes): # A subscript shouldn't have spaces separating its colons. return False if (format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN in left.subtypes or format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN in right.subtypes): # A named argument or default parameter shouldn't have spaces around it. # However, a typed argument should have a space after the colon. return lval == ':' or style.Get('SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN') if (format_token.Subtype.VARARGS_LIST in left.subtypes or format_token.Subtype.VARARGS_LIST in right.subtypes): return False if (format_token.Subtype.VARARGS_STAR in left.subtypes or format_token.Subtype.KWARGS_STAR_STAR in left.subtypes): # Don't add a space after a vararg's star or a keyword's star-star. return False if (lval == '@' and format_token.Subtype.DECORATOR in left.subtypes): # Decorators shouldn't be separated from the 'at' sign. return False if lval == '.' or rval == '.': # Don't place spaces between dots. return False if ((lval == '(' and rval == ')') or (lval == '[' and rval == ']') or (lval == '{' and rval == '}')): # Empty objects shouldn't be separted by spaces. return False if (lval in pytree_utils.OPENING_BRACKETS and rval in pytree_utils.OPENING_BRACKETS): # Nested objects' opening brackets shouldn't be separated. return False if (lval in pytree_utils.CLOSING_BRACKETS and rval in pytree_utils.CLOSING_BRACKETS): # Nested objects' closing brackets shouldn't be separated. return False if lval in pytree_utils.CLOSING_BRACKETS and rval in '([': # A call, set, dictionary, or subscript that has a call or subscript after # it shouldn't have a space between them. return False if lval in pytree_utils.OPENING_BRACKETS and _IsIdNumberStringToken(right): # Don't separate the opening bracket from the first item. return False if left.is_name and rval in '([': # Don't separate a call or array access from the name. return False if rval in pytree_utils.CLOSING_BRACKETS: # Don't separate the closing bracket from the last item. # FIXME(morbo): This might be too permissive. return False if lval == 'print' and rval == '(': # Special support for the 'print' function. return False if lval in pytree_utils.OPENING_BRACKETS and _IsUnaryOperator(right): # Don't separate a unary operator from the opening bracket. return False if (lval in pytree_utils.OPENING_BRACKETS and (format_token.Subtype.VARARGS_STAR in right.subtypes or format_token.Subtype.KWARGS_STAR_STAR in right.subtypes)): # Don't separate a '*' or '**' from the opening bracket. return False if rval == ';': # Avoid spaces before a semicolon. (Why is there a semicolon?!) return False if lval == '(' and rval == 'await': # Special support for the 'await' keyword. Don't separate the 'await' # keyword from an opening paren. return False return True def _MustBreakBefore(prev_token, cur_token): """Return True if a line break is required before the current token.""" if prev_token.is_comment: # Must break if the previous token was a comment. return True if (cur_token.is_string and prev_token.is_string and IsSurroundedByBrackets(cur_token)): # We want consecutive strings to be on separate lines. This is a # reasonable assumption, because otherwise they should have written them # all on the same line, or with a '+'. return True return pytree_utils.GetNodeAnnotation( cur_token.node, pytree_utils.Annotation.MUST_SPLIT, default=False) def _CanBreakBefore(prev_token, cur_token): """Return True if a line break may occur before the current token.""" pval = prev_token.value cval = cur_token.value if py3compat.PY3: if pval == 'yield' and cval == 'from': # Don't break before a yield argument. return False if pval in {'async', 'await'} and cval in {'def', 'with', 'for'}: # Don't break after sync keywords. return False if cur_token.split_penalty >= split_penalty.UNBREAKABLE: return False if pval == '@': # Don't break right after the beginning of a decorator. return False if cval == ':': # Don't break before the start of a block of code. return False if cval == ',': # Don't break before a comma. return False if prev_token.is_name and cval == '(': # Don't break in the middle of a function definition or call. return False if prev_token.is_name and cval == '[': # Don't break in the middle of an array dereference. return False if prev_token.is_name and cval == '.': # Don't break before the '.' in a dotted name. return False if cur_token.is_comment and prev_token.lineno == cur_token.lineno: # Don't break a comment at the end of the line. return False if format_token.Subtype.UNARY_OPERATOR in prev_token.subtypes: # Don't break after a unary token. return False return True def IsSurroundedByBrackets(tok): """Return True if the token is surrounded by brackets.""" paren_count = 0 brace_count = 0 sq_bracket_count = 0 previous_token = tok.previous_token while previous_token: if previous_token.value == ')': paren_count -= 1 elif previous_token.value == '}': brace_count -= 1 elif previous_token.value == ']': sq_bracket_count -= 1 if previous_token.value == '(': if paren_count == 0: return True paren_count += 1 elif previous_token.value == '{': if brace_count == 0: return True brace_count += 1 elif previous_token.value == '[': if sq_bracket_count == 0: return True sq_bracket_count += 1 previous_token = previous_token.previous_token return False _LOGICAL_OPERATORS = frozenset({'and', 'or'}) _BITWISE_OPERATORS = frozenset({'&', '|', '^'}) _TERM_OPERATORS = frozenset({'*', '/', '%', '//'}) def _SplitPenalty(prev_token, cur_token): """Return the penalty for breaking the line before the current token.""" pval = prev_token.value cval = cur_token.value if pval == 'not': return split_penalty.UNBREAKABLE if cur_token.node_split_penalty > 0: return cur_token.node_split_penalty if style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR'): # Prefer to split before 'and' and 'or'. if pval in _LOGICAL_OPERATORS: return style.Get('SPLIT_PENALTY_LOGICAL_OPERATOR') if cval in _LOGICAL_OPERATORS: return 0 else: # Prefer to split after 'and' and 'or'. if pval in _LOGICAL_OPERATORS: return 0 if cval in _LOGICAL_OPERATORS: return style.Get('SPLIT_PENALTY_LOGICAL_OPERATOR') if style.Get('SPLIT_BEFORE_BITWISE_OPERATOR'): # Prefer to split before '&', '|', and '^'. if pval in _BITWISE_OPERATORS: return style.Get('SPLIT_PENALTY_BITWISE_OPERATOR') if cval in _BITWISE_OPERATORS: return 0 else: # Prefer to split after '&', '|', and '^'. if pval in _BITWISE_OPERATORS: return 0 if cval in _BITWISE_OPERATORS: return style.Get('SPLIT_PENALTY_BITWISE_OPERATOR') if (format_token.Subtype.COMP_FOR in cur_token.subtypes or format_token.Subtype.COMP_IF in cur_token.subtypes): # We don't mind breaking before the 'for' or 'if' of a list comprehension. return 0 if format_token.Subtype.UNARY_OPERATOR in prev_token.subtypes: # Try not to break after a unary operator. return style.Get('SPLIT_PENALTY_AFTER_UNARY_OPERATOR') if pval == ',': # Breaking after a comma is fine, if need be. return 0 if prev_token.is_binary_op: # We would rather not split after an equality operator. return 20 if (format_token.Subtype.VARARGS_STAR in prev_token.subtypes or format_token.Subtype.KWARGS_STAR_STAR in prev_token.subtypes): # Don't split after a varargs * or kwargs **. return split_penalty.UNBREAKABLE if prev_token.OpensScope() and cval != '(': # Slightly prefer return style.Get('SPLIT_PENALTY_AFTER_OPENING_BRACKET') if cval == ':': # Don't split before a colon. return split_penalty.UNBREAKABLE if cval == '=': # Don't split before an assignment. return split_penalty.UNBREAKABLE if (format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN in prev_token.subtypes or format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN in cur_token.subtypes): # Don't break before or after an default or named assignment. return split_penalty.UNBREAKABLE if cval == '==': # We would rather not split before an equality operator. return split_penalty.STRONGLY_CONNECTED if cur_token.ClosesScope(): # Give a slight penalty for splitting before the closing scope. return 100 if pval in _TERM_OPERATORS or cval in _TERM_OPERATORS: return 50 return 0 yapf-0.15.1/yapf/yapflib/verifier.py000066400000000000000000000057471304174360200173240ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Verify that the generated code is valid code. This takes a line of code and "normalizes" it. I.e., it transforms the snippet into something that has the potential to compile. VerifyCode(): the main function exported by this module. """ import ast import re import sys import textwrap class InternalError(Exception): """Internal error in verifying formatted code.""" pass def VerifyCode(code): """Verify that the reformatted code is syntactically correct. Arguments: code: (unicode) The reformatted code snippet. Raises: SyntaxError if the code was reformatted incorrectly. """ try: compile(textwrap.dedent(code).encode('UTF-8'), '', 'exec') except SyntaxError: try: ast.parse(textwrap.dedent(code.lstrip('\n')).lstrip(), '', 'exec') except SyntaxError: try: normalized_code = _NormalizeCode(code) compile(normalized_code.encode('UTF-8'), '', 'exec') except SyntaxError: raise InternalError(sys.exc_info()[1]) def _NormalizeCode(code): """Make sure that the code snippet is compilable.""" code = textwrap.dedent(code.lstrip('\n')).lstrip() # Split the code to lines and get rid of all leading full-comment lines as # they can mess up the normalization attempt. lines = code.split('\n') i = 0 for i, line in enumerate(lines): line = line.strip() if line and not line.startswith('#'): break code = '\n'.join(lines[i:]) + '\n' if re.match(r'(if|while|for|with|def|class|async|await)\b', code): code += '\n pass' elif re.match(r'(elif|else)\b', code): try: try_code = 'if True:\n pass\n' + code + '\n pass' ast.parse( textwrap.dedent(try_code.lstrip('\n')).lstrip(), '', 'exec') code = try_code except SyntaxError: # The assumption here is that the code is on a single line. code = 'if True: pass\n' + code elif code.startswith('@'): code += '\ndef _():\n pass' elif re.match(r'try\b', code): code += '\n pass\nexcept:\n pass' elif re.match(r'(except|finally)\b', code): code = 'try:\n pass\n' + code + '\n pass' elif re.match(r'(return|yield)\b', code): code = 'def _():\n ' + code elif re.match(r'(continue|break)\b', code): code = 'while True:\n ' + code elif re.match(r'print\b', code): code = 'from __future__ import print_function\n' + code return code + '\n' yapf-0.15.1/yapf/yapflib/yapf_api.py000066400000000000000000000230011304174360200172600ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Entry points for YAPF. The main APIs that YAPF exposes to drive the reformatting. FormatFile(): reformat a file. FormatCode(): reformat a string of code. These APIs have some common arguments: style_config: (string) Either a style name or a path to a file that contains formatting style settings. If None is specified, use the default style as set in style.DEFAULT_STYLE_FACTORY lines: (list of tuples of integers) A list of tuples of lines, [start, end], that we want to format. The lines are 1-based indexed. It can be used by third-party code (e.g., IDEs) when reformatting a snippet of code rather than a whole file. print_diff: (bool) Instead of returning the reformatted source, return a diff that turns the formatted source into reformatter source. verify: (bool) True if reformatted code should be verified for syntax. """ import difflib import re import sys from lib2to3.pgen2 import tokenize from yapf.yapflib import blank_line_calculator from yapf.yapflib import comment_splicer from yapf.yapflib import continuation_splicer from yapf.yapflib import file_resources from yapf.yapflib import py3compat from yapf.yapflib import pytree_unwrapper from yapf.yapflib import pytree_utils from yapf.yapflib import reformatter from yapf.yapflib import split_penalty from yapf.yapflib import style from yapf.yapflib import subtype_assigner def FormatFile(filename, style_config=None, lines=None, print_diff=False, verify=False, in_place=False, logger=None): """Format a single Python file and return the formatted code. Arguments: filename: (unicode) The file to reformat. in_place: (bool) If True, write the reformatted code back to the file. logger: (io streamer) A stream to output logging. remaining arguments: see comment at the top of this module. Returns: Tuple of (reformatted_code, encoding, changed). reformatted_code is None if the file is sucessfully written to (having used in_place). reformatted_code is a diff if print_diff is True. Raises: IOError: raised if there was an error reading the file. ValueError: raised if in_place and print_diff are both specified. """ _CheckPythonVersion() if in_place and print_diff: raise ValueError('Cannot pass both in_place and print_diff.') original_source, newline, encoding = ReadFile(filename, logger) reformatted_source, changed = FormatCode( original_source, style_config=style_config, filename=filename, lines=lines, print_diff=print_diff, verify=verify) if reformatted_source.rstrip('\n'): lines = reformatted_source.rstrip('\n').split('\n') reformatted_source = newline.join(line for line in lines) + newline if in_place: if original_source and original_source != reformatted_source: file_resources.WriteReformattedCode(filename, reformatted_source, in_place, encoding) return None, encoding, changed return reformatted_source, encoding, changed def FormatCode(unformatted_source, filename='', style_config=None, lines=None, print_diff=False, verify=False): """Format a string of Python code. This provides an alternative entry point to YAPF. Arguments: unformatted_source: (unicode) The code to format. filename: (unicode) The name of the file being reformatted. remaining arguments: see comment at the top of this module. Returns: Tuple of (reformatted_source, changed). reformatted_source conforms to the desired formatting style. changed is True if the source changed. """ _CheckPythonVersion() style.SetGlobalStyle(style.CreateStyleFromConfig(style_config)) if not unformatted_source.endswith('\n'): unformatted_source += '\n' tree = pytree_utils.ParseCodeToTree(unformatted_source) # Run passes on the tree, modifying it in place. comment_splicer.SpliceComments(tree) continuation_splicer.SpliceContinuations(tree) subtype_assigner.AssignSubtypes(tree) split_penalty.ComputeSplitPenalties(tree) blank_line_calculator.CalculateBlankLines(tree) uwlines = pytree_unwrapper.UnwrapPyTree(tree) for uwl in uwlines: uwl.CalculateFormattingInformation() _MarkLinesToFormat(uwlines, lines) reformatted_source = reformatter.Reformat(uwlines, verify) if unformatted_source == reformatted_source: return '' if print_diff else reformatted_source, False code_diff = _GetUnifiedDiff( unformatted_source, reformatted_source, filename=filename) if print_diff: return code_diff, code_diff != '' return reformatted_source, True def _CheckPythonVersion(): # pragma: no cover errmsg = 'yapf is only supported for Python 2.7 or 3.4+' if sys.version_info[0] == 2: if sys.version_info[1] < 7: raise RuntimeError(errmsg) elif sys.version_info[0] == 3: if sys.version_info[1] < 4: raise RuntimeError(errmsg) def ReadFile(filename, logger=None): """Read the contents of the file. An optional logger can be specified to emit messages to your favorite logging stream. If specified, then no exception is raised. This is external so that it can be used by third-party applications. Arguments: filename: (unicode) The name of the file. logger: (function) A function or lambda that takes a string and emits it. Returns: The contents of filename. Raises: IOError: raised if there was an error reading the file. """ try: with open(filename, 'rb') as fd: encoding = tokenize.detect_encoding(fd.readline)[0] except IOError as err: if logger: logger(err) raise try: # Preserves line endings. with py3compat.open_with_encoding( filename, mode='r', encoding=encoding, newline='') as fd: lines = fd.readlines() line_ending = file_resources.LineEnding(lines) source = '\n'.join(line.rstrip('\r\n') for line in lines) + '\n' return source, line_ending, encoding except IOError as err: # pragma: no cover if logger: logger(err) raise DISABLE_PATTERN = r'^#.*\byapf:\s*disable\b' ENABLE_PATTERN = r'^#.*\byapf:\s*enable\b' def _MarkLinesToFormat(uwlines, lines): """Skip sections of code that we shouldn't reformat.""" if lines: for uwline in uwlines: uwline.disable = True # Sort and combine overlapping ranges. lines = sorted(lines) line_ranges = [lines[0]] if len(lines[0]) else [] index = 1 while index < len(lines): current = line_ranges[-1] if lines[index][0] <= current[1]: # The ranges overlap, so combine them. line_ranges[-1] = (current[0], max(lines[index][1], current[1])) else: line_ranges.append(lines[index]) index += 1 # Mark lines to format as not being disabled. index = 0 for start, end in sorted(line_ranges): while index < len(uwlines) and uwlines[index].last.lineno < start: index += 1 if index >= len(uwlines): break while index < len(uwlines): if uwlines[index].lineno > end: break if (uwlines[index].lineno >= start or uwlines[index].last.lineno >= start): uwlines[index].disable = False index += 1 # Now go through the lines and disable any lines explicitly marked as # disabled. index = 0 while index < len(uwlines): uwline = uwlines[index] if uwline.is_comment: if _DisableYAPF(uwline.first.value.strip()): index += 1 while index < len(uwlines): uwline = uwlines[index] if uwline.is_comment and _EnableYAPF(uwline.first.value.strip()): break uwline.disable = True index += 1 elif re.search(DISABLE_PATTERN, uwline.last.value.strip(), re.IGNORECASE): uwline.disable = True index += 1 def _DisableYAPF(line): return (re.search(DISABLE_PATTERN, line.split('\n')[0].strip(), re.IGNORECASE) or re.search(DISABLE_PATTERN, line.split('\n')[-1].strip(), re.IGNORECASE)) def _EnableYAPF(line): return (re.search(ENABLE_PATTERN, line.split('\n')[0].strip(), re.IGNORECASE) or re.search(ENABLE_PATTERN, line.split('\n')[-1].strip(), re.IGNORECASE)) def _GetUnifiedDiff(before, after, filename='code'): """Get a unified diff of the changes. Arguments: before: (unicode) The original source code. after: (unicode) The reformatted source code. filename: (unicode) The code's filename. Returns: The unified diff text. """ before = before.splitlines() after = after.splitlines() return '\n'.join( difflib.unified_diff( before, after, filename, filename, '(original)', '(reformatted)', lineterm='')) + '\n' yapf-0.15.1/yapftests/000077500000000000000000000000001304174360200145575ustar00rootroot00000000000000yapf-0.15.1/yapftests/__init__.py000066400000000000000000000011311304174360200166640ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. yapf-0.15.1/yapftests/blank_line_calculator_test.py000066400000000000000000000151741304174360200225070ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.blank_line_calculator.""" import textwrap import unittest from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper class BasicBlankLineCalculatorTest(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreateChromiumStyle()) def testDecorators(self): unformatted_code = textwrap.dedent("""\ @bork() def foo(): pass """) expected_formatted_code = textwrap.dedent("""\ @bork() def foo(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testComplexDecorators(self): unformatted_code = textwrap.dedent("""\ import sys @bork() def foo(): pass @fork() class moo(object): @bar() @baz() def method(self): pass """) expected_formatted_code = textwrap.dedent("""\ import sys @bork() def foo(): pass @fork() class moo(object): @bar() @baz() def method(self): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testCodeAfterFunctionsAndClasses(self): unformatted_code = textwrap.dedent("""\ def foo(): pass top_level_code = True class moo(object): def method_1(self): pass ivar_a = 42 ivar_b = 13 def method_2(self): pass try: raise Error except Error as error: pass """) expected_formatted_code = textwrap.dedent("""\ def foo(): pass top_level_code = True class moo(object): def method_1(self): pass ivar_a = 42 ivar_b = 13 def method_2(self): pass try: raise Error except Error as error: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testCommentSpacing(self): unformatted_code = textwrap.dedent("""\ # This is the first comment # And it's multiline # This is the second comment def foo(): pass # multiline before a # class definition # This is the second comment class qux(object): pass # An attached comment. class bar(object): '''class docstring''' # Comment attached to # function def foo(self): '''Another docstring.''' # Another multiline # comment pass """) expected_formatted_code = textwrap.dedent("""\ # This is the first comment # And it's multiline # This is the second comment def foo(): pass # multiline before a # class definition # This is the second comment class qux(object): pass # An attached comment. class bar(object): '''class docstring''' # Comment attached to # function def foo(self): '''Another docstring.''' # Another multiline # comment pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testCommentBeforeMethod(self): code = textwrap.dedent("""\ class foo(object): # pylint: disable=invalid-name def f(self): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentsBeforeClassDefs(self): code = textwrap.dedent('''\ """Test.""" # Comment class Foo(object): pass ''') uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentsBeforeDecorator(self): code = textwrap.dedent("""\ # The @foo operator adds bork to a(). @foo() def a(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ # Hello world @foo() def a(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentsAfterDecorator(self): code = textwrap.dedent("""\ class _(): def _(): pass @pytest.mark.xfail(reason="#709 and #710") # also #@pytest.mark.xfail(setuptools.tests.is_ascii, # reason="https://github.com/pypa/setuptools/issues/706") def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testInnerClasses(self): unformatted_code = textwrap.dedent("""\ class DeployAPIClient(object): class Error(Exception): pass class TaskValidationError(Error): pass class DeployAPIHTTPError(Error): pass """) expected_formatted_code = textwrap.dedent("""\ class DeployAPIClient(object): class Error(Exception): pass class TaskValidationError(Error): pass class DeployAPIHTTPError(Error): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/comment_splicer_test.py000066400000000000000000000235141304174360200213600ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.comment_splicer.""" import textwrap import unittest from yapf.yapflib import comment_splicer from yapf.yapflib import py3compat from yapf.yapflib import pytree_utils class CommentSplicerTest(unittest.TestCase): def _AssertNodeType(self, expected_type, node): self.assertEqual(expected_type, pytree_utils.NodeName(node)) def _AssertNodeIsComment(self, node, text_in_comment=None): if pytree_utils.NodeName(node) == 'simple_stmt': self._AssertNodeType('COMMENT', node.children[0]) node_value = node.children[0].value else: self._AssertNodeType('COMMENT', node) node_value = node.value if text_in_comment is not None: self.assertIn(text_in_comment, node_value) def _FindNthChildNamed(self, node, name, n=1): for i, child in enumerate( py3compat.ifilter(lambda c: pytree_utils.NodeName(c) == name, node.pre_order())): if i == n - 1: return child raise RuntimeError('No Nth child for n={0}'.format(n)) def testSimpleInline(self): code = 'foo = 1 # and a comment\n' tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) expr = tree.children[0].children[0] # Check that the expected node is still expr_stmt, but now it has 4 children # (before comment splicing it had 3), the last child being the comment. self._AssertNodeType('expr_stmt', expr) self.assertEqual(4, len(expr.children)) comment_node = expr.children[3] self._AssertNodeIsComment(comment_node, '# and a comment') def testSimpleSeparateLine(self): code = textwrap.dedent(r''' foo = 1 # first comment bar = 2 ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # The comment should've been added to the root's children (now 4, including # the ENDMARKER in the end. self.assertEqual(4, len(tree.children)) comment_node = tree.children[1] self._AssertNodeIsComment(comment_node) def testTwoLineComment(self): code = textwrap.dedent(r''' foo = 1 # first comment # second comment bar = 2 ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # This is similar to the single-line standalone comment. self.assertEqual(4, len(tree.children)) self._AssertNodeIsComment(tree.children[1]) def testCommentIsFirstChildInCompound(self): code = textwrap.dedent(r''' if x: # a comment foo = 1 ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # Look into the suite node under the 'if'. We don't care about the NEWLINE # leaf but the new COMMENT must be a child of the suite and before the # actual code leaf. if_suite = tree.children[0].children[3] self._AssertNodeType('NEWLINE', if_suite.children[0]) self._AssertNodeIsComment(if_suite.children[1]) def testCommentIsLastChildInCompound(self): code = textwrap.dedent(r''' if x: foo = 1 # a comment ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # Look into the suite node under the 'if'. We don't care about the DEDENT # leaf but the new COMMENT must be a child of the suite and after the # actual code leaf. if_suite = tree.children[0].children[3] self._AssertNodeType('DEDENT', if_suite.children[-1]) self._AssertNodeIsComment(if_suite.children[-2]) def testInlineAfterSeparateLine(self): code = textwrap.dedent(r''' bar = 1 # line comment foo = 1 # inline comment ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # The separate line comment should become a child of the root, while # the inline comment remains within its simple_node. sep_comment_node = tree.children[1] self._AssertNodeIsComment(sep_comment_node, '# line comment') expr = tree.children[2].children[0] inline_comment_node = expr.children[-1] self._AssertNodeIsComment(inline_comment_node, '# inline comment') def testSeparateLineAfterInline(self): code = textwrap.dedent(r''' bar = 1 foo = 1 # inline comment # line comment ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # The separate line comment should become a child of the root, while # the inline comment remains within its simple_node. sep_comment_node = tree.children[-2] self._AssertNodeIsComment(sep_comment_node, '# line comment') expr = tree.children[1].children[0] inline_comment_node = expr.children[-1] self._AssertNodeIsComment(inline_comment_node, '# inline comment') def testCommentBeforeDedent(self): code = textwrap.dedent(r''' if bar: z = 1 # a comment j = 2 ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # The comment should go under the tree root, not under the 'if'. self._AssertNodeIsComment(tree.children[1]) if_suite = tree.children[0].children[3] self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentTwoLevel(self): code = textwrap.dedent(r''' if foo: if bar: z = 1 # a comment y = 1 ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) if_suite = tree.children[0].children[3] # The comment is in the first if_suite, not the nested if under it. It's # right before the DEDENT self._AssertNodeIsComment(if_suite.children[-2]) self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentTwoLevelImproperlyIndented(self): code = textwrap.dedent(r''' if foo: if bar: z = 1 # comment 2 y = 1 ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) # The comment here is indented by 3 spaces, which is unlike any of the # surrounding statement indentation levels. The splicer attaches it to the # "closest" parent with smaller indentation. if_suite = tree.children[0].children[3] # The comment is in the first if_suite, not the nested if under it. It's # right before the DEDENT self._AssertNodeIsComment(if_suite.children[-2]) self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentsInClass(self): code = textwrap.dedent(r''' class Foo: """docstring abc...""" # top-level comment def foo(): pass # another comment ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) class_suite = tree.children[0].children[3] another_comment = class_suite.children[-2] self._AssertNodeIsComment(another_comment, '# another') # It's OK for the comment to be a child of funcdef, as long as it's # the first child and thus comes before the 'def'. funcdef = class_suite.children[3] toplevel_comment = funcdef.children[0] self._AssertNodeIsComment(toplevel_comment, '# top-level') def testMultipleBlockComments(self): code = textwrap.dedent(r''' # Block comment number 1 # Block comment number 2 def f(): pass ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) funcdef = tree.children[0] block_comment_1 = funcdef.children[0] self._AssertNodeIsComment(block_comment_1, '# Block comment number 1') block_comment_2 = funcdef.children[1] self._AssertNodeIsComment(block_comment_2, '# Block comment number 2') def testCommentsOnDedents(self): code = textwrap.dedent(r''' class Foo(object): # A comment for qux. def qux(self): pass # Interim comment. def mux(self): pass ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) classdef = tree.children[0] class_suite = classdef.children[6] qux_comment = class_suite.children[1] self._AssertNodeIsComment(qux_comment, '# A comment for qux.') interim_comment = class_suite.children[4] self._AssertNodeIsComment(interim_comment, '# Interim comment.') def testExprComments(self): code = textwrap.dedent(r''' foo( # Request fractions of an hour. 948.0/3600, 20) ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) trailer = self._FindNthChildNamed(tree, 'trailer', 1) comment = trailer.children[1] self._AssertNodeIsComment(comment, '# Request fractions of an hour.') def testMultipleCommentsInOneExpr(self): code = textwrap.dedent(r''' foo( # com 1 948.0/3600, # com 2 20 + 12 # com 3 ) ''') tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) trailer = self._FindNthChildNamed(tree, 'trailer', 1) self._AssertNodeIsComment(trailer.children[1], '# com 1') arglist = self._FindNthChildNamed(tree, 'arglist', 1) self._AssertNodeIsComment(arglist.children[2], '# com 2') arith_expr = self._FindNthChildNamed(tree, 'arith_expr', 1) self._AssertNodeIsComment(arith_expr.children[-1], '# com 3') if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/file_resources_test.py000066400000000000000000000167041304174360200212110ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.file_resources.""" import contextlib import os import shutil import sys import tempfile import unittest from yapf.yapflib import errors from yapf.yapflib import file_resources from yapf.yapflib import py3compat @contextlib.contextmanager def stdout_redirector(stream): # pylint: disable=invalid-name old_stdout = sys.stdout sys.stdout = stream try: yield finally: sys.stdout = old_stdout class GetDefaultStyleForDirTest(unittest.TestCase): def setUp(self): self.test_tmpdir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.test_tmpdir) def test_no_local_style(self): test_file = os.path.join(self.test_tmpdir, 'file.py') style_name = file_resources.GetDefaultStyleForDir(test_file) self.assertEqual(style_name, 'pep8') def test_with_local_style(self): # Create an empty .style.yapf file in test_tmpdir style_file = os.path.join(self.test_tmpdir, '.style.yapf') open(style_file, 'w').close() test_filename = os.path.join(self.test_tmpdir, 'file.py') self.assertEqual(style_file, file_resources.GetDefaultStyleForDir(test_filename)) test_filename = os.path.join(self.test_tmpdir, 'dir1', 'file.py') self.assertEqual(style_file, file_resources.GetDefaultStyleForDir(test_filename)) def _touch_files(filenames): for name in filenames: open(name, 'a').close() class GetCommandLineFilesTest(unittest.TestCase): def setUp(self): self.test_tmpdir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.test_tmpdir) def _make_test_dir(self, name): fullpath = os.path.join(self.test_tmpdir, name) os.makedirs(fullpath) return fullpath def test_find_files_not_dirs(self): tdir1 = self._make_test_dir('test1') tdir2 = self._make_test_dir('test2') file1 = os.path.join(tdir1, 'testfile1.py') file2 = os.path.join(tdir2, 'testfile2.py') _touch_files([file1, file2]) self.assertEqual( file_resources.GetCommandLineFiles( [file1, file2], recursive=False, exclude=None), [file1, file2]) self.assertEqual( file_resources.GetCommandLineFiles( [file1, file2], recursive=True, exclude=None), [file1, file2]) def test_nonrecursive_find_in_dir(self): tdir1 = self._make_test_dir('test1') tdir2 = self._make_test_dir('test1/foo') file1 = os.path.join(tdir1, 'testfile1.py') file2 = os.path.join(tdir2, 'testfile2.py') _touch_files([file1, file2]) self.assertRaises( errors.YapfError, file_resources.GetCommandLineFiles, command_line_file_list=[tdir1], recursive=False, exclude=None) def test_recursive_find_in_dir(self): tdir1 = self._make_test_dir('test1') tdir2 = self._make_test_dir('test2/testinner/') tdir3 = self._make_test_dir('test3/foo/bar/bas/xxx') files = [ os.path.join(tdir1, 'testfile1.py'), os.path.join(tdir2, 'testfile2.py'), os.path.join(tdir3, 'testfile3.py') ] _touch_files(files) self.assertEqual( sorted( file_resources.GetCommandLineFiles( [self.test_tmpdir], recursive=True, exclude=None)), sorted(files)) def test_recursive_find_in_dir_with_exclude(self): tdir1 = self._make_test_dir('test1') tdir2 = self._make_test_dir('test2/testinner/') tdir3 = self._make_test_dir('test3/foo/bar/bas/xxx') files = [ os.path.join(tdir1, 'testfile1.py'), os.path.join(tdir2, 'testfile2.py'), os.path.join(tdir3, 'testfile3.py') ] _touch_files(files) self.assertEqual( sorted( file_resources.GetCommandLineFiles( [self.test_tmpdir], recursive=True, exclude=['*test*3.py'])), sorted([ os.path.join(tdir1, 'testfile1.py'), os.path.join(tdir2, 'testfile2.py') ])) class IsPythonFileTest(unittest.TestCase): def setUp(self): self.test_tmpdir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.test_tmpdir) def test_with_py_extension(self): file1 = os.path.join(self.test_tmpdir, 'testfile1.py') self.assertTrue(file_resources.IsPythonFile(file1)) def test_empty_without_py_extension(self): file1 = os.path.join(self.test_tmpdir, 'testfile1') self.assertFalse(file_resources.IsPythonFile(file1)) file2 = os.path.join(self.test_tmpdir, 'testfile1.rb') self.assertFalse(file_resources.IsPythonFile(file2)) def test_python_shebang(self): file1 = os.path.join(self.test_tmpdir, 'testfile1') with open(file1, 'w') as f: f.write(u'#!/usr/bin/python\n') self.assertTrue(file_resources.IsPythonFile(file1)) file2 = os.path.join(self.test_tmpdir, 'testfile2.run') with open(file2, 'w') as f: f.write(u'#! /bin/python2\n') self.assertTrue(file_resources.IsPythonFile(file1)) def test_with_latin_encoding(self): file1 = os.path.join(self.test_tmpdir, 'testfile1') with py3compat.open_with_encoding(file1, mode='w', encoding='latin-1') as f: f.write(u'#! /bin/python2\n') self.assertTrue(file_resources.IsPythonFile(file1)) def test_with_invalid_encoding(self): file1 = os.path.join(self.test_tmpdir, 'testfile1') with open(file1, 'w') as f: f.write(u'#! /bin/python2\n') f.write(u'# -*- coding: iso-3-14159 -*-\n') self.assertFalse(file_resources.IsPythonFile(file1)) class BufferedByteStream(object): def __init__(self): self.stream = py3compat.BytesIO() def getvalue(self): # pylint: disable=invalid-name return self.stream.getvalue().decode('utf-8') @property def buffer(self): return self.stream class WriteReformattedCodeTest(unittest.TestCase): @classmethod def setUpClass(cls): cls.test_tmpdir = tempfile.mkdtemp() @classmethod def tearDownClass(cls): shutil.rmtree(cls.test_tmpdir) def test_write_to_file(self): s = u'foobar\n' with tempfile.NamedTemporaryFile(dir=self.test_tmpdir) as testfile: file_resources.WriteReformattedCode( testfile.name, s, in_place=True, encoding='utf-8') testfile.flush() with open(testfile.name) as f: self.assertEqual(f.read(), s) def test_write_to_stdout(self): s = u'foobar' stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO() with stdout_redirector(stream): file_resources.WriteReformattedCode( None, s, in_place=False, encoding='utf-8') self.assertEqual(stream.getvalue(), s) def test_write_encoded_to_stdout(self): s = '\ufeff# -*- coding: utf-8 -*-\nresult = "passed"\n' # pylint: disable=anomalous-unicode-escape-in-string stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO() with stdout_redirector(stream): file_resources.WriteReformattedCode( None, s, in_place=False, encoding='utf-8') self.assertEqual(stream.getvalue(), s) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/format_decision_state_test.py000066400000000000000000000103071304174360200225360ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.format_decision_state.""" import textwrap import unittest from yapf.yapflib import format_decision_state from yapf.yapflib import pytree_utils from yapf.yapflib import style from yapf.yapflib import unwrapped_line from yapftests import yapf_test_helper class FormatDecisionStateTest(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreateChromiumStyle()) def testSimpleFunctionDefWithNoSplitting(self): code = textwrap.dedent(r""" def f(a, b): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) uwline = unwrapped_line.UnwrappedLine(0, _FilterLine(uwlines[0])) uwline.CalculateFormattingInformation() # Add: 'f' state = format_decision_state.FormatDecisionState(uwline, 0) self.assertEqual('f', state.next_token.value) self.assertFalse(state.CanSplit()) # Add: '(' state.AddTokenToState(False, True) self.assertEqual('(', state.next_token.value) self.assertFalse(state.CanSplit()) self.assertFalse(state.MustSplit()) # Add: 'a' state.AddTokenToState(False, True) self.assertEqual('a', state.next_token.value) self.assertTrue(state.CanSplit()) self.assertFalse(state.MustSplit()) # Add: ',' state.AddTokenToState(False, True) self.assertEqual(',', state.next_token.value) self.assertFalse(state.CanSplit()) self.assertFalse(state.MustSplit()) # Add: 'b' state.AddTokenToState(False, True) self.assertEqual('b', state.next_token.value) self.assertTrue(state.CanSplit()) self.assertFalse(state.MustSplit()) # Add: ')' state.AddTokenToState(False, True) self.assertEqual(')', state.next_token.value) self.assertTrue(state.CanSplit()) self.assertFalse(state.MustSplit()) # Add: ':' state.AddTokenToState(False, True) self.assertEqual(':', state.next_token.value) self.assertFalse(state.CanSplit()) self.assertFalse(state.MustSplit()) clone = state.Clone() self.assertEqual(repr(state), repr(clone)) def testSimpleFunctionDefWithSplitting(self): code = textwrap.dedent(r""" def f(a, b): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) uwline = unwrapped_line.UnwrappedLine(0, _FilterLine(uwlines[0])) uwline.CalculateFormattingInformation() # Add: 'f' state = format_decision_state.FormatDecisionState(uwline, 0) self.assertEqual('f', state.next_token.value) self.assertFalse(state.CanSplit()) # Add: '(' state.AddTokenToState(True, True) self.assertEqual('(', state.next_token.value) self.assertFalse(state.CanSplit()) # Add: 'a' state.AddTokenToState(True, True) self.assertEqual('a', state.next_token.value) self.assertTrue(state.CanSplit()) # Add: ',' state.AddTokenToState(True, True) self.assertEqual(',', state.next_token.value) self.assertFalse(state.CanSplit()) # Add: 'b' state.AddTokenToState(True, True) self.assertEqual('b', state.next_token.value) self.assertTrue(state.CanSplit()) # Add: ')' state.AddTokenToState(True, True) self.assertEqual(')', state.next_token.value) self.assertTrue(state.CanSplit()) # Add: ':' state.AddTokenToState(True, True) self.assertEqual(':', state.next_token.value) self.assertFalse(state.CanSplit()) clone = state.Clone() self.assertEqual(repr(state), repr(clone)) def _FilterLine(uwline): """Filter out nonsemantic tokens from the UnwrappedLines.""" return [ ft for ft in uwline.tokens if ft.name not in pytree_utils.NONSEMANTIC_TOKENS ] if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/format_token_test.py000066400000000000000000000023501304174360200206600ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.format_token.""" import unittest from lib2to3 import pytree from lib2to3.pgen2 import token from yapf.yapflib import format_token class FormatTokenTest(unittest.TestCase): def testSimple(self): tok = format_token.FormatToken(pytree.Leaf(token.STRING, "'hello world'")) self.assertEqual("FormatToken(name=STRING, value='hello world')", str(tok)) self.assertTrue(tok.is_string) tok = format_token.FormatToken(pytree.Leaf(token.COMMENT, "# A comment")) self.assertEqual("FormatToken(name=COMMENT, value=# A comment)", str(tok)) self.assertTrue(tok.is_comment) if __name__ == "__main__": unittest.main() yapf-0.15.1/yapftests/line_joiner_test.py000066400000000000000000000050751304174360200204740ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.line_joiner.""" import textwrap import unittest from yapf.yapflib import line_joiner from yapf.yapflib import style from yapftests import yapf_test_helper class LineJoinerTest(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def _CheckLineJoining(self, code, join_lines): """Check that the given UnwrappedLines are joined as expected. Arguments: code: The code to check to see if we can join it. join_lines: True if we expect the lines to be joined. """ uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(line_joiner.CanMergeMultipleLines(uwlines), join_lines) def testSimpleSingleLineStatement(self): code = textwrap.dedent(u"""\ if isinstance(a, int): continue """) self._CheckLineJoining(code, join_lines=True) def testSimpleMultipleLineStatement(self): code = textwrap.dedent(u"""\ if isinstance(b, int): continue """) self._CheckLineJoining(code, join_lines=False) def testSimpleMultipleLineComplexStatement(self): code = textwrap.dedent(u"""\ if isinstance(c, int): while True: continue """) self._CheckLineJoining(code, join_lines=False) def testSimpleMultipleLineStatementWithComment(self): code = textwrap.dedent(u"""\ if isinstance(d, int): continue # We're pleased that d's an int. """) self._CheckLineJoining(code, join_lines=True) def testSimpleMultipleLineStatementWithLargeIndent(self): code = textwrap.dedent(u"""\ if isinstance(e, int): continue """) self._CheckLineJoining(code, join_lines=True) def testOverColumnLimit(self): code = textwrap.dedent(u"""\ if instance(bbbbbbbbbbbbbbbbbbbbbbbbb, int): cccccccccccccccccccccccccc = ddddddddddddddddddddd """) self._CheckLineJoining(code, join_lines=False) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/main_test.py000066400000000000000000000103731304174360200171200ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.__init__.main.""" from contextlib import contextmanager import sys import unittest import yapf try: from StringIO import StringIO except ImportError: # Python 3 # Note: io.StringIO is different in Python 2, so try for python 2 first. from io import StringIO from yapf.yapflib import py3compat class IO(object): """IO is a thin wrapper around StringIO. This is strictly to wrap the Python 3 StringIO object so that it can supply a "buffer" attribute. """ class Buffer(object): def __init__(self): self.string_io = StringIO() def write(self, s): if py3compat.PY3 and isinstance(s, bytes): s = str(s, 'utf-8') self.string_io.write(s) def getvalue(self): return self.string_io.getvalue() def __init__(self): self.buffer = self.Buffer() def write(self, s): self.buffer.write(s) def getvalue(self): return self.buffer.getvalue() @contextmanager def captured_output(): new_out, new_err = IO(), IO() old_out, old_err = sys.stdout, sys.stderr try: sys.stdout, sys.stderr = new_out, new_err yield sys.stdout, sys.stderr finally: sys.stdout, sys.stderr = old_out, old_err @contextmanager def patched_input(code): "Monkey patch code as though it were coming from stdin." def lines(): for line in code.splitlines(): yield line raise EOFError() def patch_raw_input(lines=lines()): return next(lines) try: raw_input = yapf.py3compat.raw_input yapf.py3compat.raw_input = patch_raw_input yield finally: yapf.py3compat.raw_input = raw_input class RunMainTest(unittest.TestCase): def testShouldHandleYapfError(self): """run_main should handle YapfError and sys.exit(1)""" expected_message = 'yapf: Input filenames did not match any python files\n' sys.argv = ['yapf', 'foo.c'] with captured_output() as (out, err): with self.assertRaises(SystemExit): yapf.run_main() self.assertEqual(out.getvalue(), '') self.assertEqual(err.getvalue(), expected_message) class MainTest(unittest.TestCase): def testNoPythonFilesMatched(self): with self.assertRaisesRegexp(yapf.errors.YapfError, 'did not match any python files'): yapf.main(['yapf', 'foo.c']) def testEchoInput(self): code = "a = 1\nb = 2\n" with patched_input(code): with captured_output() as (out, err): ret = yapf.main([]) self.assertEqual(ret, 0) self.assertEqual(out.getvalue(), code) def testEchoInputWithStyle(self): code = "def f(a = 1):\n return 2*a\n" chromium_code = "def f(a=1):\n return 2 * a\n" with patched_input(code): with captured_output() as (out, err): ret = yapf.main(['-', '--style=chromium']) self.assertEqual(ret, 0) self.assertEqual(out.getvalue(), chromium_code) def testEchoBadInput(self): bad_syntax = " a = 1\n" with patched_input(bad_syntax): with captured_output() as (out, err): with self.assertRaisesRegexp(SyntaxError, "unexpected indent"): yapf.main([]) def testHelp(self): with captured_output() as (out, err): ret = yapf.main(['-', '--style-help', '--style=pep8']) self.assertEqual(ret, 0) help_message = out.getvalue() self.assertIn("indent_width=4", help_message) self.assertIn("The number of spaces required before a trailing comment.", help_message) def testVersion(self): with captured_output() as (out, err): ret = yapf.main(['-', '--version']) self.assertEqual(ret, 0) version = 'yapf {}\n'.format(yapf.__version__) self.assertEqual(version, out.getvalue()) yapf-0.15.1/yapftests/pytree_unwrapper_test.py000066400000000000000000000222171304174360200216070ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.pytree_unwrapper.""" import textwrap import unittest from yapf.yapflib import pytree_utils from yapftests import yapf_test_helper class PytreeUnwrapperTest(yapf_test_helper.YAPFTest): def _CheckUnwrappedLines(self, uwlines, list_of_expected): """Check that the given UnwrappedLines match expectations. Args: uwlines: list of UnwrappedLine list_of_expected: list of (depth, values) pairs. Non-semantic tokens are filtered out from the expected values. """ actual = [] for uwl in uwlines: filtered_values = [ ft.value for ft in uwl.tokens if ft.name not in pytree_utils.NONSEMANTIC_TOKENS ] actual.append((uwl.depth, filtered_values)) self.assertEqual(list_of_expected, actual) def testSimpleFileScope(self): code = textwrap.dedent(r""" x = 1 # a comment y = 2 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['x', '=', '1']), (0, ['# a comment']), (0, ['y', '=', '2']), ]) def testSimpleMultilineStatement(self): code = textwrap.dedent(r""" y = (1 + x) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['y', '=', '(', '1', '+', 'x', ')']), ]) def testFileScopeWithInlineComment(self): code = textwrap.dedent(r""" x = 1 # a comment y = 2 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['x', '=', '1', '# a comment']), (0, ['y', '=', '2']), ]) def testSimpleIf(self): code = textwrap.dedent(r""" if foo: x = 1 y = 2 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['if', 'foo', ':']), (1, ['x', '=', '1']), (1, ['y', '=', '2']), ]) def testSimpleIfWithComments(self): code = textwrap.dedent(r""" # c1 if foo: # c2 x = 1 y = 2 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['# c1']), (0, ['if', 'foo', ':', '# c2']), (1, ['x', '=', '1']), (1, ['y', '=', '2']), ]) def testIfWithCommentsInside(self): code = textwrap.dedent(r""" if foo: # c1 x = 1 # c2 # c3 y = 2 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['if', 'foo', ':']), (1, ['# c1']), (1, ['x', '=', '1', '# c2']), (1, ['# c3']), (1, ['y', '=', '2']), ]) def testIfElifElse(self): code = textwrap.dedent(r""" if x: x = 1 # c1 elif y: # c2 y = 1 else: # c3 z = 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['if', 'x', ':']), (1, ['x', '=', '1', '# c1']), (0, ['elif', 'y', ':', '# c2']), (1, ['y', '=', '1']), (0, ['else', ':']), (1, ['# c3']), (1, ['z', '=', '1']), ]) def testNestedCompoundTwoLevel(self): code = textwrap.dedent(r""" if x: x = 1 # c1 while t: # c2 j = 1 k = 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['if', 'x', ':']), (1, ['x', '=', '1', '# c1']), (1, ['while', 't', ':']), (2, ['# c2']), (2, ['j', '=', '1']), (1, ['k', '=', '1']), ]) def testSimpleWhile(self): code = textwrap.dedent(r""" while x > 1: # c1 # c2 x = 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['while', 'x', '>', '1', ':', '# c1']), (1, ['# c2']), (1, ['x', '=', '1']), ]) def testSimpleTry(self): code = textwrap.dedent(r""" try: pass except: pass except: pass else: pass finally: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['try', ':']), (1, ['pass']), (0, ['except', ':']), (1, ['pass']), (0, ['except', ':']), (1, ['pass']), (0, ['else', ':']), (1, ['pass']), (0, ['finally', ':']), (1, ['pass']), ]) def testSimpleFuncdef(self): code = textwrap.dedent(r""" def foo(x): # c1 # c2 return x """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), (1, ['# c2']), (1, ['return', 'x']), ]) def testTwoFuncDefs(self): code = textwrap.dedent(r""" def foo(x): # c1 # c2 return x def bar(): # c3 # c4 return x """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), (1, ['# c2']), (1, ['return', 'x']), (0, ['def', 'bar', '(', ')', ':', '# c3']), (1, ['# c4']), (1, ['return', 'x']), ]) def testSimpleClassDef(self): code = textwrap.dedent(r""" class Klass: # c1 # c2 p = 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['class', 'Klass', ':', '# c1']), (1, ['# c2']), (1, ['p', '=', '1']), ]) def testSingleLineStmtInFunc(self): code = textwrap.dedent(r""" def f(): return 37 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['def', 'f', '(', ')', ':']), (1, ['return', '37']), ]) def testMultipleComments(self): code = textwrap.dedent(r""" # Comment #1 # Comment #2 def f(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [ (0, ['# Comment #1']), (0, ['# Comment #2']), (0, ['def', 'f', '(', ')', ':']), (1, ['pass']), ]) def testSplitListWithComment(self): code = textwrap.dedent(r""" a = [ 'a', 'b', 'c', # hello world ] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckUnwrappedLines(uwlines, [(0, [ 'a', '=', '[', "'a'", ',', "'b'", ',', "'c'", ',', '# hello world', ']' ])]) class MatchBracketsTest(yapf_test_helper.YAPFTest): def _CheckMatchingBrackets(self, uwlines, list_of_expected): """Check that the tokens have the expected matching bracket. Arguments: uwlines: list of UnwrappedLine. list_of_expected: list of (index, index) pairs. The matching brackets at the indexes need to match. Non-semantic tokens are filtered out from the expected values. """ actual = [] for uwl in uwlines: filtered_values = [(ft, ft.matching_bracket) for ft in uwl.tokens if ft.name not in pytree_utils.NONSEMANTIC_TOKENS] if filtered_values: actual.append(filtered_values) for index, bracket_list in enumerate(list_of_expected): uwline = actual[index] if not bracket_list: for value in uwline: self.assertIsNone(value[1]) else: for open_bracket, close_bracket in bracket_list: self.assertEqual(uwline[open_bracket][0], uwline[close_bracket][1]) self.assertEqual(uwline[close_bracket][0], uwline[open_bracket][1]) def testFunctionDef(self): code = textwrap.dedent("""\ def foo(a, b={'hello': ['w','d']}, c=[42, 37]): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckMatchingBrackets(uwlines, [ [(2, 24), (7, 15), (10, 14), (19, 23)], [], ]) def testDecorator(self): code = textwrap.dedent("""\ @bar() def foo(a, b, c): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckMatchingBrackets(uwlines, [ [(2, 3)], [(2, 8)], [], ]) def testClassDef(self): code = textwrap.dedent("""\ class A(B, C, D): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckMatchingBrackets(uwlines, [ [(2, 8)], [], ]) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/pytree_utils_test.py000066400000000000000000000177211304174360200207300ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.pytree_utils.""" import unittest from lib2to3 import pygram from lib2to3 import pytree from lib2to3.pgen2 import token from yapf.yapflib import pytree_utils # More direct access to the symbol->number mapping living within the grammar # module. _GRAMMAR_SYMBOL2NUMBER = pygram.python_grammar.symbol2number _FOO = 'foo' _FOO1 = 'foo1' _FOO2 = 'foo2' _FOO3 = 'foo3' _FOO4 = 'foo4' _FOO5 = 'foo5' class NodeNameTest(unittest.TestCase): def testNodeNameForLeaf(self): leaf = pytree.Leaf(token.LPAR, '(') self.assertEqual('LPAR', pytree_utils.NodeName(leaf)) def testNodeNameForNode(self): leaf = pytree.Leaf(token.LPAR, '(') node = pytree.Node(pygram.python_grammar.symbol2number['suite'], [leaf]) self.assertEqual('suite', pytree_utils.NodeName(node)) class ParseCodeToTreeTest(unittest.TestCase): def testParseCodeToTree(self): # Since ParseCodeToTree is a thin wrapper around underlying lib2to3 # functionality, only a sanity test here... tree = pytree_utils.ParseCodeToTree('foo = 2\n') self.assertEqual('file_input', pytree_utils.NodeName(tree)) self.assertEqual(2, len(tree.children)) self.assertEqual('simple_stmt', pytree_utils.NodeName(tree.children[0])) def testPrintFunctionToTree(self): tree = pytree_utils.ParseCodeToTree( 'print("hello world", file=sys.stderr)\n') self.assertEqual('file_input', pytree_utils.NodeName(tree)) self.assertEqual(2, len(tree.children)) self.assertEqual('simple_stmt', pytree_utils.NodeName(tree.children[0])) def testPrintStatementToTree(self): tree = pytree_utils.ParseCodeToTree('print "hello world"\n') self.assertEqual('file_input', pytree_utils.NodeName(tree)) self.assertEqual(2, len(tree.children)) self.assertEqual('simple_stmt', pytree_utils.NodeName(tree.children[0])) def testClassNotLocal(self): tree = pytree_utils.ParseCodeToTree('class nonlocal: pass\n') self.assertEqual('file_input', pytree_utils.NodeName(tree)) self.assertEqual(2, len(tree.children)) self.assertEqual('classdef', pytree_utils.NodeName(tree.children[0])) class InsertNodesBeforeAfterTest(unittest.TestCase): def _BuildSimpleTree(self): # Builds a simple tree we can play with in the tests. # The tree looks like this: # # suite: # LPAR # LPAR # simple_stmt: # NAME('foo') # lpar1 = pytree.Leaf(token.LPAR, '(') lpar2 = pytree.Leaf(token.LPAR, '(') simple_stmt = pytree.Node(_GRAMMAR_SYMBOL2NUMBER['simple_stmt'], [pytree.Leaf(token.NAME, 'foo')]) return pytree.Node(_GRAMMAR_SYMBOL2NUMBER['suite'], [lpar1, lpar2, simple_stmt]) def _MakeNewNodeRPAR(self): return pytree.Leaf(token.RPAR, ')') def setUp(self): self._simple_tree = self._BuildSimpleTree() def testInsertNodesBefore(self): # Insert before simple_stmt and make sure it went to the right place pytree_utils.InsertNodesBefore([self._MakeNewNodeRPAR()], self._simple_tree.children[2]) self.assertEqual(4, len(self._simple_tree.children)) self.assertEqual('RPAR', pytree_utils.NodeName(self._simple_tree.children[2])) self.assertEqual('simple_stmt', pytree_utils.NodeName(self._simple_tree.children[3])) def testInsertNodesBeforeFirstChild(self): # Insert before the first child of its parent simple_stmt = self._simple_tree.children[2] foo_child = simple_stmt.children[0] pytree_utils.InsertNodesBefore([self._MakeNewNodeRPAR()], foo_child) self.assertEqual(3, len(self._simple_tree.children)) self.assertEqual(2, len(simple_stmt.children)) self.assertEqual('RPAR', pytree_utils.NodeName(simple_stmt.children[0])) self.assertEqual('NAME', pytree_utils.NodeName(simple_stmt.children[1])) def testInsertNodesAfter(self): # Insert after and make sure it went to the right place pytree_utils.InsertNodesAfter([self._MakeNewNodeRPAR()], self._simple_tree.children[2]) self.assertEqual(4, len(self._simple_tree.children)) self.assertEqual('simple_stmt', pytree_utils.NodeName(self._simple_tree.children[2])) self.assertEqual('RPAR', pytree_utils.NodeName(self._simple_tree.children[3])) def testInsertNodesAfterLastChild(self): # Insert after the last child of its parent simple_stmt = self._simple_tree.children[2] foo_child = simple_stmt.children[0] pytree_utils.InsertNodesAfter([self._MakeNewNodeRPAR()], foo_child) self.assertEqual(3, len(self._simple_tree.children)) self.assertEqual(2, len(simple_stmt.children)) self.assertEqual('NAME', pytree_utils.NodeName(simple_stmt.children[0])) self.assertEqual('RPAR', pytree_utils.NodeName(simple_stmt.children[1])) def testInsertNodesWhichHasParent(self): # Try to insert an existing tree node into another place and fail. with self.assertRaises(RuntimeError): pytree_utils.InsertNodesAfter([self._simple_tree.children[1]], self._simple_tree.children[0]) class AnnotationsTest(unittest.TestCase): def setUp(self): self._leaf = pytree.Leaf(token.LPAR, '(') self._node = pytree.Node(_GRAMMAR_SYMBOL2NUMBER['simple_stmt'], [pytree.Leaf(token.NAME, 'foo')]) def testGetWhenNone(self): self.assertIsNone(pytree_utils.GetNodeAnnotation(self._leaf, _FOO)) def testSetWhenNone(self): pytree_utils.SetNodeAnnotation(self._leaf, _FOO, 20) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO), 20) def testSetAgain(self): pytree_utils.SetNodeAnnotation(self._leaf, _FOO, 20) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO), 20) pytree_utils.SetNodeAnnotation(self._leaf, _FOO, 30) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO), 30) def testMultiple(self): pytree_utils.SetNodeAnnotation(self._leaf, _FOO, 20) pytree_utils.SetNodeAnnotation(self._leaf, _FOO1, 1) pytree_utils.SetNodeAnnotation(self._leaf, _FOO2, 2) pytree_utils.SetNodeAnnotation(self._leaf, _FOO3, 3) pytree_utils.SetNodeAnnotation(self._leaf, _FOO4, 4) pytree_utils.SetNodeAnnotation(self._leaf, _FOO5, 5) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO), 20) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO1), 1) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO2), 2) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO3), 3) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO4), 4) self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO5), 5) def testSubtype(self): pytree_utils.AppendNodeAnnotation(self._leaf, pytree_utils.Annotation.SUBTYPE, _FOO) self.assertSetEqual( pytree_utils.GetNodeAnnotation(self._leaf, pytree_utils.Annotation.SUBTYPE), {_FOO}) pytree_utils.RemoveSubtypeAnnotation(self._leaf, _FOO) self.assertSetEqual( pytree_utils.GetNodeAnnotation(self._leaf, pytree_utils.Annotation.SUBTYPE), set()) def testSetOnNode(self): pytree_utils.SetNodeAnnotation(self._node, _FOO, 20) self.assertEqual(pytree_utils.GetNodeAnnotation(self._node, _FOO), 20) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/pytree_visitor_test.py000066400000000000000000000077511304174360200212710ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.pytree_visitor.""" import unittest from yapf.yapflib import py3compat from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor class _NodeNameCollector(pytree_visitor.PyTreeVisitor): """A tree visitor that collects the names of all tree nodes into a list. Attributes: all_node_names: collected list of the names, available when the traversal is over. name_node_values: collects a list of NAME leaves (in addition to those going into all_node_names). """ def __init__(self): self.all_node_names = [] self.name_node_values = [] def DefaultNodeVisit(self, node): self.all_node_names.append(pytree_utils.NodeName(node)) super(_NodeNameCollector, self).DefaultNodeVisit(node) def DefaultLeafVisit(self, leaf): self.all_node_names.append(pytree_utils.NodeName(leaf)) def Visit_NAME(self, leaf): self.name_node_values.append(leaf.value) self.DefaultLeafVisit(leaf) _VISITOR_TEST_SIMPLE_CODE = r""" foo = bar baz = x """ _VISITOR_TEST_NESTED_CODE = r""" if x: if y: return z """ class PytreeVisitorTest(unittest.TestCase): def testCollectAllNodeNamesSimpleCode(self): tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) collector = _NodeNameCollector() collector.Visit(tree) expected_names = [ 'file_input', 'simple_stmt', 'expr_stmt', 'NAME', 'EQUAL', 'NAME', 'NEWLINE', 'simple_stmt', 'expr_stmt', 'NAME', 'EQUAL', 'NAME', 'NEWLINE', 'ENDMARKER', ] # yapf: disable self.assertEqual(expected_names, collector.all_node_names) expected_name_node_values = ['foo', 'bar', 'baz', 'x'] self.assertEqual(expected_name_node_values, collector.name_node_values) def testCollectAllNodeNamesNestedCode(self): tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_NESTED_CODE) collector = _NodeNameCollector() collector.Visit(tree) expected_names = [ 'file_input', 'if_stmt', 'NAME', 'NAME', 'COLON', 'suite', 'NEWLINE', 'INDENT', 'if_stmt', 'NAME', 'NAME', 'COLON', 'suite', 'NEWLINE', 'INDENT', 'simple_stmt', 'return_stmt', 'NAME', 'NAME', 'NEWLINE', 'DEDENT', 'DEDENT', 'ENDMARKER', ] # yapf: disable self.assertEqual(expected_names, collector.all_node_names) expected_name_node_values = ['if', 'x', 'if', 'y', 'return', 'z'] self.assertEqual(expected_name_node_values, collector.name_node_values) def testDumper(self): # PyTreeDumper is mainly a debugging utility, so only do basic sanity # checking. tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) stream = py3compat.StringIO() pytree_visitor.PyTreeDumper(target_stream=stream).Visit(tree) dump_output = stream.getvalue() self.assertIn('file_input [3 children]', dump_output) self.assertIn("NAME(Leaf(NAME, 'foo'))", dump_output) self.assertIn("EQUAL(Leaf(EQUAL, '='))", dump_output) def testDumpPyTree(self): # Similar sanity checking for the convenience wrapper DumpPyTree tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) stream = py3compat.StringIO() pytree_visitor.DumpPyTree(tree, target_stream=stream) dump_output = stream.getvalue() self.assertIn('file_input [3 children]', dump_output) self.assertIn("NAME(Leaf(NAME, 'foo'))", dump_output) self.assertIn("EQUAL(Leaf(EQUAL, '='))", dump_output) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_basic_test.py000066400000000000000000002100361304174360200216650ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Basic tests for yapf.reformatter.""" import textwrap import unittest from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper class BasicReformatterTest(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreateChromiumStyle()) def testSimple(self): unformatted_code = textwrap.dedent("""\ if a+b: pass """) expected_formatted_code = textwrap.dedent("""\ if a + b: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSimpleFunctions(self): unformatted_code = textwrap.dedent("""\ def g(): pass def f(): pass """) expected_formatted_code = textwrap.dedent("""\ def g(): pass def f(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSimpleFunctionsWithTrailingComments(self): unformatted_code = textwrap.dedent("""\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def f( # Intermediate comment ): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) expected_formatted_code = textwrap.dedent("""\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def f( # Intermediate comment ): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testBlankLinesAtEndOfFile(self): unformatted_code = textwrap.dedent("""\ def foobar(): # foo pass """) expected_formatted_code = textwrap.dedent("""\ def foobar(): # foo pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ x = { 'a':37,'b':42, 'c':927} """) expected_formatted_code = textwrap.dedent("""\ x = {'a': 37, 'b': 42, 'c': 927} """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testMultipleUgliness(self): unformatted_code = textwrap.dedent("""\ x = { 'a':37,'b':42, 'c':927} y = 'hello ''world' z = 'hello '+'world' a = 'hello {}'.format('world') class foo ( object ): def f (self ): return 37*-+2 def g(self, x,y=42): return y def f ( a ) : return 37+-+a[42-x : y**3] """) expected_formatted_code = textwrap.dedent("""\ x = {'a': 37, 'b': 42, 'c': 927} y = 'hello ' 'world' z = 'hello ' + 'world' a = 'hello {}'.format('world') class foo(object): def f(self): return 37 * -+2 def g(self, x, y=42): return y def f(a): return 37 + -+a[42 - x:y**3] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testComments(self): unformatted_code = textwrap.dedent("""\ class Foo(object): pass # Attached comment class Bar(object): pass global_assignment = 42 # Comment attached to class with decorator. # Comment attached to class with decorator. @noop @noop class Baz(object): pass # Intermediate comment class Qux(object): pass """) expected_formatted_code = textwrap.dedent("""\ class Foo(object): pass # Attached comment class Bar(object): pass global_assignment = 42 # Comment attached to class with decorator. # Comment attached to class with decorator. @noop @noop class Baz(object): pass # Intermediate comment class Qux(object): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSingleComment(self): code = textwrap.dedent("""\ # Thing 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentsInDataLiteral(self): code = textwrap.dedent("""\ def f(): return collections.OrderedDict({ # First comment. 'fnord': 37, # Second comment. # Continuation of second comment. 'bork': 42, # Ending comment. }) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testEndingWhitespaceAfterSimpleStatement(self): code = textwrap.dedent("""\ import foo as bar # Thing 1 # Thing 2 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDocstrings(self): unformatted_code = textwrap.dedent('''\ u"""Module-level docstring.""" import os class Foo(object): """Class-level docstring.""" # A comment for qux. def qux(self): """Function-level docstring. A multiline function docstring. """ print('hello {}'.format('world')) return 42 ''') expected_formatted_code = textwrap.dedent('''\ u"""Module-level docstring.""" import os class Foo(object): """Class-level docstring.""" # A comment for qux. def qux(self): """Function-level docstring. A multiline function docstring. """ print('hello {}'.format('world')) return 42 ''') uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDocstringAndMultilineComment(self): unformatted_code = textwrap.dedent('''\ """Hello world""" # A multiline # comment class bar(object): """class docstring""" # class multiline # comment def foo(self): """Another docstring.""" # Another multiline # comment pass ''') expected_formatted_code = textwrap.dedent('''\ """Hello world""" # A multiline # comment class bar(object): """class docstring""" # class multiline # comment def foo(self): """Another docstring.""" # Another multiline # comment pass ''') uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testMultilineDocstringAndMultilineComment(self): unformatted_code = textwrap.dedent('''\ """Hello world RIP Dennis Richie. """ # A multiline # comment class bar(object): """class docstring A classy class. """ # class multiline # comment def foo(self): """Another docstring. A functional function. """ # Another multiline # comment pass ''') expected_formatted_code = textwrap.dedent('''\ """Hello world RIP Dennis Richie. """ # A multiline # comment class bar(object): """class docstring A classy class. """ # class multiline # comment def foo(self): """Another docstring. A functional function. """ # Another multiline # comment pass ''') uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testTupleCommaBeforeLastParen(self): unformatted_code = textwrap.dedent("""\ a = ( 1, ) """) expected_formatted_code = textwrap.dedent("""\ a = (1,) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNoBreakOutsideOfBracket(self): # FIXME(morbo): How this is formatted is not correct. But it's syntactically # correct. unformatted_code = textwrap.dedent("""\ def f(): assert port >= minimum, \ 'Unexpected port %d when minimum was %d.' % (port, minimum) """) expected_formatted_code = textwrap.dedent("""\ def f(): assert port >= minimum, 'Unexpected port %d when minimum was %d.' % (port, minimum) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testBlankLinesBeforeDecorators(self): unformatted_code = textwrap.dedent("""\ @foo() class A(object): @bar() @baz() def x(self): pass """) expected_formatted_code = textwrap.dedent("""\ @foo() class A(object): @bar() @baz() def x(self): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testCommentBetweenDecorators(self): unformatted_code = textwrap.dedent("""\ @foo() # frob @bar def x (self): pass """) expected_formatted_code = textwrap.dedent("""\ @foo() # frob @bar def x(self): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testListComprehension(self): unformatted_code = textwrap.dedent("""\ def given(y): [k for k in () if k in y] """) expected_formatted_code = textwrap.dedent("""\ def given(y): [k for k in () if k in y] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testOpeningAndClosingBrackets(self): unformatted_code = textwrap.dedent("""\ foo( ( 1, 2, 3, ) ) """) expected_formatted_code = textwrap.dedent("""\ foo(( 1, 2, 3,)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSingleLineFunctions(self): unformatted_code = textwrap.dedent("""\ def foo(): return 42 """) expected_formatted_code = textwrap.dedent("""\ def foo(): return 42 """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNoQueueSeletionInMiddleOfLine(self): # If the queue isn't properly consttructed, then a token in the middle of # the line may be selected as the one with least penalty. The tokens after # that one are then splatted at the end of the line with no formatting. # FIXME(morbo): The formatting here isn't ideal. unformatted_code = textwrap.dedent("""\ find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in \ node.child) + " >" """) expected_formatted_code = textwrap.dedent("""\ find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >" """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNoSpacesBetweenSubscriptsAndCalls(self): unformatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc() [42] (a, 2) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc()[42](a, 2) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): # Unary operator. unformatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc[ -1 ]( -42 ) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc[-1](-42) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) # Varargs and kwargs. unformatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc( *varargs ) aaaaaaaaaa = bbbbbbbb.ccccccccc( **kwargs ) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc(*varargs) aaaaaaaaaa = bbbbbbbb.ccccccccc(**kwargs) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testMultilineCommentReformatted(self): unformatted_code = textwrap.dedent("""\ if True: # This is a multiline # comment. pass """) expected_formatted_code = textwrap.dedent("""\ if True: # This is a multiline # comment. pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDictionaryMakerFormatting(self): unformatted_code = textwrap.dedent("""\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', 'del_stmt': 'pass_stmt', lambda: 'break_stmt': 'continue_stmt', 'return_stmt': 'raise_stmt', 'yield_stmt': 'import_stmt', lambda: 'global_stmt': 'exec_stmt', 'assert_stmt': 'if_stmt', 'while_stmt': 'for_stmt', }) """) expected_formatted_code = textwrap.dedent("""\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', 'del_stmt': 'pass_stmt', lambda: 'break_stmt': 'continue_stmt', 'return_stmt': 'raise_stmt', 'yield_stmt': 'import_stmt', lambda: 'global_stmt': 'exec_stmt', 'assert_stmt': 'if_stmt', 'while_stmt': 'for_stmt', }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSimpleMultilineCode(self): unformatted_code = textwrap.dedent("""\ if True: aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, \ xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, \ xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) """) expected_formatted_code = textwrap.dedent("""\ if True: aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testMultilineComment(self): code = textwrap.dedent("""\ if Foo: # Hello world # Yo man. # Yo man. # Yo man. # Yo man. a = 42 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testMultilineString(self): code = textwrap.dedent("""\ code = textwrap.dedent('''\ if Foo: # Hello world # Yo man. # Yo man. # Yo man. # Yo man. a = 42 ''') """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent('''\ def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """+despot["Nicholas"]+"""
Minion: """+serf["Dmitri"]+"""
Residence: """+palace["Winter"]+"""
""" ''') expected_formatted_code = textwrap.dedent('''\ def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """ + despot["Nicholas"] + """
Minion: """ + serf["Dmitri"] + """
Residence: """ + palace["Winter"] + """
""" ''') uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSimpleMultilineWithComments(self): code = textwrap.dedent("""\ if ( # This is the first comment a and # This is the second comment # This is the third comment b): # A trailing comment # Whoa! A normal comment!! pass # Another trailing comment """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testMatchingParenSplittingMatching(self): unformatted_code = textwrap.dedent("""\ def f(): raise RuntimeError('unable to find insertion point for target node', (target,)) """) expected_formatted_code = textwrap.dedent("""\ def f(): raise RuntimeError('unable to find insertion point for target node', (target,)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testContinuationIndent(self): unformatted_code = textwrap.dedent('''\ class F: def _ProcessArgLists(self, node): """Common method for processing argument lists.""" for child in node.children: if isinstance(child, pytree.Leaf): self._SetTokenSubtype( child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get( child.value, format_token.Subtype.NONE)) ''') expected_formatted_code = textwrap.dedent('''\ class F: def _ProcessArgLists(self, node): """Common method for processing argument lists.""" for child in node.children: if isinstance(child, pytree.Leaf): self._SetTokenSubtype( child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get(child.value, format_token.Subtype.NONE)) ''') uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testTrailingCommaAndBracket(self): unformatted_code = textwrap.dedent('''\ a = { 42, } b = ( 42, ) c = [ 42, ] ''') expected_formatted_code = textwrap.dedent('''\ a = {42,} b = (42,) c = [42,] ''') uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testI18n(self): code = textwrap.dedent("""\ N_('Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world.') # A comment is here. """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ foo('Fake function call') #. Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testI18nCommentsInDataLiteral(self): code = textwrap.dedent("""\ def f(): return collections.OrderedDict({ #. First i18n comment. 'bork': 'foo', #. Second i18n comment. 'snork': 'bar#.*=\\\\0', }) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testClosingBracketIndent(self): code = textwrap.dedent('''\ def f(): def g(): while ( xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): pass ''') uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testClosingBracketsInlinedInCall(self): unformatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): self.aaaaaaaa = xxxxxxxxxxxxxxxxxxx.yyyyyyyyyyyyy( self.cccccc.ddddddddd.eeeeeeee, options={ "forkforkfork": 1, "borkborkbork": 2, "corkcorkcork": 3, "horkhorkhork": 4, "porkporkpork": 5, }) """) expected_formatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): self.aaaaaaaa = xxxxxxxxxxxxxxxxxxx.yyyyyyyyyyyyy( self.cccccc.ddddddddd.eeeeeeee, options={ "forkforkfork": 1, "borkborkbork": 2, "corkcorkcork": 3, "horkhorkhork": 4, "porkporkpork": 5, }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testLineWrapInForExpression(self): code = textwrap.dedent("""\ class A: def x(self, node, name, n=1): for i, child in enumerate( itertools.ifilter(lambda c: pytree_utils.NodeName(c) == name, node.pre_order())): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testFunctionCallContinuationLine(self): code = textwrap.dedent("""\ class foo: def bar(self, node, name, n=1): if True: if True: return [(aaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb( cccc, ddddddddddddddddddddddddddddddddddddd))] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testI18nNonFormatting(self): code = textwrap.dedent("""\ class F(object): def __init__(self, fieldname, #. Error message indicating an invalid e-mail address. message=N_('Please check your email address.'), **kwargs): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoSpaceBetweenUnaryOpAndOpeningParen(self): code = textwrap.dedent("""\ if ~(a or b): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentBeforeFuncDef(self): code = textwrap.dedent("""\ class Foo(object): a = 42 # This is a comment. def __init__(self, xxxxxxx, yyyyy=0, zzzzzzz=None, aaaaaaaaaaaaaaaaaa=False, bbbbbbbbbbbbbbb=False): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testExcessLineCountWithDefaultKeywords(self): unformatted_code = textwrap.dedent("""\ class Fnord(object): def Moo(self): aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb( ccccccccccccc=ccccccccccccc, ddddddd=ddddddd, eeee=eeee, fffff=fffff, ggggggg=ggggggg, hhhhhhhhhhhhh=hhhhhhhhhhhhh, iiiiiii=iiiiiiiiiiiiii) """) expected_formatted_code = textwrap.dedent("""\ class Fnord(object): def Moo(self): aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb( ccccccccccccc=ccccccccccccc, ddddddd=ddddddd, eeee=eeee, fffff=fffff, ggggggg=ggggggg, hhhhhhhhhhhhh=hhhhhhhhhhhhh, iiiiiii=iiiiiiiiiiiiii) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSpaceAfterNotOperator(self): code = textwrap.dedent("""\ if not (this and that): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoPenaltySplitting(self): code = textwrap.dedent("""\ def f(): if True: if True: python_files.extend( os.path.join(filename, f) for f in os.listdir(filename) if IsPythonFile(os.path.join(filename, f))) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testExpressionPenalties(self): code = textwrap.dedent("""\ def f(): if ((left.value == '(' and right.value == ')') or (left.value == '[' and right.value == ']') or (left.value == '{' and right.value == '}')): return False """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testLineDepthOfSingleLineStatement(self): unformatted_code = textwrap.dedent("""\ while True: continue for x in range(3): continue try: a = 42 except: b = 42 with open(a) as fd: a = fd.read() """) expected_formatted_code = textwrap.dedent("""\ while True: continue for x in range(3): continue try: a = 42 except: b = 42 with open(a) as fd: a = fd.read() """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplitListWithTerminatingComma(self): unformatted_code = textwrap.dedent("""\ FOO = ['bar', 'baz', 'mux', 'qux', 'quux', 'quuux', 'quuuux', 'quuuuux', 'quuuuuux', 'quuuuuuux', lambda a, b: 37,] """) expected_formatted_code = textwrap.dedent("""\ FOO = [ 'bar', 'baz', 'mux', 'qux', 'quux', 'quuux', 'quuuux', 'quuuuux', 'quuuuuux', 'quuuuuuux', lambda a, b: 37, ] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplitListWithInterspersedComments(self): code = textwrap.dedent("""\ FOO = [ 'bar', # bar 'baz', # baz 'mux', # mux 'qux', # qux 'quux', # quux 'quuux', # quuux 'quuuux', # quuuux 'quuuuux', # quuuuux 'quuuuuux', # quuuuuux 'quuuuuuux', # quuuuuuux lambda a, b: 37 # lambda ] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testRelativeImportStatements(self): code = textwrap.dedent("""\ from ... import bork """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testSingleLineList(self): # A list on a single line should prefer to remain contiguous. unformatted_code = textwrap.dedent("""\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", ".............................................." ) """) expected_formatted_code = textwrap.dedent("""\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", "..............................................") """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testBlankLinesBeforeFunctionsNotInColumnZero(self): unformatted_code = textwrap.dedent("""\ import signal try: signal.SIGALRM # .................................................................. # ............................................................... def timeout(seconds=1): pass except: pass """) expected_formatted_code = textwrap.dedent("""\ import signal try: signal.SIGALRM # .................................................................. # ............................................................... def timeout(seconds=1): pass except: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNoKeywordArgumentBreakage(self): code = textwrap.dedent("""\ class A(object): def b(self): if self.aaaaaaaaaaaaaaaaaaaa not in self.bbbbbbbbbb( cccccccccccccccccccc=True): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testTrailerOnSingleLine(self): code = textwrap.dedent("""\ urlpatterns = patterns('', url(r'^$', 'homepage_view'), url(r'^/login/$', 'login_view'), url(r'^/login/$', 'logout_view'), url(r'^/user/(?P\\w+)/$', 'profile_view')) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testIfConditionalParens(self): code = textwrap.dedent("""\ class Foo: def bar(): if True: if (child.type == grammar_token.NAME and child.value in substatement_names): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testContinuationMarkers(self): code = textwrap.dedent("""\ text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. "\\ "Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur "\\ "ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis "\\ "sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. "\\ "Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet" """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ from __future__ import nested_scopes, generators, division, absolute_import, with_statement, \\ print_function, unicode_literals """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ if aaaaaaaaa == 42 and bbbbbbbbbbbbbb == 42 and \\ cccccccc == 42: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentsWithContinuationMarkers(self): code = textwrap.dedent("""\ def fn(arg): v = fn2(key1=True, #c1 key2=arg)\\ .fn3() """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testEmptyContainers(self): code = textwrap.dedent("""\ flags.DEFINE_list( 'output_dirs', [], 'Lorem ipsum dolor sit amet, consetetur adipiscing elit. Donec a diam lectus. ' 'Sed sit amet ipsum mauris. Maecenas congue.') """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testSplitStringsIfSurroundedByParens(self): unformatted_code = textwrap.dedent("""\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') """) expected_formatted_code = textwrap.dedent("""\ a = foo.bar({ 'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42] } + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' \ 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' \ 'ddddddddddddddddddddddddddddd' """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testMultilineShebang(self): code = textwrap.dedent("""\ #!/bin/sh if "true" : '''\' then export FOO=123 exec /usr/bin/env python "$0" "$@" exit 127 fi ''' import os assert os.environ['FOO'] == '123' """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoSplittingAroundTermOperators(self): code = textwrap.dedent("""\ a_very_long_function_call_yada_yada_etc_etc_etc(long_arg1, long_arg2 / long_arg3) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoSplittingWithinSubscriptList(self): code = textwrap.dedent("""\ somequitelongvariablename.somemember[(a, b)] = { 'somelongkey': 1, 'someotherlongkey': 2 } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testExcessCharacters(self): code = textwrap.dedent("""\ class foo: def bar(self): self.write(s=[ '%s%s %s' % ('many of really', 'long strings', '+ just makes up 81') ]) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDictSetGenerator(self): code = textwrap.dedent("""\ foo = { variable: 'hello world. How are you today?' for variable in fnord if variable != 37 } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testUnaryOpInDictionaryValue(self): code = textwrap.dedent("""\ beta = "123" test = {'alpha': beta[-1]} print(beta[-1]) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testUnaryNotOperator(self): code = textwrap.dedent("""\ if True: if True: if True: if True: remote_checksum = self.get_checksum(conn, tmp, dest, inject, not directory_prepended, source) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testRelaxArraySubscriptAffinity(self): code = textwrap.dedent("""\ class A(object): def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): if True: if True: if True: if True: if row[4] is None or row[5] is None: bbbbbbbbbbbbb['..............'] = row[5] if row[ 5] is not None else 5 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testFunctionCallInDict(self): code = "a = {'a': b(c=d, **e)}\n" uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testFunctionCallInNestedDict(self): code = "a = {'a': {'a': {'a': b(c=d, **e)}}}\n" uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testUnbreakableNot(self): code = textwrap.dedent("""\ def test(): if not "Foooooooooooooooooooooooooooooo" or "Foooooooooooooooooooooooooooooo" == "Foooooooooooooooooooooooooooooo": pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testSplitListWithComment(self): code = textwrap.dedent("""\ a = [ 'a', 'b', 'c' # hello world ] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testOverColumnLimit(self): unformatted_code = textwrap.dedent("""\ class Test: def testSomething(self): expected = { ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', } """) expected_formatted_code = textwrap.dedent("""\ class Test: def testSomething(self): expected = { ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testEndingComment(self): code = textwrap.dedent("""\ a = f( a="something", b="something requiring comment which is quite long", # comment about b (pushes line over 79) c="something else, about which comment doesn't make sense") """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testContinuationSpaceRetention(self): code = textwrap.dedent("""\ def fn(): return module \\ .method(Object(data, fn2(arg) )) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testIfExpressionWithFunctionCall(self): code = textwrap.dedent("""\ if x or z.y(a, c, aaaaaaaaaaaaaaaaaaaaa=aaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbb=bbbbbbbbbbbbbbbbbb): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testUnformattedAfterMultilineString(self): code = textwrap.dedent("""\ def foo(): com_text = \\ ''' TEST ''' % (input_fname, output_fname) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoSpacesAroundKeywordDefaultValues(self): code = textwrap.dedent("""\ sources = { 'json': request.get_json(silent=True) or {}, 'json2': request.get_json(silent=True), } json = request.get_json(silent=True) or {} """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoSplittingBeforeEndingSubscriptBracket(self): unformatted_code = textwrap.dedent("""\ if True: if True: status = cf.describe_stacks(StackName=stackname)[u'Stacks'][0][u'StackStatus'] """) expected_formatted_code = textwrap.dedent("""\ if True: if True: status = cf.describe_stacks( StackName=stackname)[u'Stacks'][0][u'StackStatus'] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNoSplittingOnSingleArgument(self): unformatted_code = textwrap.dedent("""\ xxxxxxxxxxxxxx = (re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(1)) xxxxxxxxxxxxxx = (re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(a.b) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(c.d)) """) expected_formatted_code = textwrap.dedent("""\ xxxxxxxxxxxxxx = ( re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(1)) xxxxxxxxxxxxxx = ( re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(a.b) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(c.d)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingArraysSensibly(self): unformatted_code = textwrap.dedent("""\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list['bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',') aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list('bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') """) expected_formatted_code = textwrap.dedent("""\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list[ 'bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',') aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list( 'bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testComprehensionForAndIf(self): unformatted_code = textwrap.dedent("""\ class f: def __repr__(self): tokens_repr = ','.join(['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens]) """) expected_formatted_code = textwrap.dedent("""\ class f: def __repr__(self): tokens_repr = ','.join( ['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens]) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testFunctionCallArguments(self): unformatted_code = textwrap.dedent("""\ def f(): if True: pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True), ancestor_at_indent) pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True)) """) expected_formatted_code = textwrap.dedent("""\ def f(): if True: pytree_utils.InsertNodesBefore( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True), ancestor_at_indent) pytree_utils.InsertNodesBefore( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testBinaryOperators(self): unformatted_code = textwrap.dedent("""\ a = b ** 37 c = (20 ** -3) / (_GRID_ROWS ** (code_length - 10)) """) expected_formatted_code = textwrap.dedent("""\ a = b**37 c = (20**-3) / (_GRID_ROWS**(code_length - 10)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ def f(): if True: if (self.stack[-1].split_before_closing_bracket and # FIXME(morbo): Use the 'matching_bracket' instead of this. # FIXME(morbo): Don't forget about tuples! current.value in ']}'): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testContiguousList(self): code = textwrap.dedent("""\ [retval1, retval2] = a_very_long_function(argument_1, argument2, argument_3, argument_4) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testArgsAndKwargsFormatting(self): code = textwrap.dedent("""\ a(a=aaaaaaaaaaaaaaaaaaaaa, b=aaaaaaaaaaaaaaaaaaaaaaaa, c=aaaaaaaaaaaaaaaaaa, *d, **e) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testCommentColumnLimitOverflow(self): code = textwrap.dedent("""\ def f(): if True: TaskManager.get_tags = MagicMock( name='get_tags_mock', return_value=[157031694470475], # side_effect=[(157031694470475), (157031694470475),], ) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testMultilineLambdas(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: chromium, allow_multiline_lambdas: true}')) unformatted_code = textwrap.dedent("""\ class SomeClass(object): do_something = True def succeeded(self, dddddddddddddd): d = defer.succeed(None) if self.do_something: d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccc(dddddddddddddd)) return d """) expected_formatted_code = textwrap.dedent("""\ class SomeClass(object): do_something = True def succeeded(self, dddddddddddddd): d = defer.succeed(None) if self.do_something: d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb. cccccccccccccccccccccccccccccccc(dddddddddddddd)) return d """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreateChromiumStyle()) def testStableDictionaryFormatting(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, indent_width: 2, ' 'continuation_indent_width: 4, indent_dictionary_value: True}')) code = textwrap.dedent("""\ class A(object): def method(self): filters = { 'expressions': [{ 'field': { 'search_field': { 'user_field': 'latest_party__number_of_guests' }, } }] } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(code, reformatted_code) uwlines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(code, reformatted_code) finally: style.SetGlobalStyle(style.CreateChromiumStyle()) def testDontSplitKeywordValueArguments(self): unformatted_code = textwrap.dedent("""\ def mark_game_scored(gid): _connect.execute(_games.update().where(_games.c.gid == gid).values( scored=True)) """) expected_formatted_code = textwrap.dedent("""\ def mark_game_scored(gid): _connect.execute( _games.update().where(_games.c.gid == gid).values(scored=True)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDontAddBlankLineAfterMultilineString(self): code = textwrap.dedent("""\ query = '''SELECT id FROM table WHERE day in {}''' days = ",".join(days) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testFormattingListComprehensions(self): code = textwrap.dedent("""\ def a(): if True: if True: if True: columns = [ x for x, y in self._heap_this_is_very_long if x.route[0] == choice ] self._heap = [x for x in self._heap if x.route and x.route[0] == choice] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoSplittingWhenBinPacking(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, indent_width: 2, ' 'continuation_indent_width: 4, indent_dictionary_value: True, ' 'dedent_closing_brackets: True, ' 'split_before_named_assigns: False}')) code = textwrap.dedent("""\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4, ) a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4 ) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(code, reformatted_code) uwlines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(code, reformatted_code) finally: style.SetGlobalStyle(style.CreateChromiumStyle()) def testNotSplittingAfterSubscript(self): unformatted_code = textwrap.dedent("""\ if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b(c == d[ 'eeeeee']).ffffff(): pass """) expected_formatted_code = textwrap.dedent("""\ if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b( c == d['eeeeee']).ffffff(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingOneArgumentList(self): unformatted_code = textwrap.dedent("""\ def _(): if True: if True: if True: if True: if True: boxes[id_] = np.concatenate((points.min(axis=0), qoints.max(axis=0))) """) expected_formatted_code = textwrap.dedent("""\ def _(): if True: if True: if True: if True: if True: boxes[id_] = np.concatenate( (points.min(axis=0), qoints.max(axis=0))) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingBeforeFirstElementListArgument(self): unformatted_code = textwrap.dedent("""\ class _(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): if True: if True: if True: return cls._create_investigation_result( ( clue for clue in combination if not clue == Verifier.UNMATCHED ), constraints, InvestigationResult.OR ) """) expected_formatted_code = textwrap.dedent("""\ class _(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): if True: if True: if True: return cls._create_investigation_result( (clue for clue in combination if not clue == Verifier.UNMATCHED), constraints, InvestigationResult.OR) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingArgumentsTerminatedByComma(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: chromium, ' 'split_arguments_when_comma_terminated: True}')) unformatted_code = textwrap.dedent("""\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3,) a_very_long_function_name(long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4) a_very_long_function_name(long_argument_name_1, long_argument_name_2, long_argument_name_3, long_argument_name_4,) r =f0 (1, 2,3,) """) expected_formatted_code = textwrap.dedent("""\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name( argument_name_1=1, argument_name_2=2, argument_name_3=3, ) a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4) a_very_long_function_name( long_argument_name_1, long_argument_name_2, long_argument_name_3, long_argument_name_4, ) r = f0( 1, 2, 3, ) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(expected_formatted_code, reformatted_code) uwlines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(expected_formatted_code, reformatted_code) finally: style.SetGlobalStyle(style.CreateChromiumStyle()) def testImportAsList(self): code = textwrap.dedent("""\ from toto import titi, tata, tutu # noqa from toto import titi, tata, tutu from toto import (titi, tata, tutu) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDictionaryValuesOnOwnLines(self): unformatted_code = textwrap.dedent("""\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb': Check('YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY', '=', True), 'ccccccccccccccc': Check('XXXXXXXXXXXXXXXXXXX', '!=', 'SUSPENDED'), 'dddddddddddddddddddddddddddddd': Check('WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW', '=', False), 'eeeeeeeeeeeeeeeeeeeeeeeeeeeee': Check('VVVVVVVVVVVVVVVVVVVVVVVVVVVVVV', '=', False), 'ffffffffffffffffffffffffff': Check('UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU', '=', True), 'ggggggggggggggggg': Check('TTTTTTTTTTTTTTTTTTTTTTTTTTTTTT', '=', True), 'hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh': Check('SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS', '=', True), 'iiiiiiiiiiiiiiiiiiiiiiii': Check('RRRRRRRRRRRRRRRRRRRRRRRRRRR', '=', True), 'jjjjjjjjjjjjjjjjjjjjjjjjjj': Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } """) expected_formatted_code = textwrap.dedent("""\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb': Check('YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY', '=', True), 'ccccccccccccccc': Check('XXXXXXXXXXXXXXXXXXX', '!=', 'SUSPENDED'), 'dddddddddddddddddddddddddddddd': Check('WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW', '=', False), 'eeeeeeeeeeeeeeeeeeeeeeeeeeeee': Check('VVVVVVVVVVVVVVVVVVVVVVVVVVVVVV', '=', False), 'ffffffffffffffffffffffffff': Check('UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU', '=', True), 'ggggggggggggggggg': Check('TTTTTTTTTTTTTTTTTTTTTTTTTTTTTT', '=', True), 'hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh': Check('SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS', '=', True), 'iiiiiiiiiiiiiiiiiiiiiiii': Check('RRRRRRRRRRRRRRRRRRRRRRRRRRR', '=', True), 'jjjjjjjjjjjjjjjjjjjjjjjjjj': Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDictionaryOnOwnLine(self): unformatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={ 'a': 'b' }, branch_key=branch.key, collection_key=collection.key) """) expected_formatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={'a': 'b'}, branch_key=branch.key, collection_key=collection.key) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={ 'a': 'b' }, branch_key=branch.key, collection_key=collection.key, collection_key2=collection.key2) """) expected_formatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={'a': 'b'}, branch_key=branch.key, collection_key=collection.key, collection_key2=collection.key2) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNestedListsInDictionary(self): unformatted_code = textwrap.dedent("""\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ('^7913', # AAAAAAAAAAAAAA. ), 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': ('^6242', # BBBBBBBBBBBBBBB. ), 'vvvvvvvvvvvvvvvvvvv': ('^27959', # CCCCCCCCCCCCCCCCCC. '^19746', # DDDDDDDDDDDDDDDDDDDDDDD. '^22907', # EEEEEEEEEEEEEEEEEEEEEEEE. '^21098', # FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF. '^22826', # GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG. '^22769', # HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH. '^22935', # IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII. '^3982', # JJJJJJJJJJJJJ. ), 'uuuuuuuuuuuu': ('^19745', # LLLLLLLLLLLLLLLLLLLLLLLLLL. '^21324', # MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM. '^22831', # NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN. '^17081', # OOOOOOOOOOOOOOOOOOOOO. ), 'eeeeeeeeeeeeee': ( '^9416', # Reporter email. Not necessarily the reporter. '^^3', # This appears to be the raw email field. ), 'cccccccccc': ('^21109', # PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP. ), } """) expected_formatted_code = textwrap.dedent("""\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ( '^7913', # AAAAAAAAAAAAAA. ), 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': ( '^6242', # BBBBBBBBBBBBBBB. ), 'vvvvvvvvvvvvvvvvvvv': ( '^27959', # CCCCCCCCCCCCCCCCCC. '^19746', # DDDDDDDDDDDDDDDDDDDDDDD. '^22907', # EEEEEEEEEEEEEEEEEEEEEEEE. '^21098', # FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF. '^22826', # GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG. '^22769', # HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH. '^22935', # IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII. '^3982', # JJJJJJJJJJJJJ. ), 'uuuuuuuuuuuu': ( '^19745', # LLLLLLLLLLLLLLLLLLLLLLLLLL. '^21324', # MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM. '^22831', # NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN. '^17081', # OOOOOOOOOOOOOOOOOOOOO. ), 'eeeeeeeeeeeeee': ( '^9416', # Reporter email. Not necessarily the reporter. '^^3', # This appears to be the raw email field. ), 'cccccccccc': ( '^21109', # PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP. ), } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testNestedDictionary(self): unformatted_code = textwrap.dedent("""\ class _(): def _(): breadcrumbs = [{'name': 'Admin', 'url': url_for(".home")}, {'title': title},] breadcrumbs = [{'name': 'Admin', 'url': url_for(".home")}, {'title': title}] """) expected_formatted_code = textwrap.dedent("""\ class _(): def _(): breadcrumbs = [ { 'name': 'Admin', 'url': url_for(".home") }, { 'title': title }, ] breadcrumbs = [{'name': 'Admin', 'url': url_for(".home")}, {'title': title}] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDictionaryElementsOnOneLine(self): code = textwrap.dedent("""\ class _(): @mock.patch.dict( os.environ, {'HTTP_' + xsrf._XSRF_TOKEN_HEADER.replace('-', '_'): 'atoken'}) def _(): pass AAAAAAAAAAAAAAAAAAAAAAAA = { Environment.XXXXXXXXXX: 'some text more text even more tex', Environment.YYYYYYY: 'some text more text even more text yet ag', Environment.ZZZZZZZZZZZ: 'some text more text even mor etext yet again tex', } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNotInParams(self): unformatted_code = textwrap.dedent("""\ list("a long line to break the line. a long line to break the brk a long lin", not True) """) expected_code = textwrap.dedent("""\ list("a long line to break the line. a long line to break the brk a long lin", not True) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertEqual(expected_code, reformatter.Reformat(uwlines)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_buganizer_test.py000066400000000000000000001464231304174360200226020ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Buganizer tests for yapf.reformatter.""" import textwrap import unittest from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper class BuganizerFixes(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreateChromiumStyle()) def testB33842726(self): unformatted_code = textwrap.dedent("""\ class _(): def _(): hints.append(('hg tag -f -l -r %s %s # %s' % (short(ctx.node( )), candidatetag, firstline))[:78]) """) expected_formatted_code = textwrap.dedent("""\ class _(): def _(): hints.append(('hg tag -f -l -r %s %s # %s' % (short(ctx.node()), candidatetag, firstline))[:78]) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB32931780(self): unformatted_code = textwrap.dedent("""\ environments = { 'prod': { # this is a comment before the first entry. 'entry one': 'an entry.', # this is the comment before the second entry. 'entry number 2.': 'something', # this is the comment before the third entry and it's a doozy. So big! 'who': 'allin', # This is an entry that has a dictionary in it. It's ugly 'something': { 'page': ['this-is-a-page@xxxxxxxx.com', 'something-for-eml@xxxxxx.com'], 'bug': ['bugs-go-here5300@xxxxxx.com'], 'email': ['sometypeof-email@xxxxxx.com'], }, # a short comment 'yolo!!!!!': 'another-email-address@xxxxxx.com', # this entry has an implicit string concatenation 'implicit': 'https://this-is-very-long.url-addr.com/' '?something=something%20some%20more%20stuff..', # A more normal entry. '.....': 'this is an entry', } } """) expected_formatted_code = textwrap.dedent("""\ environments = { 'prod': { # this is a comment before the first entry. 'entry one': 'an entry.', # this is the comment before the second entry. 'entry number 2.': 'something', # this is the comment before the third entry and it's a doozy. So big! 'who': 'allin', # This is an entry that has a dictionary in it. It's ugly 'something': { 'page': ['this-is-a-page@xxxxxxxx.com', 'something-for-eml@xxxxxx.com'], 'bug': ['bugs-go-here5300@xxxxxx.com'], 'email': ['sometypeof-email@xxxxxx.com'], }, # a short comment 'yolo!!!!!': 'another-email-address@xxxxxx.com', # this entry has an implicit string concatenation 'implicit': 'https://this-is-very-long.url-addr.com/' '?something=something%20some%20more%20stuff..', # A more normal entry. '.....': 'this is an entry', } } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB33047408(self): code = textwrap.dedent("""\ def _(): for sort in (sorts or []): request['sorts'].append({ 'field': { 'user_field': sort }, 'order': 'ASCENDING' }) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB32714745(self): code = textwrap.dedent("""\ class _(): def _BlankDefinition(): '''Return a generic blank dictionary for a new field.''' return { 'type': '', 'validation': '', 'name': 'fieldname', 'label': 'Field Label', 'help': '', 'initial': '', 'required': False, 'required_msg': 'Required', 'invalid_msg': 'Please enter a valid value', 'options': { 'regex': '', 'widget_attr': '', 'choices_checked': '', 'choices_count': '', 'choices': {} }, 'isnew': True, 'dirty': False, } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB32737279(self): unformatted_code = textwrap.dedent("""\ here_is_a_dict = { 'key': # Comment. 'value' } """) expected_formatted_code = textwrap.dedent("""\ here_is_a_dict = { 'key': # Comment. 'value' } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB32570937(self): code = textwrap.dedent("""\ def _(): if (job_message.ball not in ('*', ball) or job_message.call not in ('*', call) or job_message.mall not in ('*', job_name)): return False """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB31937033(self): code = textwrap.dedent("""\ class _(): def __init__(self, metric, fields_cb=None): self._fields_cb = fields_cb or (lambda *unused_args, **unused_kwargs: {}) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB31911533(self): code = textwrap.dedent("""\ class _(): @parameterized.NamedParameters( ('IncludingModInfoWithHeaderList', AAAA, aaaa), ('IncludingModInfoWithoutHeaderList', BBBB, bbbbb), ('ExcludingModInfoWithHeaderList', CCCCC, cccc), ('ExcludingModInfoWithoutHeaderList', DDDDD, ddddd),) def _(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB31847238(self): unformatted_code = textwrap.dedent("""\ class _(): def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unused-argument return 1 def xxxxx(self, yyyyy, zzzzzzzzzzzzzz=None): # A normal comment that runs over the column limit. return 1 """) expected_formatted_code = textwrap.dedent("""\ class _(): def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unused-argument return 1 def xxxxx( self, yyyyy, zzzzzzzzzzzzzz=None): # A normal comment that runs over the column limit. return 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB30760569(self): unformatted_code = textwrap.dedent("""\ {'1234567890123456789012345678901234567890123456789012345678901234567890': '1234567890123456789012345678901234567890'} """) expected_formatted_code = textwrap.dedent("""\ { '1234567890123456789012345678901234567890123456789012345678901234567890': '1234567890123456789012345678901234567890' } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB26034238(self): unformatted_code = textwrap.dedent("""\ class Thing: def Function(self): thing.Scrape('/aaaaaaaaa/bbbbbbbbbb/ccccc/dddd/eeeeeeeeeeeeee/ffffffffffffff').AndReturn(42) """) expected_formatted_code = textwrap.dedent("""\ class Thing: def Function(self): thing.Scrape( '/aaaaaaaaa/bbbbbbbbbb/ccccc/dddd/eeeeeeeeeeeeee/ffffffffffffff' ).AndReturn(42) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB30536435(self): unformatted_code = textwrap.dedent("""\ def main(unused_argv): if True: if True: aaaaaaaaaaa.comment('import-from[{}] {} {}'.format( bbbbbbbbb.usage, ccccccccc.within, imports.ddddddddddddddddddd(name_item.ffffffffffffffff))) """) expected_formatted_code = textwrap.dedent("""\ def main(unused_argv): if True: if True: aaaaaaaaaaa.comment('import-from[{}] {} {}'.format( bbbbbbbbb.usage, ccccccccc.within, imports.ddddddddddddddddddd(name_item.ffffffffffffffff))) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB30442148(self): unformatted_code = textwrap.dedent("""\ def lulz(): return (some_long_module_name.SomeLongClassName. some_long_attribute_name.some_long_method_name()) """) expected_formatted_code = textwrap.dedent("""\ def lulz(): return (some_long_module_name.SomeLongClassName.some_long_attribute_name. some_long_method_name()) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB26868213(self): unformatted_code = textwrap.dedent("""\ def _(): xxxxxxxxxxxxxxxxxxx = { 'ssssss': {'ddddd': 'qqqqq', 'p90': aaaaaaaaaaaaaaaaa, 'p99': bbbbbbbbbbbbbbbbb, 'lllllllllllll': yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy(),}, 'bbbbbbbbbbbbbbbbbbbbbbbbbbbb': { 'ddddd': 'bork bork bork bo', 'p90': wwwwwwwwwwwwwwwww, 'p99': wwwwwwwwwwwwwwwww, 'lllllllllllll': None, # use the default } } """) expected_formatted_code = textwrap.dedent("""\ def _(): xxxxxxxxxxxxxxxxxxx = { 'ssssss': { 'ddddd': 'qqqqq', 'p90': aaaaaaaaaaaaaaaaa, 'p99': bbbbbbbbbbbbbbbbb, 'lllllllllllll': yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy(), }, 'bbbbbbbbbbbbbbbbbbbbbbbbbbbb': { 'ddddd': 'bork bork bork bo', 'p90': wwwwwwwwwwwwwwwww, 'p99': wwwwwwwwwwwwwwwww, 'lllllllllllll': None, # use the default } } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB30173198(self): code = textwrap.dedent("""\ class _(): def _(): self.assertFalse( evaluation_runner.get_larps_in_eval_set('these_arent_the_larps')) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB29908765(self): code = textwrap.dedent("""\ class _(): def __repr__(self): return '' % (self._id, self._stub._stub.rpc_channel().target()) # pylint:disable=protected-access """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB30087362(self): code = textwrap.dedent("""\ def _(): for s in sorted(env['foo']): bar() # This is a comment # This is another comment foo() """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB29093579(self): unformatted_code = textwrap.dedent("""\ def _(): _xxxxxxxxxxxxxxx(aaaaaaaa, bbbbbbbbbbbbbb.cccccccccc[ dddddddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffff]) """) expected_formatted_code = textwrap.dedent("""\ def _(): _xxxxxxxxxxxxxxx( aaaaaaaa, bbbbbbbbbbbbbb.cccccccccc[dddddddddddddddddddddddddddd. eeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffff]) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB26382315(self): code = textwrap.dedent("""\ @hello_world # This is a first comment # Comment def foo(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB27616132(self): unformatted_code = textwrap.dedent("""\ if True: query.fetch_page.assert_has_calls([ mock.call(100, start_cursor=None), mock.call(100, start_cursor=cursor_1), mock.call(100, start_cursor=cursor_2), ]) """) expected_formatted_code = textwrap.dedent("""\ if True: query.fetch_page.assert_has_calls([ mock.call( 100, start_cursor=None), mock.call( 100, start_cursor=cursor_1), mock.call( 100, start_cursor=cursor_2), ]) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB27590179(self): unformatted_code = textwrap.dedent("""\ if True: if True: self.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ( { True: self.bbb.cccccccccc(ddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee), False: self.bbb.cccccccccc(ddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee) }) """) expected_formatted_code = textwrap.dedent("""\ if True: if True: self.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ({ True: self.bbb.cccccccccc(ddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee), False: self.bbb.cccccccccc(ddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee) }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB27266946(self): unformatted_code = textwrap.dedent("""\ def _(): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = (self.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccccccc) """) expected_formatted_code = textwrap.dedent("""\ def _(): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ( self.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb. cccccccccccccccccccccccccccccccccccc) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB25505359(self): code = textwrap.dedent("""\ _EXAMPLE = { 'aaaaaaaaaaaaaa': [{ 'bbbb': 'cccccccccccccccccccccc', 'dddddddddddd': [] }, { 'bbbb': 'ccccccccccccccccccc', 'dddddddddddd': [] }] } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB25324261(self): code = textwrap.dedent("""\ aaaaaaaaa = set(bbbb.cccc for ddd in eeeeee.fffffffffff.gggggggggggggggg for cccc in ddd.specification) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB25136704(self): code = textwrap.dedent("""\ class f: def test(self): self.bbbbbbb[0]['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', { 'xxxxxx': 'yyyyyy' }] = cccccc.ddd('1m', '10x1+1') """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB25165602(self): code = textwrap.dedent("""\ def f(): ids = {u: i for u, i in zip(self.aaaaa, xrange(42, 42 + len(self.aaaaaa)))} """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB25157123(self): code = textwrap.dedent("""\ def ListArgs(): FairlyLongMethodName([relatively_long_identifier_for_a_list], another_argument_with_a_long_identifier) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB25136820(self): unformatted_code = textwrap.dedent("""\ def foo(): return collections.OrderedDict({ # Preceding comment. 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa': '$bbbbbbbbbbbbbbbbbbbbbbbb', }) """) expected_formatted_code = textwrap.dedent("""\ def foo(): return collections.OrderedDict({ # Preceding comment. 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa': '$bbbbbbbbbbbbbbbbbbbbbbbb', }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB25131481(self): unformatted_code = textwrap.dedent("""\ APPARENT_ACTIONS = ('command_type', { 'materialize': lambda x: some_type_of_function('materialize ' + x.command_def), '#': lambda x: x # do nothing }) """) expected_formatted_code = textwrap.dedent("""\ APPARENT_ACTIONS = ( 'command_type', { 'materialize': lambda x: some_type_of_function('materialize ' + x.command_def), '#': lambda x: x # do nothing }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB23445244(self): unformatted_code = textwrap.dedent("""\ def foo(): if True: return xxxxxxxxxxxxxxxx( command, extra_env={ "OOOOOOOOOOOOOOOOOOOOO": FLAGS.zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz, "PPPPPPPPPPPPPPPPPPPPP": FLAGS.aaaaaaaaaaaaaa + FLAGS.bbbbbbbbbbbbbbbbbbb, }) """) expected_formatted_code = textwrap.dedent("""\ def foo(): if True: return xxxxxxxxxxxxxxxx( command, extra_env={ "OOOOOOOOOOOOOOOOOOOOO": FLAGS.zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz, "PPPPPPPPPPPPPPPPPPPPP": FLAGS.aaaaaaaaaaaaaa + FLAGS.bbbbbbbbbbbbbbbbbbb, }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB20559654(self): unformatted_code = textwrap.dedent("""\ class A(object): def foo(self): unused_error, result = server.Query( ['AA BBBB CCC DDD EEEEEEEE X YY ZZZZ FFF EEE AAAAAAAA'], aaaaaaaaaaa=True, bbbbbbbb=None) """) expected_formatted_code = textwrap.dedent("""\ class A(object): def foo(self): unused_error, result = server.Query( ['AA BBBB CCC DDD EEEEEEEE X YY ZZZZ FFF EEE AAAAAAAA'], aaaaaaaaaaa=True, bbbbbbbb=None) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB23943842(self): unformatted_code = textwrap.dedent("""\ class F(): def f(): self.assertDictEqual( accounts, { 'foo': {'account': 'foo', 'lines': 'l1\\nl2\\nl3\\n1 line(s) were elided.'}, 'bar': {'account': 'bar', 'lines': 'l5\\nl6\\nl7'}, 'wiz': {'account': 'wiz', 'lines': 'l8'} }) """) expected_formatted_code = textwrap.dedent("""\ class F(): def f(): self.assertDictEqual(accounts, { 'foo': { 'account': 'foo', 'lines': 'l1\\nl2\\nl3\\n1 line(s) were elided.' }, 'bar': { 'account': 'bar', 'lines': 'l5\\nl6\\nl7' }, 'wiz': { 'account': 'wiz', 'lines': 'l8' } }) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB20551180(self): unformatted_code = textwrap.dedent("""\ def foo(): if True: return (struct.pack('aaaa', bbbbbbbbbb, ccccccccccccccc, dddddddd) + eeeeeee) """) expected_formatted_code = textwrap.dedent("""\ def foo(): if True: return ( struct.pack('aaaa', bbbbbbbbbb, ccccccccccccccc, dddddddd) + eeeeeee) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB23944849(self): unformatted_code = textwrap.dedent("""\ class A(object): def xxxxxxxxx(self, aaaaaaa, bbbbbbb=ccccccccccc, dddddd=300, eeeeeeeeeeeeee=None, fffffffffffffff=0): pass """) expected_formatted_code = textwrap.dedent("""\ class A(object): def xxxxxxxxx(self, aaaaaaa, bbbbbbb=ccccccccccc, dddddd=300, eeeeeeeeeeeeee=None, fffffffffffffff=0): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB23935890(self): unformatted_code = textwrap.dedent("""\ class F(): def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, eeeeeeeeeeeeeee): pass """) expected_formatted_code = textwrap.dedent("""\ class F(): def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, eeeeeeeeeeeeeee): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB28414371(self): code = textwrap.dedent("""\ def _(): return ((m.fffff( m.rrr('mmmmmmmmmmmmmmmm', 'ssssssssssssssssssssssssss'), ffffffffffffffff) | m.wwwwww(m.ddddd('1h')) | m.ggggggg(bbbbbbbbbbbbbbb) | m.ppppp( (1 - m.ffffffffffffffff(llllllllllllllllllllll * 1000000, m.vvv)) * m.ddddddddddddddddd(m.vvv)), m.fffff( m.rrr('mmmmmmmmmmmmmmmm', 'sssssssssssssssssssssss'), dict( ffffffffffffffff, **{ 'mmmmmm:ssssss': m.rrrrrrrrrrr( '|'.join(iiiiiiiiiiiiii), iiiiii=True) })) | m.wwwwww(m.rrrr('1h')) | m.ggggggg(bbbbbbbbbbbbbbb)) | m.jjjj() | m.ppppp(m.vvv[0] + m.vvv[1])) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB20127686(self): code = textwrap.dedent("""\ def f(): if True: return ((m.fffff( m.rrr('xxxxxxxxxxxxxxxx', 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'), mmmmmmmm) | m.wwwwww(m.rrrr(self.tttttttttt, self.mmmmmmmmmmmmmmmmmmmmm)) | m.ggggggg(self.gggggggg, m.sss()), m.fffff('aaaaaaaaaaaaaaaa') | m.wwwwww(m.ddddd(self.tttttttttt, self.mmmmmmmmmmmmmmmmmmmmm)) | m.ggggggg(self.gggggggg)) | m.jjjj() | m.ppppp(m.VAL[0] / m.VAL[1])) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB20016122(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_penalty_import_names: 35}')) unformatted_code = textwrap.dedent("""\ from a_very_long_or_indented_module_name_yada_yada import (long_argument_1, long_argument_2) """) expected_formatted_code = textwrap.dedent("""\ from a_very_long_or_indented_module_name_yada_yada import ( long_argument_1, long_argument_2) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) try: style.SetGlobalStyle( style.CreateStyleFromConfig('{based_on_style: chromium, ' 'split_before_logical_operator: True}')) code = textwrap.dedent("""\ class foo(): def __eq__(self, other): return (isinstance(other, type(self)) and self.xxxxxxxxxxx == other.xxxxxxxxxxx and self.xxxxxxxx == other.xxxxxxxx and self.aaaaaaaaaaaa == other.aaaaaaaaaaaa and self.bbbbbbbbbbb == other.bbbbbbbbbbb and self.ccccccccccccccccc == other.ccccccccccccccccc and self.ddddddddddddddddddddddd == other.ddddddddddddddddddddddd and self.eeeeeeeeeeee == other.eeeeeeeeeeee and self.ffffffffffffff == other.time_completed and self.gggggg == other.gggggg and self.hhh == other.hhh and len(self.iiiiiiii) == len(other.iiiiiiii) and all(jjjjjjj in other.iiiiiiii for jjjjjjj in self.iiiiiiii)) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreateChromiumStyle()) def testB22527411(self): unformatted_code = textwrap.dedent("""\ def f(): if True: aaaaaa.bbbbbbbbbbbbbbbbbbbb[-1].cccccccccccccc.ddd().eeeeeeee(ffffffffffffff) """) expected_formatted_code = textwrap.dedent("""\ def f(): if True: aaaaaa.bbbbbbbbbbbbbbbbbbbb[-1].cccccccccccccc.ddd().eeeeeeee( ffffffffffffff) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB20849933(self): unformatted_code = textwrap.dedent("""\ def main(unused_argv): if True: aaaaaaaa = { 'xxx': '%s/cccccc/ddddddddddddddddddd.jar' % (eeeeee.FFFFFFFFFFFFFFFFFF), } """) expected_formatted_code = textwrap.dedent("""\ def main(unused_argv): if True: aaaaaaaa = { 'xxx': '%s/cccccc/ddddddddddddddddddd.jar' % (eeeeee.FFFFFFFFFFFFFFFFFF), } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB20813997(self): code = textwrap.dedent("""\ def myfunc_1(): myarray = numpy.zeros((2, 2, 2)) print(myarray[:, 1, :]) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB20605036(self): code = textwrap.dedent("""\ foo = { 'aaaa': { # A comment for no particular reason. 'xxxxxxxx': 'bbbbbbbbb', 'yyyyyyyyyyyyyyyyyy': 'cccccccccccccccccccccccccccccc' 'dddddddddddddddddddddddddddddddddddddddddd', } } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB20562732(self): code = textwrap.dedent("""\ foo = [ # Comment about first list item 'First item', # Comment about second list item 'Second item', ] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB20128830(self): code = textwrap.dedent("""\ a = { 'xxxxxxxxxxxxxxxxxxxx': { 'aaaa': 'mmmmmmm', 'bbbbb': 'mmmmmmmmmmmmmmmmmmmmm', 'cccccccccc': [ 'nnnnnnnnnnn', 'ooooooooooo', 'ppppppppppp', 'qqqqqqqqqqq', ], }, } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB20073838(self): code = textwrap.dedent("""\ class DummyModel(object): def do_nothing(self, class_1_count): if True: class_0_count = num_votes - class_1_count return ('{class_0_name}={class_0_count}, {class_1_name}={class_1_count}' .format( class_0_name=self.class_0_name, class_0_count=class_0_count, class_1_name=self.class_1_name, class_1_count=class_1_count)) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB19626808(self): code = textwrap.dedent("""\ if True: aaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbb( 'ccccccccccc', ddddddddd='eeeee').fffffffff([ggggggggggggggggggggg]) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB19547210(self): code = textwrap.dedent("""\ while True: if True: if True: if True: if xxxxxxxxxxxx.yyyyyyy(aa).zzzzzzz() not in ( xxxxxxxxxxxx.yyyyyyyyyyyyyy.zzzzzzzz, xxxxxxxxxxxx.yyyyyyyyyyyyyy.zzzzzzzz): continue """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB19377034(self): code = textwrap.dedent("""\ def f(): if (aaaaaaaaaaaaaaa.start >= aaaaaaaaaaaaaaa.end or bbbbbbbbbbbbbbb.start >= bbbbbbbbbbbbbbb.end): return False """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB19372573(self): code = textwrap.dedent("""\ def f(): if a: return 42 while True: if b: continue if c: break return 0 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) try: style.SetGlobalStyle(style.CreatePEP8Style()) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreateChromiumStyle()) def testB19353268(self): code = textwrap.dedent("""\ a = {1, 2, 3}[x] b = {'foo': 42, 'bar': 37}['foo'] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB19287512(self): unformatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): with xxxxxxxxxx.yyyyy( 'aaaaaaa.bbbbbbbb.ccccccc.dddddddddddddddddddd.eeeeeeeeeee', fffffffffff=(aaaaaaa.bbbbbbbb.ccccccc.dddddddddddddddddddd .Mmmmmmmmmmmmmmmmmm(-1, 'permission error'))): self.assertRaises(nnnnnnnnnnnnnnnn.ooooo, ppppp.qqqqqqqqqqqqqqqqq) """) expected_formatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): with xxxxxxxxxx.yyyyy( 'aaaaaaa.bbbbbbbb.ccccccc.dddddddddddddddddddd.eeeeeeeeeee', fffffffffff=( aaaaaaa.bbbbbbbb.ccccccc.dddddddddddddddddddd.Mmmmmmmmmmmmmmmmmm( -1, 'permission error'))): self.assertRaises(nnnnnnnnnnnnnnnn.ooooo, ppppp.qqqqqqqqqqqqqqqqq) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB19194420(self): code = textwrap.dedent("""\ method.Set('long argument goes here that causes the line to break', lambda arg2=0.5: arg2) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB19073499(self): code = textwrap.dedent("""\ instance = ( aaaaaaa.bbbbbbb().ccccccccccccccccc().ddddddddddd({ 'aa': 'context!' }).eeeeeeeeeeeeeeeeeee( { # Inline comment about why fnord has the value 6. 'fnord': 6 })) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB18257115(self): code = textwrap.dedent("""\ if True: if True: self._Test(aaaa, bbbbbbb.cccccccccc, dddddddd, eeeeeeeeeee, [ffff, ggggggggggg, hhhhhhhhhhhh, iiiiii, jjjj]) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB18256666(self): code = textwrap.dedent("""\ class Foo(object): def Bar(self): aaaaa.bbbbbbb( ccc='ddddddddddddddd', eeee='ffffffffffffffffffffff-%s-%s' % (gggg, int(time.time())), hhhhhh={ 'iiiiiiiiiii': iiiiiiiiiii, 'jjjj': jjjj.jjjjj(), 'kkkkkkkkkkkk': kkkkkkkkkkkk, }, llllllllll=mmmmmm.nnnnnnnnnnnnnnnn) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB18256826(self): code = textwrap.dedent("""\ if True: pass # A multiline comment. # Line two. elif False: pass if True: pass # A multiline comment. # Line two. elif False: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB18255697(self): code = textwrap.dedent("""\ AAAAAAAAAAAAAAA = { 'XXXXXXXXXXXXXX': 4242, # Inline comment # Next comment 'YYYYYYYYYYYYYYYY': ['zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz'], } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testB17534869(self): unformatted_code = textwrap.dedent("""\ if True: self.assertLess(abs(time.time()-aaaa.bbbbbbbbbbb( datetime.datetime.now())), 1) """) expected_formatted_code = textwrap.dedent("""\ if True: self.assertLess( abs(time.time() - aaaa.bbbbbbbbbbb(datetime.datetime.now())), 1) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB17489866(self): unformatted_code = textwrap.dedent("""\ def f(): if True: if True: return aaaa.bbbbbbbbb(ccccccc=dddddddddddddd({('eeee', \ 'ffffffff'): str(j)})) """) expected_formatted_code = textwrap.dedent("""\ def f(): if True: if True: return aaaa.bbbbbbbbb(ccccccc=dddddddddddddd({ ('eeee', 'ffffffff'): str(j) })) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB17133019(self): unformatted_code = textwrap.dedent("""\ class aaaaaaaaaaaaaa(object): def bbbbbbbbbb(self): with io.open("/dev/null", "rb"): with io.open(os.path.join(aaaaa.bbbbb.ccccccccccc, DDDDDDDDDDDDDDD, "eeeeeeeee ffffffffff" ), "rb") as gggggggggggggggggggg: print(gggggggggggggggggggg) """) expected_formatted_code = textwrap.dedent("""\ class aaaaaaaaaaaaaa(object): def bbbbbbbbbb(self): with io.open("/dev/null", "rb"): with io.open( os.path.join(aaaaa.bbbbb.ccccccccccc, DDDDDDDDDDDDDDD, "eeeeeeeee ffffffffff"), "rb") as gggggggggggggggggggg: print(gggggggggggggggggggg) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB17011869(self): unformatted_code = textwrap.dedent("""\ '''blah......''' class SomeClass(object): '''blah.''' AAAAAAAAAAAA = { # Comment. 'BBB': 1.0, 'DDDDDDDD': 0.4811 } """) expected_formatted_code = textwrap.dedent("""\ '''blah......''' class SomeClass(object): '''blah.''' AAAAAAAAAAAA = { # Comment. 'BBB': 1.0, 'DDDDDDDD': 0.4811 } """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB16783631(self): unformatted_code = textwrap.dedent("""\ if True: with aaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccc(ddddddddddddd, eeeeeeeee=self.fffffffffffff )as gggg: pass """) expected_formatted_code = textwrap.dedent("""\ if True: with aaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccc( ddddddddddddd, eeeeeeeee=self.fffffffffffff) as gggg: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB16572361(self): unformatted_code = textwrap.dedent("""\ def foo(self): def bar(my_dict_name): self.my_dict_name['foo-bar-baz-biz-boo-baa-baa'].IncrementBy.assert_called_once_with('foo_bar_baz_boo') """) expected_formatted_code = textwrap.dedent("""\ def foo(self): def bar(my_dict_name): self.my_dict_name[ 'foo-bar-baz-biz-boo-baa-baa'].IncrementBy.assert_called_once_with( 'foo_bar_baz_boo') """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB15884241(self): unformatted_code = textwrap.dedent("""\ if 1: if 1: for row in AAAA: self.create(aaaaaaaa="/aaa/bbbb/cccc/dddddd/eeeeeeeeeeeeeeeeeeeeeeeeee/%s" % row [0].replace(".foo", ".bar"), aaaaa=bbb[1], ccccc=bbb[2], dddd=bbb[3], eeeeeeeeeee=[s.strip() for s in bbb[4].split(",")], ffffffff=[s.strip() for s in bbb[5].split(",")], gggggg=bbb[6]) """) expected_formatted_code = textwrap.dedent("""\ if 1: if 1: for row in AAAA: self.create( aaaaaaaa="/aaa/bbbb/cccc/dddddd/eeeeeeeeeeeeeeeeeeeeeeeeee/%s" % row[0].replace(".foo", ".bar"), aaaaa=bbb[1], ccccc=bbb[2], dddd=bbb[3], eeeeeeeeeee=[s.strip() for s in bbb[4].split(",")], ffffffff=[s.strip() for s in bbb[5].split(",")], gggggg=bbb[6]) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB15697268(self): unformatted_code = textwrap.dedent("""\ def main(unused_argv): ARBITRARY_CONSTANT_A = 10 an_array_with_an_exceedingly_long_name = range(ARBITRARY_CONSTANT_A + 1) ok = an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A] bad_slice = map(math.sqrt, an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A]) a_long_name_slicing = an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A] bad_slice = ("I am a crazy, no good, string whats too long, etc." + " no really ")[:ARBITRARY_CONSTANT_A] """) expected_formatted_code = textwrap.dedent("""\ def main(unused_argv): ARBITRARY_CONSTANT_A = 10 an_array_with_an_exceedingly_long_name = range(ARBITRARY_CONSTANT_A + 1) ok = an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A] bad_slice = map(math.sqrt, an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A]) a_long_name_slicing = an_array_with_an_exceedingly_long_name[: ARBITRARY_CONSTANT_A] bad_slice = ("I am a crazy, no good, string whats too long, etc." + " no really ")[:ARBITRARY_CONSTANT_A] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB15597568(self): unformatted_code = textwrap.dedent("""\ if True: if True: if True: print(("Return code was %d" + (", and the process timed out." if did_time_out else ".")) % errorcode) """) expected_formatted_code = textwrap.dedent("""\ if True: if True: if True: print(("Return code was %d" + (", and the process timed out." if did_time_out else ".")) % errorcode) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB15542157(self): unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaa = bbbb.ccccccccccccccc(dddddd.eeeeeeeeeeeeee, ffffffffffffffffff, gggggg.hhhhhhhhhhhhhhhhh) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaa = bbbb.ccccccccccccccc(dddddd.eeeeeeeeeeeeee, ffffffffffffffffff, gggggg.hhhhhhhhhhhhhhhhh) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB15438132(self): unformatted_code = textwrap.dedent("""\ if aaaaaaa.bbbbbbbbbb: cccccc.dddddddddd(eeeeeeeeeee=fffffffffffff.gggggggggggggggggg) if hhhhhh.iiiii.jjjjjjjjjjjjj: # This is a comment in the middle of it all. kkkkkkk.llllllllll.mmmmmmmmmmmmm = True if (aaaaaa.bbbbb.ccccccccccccc != ddddddd.eeeeeeeeee.fffffffffffff or eeeeee.fffff.ggggggggggggggggggggggggggg() != hhhhhhh.iiiiiiiiii.jjjjjjjjjjjj): aaaaaaaa.bbbbbbbbbbbb( aaaaaa.bbbbb.cc, dddddddddddd=eeeeeeeeeeeeeeeeeee.fffffffffffffffff( gggggg.hh, iiiiiiiiiiiiiiiiiii.jjjjjjjjjj.kkkkkkk, lllll.mm), nnnnnnnnnn=ooooooo.pppppppppp) """) expected_formatted_code = textwrap.dedent("""\ if aaaaaaa.bbbbbbbbbb: cccccc.dddddddddd(eeeeeeeeeee=fffffffffffff.gggggggggggggggggg) if hhhhhh.iiiii.jjjjjjjjjjjjj: # This is a comment in the middle of it all. kkkkkkk.llllllllll.mmmmmmmmmmmmm = True if (aaaaaa.bbbbb.ccccccccccccc != ddddddd.eeeeeeeeee.fffffffffffff or eeeeee.fffff.ggggggggggggggggggggggggggg() != hhhhhhh.iiiiiiiiii.jjjjjjjjjjjj): aaaaaaaa.bbbbbbbbbbbb( aaaaaa.bbbbb.cc, dddddddddddd=eeeeeeeeeeeeeeeeeee.fffffffffffffffff( gggggg.hh, iiiiiiiiiiiiiiiiiii.jjjjjjjjjj.kkkkkkk, lllll.mm), nnnnnnnnnn=ooooooo.pppppppppp) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB14468247(self): unformatted_code = textwrap.dedent("""\ call(a=1, b=2, ) """) expected_formatted_code = textwrap.dedent("""\ call( a=1, b=2,) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB14406499(self): unformatted_code = textwrap.dedent("""\ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, \ parameter_5, parameter_6): pass """) expected_formatted_code = textwrap.dedent("""\ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testB13900309(self): unformatted_code = textwrap.dedent("""\ self.aaaaaaaaaaa( # A comment in the middle of it all. 948.0/3600, self.bbb.ccccccccccccccccccccc(dddddddddddddddd.eeee, True)) """) expected_formatted_code = textwrap.dedent("""\ self.aaaaaaaaaaa( # A comment in the middle of it all. 948.0 / 3600, self.bbb.ccccccccccccccccccccc(dddddddddddddddd.eeee, True)) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) code = textwrap.dedent("""\ aaaaaaaaaa.bbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccc( DC_1, (CL - 50, CL), AAAAAAAA, BBBBBBBBBBBBBBBB, 98.0, CCCCCCC).ddddddddd( # Look! A comment is here. AAAAAAAA - (20 * 60 - 5)) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc().dddddddddddddddddddddddddd(1, 2, 3, 4) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc( ).dddddddddddddddddddddddddd(1, 2, 3, 4) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc(x).dddddddddddddddddddddddddd(1, 2, 3, 4) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc( x).dddddddddddddddddddddddddd(1, 2, 3, 4) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).dddddddddddddddddddddddddd(1, 2, 3, 4) """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa( xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).dddddddddddddddddddddddddd(1, 2, 3, 4) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa().bbbbbbbbbbbbbbbbbbbbbbbb().ccccccccccccccccccc().\ dddddddddddddddddd().eeeeeeeeeeeeeeeeeeeee().fffffffffffffffff().gggggggggggggggggg() """) expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa().bbbbbbbbbbbbbbbbbbbbbbbb().ccccccccccccccccccc( ).dddddddddddddddddd().eeeeeeeeeeeeeeeeeeeee().fffffffffffffffff( ).gggggggggggggggggg() """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_facebook_test.py000066400000000000000000000341071304174360200223600ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Facebook tests for yapf.reformatter.""" import textwrap import unittest from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper class TestsForFacebookStyle(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreateFacebookStyle()) def testNoNeedForLineBreaks(self): unformatted_code = textwrap.dedent("""\ def overly_long_function_name( just_one_arg, **kwargs): pass """) expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name(just_one_arg, **kwargs): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDedentClosingBracket(self): unformatted_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long ): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testBreakAfterOpeningBracketIfContentsTooBig(self): unformatted_code = textwrap.dedent("""\ def overly_long_function_name(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z): pass """) expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name( a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, \ v, w, x, y, z ): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDedentClosingBracketWithComments(self): unformatted_code = textwrap.dedent("""\ def overly_long_function_name( # comment about the first argument first_argument_with_a_very_long_name_or_so, # comment about the second argument second_argument_makes_the_line_too_long): pass """) expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name( # comment about the first argument first_argument_with_a_very_long_name_or_so, # comment about the second argument second_argument_makes_the_line_too_long ): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDedentImportAsNames(self): code = textwrap.dedent("""\ from module import ( internal_function as function, SOME_CONSTANT_NUMBER1, SOME_CONSTANT_NUMBER2, SOME_CONSTANT_NUMBER3, ) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDedentTestListGexp(self): # TODO(ambv): Arguably _DetermineMustSplitAnnotation shouldn't enforce # breaks only on the basis of a trailing comma if the entire thing fits # in a single line. code = textwrap.dedent("""\ try: pass except ( IOError, OSError, LookupError, RuntimeError, OverflowError ) as exception: pass try: pass except ( IOError, OSError, LookupError, RuntimeError, OverflowError, ) as exception: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testBrokenIdempotency(self): # TODO(ambv): The following behaviour should be fixed. pass0_code = textwrap.dedent("""\ try: pass except (IOError, OSError, LookupError, RuntimeError, OverflowError) as exception: pass """) pass1_code = textwrap.dedent("""\ try: pass except ( IOError, OSError, LookupError, RuntimeError, OverflowError ) as exception: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(pass0_code) self.assertCodeEqual(pass1_code, reformatter.Reformat(uwlines)) pass2_code = textwrap.dedent("""\ try: pass except ( IOError, OSError, LookupError, RuntimeError, OverflowError ) as exception: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(pass1_code) self.assertCodeEqual(pass2_code, reformatter.Reformat(uwlines)) def testIfExprHangingIndent(self): unformatted_code = textwrap.dedent("""\ if True: if True: if True: if not self.frobbies and ( self.foobars.counters['db.cheeses'] != 1 or self.foobars.counters['db.marshmellow_skins'] != 1): pass """) expected_formatted_code = textwrap.dedent("""\ if True: if True: if True: if not self.frobbies and ( self.foobars.counters['db.cheeses'] != 1 or self.foobars.counters['db.marshmellow_skins'] != 1 ): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSimpleDedenting(self): unformatted_code = textwrap.dedent("""\ if True: self.assertEqual(result.reason_not_added, "current preflight is still running") """) expected_formatted_code = textwrap.dedent("""\ if True: self.assertEqual( result.reason_not_added, "current preflight is still running" ) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDedentingWithSubscripts(self): unformatted_code = textwrap.dedent("""\ class Foo: class Bar: @classmethod def baz(cls, clues_list, effect, constraints, constraint_manager): if clues_lists: return cls.single_constraint_not(clues_lists, effect, constraints[0], constraint_manager) """) expected_formatted_code = textwrap.dedent("""\ class Foo: class Bar: @classmethod def baz(cls, clues_list, effect, constraints, constraint_manager): if clues_lists: return cls.single_constraint_not( clues_lists, effect, constraints[0], constraint_manager ) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testDedentingCallsWithInnerLists(self): code = textwrap.dedent("""\ class _(): def _(): cls.effect_clues = { 'effect': Clue((cls.effect_time, 'apache_host'), effect_line, 40) } """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDedentingListComprehension(self): unformatted_code = textwrap.dedent("""\ class Foo(): def _pack_results_for_constraint_or(): self.param_groups = dict( ( key + 1, ParamGroup(groups[key], default_converter) ) for key in six.moves.range(len(groups)) ) for combination in cls._clues_combinations(clues_lists): if all( cls._verify_constraint(combination, effect, constraint) for constraint in constraints ): pass guessed_dict = dict( ( key, guessed_pattern_matches[key] ) for key in six.moves.range(len(guessed_pattern_matches)) ) content = "".join( itertools.chain( (first_line_fragment, ), lines_between, (last_line_fragment, ) ) ) rule = Rule( [self.cause1, self.cause2, self.cause1, self.cause2], self.effect, constraints1, Rule.LINKAGE_AND ) assert sorted(log_type.files_to_parse) == [ ('localhost', os.path.join(path, 'node_1.log'), super_parser), ('localhost', os.path.join(path, 'node_2.log'), super_parser) ] """) expected_formatted_code = textwrap.dedent("""\ class Foo(): def _pack_results_for_constraint_or(): self.param_groups = dict( (key + 1, ParamGroup(groups[key], default_converter)) for key in six.moves.range(len(groups)) ) for combination in cls._clues_combinations(clues_lists): if all( cls._verify_constraint(combination, effect, constraint) for constraint in constraints ): pass guessed_dict = dict( (key, guessed_pattern_matches[key]) for key in six.moves.range(len(guessed_pattern_matches)) ) content = "".join( itertools.chain( (first_line_fragment, ), lines_between, (last_line_fragment, ) ) ) rule = Rule( [self.cause1, self.cause2, self.cause1, self.cause2], self.effect, constraints1, Rule.LINKAGE_AND ) assert sorted(log_type.files_to_parse) == [ ('localhost', os.path.join(path, 'node_1.log'), super_parser), ('localhost', os.path.join(path, 'node_2.log'), super_parser) ] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testMustSplitDedenting(self): code = textwrap.dedent("""\ class _(): def _(): effect_line = FrontInput( effect_line_offset, line_content, LineSource('localhost', xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx) ) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDedentIfConditional(self): code = textwrap.dedent("""\ class _(): def _(): if True: if not self.frobbies and ( self.foobars.counters['db.cheeses'] != 1 or self.foobars.counters['db.marshmellow_skins'] != 1 ): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDedentSet(self): code = textwrap.dedent("""\ class _(): def _(): assert set(self.constraint_links.get_links()) == set( [ (2, 10, 100), (2, 10, 200), (2, 20, 100), (2, 20, 200), ] ) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testDedentingInnerScope(self): code = textwrap.dedent("""\ class Foo(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): return cls._create_investigation_result( (clue for clue in combination if not clue == Verifier.UNMATCHED), constraints, InvestigationResult.OR ) """) uwlines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(code, reformatted_code) uwlines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(uwlines) self.assertCodeEqual(code, reformatted_code) def testCommentWithNewlinesInPrefix(self): unformatted_code = textwrap.dedent("""\ def foo(): if 0: return False #a deadly comment elif 1: return True print(foo()) """) expected_formatted_code = textwrap.dedent("""\ def foo(): if 0: return False #a deadly comment elif 1: return True print(foo()) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_pep8_test.py000066400000000000000000000270121304174360200214600ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """PEP8 tests for yapf.reformatter.""" import textwrap import unittest from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper class TestsForPEP8Style(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testIndent4(self): unformatted_code = textwrap.dedent("""\ if a+b: pass """) expected_formatted_code = textwrap.dedent("""\ if a + b: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSingleLineIfStatements(self): code = textwrap.dedent("""\ if True: a = 42 elif False: b = 42 else: c = 42 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testNoBlankBetweenClassAndDef(self): unformatted_code = textwrap.dedent("""\ class Foo: def joe(): pass """) expected_formatted_code = textwrap.dedent("""\ class Foo: def joe(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSingleWhiteBeforeTrailingComment(self): unformatted_code = textwrap.dedent("""\ if a+b: # comment pass """) expected_formatted_code = textwrap.dedent("""\ if a + b: # comment pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingSemicolonStatements(self): unformatted_code = textwrap.dedent("""\ def f(): x = y + 42 ; z = n * 42 if True: a += 1 ; b += 1; c += 1 """) expected_formatted_code = textwrap.dedent("""\ def f(): x = y + 42 z = n * 42 if True: a += 1 b += 1 c += 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSpaceBetweenEndingCommandAndClosingBracket(self): unformatted_code = textwrap.dedent("""\ a = [ 1, ] """) expected_formatted_code = textwrap.dedent("""\ a = [1, ] """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testContinuedNonOudentedLine(self): code = textwrap.dedent("""\ class eld(d): if str(geom.geom_type).upper( ) != self.geom_type and not self.geom_type == 'GEOMETRY': ror(code='om_type') """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines)) def testWrappingPercentExpressions(self): unformatted_code = textwrap.dedent("""\ def f(): if True: zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) """) expected_formatted_code = textwrap.dedent("""\ def f(): if True: zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testAlignClosingBracketWithVisualIndentation(self): unformatted_code = textwrap.dedent("""\ TEST_LIST = ('foo', 'bar', # first comment 'baz' # second comment ) """) expected_formatted_code = textwrap.dedent("""\ TEST_LIST = ( 'foo', 'bar', # first comment 'baz' # second comment ) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) unformatted_code = textwrap.dedent("""\ def f(): def g(): while (xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb' ): pass """) expected_formatted_code = textwrap.dedent("""\ def f(): def g(): while (xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and xxxxxxxxxxxxxxxxxxxx( yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testIndentSizeChanging(self): unformatted_code = textwrap.dedent("""\ if True: runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0 """) expected_formatted_code = textwrap.dedent("""\ if True: runtime_mins = ( program_end_time - program_start_time).total_seconds() / 60.0 """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testHangingIndentCollision(self): unformatted_code = textwrap.dedent("""\ if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): pass elif (xxxxxxxxxxxxxxx(aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)): pass def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass for connection in itertools.chain(branch.contact, branch.address, morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore): dosomething(connection) """) expected_formatted_code = textwrap.dedent("""\ if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): pass elif (xxxxxxxxxxxxxxx( aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)): pass def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass for connection in itertools.chain( branch.contact, branch.address, morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore): dosomething(connection) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingBeforeLogicalOperator(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_logical_operator: True}')) unformatted_code = textwrap.dedent("""\ def foo(): return bool(update.message.new_chat_member or update.message.left_chat_member or update.message.new_chat_title or update.message.new_chat_photo or update.message.delete_chat_photo or update.message.group_chat_created or update.message.supergroup_chat_created or update.message.channel_chat_created or update.message.migrate_to_chat_id or update.message.migrate_from_chat_id or update.message.pinned_message) """) expected_formatted_code = textwrap.dedent("""\ def foo(): return bool( update.message.new_chat_member or update.message.left_chat_member or update.message.new_chat_title or update.message.new_chat_photo or update.message.delete_chat_photo or update.message.group_chat_created or update.message.supergroup_chat_created or update.message.channel_chat_created or update.message.migrate_to_chat_id or update.message.migrate_from_chat_id or update.message.pinned_message) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testContiguousListEndingWithComment(self): unformatted_code = textwrap.dedent("""\ if True: if True: keys.append(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned. """) expected_formatted_code = textwrap.dedent("""\ if True: if True: keys.append( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned. """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testSplittingBeforeFirstArgument(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_first_argument: True}')) unformatted_code = textwrap.dedent("""\ a_very_long_function_name(long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4) """) expected_formatted_code = textwrap.dedent("""\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_python3_test.py000066400000000000000000000163331304174360200222140ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Python 3 tests for yapf.reformatter.""" import sys import textwrap import unittest from yapf.yapflib import py3compat from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper @unittest.skipUnless(py3compat.PY3, 'Requires Python 3') class TestsForPython3Code(yapf_test_helper.YAPFTest): """Test a few constructs that are new Python 3 syntax.""" @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testTypedNames(self): unformatted_code = textwrap.dedent("""\ def x(aaaaaaaaaaaaaaa:int,bbbbbbbbbbbbbbbb:str,ccccccccccccccc:dict,eeeeeeeeeeeeee:set={1, 2, 3})->bool: pass """) expected_formatted_code = textwrap.dedent("""\ def x(aaaaaaaaaaaaaaa: int, bbbbbbbbbbbbbbbb: str, ccccccccccccccc: dict, eeeeeeeeeeeeee: set={1, 2, 3}) -> bool: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testKeywordOnlyArgSpecifier(self): unformatted_code = textwrap.dedent("""\ def foo(a, *, kw): return a+kw """) expected_formatted_code = textwrap.dedent("""\ def foo(a, *, kw): return a + kw """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testPEP448ParameterExpansion(self): unformatted_code = textwrap.dedent("""\ { ** x } { **{} } { **{ **x }, **x } {'a': 1, **kw , 'b':3, **kw2 } """) expected_formatted_code = textwrap.dedent("""\ {**x} {**{}} {**{**x}, **x} {'a': 1, **kw, 'b': 3, **kw2} """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testAnnotations(self): unformatted_code = textwrap.dedent("""\ def foo(a: list, b: "bar") -> dict: return a+b """) expected_formatted_code = textwrap.dedent("""\ def foo(a: list, b: "bar") -> dict: return a + b """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testExecAsNonKeyword(self): unformatted_code = 'methods.exec( sys.modules[name])\n' expected_formatted_code = 'methods.exec(sys.modules[name])\n' uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testAsyncFunctions(self): if sys.version_info[1] < 5: return code = textwrap.dedent("""\ import asyncio import time @print_args async def slow_operation(): await asyncio.sleep(1) # print("Slow operation {} complete".format(n)) async def main(): start = time.time() if (await get_html()): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(uwlines, verify=False)) def testNoSpacesAroundPowerOparator(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, SPACES_AROUND_POWER_OPERATOR: True}')) unformatted_code = textwrap.dedent("""\ a**b """) expected_formatted_code = textwrap.dedent("""\ a ** b """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testSpacesAroundDefaultOrNamedAssign(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, ' 'SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN: True}')) unformatted_code = textwrap.dedent("""\ f(a=5) """) expected_formatted_code = textwrap.dedent("""\ f(a = 5) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testTypeHint(self): unformatted_code = textwrap.dedent("""\ def foo(x: int=42): pass def foo2(x: 'int' =42): pass """) expected_formatted_code = textwrap.dedent("""\ def foo(x: int=42): pass def foo2(x: 'int'=42): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testMatrixMultiplication(self): unformatted_code = textwrap.dedent("""\ a=b@c """) expected_formatted_code = textwrap.dedent("""\ a = b @ c """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testAsyncWithPrecedingComment(self): if sys.version_info[1] < 5: return unformatted_code = textwrap.dedent("""\ import asyncio # Comment async def bar(): pass async def foo(): pass """) expected_formatted_code = textwrap.dedent("""\ import asyncio # Comment async def bar(): pass async def foo(): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) def testKeepTypesIntact(self): if sys.version_info[1] < 5: return unformatted_code = textwrap.dedent("""\ def _ReduceAbstractContainers( self, *args: Optional[automation_converter.PyiCollectionAbc]) -> List[ automation_converter.PyiCollectionAbc]: pass """) expected_formatted_code = textwrap.dedent("""\ def _ReduceAbstractContainers( self, *args: Optional[automation_converter.PyiCollectionAbc] ) -> List[automation_converter.PyiCollectionAbc]: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_style_config_test.py000066400000000000000000000036401304174360200232720ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Style config tests for yapf.reformatter.""" import textwrap import unittest from yapf.yapflib import reformatter from yapf.yapflib import style from yapftests import yapf_test_helper class TestsForStyleConfig(yapf_test_helper.YAPFTest): def setUp(self): self.current_style = style.DEFAULT_STYLE def testSetGlobalStyle(self): try: style.SetGlobalStyle(style.CreateChromiumStyle()) unformatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) expected_formatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style unformatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) expected_formatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/reformatter_verify_test.py000066400000000000000000000067671304174360200221260ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.reformatter.""" import textwrap import unittest from yapf.yapflib import py3compat from yapf.yapflib import reformatter from yapf.yapflib import style from yapf.yapflib import verifier from yapftests import yapf_test_helper @unittest.skipIf(py3compat.PY3, 'Requires Python 2') class TestVerifyNoVerify(yapf_test_helper.YAPFTest): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testVerifyException(self): unformatted_code = textwrap.dedent("""\ class ABC(metaclass=type): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) with self.assertRaises(verifier.InternalError): reformatter.Reformat(uwlines, verify=True) reformatter.Reformat(uwlines) # verify should be False by default. def testNoVerify(self): unformatted_code = textwrap.dedent("""\ class ABC(metaclass=type): pass """) expected_formatted_code = textwrap.dedent("""\ class ABC(metaclass=type): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual( expected_formatted_code, reformatter.Reformat( uwlines, verify=False)) def testVerifyFutureImport(self): unformatted_code = textwrap.dedent("""\ from __future__ import print_function def call_my_function(the_function): the_function("hi") if __name__ == "__main__": call_my_function(print) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) with self.assertRaises(verifier.InternalError): reformatter.Reformat(uwlines, verify=True) expected_formatted_code = textwrap.dedent("""\ from __future__ import print_function def call_my_function(the_function): the_function("hi") if __name__ == "__main__": call_my_function(print) """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual( expected_formatted_code, reformatter.Reformat( uwlines, verify=False)) def testContinuationLineShouldBeDistinguished(self): unformatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): if self.solo_generator_that_is_long is None and len( self.generators + self.next_batch) == 1: pass """) expected_formatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): if self.solo_generator_that_is_long is None and len( self.generators + self.next_batch) == 1: pass """) uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual( expected_formatted_code, reformatter.Reformat( uwlines, verify=False)) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/split_penalty_test.py000066400000000000000000000151761304174360200210710ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.split_penalty.""" import sys import textwrap import unittest from lib2to3 import pytree from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor from yapf.yapflib import split_penalty UNBREAKABLE = split_penalty.UNBREAKABLE VERY_STRONGLY_CONNECTED = split_penalty.VERY_STRONGLY_CONNECTED DOTTED_NAME = split_penalty.DOTTED_NAME STRONGLY_CONNECTED = split_penalty.STRONGLY_CONNECTED CONTIGUOUS_LIST = split_penalty.CONTIGUOUS_LIST class SplitPenaltyTest(unittest.TestCase): def _ParseAndComputePenalties(self, code, dumptree=False): """Parses the code and computes split penalties. Arguments: code: code to parse as a string dumptree: if True, the parsed pytree (after penalty assignment) is dumped to stderr. Useful for debugging. Returns: Parse tree. """ tree = pytree_utils.ParseCodeToTree(code) split_penalty.ComputeSplitPenalties(tree) if dumptree: pytree_visitor.DumpPyTree(tree, target_stream=sys.stderr) return tree def _CheckPenalties(self, tree, list_of_expected): """Check that the tokens in the tree have the correct penalties. Args: tree: the pytree. list_of_expected: list of (name, penalty) pairs. Non-semantic tokens are filtered out from the expected values. """ def FlattenRec(tree): if pytree_utils.NodeName(tree) in pytree_utils.NONSEMANTIC_TOKENS: return [] if isinstance(tree, pytree.Leaf): return [(tree.value, pytree_utils.GetNodeAnnotation( tree, pytree_utils.Annotation.SPLIT_PENALTY))] nodes = [] for node in tree.children: nodes += FlattenRec(node) return nodes self.assertEqual(list_of_expected, FlattenRec(tree)) def testUnbreakable(self): # Test function definitions. code = textwrap.dedent(r""" def foo(x): pass """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('def', None), ('foo', UNBREAKABLE), ('(', UNBREAKABLE), ('x', None), (')', STRONGLY_CONNECTED), (':', UNBREAKABLE), ('pass', None), ]) # Test function definition with trailing comment. code = textwrap.dedent(r""" def foo(x): # trailing comment pass """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('def', None), ('foo', UNBREAKABLE), ('(', UNBREAKABLE), ('x', None), (')', STRONGLY_CONNECTED), (':', UNBREAKABLE), ('pass', None), ]) # Test class definitions. code = textwrap.dedent(r""" class A: pass class B(A): pass """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('class', None), ('A', UNBREAKABLE), (':', UNBREAKABLE), ('pass', None), ('class', None), ('B', UNBREAKABLE), ('(', UNBREAKABLE), ('A', None), (')', None), (':', UNBREAKABLE), ('pass', None), ]) # Test lambda definitions. code = textwrap.dedent(r""" lambda a, b: None """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('lambda', None), ('a', UNBREAKABLE), (',', UNBREAKABLE), ('b', UNBREAKABLE), (':', UNBREAKABLE), ('None', UNBREAKABLE), ]) # Test dotted names. code = textwrap.dedent(r""" import a.b.c """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('import', None), ('a', None), ('.', UNBREAKABLE), ('b', UNBREAKABLE), ('.', UNBREAKABLE), ('c', UNBREAKABLE), ]) def testStronglyConnected(self): # Test dictionary keys. code = textwrap.dedent(r""" a = { 'x': 42, y(lambda a: 23): 37, } """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('a', None), ('=', None), ('{', None), ("'x'", None), (':', STRONGLY_CONNECTED), ('42', None), (',', None), ('y', None), ('(', UNBREAKABLE), ('lambda', STRONGLY_CONNECTED), ('a', UNBREAKABLE), (':', UNBREAKABLE), ('23', UNBREAKABLE), (')', VERY_STRONGLY_CONNECTED), (':', STRONGLY_CONNECTED), ('37', None), (',', None), ('}', None), ]) # Test list comprehension. code = textwrap.dedent(r""" [a for a in foo if a.x == 37] """) tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('[', None), ('a', STRONGLY_CONNECTED), ('for', STRONGLY_CONNECTED), ('a', STRONGLY_CONNECTED), ('in', STRONGLY_CONNECTED), ('foo', STRONGLY_CONNECTED), ('if', STRONGLY_CONNECTED), ('a', STRONGLY_CONNECTED), ('.', UNBREAKABLE), ('x', DOTTED_NAME), ('==', STRONGLY_CONNECTED), ('37', STRONGLY_CONNECTED), (']', STRONGLY_CONNECTED), ]) def testFuncCalls(self): code = 'foo(1, 2, 3)\n' tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('foo', None), ('(', UNBREAKABLE), ('1', CONTIGUOUS_LIST), (',', CONTIGUOUS_LIST), ('2', CONTIGUOUS_LIST), (',', CONTIGUOUS_LIST), ('3', CONTIGUOUS_LIST), (')', VERY_STRONGLY_CONNECTED), ]) # Now a method call, which has more than one trailer code = 'foo.bar.baz(1, 2, 3)\n' tree = self._ParseAndComputePenalties(code) self._CheckPenalties(tree, [ ('foo', None), ('.', UNBREAKABLE), ('bar', DOTTED_NAME), ('.', STRONGLY_CONNECTED), ('baz', DOTTED_NAME), ('(', STRONGLY_CONNECTED), ('1', CONTIGUOUS_LIST), (',', CONTIGUOUS_LIST), ('2', CONTIGUOUS_LIST), (',', CONTIGUOUS_LIST), ('3', CONTIGUOUS_LIST), (')', VERY_STRONGLY_CONNECTED), ]) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/style_test.py000066400000000000000000000207111304174360200173310ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.style.""" import contextlib import shutil import tempfile import textwrap import unittest from yapf.yapflib import style class UtilsTest(unittest.TestCase): def testStringListConverter(self): self.assertEqual(style._StringListConverter('foo, bar'), ['foo', 'bar']) self.assertEqual(style._StringListConverter('foo,bar'), ['foo', 'bar']) self.assertEqual(style._StringListConverter(' foo'), ['foo']) self.assertEqual( style._StringListConverter('joe ,foo, bar'), ['joe', 'foo', 'bar']) def testBoolConverter(self): self.assertEqual(style._BoolConverter('true'), True) self.assertEqual(style._BoolConverter('1'), True) self.assertEqual(style._BoolConverter('false'), False) self.assertEqual(style._BoolConverter('0'), False) def _LooksLikeChromiumStyle(cfg): return (cfg['INDENT_WIDTH'] == 2 and cfg['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF']) def _LooksLikeGoogleStyle(cfg): return (cfg['INDENT_WIDTH'] == 4 and cfg['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF']) def _LooksLikePEP8Style(cfg): return (cfg['INDENT_WIDTH'] == 4 and not cfg['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF']) def _LooksLikeFacebookStyle(cfg): return (cfg['INDENT_WIDTH'] == 4 and cfg['DEDENT_CLOSING_BRACKETS']) class PredefinedStylesByNameTest(unittest.TestCase): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testDefault(self): # default is PEP8 cfg = style.CreateStyleFromConfig(None) self.assertTrue(_LooksLikePEP8Style(cfg)) def testPEP8ByName(self): for pep8_name in ('PEP8', 'pep8', 'Pep8'): cfg = style.CreateStyleFromConfig(pep8_name) self.assertTrue(_LooksLikePEP8Style(cfg)) def testGoogleByName(self): for google_name in ('google', 'Google', 'GOOGLE'): cfg = style.CreateStyleFromConfig(google_name) self.assertTrue(_LooksLikeGoogleStyle(cfg)) def testChromiumByName(self): for chromium_name in ('chromium', 'Chromium', 'CHROMIUM'): cfg = style.CreateStyleFromConfig(chromium_name) self.assertTrue(_LooksLikeChromiumStyle(cfg)) def testFacebookByName(self): for fb_name in ('facebook', 'FACEBOOK', 'Facebook'): cfg = style.CreateStyleFromConfig(fb_name) self.assertTrue(_LooksLikeFacebookStyle(cfg)) @contextlib.contextmanager def _TempFileContents(dirname, contents): with tempfile.NamedTemporaryFile(dir=dirname, mode='w') as f: f.write(contents) f.flush() yield f class StyleFromFileTest(unittest.TestCase): @classmethod def setUpClass(cls): cls.test_tmpdir = tempfile.mkdtemp() style.SetGlobalStyle(style.CreatePEP8Style()) @classmethod def tearDownClass(cls): shutil.rmtree(cls.test_tmpdir) def testDefaultBasedOnStyle(self): cfg = textwrap.dedent('''\ [style] continuation_indent_width = 20 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikePEP8Style(cfg)) self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testDefaultBasedOnPEP8Style(self): cfg = textwrap.dedent('''\ [style] based_on_style = pep8 continuation_indent_width = 40 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikePEP8Style(cfg)) self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 40) def testDefaultBasedOnChromiumStyle(self): cfg = textwrap.dedent('''\ [style] based_on_style = chromium continuation_indent_width = 30 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikeChromiumStyle(cfg)) self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 30) def testDefaultBasedOnGoogleStyle(self): cfg = textwrap.dedent('''\ [style] based_on_style = google continuation_indent_width = 20 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikeGoogleStyle(cfg)) self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testDefaultBasedOnFacebookStyle(self): cfg = textwrap.dedent('''\ [style] based_on_style = facebook continuation_indent_width = 20 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikeFacebookStyle(cfg)) self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testBoolOptionValue(self): cfg = textwrap.dedent('''\ [style] based_on_style = chromium SPLIT_BEFORE_NAMED_ASSIGNS=False split_before_logical_operator = true ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikeChromiumStyle(cfg)) self.assertEqual(cfg['SPLIT_BEFORE_NAMED_ASSIGNS'], False) self.assertEqual(cfg['SPLIT_BEFORE_LOGICAL_OPERATOR'], True) def testStringListOptionValue(self): cfg = textwrap.dedent('''\ [style] based_on_style = chromium I18N_FUNCTION_CALL = N_, V_, T_ ''') with _TempFileContents(self.test_tmpdir, cfg) as f: cfg = style.CreateStyleFromConfig(f.name) self.assertTrue(_LooksLikeChromiumStyle(cfg)) self.assertEqual(cfg['I18N_FUNCTION_CALL'], ['N_', 'V_', 'T_']) def testErrorNoStyleFile(self): with self.assertRaisesRegexp(style.StyleConfigError, 'is not a valid style or file path'): style.CreateStyleFromConfig('/8822/xyznosuchfile') def testErrorNoStyleSection(self): cfg = textwrap.dedent('''\ [s] indent_width=2 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: with self.assertRaisesRegexp(style.StyleConfigError, 'Unable to find section'): style.CreateStyleFromConfig(f.name) def testErrorUnknownStyleOption(self): cfg = textwrap.dedent('''\ [style] indent_width=2 hummus=2 ''') with _TempFileContents(self.test_tmpdir, cfg) as f: with self.assertRaisesRegexp(style.StyleConfigError, 'Unknown style option'): style.CreateStyleFromConfig(f.name) class StyleFromCommandLine(unittest.TestCase): @classmethod def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testDefaultBasedOnStyle(self): cfg = style.CreateStyleFromConfig( '{based_on_style: pep8,' ' indent_width: 2,' ' blank_line_before_nested_class_or_def: True}') self.assertTrue(_LooksLikeChromiumStyle(cfg)) self.assertEqual(cfg['INDENT_WIDTH'], 2) def testDefaultBasedOnStyleNotStrict(self): cfg = style.CreateStyleFromConfig( '{based_on_style : pep8' ' ,indent_width=2' ' blank_line_before_nested_class_or_def:True}') self.assertTrue(_LooksLikeChromiumStyle(cfg)) self.assertEqual(cfg['INDENT_WIDTH'], 2) def testDefaultBasedOnStyleBadString(self): self.assertRaisesRegexp(style.StyleConfigError, 'Unknown style option', style.CreateStyleFromConfig, '{based_on_styl: pep8}') self.assertRaisesRegexp(style.StyleConfigError, 'not a valid', style.CreateStyleFromConfig, '{INDENT_WIDTH: FOUR}') self.assertRaisesRegexp(style.StyleConfigError, 'Invalid style dict', style.CreateStyleFromConfig, '{based_on_style: pep8') class StyleHelp(unittest.TestCase): def testHelpKeys(self): settings = sorted(style.Help()) expected = sorted(style._style) self.assertListEqual(settings, expected) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/subtype_assigner_test.py000066400000000000000000000173341304174360200215660ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.subtype_assigner.""" import textwrap import unittest from yapf.yapflib import format_token from yapf.yapflib import pytree_utils from yapftests import yapf_test_helper class SubtypeAssignerTest(yapf_test_helper.YAPFTest): def _CheckFormatTokenSubtypes(self, uwlines, list_of_expected): """Check that the tokens in the UnwrappedLines have the expected subtypes. Args: uwlines: list of UnwrappedLine. list_of_expected: list of (name, subtype) pairs. Non-semantic tokens are filtered out from the expected values. """ actual = [] for uwl in uwlines: filtered_values = [(ft.value, ft.subtypes) for ft in uwl.tokens if ft.name not in pytree_utils.NONSEMANTIC_TOKENS] if filtered_values: actual.append(filtered_values) self.assertEqual(list_of_expected, actual) def testFuncDefDefaultAssign(self): code = textwrap.dedent(r""" def foo(a=37, *b, **c): return -x[:42] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('def', [format_token.Subtype.NONE]), ('foo', {format_token.Subtype.FUNC_DEF}), ('(', [format_token.Subtype.NONE]), ('a', {format_token.Subtype.NONE, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), ('=', {format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), ('37', {format_token.Subtype.NONE, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), (',', {format_token.Subtype.NONE}), ('*', {format_token.Subtype.VARARGS_STAR, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), ('b', {format_token.Subtype.NONE, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), (',', {format_token.Subtype.NONE}), ('**', {format_token.Subtype.KWARGS_STAR_STAR, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), ('c', {format_token.Subtype.NONE, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), (')', [format_token.Subtype.NONE]), (':', [format_token.Subtype.NONE])], [('return', [format_token.Subtype.NONE]), ('-', {format_token.Subtype.UNARY_OPERATOR}), ('x', [format_token.Subtype.NONE]), ('[', {format_token.Subtype.SUBSCRIPT_BRACKET}), (':', {format_token.Subtype.SUBSCRIPT_COLON}), ('42', [format_token.Subtype.NONE]), (']', {format_token.Subtype.SUBSCRIPT_BRACKET})], ]) # yapf: disable def testFuncCallWithDefaultAssign(self): code = textwrap.dedent(r""" foo(x, a='hello world') """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('foo', [format_token.Subtype.NONE]), ('(', [format_token.Subtype.NONE]), ('x', {format_token.Subtype.NONE, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), (',', {format_token.Subtype.NONE}), ('a', {format_token.Subtype.NONE, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), ('=', {format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN}), ("'hello world'", {format_token.Subtype.NONE}), (')', [format_token.Subtype.NONE])], ]) # yapf: disable def testSetComprehension(self): code = textwrap.dedent("""\ def foo(strs): return {s.lower() for s in strs} """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('def', [format_token.Subtype.NONE]), ('foo', {format_token.Subtype.FUNC_DEF}), ('(', [format_token.Subtype.NONE]), ('strs', [format_token.Subtype.NONE]), (')', [format_token.Subtype.NONE]), (':', [format_token.Subtype.NONE])], [('return', [format_token.Subtype.NONE]), ('{', [format_token.Subtype.NONE]), ('s', [format_token.Subtype.NONE]), ('.', [format_token.Subtype.NONE]), ('lower', [format_token.Subtype.NONE]), ('(', [format_token.Subtype.NONE]), (')', [format_token.Subtype.NONE]), ('for', {format_token.Subtype.DICT_SET_GENERATOR, format_token.Subtype.COMP_FOR}), ('s', {format_token.Subtype.COMP_FOR}), ('in', {format_token.Subtype.COMP_FOR}), ('strs', {format_token.Subtype.COMP_FOR}), ('}', [format_token.Subtype.NONE])] ]) # yapf: disable def testUnaryNotOperator(self): code = textwrap.dedent("""\ not a """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('not', {format_token.Subtype.UNARY_OPERATOR}), ('a', [format_token.Subtype.NONE])] ]) # yapf: disable def testBitwiseOperators(self): code = textwrap.dedent("""\ x = ((a | (b ^ 3) & c) << 3) >> 1 """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('x', [format_token.Subtype.NONE]), ('=', {format_token.Subtype.ASSIGN_OPERATOR}), ('(', [format_token.Subtype.NONE]), ('(', [format_token.Subtype.NONE]), ('a', [format_token.Subtype.NONE]), ('|', {format_token.Subtype.BINARY_OPERATOR}), ('(', [format_token.Subtype.NONE]), ('b', [format_token.Subtype.NONE]), ('^', {format_token.Subtype.BINARY_OPERATOR}), ('3', [format_token.Subtype.NONE]), (')', [format_token.Subtype.NONE]), ('&', {format_token.Subtype.BINARY_OPERATOR}), ('c', [format_token.Subtype.NONE]), (')', [format_token.Subtype.NONE]), ('<<', {format_token.Subtype.BINARY_OPERATOR}), ('3', [format_token.Subtype.NONE]), (')', [format_token.Subtype.NONE]), ('>>', {format_token.Subtype.BINARY_OPERATOR}), ('1', [format_token.Subtype.NONE])], ]) # yapf: disable def testSubscriptColon(self): code = textwrap.dedent("""\ x[0:42:1] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('x', [format_token.Subtype.NONE]), ('[', {format_token.Subtype.SUBSCRIPT_BRACKET}), ('0', [format_token.Subtype.NONE]), (':', {format_token.Subtype.SUBSCRIPT_COLON}), ('42', [format_token.Subtype.NONE]), (':', {format_token.Subtype.SUBSCRIPT_COLON}), ('1', [format_token.Subtype.NONE]), (']', {format_token.Subtype.SUBSCRIPT_BRACKET})], ]) def testFunctionCallWithStarExpression(self): code = textwrap.dedent("""\ [a, *b] """) uwlines = yapf_test_helper.ParseAndUnwrap(code) self._CheckFormatTokenSubtypes(uwlines, [ [('[', [format_token.Subtype.NONE]), ('a', [format_token.Subtype.NONE]), (',', [format_token.Subtype.NONE]), ('*', {format_token.Subtype.UNARY_OPERATOR}), ('b', [format_token.Subtype.NONE]), (']', [format_token.Subtype.NONE])] ]) # yapf: disable if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/unwrapped_line_test.py000066400000000000000000000062271304174360200212130ustar00rootroot00000000000000# Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.unwrapped_line.""" import textwrap import unittest from lib2to3 import pytree from lib2to3.pgen2 import token from yapf.yapflib import format_token from yapf.yapflib import split_penalty from yapf.yapflib import unwrapped_line from yapftests import yapf_test_helper class UnwrappedLineBasicTest(unittest.TestCase): def testConstruction(self): toks = _MakeFormatTokenList([(token.DOT, '.'), (token.VBAR, '|')]) uwl = unwrapped_line.UnwrappedLine(20, toks) self.assertEqual(20, uwl.depth) self.assertEqual(['DOT', 'VBAR'], [tok.name for tok in uwl.tokens]) def testFirstLast(self): toks = _MakeFormatTokenList([(token.DOT, '.'), (token.LPAR, '('), (token.VBAR, '|')]) uwl = unwrapped_line.UnwrappedLine(20, toks) self.assertEqual(20, uwl.depth) self.assertEqual('DOT', uwl.first.name) self.assertEqual('VBAR', uwl.last.name) def testAsCode(self): toks = _MakeFormatTokenList([(token.DOT, '.'), (token.LPAR, '('), (token.VBAR, '|')]) uwl = unwrapped_line.UnwrappedLine(2, toks) self.assertEqual(' . ( |', uwl.AsCode()) def testAppendToken(self): uwl = unwrapped_line.UnwrappedLine(0) uwl.AppendToken(_MakeFormatTokenLeaf(token.LPAR, '(')) uwl.AppendToken(_MakeFormatTokenLeaf(token.RPAR, ')')) self.assertEqual(['LPAR', 'RPAR'], [tok.name for tok in uwl.tokens]) def testAppendNode(self): uwl = unwrapped_line.UnwrappedLine(0) uwl.AppendNode(pytree.Leaf(token.LPAR, '(')) uwl.AppendNode(pytree.Leaf(token.RPAR, ')')) self.assertEqual(['LPAR', 'RPAR'], [tok.name for tok in uwl.tokens]) class UnwrappedLineFormattingInformationTest(yapf_test_helper.YAPFTest): def testFuncDef(self): code = textwrap.dedent(r""" def f(a, b): pass """) uwlines = yapf_test_helper.ParseAndUnwrap(code) f = uwlines[0].tokens[1] self.assertFalse(f.can_break_before) self.assertFalse(f.must_break_before) self.assertEqual(f.split_penalty, split_penalty.UNBREAKABLE) lparen = uwlines[0].tokens[2] self.assertFalse(lparen.can_break_before) self.assertFalse(lparen.must_break_before) self.assertEqual(lparen.split_penalty, split_penalty.UNBREAKABLE) def _MakeFormatTokenLeaf(token_type, token_value): return format_token.FormatToken(pytree.Leaf(token_type, token_value)) def _MakeFormatTokenList(token_type_values): return [ _MakeFormatTokenLeaf(token_type, token_value) for token_type, token_value in token_type_values ] if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/yapf_test.py000066400000000000000000001123761304174360200171410ustar00rootroot00000000000000# -*- coding: utf-8 -*- # Copyright 2015-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for yapf.yapf.""" import io import logging import os import shutil import subprocess import sys import tempfile import textwrap import unittest from yapf.yapflib import py3compat from yapf.yapflib import style from yapf.yapflib import yapf_api ROOT_DIR = os.path.dirname(os.path.abspath(os.path.dirname(__file__))) # Verification is turned off by default, but want to enable it for testing. YAPF_BINARY = [sys.executable, '-m', 'yapf', '--verify', '--no-local-style'] class FormatCodeTest(unittest.TestCase): def _Check(self, unformatted_code, expected_formatted_code): formatted_code, _ = yapf_api.FormatCode( unformatted_code, style_config='chromium') self.assertEqual(expected_formatted_code, formatted_code) def testSimple(self): unformatted_code = textwrap.dedent("""\ print('foo') """) self._Check(unformatted_code, unformatted_code) def testNoEndingNewline(self): unformatted_code = textwrap.dedent("""\ if True: pass""") expected_formatted_code = textwrap.dedent("""\ if True: pass """) self._Check(unformatted_code, expected_formatted_code) class FormatFileTest(unittest.TestCase): def setUp(self): self.test_tmpdir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.test_tmpdir) def assertCodeEqual(self, expected_code, code): if code != expected_code: msg = 'Code format mismatch:\n' msg += 'Expected:\n >' msg += '\n > '.join(expected_code.splitlines()) msg += '\nActual:\n >' msg += '\n > '.join(code.splitlines()) # TODO(sbc): maybe using difflib here to produce easy to read deltas? self.fail(msg) def _MakeTempFileWithContents(self, filename, contents): path = os.path.join(self.test_tmpdir, filename) with py3compat.open_with_encoding(path, mode='w', encoding='utf-8') as f: f.write(py3compat.unicode(contents)) return path def testFormatFile(self): unformatted_code = textwrap.dedent("""\ if True: pass """) f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) expected_formatted_code_pep8 = textwrap.dedent("""\ if True: pass """) expected_formatted_code_chromium = textwrap.dedent("""\ if True: pass """) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(expected_formatted_code_pep8, formatted_code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='chromium') self.assertCodeEqual(expected_formatted_code_chromium, formatted_code) def testDisableLinesPattern(self): unformatted_code = textwrap.dedent("""\ if a: b # yapf: disable if f: g if h: i """) f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) expected_formatted_code = textwrap.dedent("""\ if a: b # yapf: disable if f: g if h: i """) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisableAndReenableLinesPattern(self): unformatted_code = textwrap.dedent("""\ if a: b # yapf: disable if f: g # yapf: enable if h: i """) f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) expected_formatted_code = textwrap.dedent("""\ if a: b # yapf: disable if f: g # yapf: enable if h: i """) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisablePartOfMultilineComment(self): unformatted_code = textwrap.dedent("""\ if a: b # This is a multiline comment that disables YAPF. # yapf: disable if f: g # yapf: enable # This is a multiline comment that enables YAPF. if h: i """) f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) expected_formatted_code = textwrap.dedent("""\ if a: b # This is a multiline comment that disables YAPF. # yapf: disable if f: g # yapf: enable # This is a multiline comment that enables YAPF. if h: i """) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(expected_formatted_code, formatted_code) code = textwrap.dedent("""\ def foo_function(): # some comment # yapf: disable foo( bar, baz ) # yapf: enable """) f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(code, formatted_code) def testFormatFileLinesSelection(self): unformatted_code = textwrap.dedent("""\ if a: b if f: g if h: i """) f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) expected_formatted_code_lines1and2 = textwrap.dedent("""\ if a: b if f: g if h: i """) formatted_code, _, _ = yapf_api.FormatFile( f, style_config='pep8', lines=[(1, 2)]) self.assertCodeEqual(expected_formatted_code_lines1and2, formatted_code) expected_formatted_code_lines3 = textwrap.dedent("""\ if a: b if f: g if h: i """) formatted_code, _, _ = yapf_api.FormatFile( f, style_config='pep8', lines=[(3, 3)]) self.assertCodeEqual(expected_formatted_code_lines3, formatted_code) def testFormatFileDiff(self): unformatted_code = textwrap.dedent("""\ if True: pass """) f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) diff, _, _ = yapf_api.FormatFile(f, print_diff=True) self.assertTrue(u'+ pass' in diff) def testFormatFileInPlace(self): unformatted_code = 'True==False\n' formatted_code = 'True == False\n' f = self._MakeTempFileWithContents('testfile1.py', unformatted_code) result, _, _ = yapf_api.FormatFile(f, in_place=True) self.assertEqual(result, None) with open(f) as fd: self.assertCodeEqual(formatted_code, fd.read()) self.assertRaises( ValueError, yapf_api.FormatFile, f, in_place=True, print_diff=True) def testNoFile(self): stream = py3compat.StringIO() handler = logging.StreamHandler(stream) logger = logging.getLogger('mylogger') logger.addHandler(handler) self.assertRaises( IOError, yapf_api.FormatFile, 'not_a_file.py', logger=logger.error) self.assertEqual(stream.getvalue(), "[Errno 2] No such file or directory: 'not_a_file.py'\n") def testCommentsUnformatted(self): code = textwrap.dedent("""\ foo = [# A list of things # bork 'one', # quark 'two'] # yapf: disable """) f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(code, formatted_code) def testDisabledHorizontalFormattingOnNewLine(self): code = textwrap.dedent("""\ # yapf: disable a = [ 1] # yapf: enable """) f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(code, formatted_code) def testDisabledSemiColonSeparatedStatements(self): code = textwrap.dedent("""\ # yapf: disable if True: a ; b """) f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='pep8') self.assertCodeEqual(code, formatted_code) def testDisabledMultilineStringInDictionary(self): code = textwrap.dedent("""\ # yapf: disable A = [ { "aaaaaaaaaaaaaaaaaaa": ''' bbbbbbbbbbb: "ccccccccccc" dddddddddddddd: 1 eeeeeeee: 0 ffffffffff: "ggggggg" ''', }, ] """) f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='chromium') self.assertCodeEqual(code, formatted_code) def testDisabledWithPrecedingText(self): code = textwrap.dedent("""\ # TODO(fix formatting): yapf: disable A = [ { "aaaaaaaaaaaaaaaaaaa": ''' bbbbbbbbbbb: "ccccccccccc" dddddddddddddd: 1 eeeeeeee: 0 ffffffffff: "ggggggg" ''', }, ] """) f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='chromium') self.assertCodeEqual(code, formatted_code) def testCRLFLineEnding(self): code = 'class _():\r\n pass\r\n' f = self._MakeTempFileWithContents('testfile1.py', code) formatted_code, _, _ = yapf_api.FormatFile(f, style_config='chromium') self.assertCodeEqual(code, formatted_code) class CommandLineTest(unittest.TestCase): """Test how calling yapf from the command line acts.""" @classmethod def setUpClass(cls): cls.test_tmpdir = tempfile.mkdtemp() @classmethod def tearDownClass(cls): shutil.rmtree(cls.test_tmpdir) def assertYapfReformats(self, unformatted, expected, extra_options=None): """Check that yapf reformats the given code as expected. Invokes yapf in a subprocess, piping the unformatted code into its stdin. Checks that the formatted output is as expected. Arguments: unformatted: unformatted code - input to yapf expected: expected formatted code at the output of yapf extra_options: iterable of extra command-line options to pass to yapf """ cmdline = YAPF_BINARY + (extra_options or []) p = subprocess.Popen( cmdline, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) reformatted_code, stderrdata = p.communicate(unformatted.encode('utf-8')) self.assertEqual(stderrdata, b'') self.assertEqual(reformatted_code.decode('utf-8'), expected) def testUnicodeEncodingPipedToFile(self): unformatted_code = textwrap.dedent(u"""\ def foo(): print('⇒') """) with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as outfile: with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as testfile: testfile.write(unformatted_code.encode('UTF-8')) subprocess.check_call( YAPF_BINARY + ['--diff', testfile.name], stdout=outfile) def testInPlaceReformatting(self): unformatted_code = textwrap.dedent("""\ def foo(): x = 37 """) expected_formatted_code = textwrap.dedent("""\ def foo(): x = 37 """) with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as testfile: testfile.write(unformatted_code.encode('UTF-8')) testfile.seek(0) p = subprocess.Popen(YAPF_BINARY + ['--in-place', testfile.name]) p.wait() with io.open(testfile.name, mode='r', newline='') as fd: reformatted_code = fd.read() self.assertEqual(reformatted_code, expected_formatted_code) def testInPlaceReformattingBlank(self): unformatted_code = u'\n\n' expected_formatted_code = u'\n' with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as testfile: testfile.write(unformatted_code.encode('UTF-8')) testfile.seek(0) p = subprocess.Popen(YAPF_BINARY + ['--in-place', testfile.name]) p.wait() with io.open(testfile.name, mode='r', newline='') as fd: reformatted_code = fd.read() self.assertEqual(reformatted_code, expected_formatted_code) def testInPlaceReformattingEmpty(self): unformatted_code = u'' expected_formatted_code = u'' with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as testfile: testfile.write(unformatted_code.encode('UTF-8')) testfile.seek(0) p = subprocess.Popen(YAPF_BINARY + ['--in-place', testfile.name]) p.wait() with py3compat.open_with_encoding( testfile.name, mode='r', encoding='utf-8') as fd: reformatted_code = fd.read() self.assertEqual(reformatted_code, expected_formatted_code) def testReadFromStdin(self): unformatted_code = textwrap.dedent("""\ def foo(): x = 37 """) expected_formatted_code = textwrap.dedent("""\ def foo(): x = 37 """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReadFromStdinWithEscapedStrings(self): unformatted_code = textwrap.dedent("""\ s = "foo\\nbar" """) expected_formatted_code = textwrap.dedent("""\ s = "foo\\nbar" """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testSetChromiumStyle(self): unformatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) expected_formatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--style=chromium']) def testSetCustomStyleBasedOnChromium(self): unformatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) expected_formatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) with tempfile.NamedTemporaryFile(dir=self.test_tmpdir, mode='w') as f: f.write( textwrap.dedent('''\ [style] based_on_style = chromium SPACES_BEFORE_COMMENT = 4 ''')) f.flush() self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--style={0}'.format(f.name)]) def testReadSingleLineCodeFromStdin(self): unformatted_code = textwrap.dedent("""\ if True: pass """) expected_formatted_code = textwrap.dedent("""\ if True: pass """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testEncodingVerification(self): unformatted_code = textwrap.dedent("""\ '''The module docstring.''' # -*- coding: utf-8 -*- def f(): x = 37 """) with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as outfile: with tempfile.NamedTemporaryFile( suffix='.py', dir=self.test_tmpdir) as testfile: testfile.write(unformatted_code.encode('utf-8')) subprocess.check_call( YAPF_BINARY + ['--diff', testfile.name], stdout=outfile) def testReformattingSpecificLines(self): unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) # TODO(ambv): the `expected_formatted_code` here is not PEP8 compliant, # raising "E129 visually indented line with same indent as next logical # line" with flake8. self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-2']) def testOmitFormattingLinesBeforeDisabledFunctionComment(self): unformatted_code = textwrap.dedent("""\ import sys # Comment def some_func(x): x = ["badly" , "formatted","line" ] """) expected_formatted_code = textwrap.dedent("""\ import sys # Comment def some_func(x): x = ["badly", "formatted", "line"] """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '5-5']) def testReformattingSkippingLines(self): unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass # yapf: disable def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass # yapf: enable """) expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass # yapf: disable def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass # yapf: enable """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReformattingSkippingToEndOfFile(self): unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass # yapf: disable def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def f(): def e(): while (xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): pass """) expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass # yapf: disable def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def f(): def e(): while (xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and xxxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): pass """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReformattingSkippingSingleLine(self): unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testDisableWholeDataStructure(self): unformatted_code = textwrap.dedent("""\ A = set([ 'hello', 'world', ]) # yapf: disable """) expected_formatted_code = textwrap.dedent("""\ A = set([ 'hello', 'world', ]) # yapf: disable """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testDisableButAdjustIndentations(self): unformatted_code = textwrap.dedent("""\ class SplitPenaltyTest(unittest.TestCase): def testUnbreakable(self): self._CheckPenalties(tree, [ ]) # yapf: disable """) expected_formatted_code = textwrap.dedent("""\ class SplitPenaltyTest(unittest.TestCase): def testUnbreakable(self): self._CheckPenalties(tree, [ ]) # yapf: disable """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testRetainingHorizontalWhitespace(self): unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy (zzzzzzzzzzzzz [0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy (zzzzzzzzzzzzz [0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testRetainingVerticalWhitespace(self): unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-2']) unformatted_code = textwrap.dedent("""\ if a: b if c: to_much + indent same #comment # trailing whitespace """) expected_formatted_code = textwrap.dedent("""\ if a: b if c: to_much + indent same #comment # trailing whitespace """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '3-3', '--lines', '13-13']) unformatted_code = textwrap.dedent("""\ ''' docstring ''' import blah """) self.assertYapfReformats( unformatted_code, unformatted_code, extra_options=['--lines', '2-2']) def testRetainingSemicolonsWhenSpecifyingLines(self): unformatted_code = textwrap.dedent("""\ a = line_to_format def f(): x = y + 42; z = n * 42 if True: a += 1 ; b += 1 ; c += 1 """) expected_formatted_code = textwrap.dedent("""\ a = line_to_format def f(): x = y + 42; z = n * 42 if True: a += 1 ; b += 1 ; c += 1 """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-1']) def testDisabledMultilineStrings(self): unformatted_code = textwrap.dedent('''\ foo=42 def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """+despot["Nicholas"]+"""
Minion: """+serf["Dmitri"]+"""
Residence: """+palace["Winter"]+"""
""" ''') expected_formatted_code = textwrap.dedent('''\ foo = 42 def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """+despot["Nicholas"]+"""
Minion: """+serf["Dmitri"]+"""
Residence: """+palace["Winter"]+"""
""" ''') self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-1']) def testDisableWhenSpecifyingLines(self): unformatted_code = textwrap.dedent("""\ # yapf: disable A = set([ 'hello', 'world', ]) # yapf: enable B = set([ 'hello', 'world', ]) # yapf: disable """) expected_formatted_code = textwrap.dedent("""\ # yapf: disable A = set([ 'hello', 'world', ]) # yapf: enable B = set([ 'hello', 'world', ]) # yapf: disable """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-10']) def testDisableFormattingInDataLiteral(self): unformatted_code = textwrap.dedent("""\ def horrible(): oh_god() why_would_you() [ 'do', 'that', ] def still_horrible(): oh_god() why_would_you() [ 'do', 'that' ] """) expected_formatted_code = textwrap.dedent("""\ def horrible(): oh_god() why_would_you() [ 'do', 'that', ] def still_horrible(): oh_god() why_would_you() ['do', 'that'] """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '14-15']) def testRetainVerticalFormattingBetweenDisabledAndEnabledLines(self): unformatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) self.assertEqual( ('ddddddddddddddddddddddddd', 'eeeeeeeeeeeeeeeeeeeeeeeee.%s' % c.ffffffffffff), gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) expected_formatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) self.assertEqual(('ddddddddddddddddddddddddd', 'eeeeeeeeeeeeeeeeeeeeeeeee.%s' % c.ffffffffffff), gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '4-7']) def testFormatLinesSpecifiedInMiddleOfExpression(self): unformatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) self.assertEqual( ('ddddddddddddddddddddddddd', 'eeeeeeeeeeeeeeeeeeeeeeeee.%s' % c.ffffffffffff), gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) expected_formatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) self.assertEqual(('ddddddddddddddddddddddddd', 'eeeeeeeeeeeeeeeeeeeeeeeee.%s' % c.ffffffffffff), gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '5-6']) def testCommentFollowingMultilineString(self): unformatted_code = textwrap.dedent("""\ def foo(): '''First line. Second line. ''' # comment x = '''hello world''' # second comment return 42 # another comment """) expected_formatted_code = textwrap.dedent("""\ def foo(): '''First line. Second line. ''' # comment x = '''hello world''' # second comment return 42 # another comment """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-1']) def testDedentClosingBracket(self): # no line-break on the first argument, not dedenting closing brackets unformatted_code = textwrap.dedent("""\ def overly_long_function_name(first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name(first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--style=pep8']) # TODO(ambv): currently the following produces the closing bracket on a new # line but indented to the opening bracket which is the worst of both # worlds. Expected behaviour would be to format as --style=pep8 does in # this case. # self.assertYapfReformats(unformatted_code, expected_formatted_code, # extra_options=['--style=facebook']) # line-break before the first argument, dedenting closing brackets if set unformatted_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) expected_formatted_pep8_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, \ second_argument_makes_the_line_too_long): pass """) expected_formatted_fb_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long ): pass """) self.assertYapfReformats( unformatted_code, expected_formatted_fb_code, extra_options=['--style=facebook']) # TODO(ambv): currently the following produces code that is not PEP8 # compliant, raising "E125 continuation line with same indent as next # logical line" with flake8. Expected behaviour for PEP8 would be to use # double-indentation here. # self.assertYapfReformats(unformatted_code, expected_formatted_pep8_code, # extra_options=['--style=pep8']) def testCoalesceBrackets(self): unformatted_code = textwrap.dedent("""\ some_long_function_name_foo({ 'first_argument_of_the_thing': id, 'second_argument_of_the_thing': "some thing"} )""") expected_formatted_code = textwrap.dedent("""\ some_long_function_name_foo({ 'first_argument_of_the_thing': id, 'second_argument_of_the_thing': "some thing" }) """) with tempfile.NamedTemporaryFile(dir=self.test_tmpdir, mode='w') as f: f.write( textwrap.dedent('''\ [style] based_on_style = facebook column_limit=82 coalesce_brackets = True ''')) f.flush() self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--style={0}'.format(f.name)]) def testPseudoParenSpaces(self): unformatted_code = textwrap.dedent("""\ def foo(): def bar(): return {msg_id: author for author, msg_id in reader} """) expected_formatted_code = textwrap.dedent("""\ def foo(): def bar(): return {msg_id: author for author, msg_id in reader} """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-1', '--style', 'chromium']) def testMultilineCommentFormattingDisabled(self): unformatted_code = textwrap.dedent("""\ # This is a comment FOO = { aaaaaaaa.ZZZ: [ bbbbbbbbbb.Pop(), # Multiline comment. # Line two. bbbbbbbbbb.Pop(), ], 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx': ('yyyyy', zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz), '#': lambda x: x # do nothing } """) expected_formatted_code = textwrap.dedent("""\ # This is a comment FOO = { aaaaaaaa.ZZZ: [ bbbbbbbbbb.Pop(), # Multiline comment. # Line two. bbbbbbbbbb.Pop(), ], 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx': ('yyyyy', zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz), '#': lambda x: x # do nothing } """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-1', '--style', 'chromium']) def testTrailingCommentsWithDisabledFormatting(self): unformatted_code = textwrap.dedent("""\ import os SCOPES = [ 'hello world' # This is a comment. ] """) expected_formatted_code = textwrap.dedent("""\ import os SCOPES = [ 'hello world' # This is a comment. ] """) self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--lines', '1-1', '--style', 'chromium']) def testUseTabs(self): unformatted_code = textwrap.dedent("""\ def foo_function(): if True: pass """) expected_formatted_code = textwrap.dedent("""\ def foo_function(): if True: pass """) with tempfile.NamedTemporaryFile(dir=self.test_tmpdir, mode='w') as f: f.write( textwrap.dedent('''\ [style] based_on_style = chromium USE_TABS = true INDENT_WIDTH=1 ''')) f.flush() self.assertYapfReformats( unformatted_code, expected_formatted_code, extra_options=['--style={0}'.format(f.name)]) class BadInputTest(unittest.TestCase): """Test yapf's behaviour when passed bad input.""" def testBadSyntax(self): code = ' a = 1\n' self.assertRaises(SyntaxError, yapf_api.FormatCode, code) class DiffIndentTest(unittest.TestCase): @staticmethod def _OwnStyle(): my_style = style.CreatePEP8Style() my_style['INDENT_WIDTH'] = 3 my_style['CONTINUATION_INDENT_WIDTH'] = 3 return my_style def _Check(self, unformatted_code, expected_formatted_code): formatted_code, _ = yapf_api.FormatCode( unformatted_code, style_config=style.SetGlobalStyle(self._OwnStyle())) self.assertEqual(expected_formatted_code, formatted_code) def testSimple(self): unformatted_code = textwrap.dedent("""\ for i in range(5): print('bar') """) expected_formatted_code = textwrap.dedent("""\ for i in range(5): print('bar') """) self._Check(unformatted_code, expected_formatted_code) if __name__ == '__main__': unittest.main() yapf-0.15.1/yapftests/yapf_test_helper.py000066400000000000000000000052641304174360200204750ustar00rootroot00000000000000# Copyright 2016-2017 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Support module for tests for yapf.""" import difflib import sys import unittest from yapf.yapflib import blank_line_calculator from yapf.yapflib import comment_splicer from yapf.yapflib import continuation_splicer from yapf.yapflib import pytree_unwrapper from yapf.yapflib import pytree_utils from yapf.yapflib import pytree_visitor from yapf.yapflib import split_penalty from yapf.yapflib import style from yapf.yapflib import subtype_assigner class YAPFTest(unittest.TestCase): def assertCodeEqual(self, expected_code, code): if code != expected_code: msg = ['Code format mismatch:', 'Expected:'] linelen = style.Get('COLUMN_LIMIT') for l in expected_code.splitlines(): if len(l) > linelen: msg.append('!> %s' % l) else: msg.append(' > %s' % l) msg.append('Actual:') for l in code.splitlines(): if len(l) > linelen: msg.append('!> %s' % l) else: msg.append(' > %s' % l) msg.append('Diff:') msg.extend( difflib.unified_diff( code.splitlines(), expected_code.splitlines(), fromfile='actual', tofile='expected', lineterm='')) self.fail('\n'.join(msg)) def ParseAndUnwrap(code, dumptree=False): """Produces unwrapped lines from the given code. Parses the code into a tree, performs comment splicing and runs the unwrapper. Arguments: code: code to parse as a string dumptree: if True, the parsed pytree (after comment splicing) is dumped to stderr. Useful for debugging. Returns: List of unwrapped lines. """ tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) continuation_splicer.SpliceContinuations(tree) subtype_assigner.AssignSubtypes(tree) split_penalty.ComputeSplitPenalties(tree) blank_line_calculator.CalculateBlankLines(tree) if dumptree: pytree_visitor.DumpPyTree(tree, target_stream=sys.stderr) uwlines = pytree_unwrapper.UnwrapPyTree(tree) for uwl in uwlines: uwl.CalculateFormattingInformation() return uwlines