Merge QP1A.180823.001
Change-Id: I5757e4de4d821096af4f3f3fa676a8d96bd7fde7
diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 0000000..3c3efd7
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,5 @@
+[report]
+# Verifier is used for testing only.
+omit =
+ */__main__.py
+ */verifier.py
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..0736228
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,14 @@
+# 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
diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..06d70e9
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,8 @@
+[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
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3fd6b2b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,34 @@
+#==============================================================================#
+# 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
diff --git a/.style.yapf b/.style.yapf
new file mode 100644
index 0000000..823a973
--- /dev/null
+++ b/.style.yapf
@@ -0,0 +1,3 @@
+[style]
+# YAPF uses the chromium style
+based_on_style = chromium
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..1d90518
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,28 @@
+language: 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
diff --git a/.vimrc b/.vimrc
new file mode 100644
index 0000000..e54f1d3
--- /dev/null
+++ b/.vimrc
@@ -0,0 +1,4 @@
+" Force indentation styles for this directory
+autocmd FileType python set shiftwidth=2
+autocmd FileType python set tabstop=2
+autocmd FileType python set softtabstop=2
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..b5e878e
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,9 @@
+# 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 <email address>
+# The email address is not required for organizations.
+
+Google Inc.
diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 0000000..4693f03
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,565 @@
+# Change Log
+# All notable changes to this project will be documented in this file.
+# This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [0.23.0] UNRELEASED
+### Added
+- `DISABLE_ENDING_COMMA_HEURISTIC` is a new knob to disable the heuristic which
+ splits a list onto separate lines if the list is comma-terminated.
+### Fixed
+- There's no need to increase N_TOKENS. In fact, it causes other things which
+ use lib2to3 to fail if called from YAPF.
+- Change the exception message instead of creating a new one that's just a
+ clone.
+
+## [0.22.0] 2018-05-15
+### Added
+- The `BLANK_LINE_BEFORE_MODULE_DOCSTRING` knob adds a blank line before a
+ module's docstring.
+- The `SPLIT_ALL_COMMA_SEPARATED_VALUES` knob causes all lists, tuples, dicts
+ function defs, etc... to split on all values, instead of maximizing the
+ number of elements on each line, when not able to fit on a single line.
+### Changed
+- Improve the heuristic we use to determine when to split at the start of a
+ function call. First check whether or not all elements can fit in the space
+ without wrapping. If not, then we split.
+- Check all of the elements of a tuple. Similarly to how arguments are
+ analyzed. This allows tuples to be split more rationally.
+- Adjust splitting penalties around arithmetic operators so that the code can
+ flow more freely. The code must flow!
+- Try to meld an argument list's closing parenthesis to the last argument.
+### Fixed
+- Attempt to determine if long lambdas are allowed. This can be done on a
+ case-by-case basis with a "pylint" disable comment.
+- A comment before a decorator isn't part of the decorator's line.
+- Only force a new wrapped line after a comment in a decorator when it's the
+ first token in the decorator.
+
+## [0.21.0] 2018-03-18
+### Added
+- Introduce a new option of formatting multiline literals. Add
+ `SPLIT_BEFORE_CLOSING_BRACKET` knob to control whether closing bracket should
+ get their own line.
+- Added `CONTINUATION_ALIGN_STYLE` knob to choose continuation alignment style
+ when `USE_TABS` is enabled.
+- Add 'BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION' knob to control the number
+ of blank lines between top-level function and class definitions.
+### Fixed
+- Don't split ellipses.
+
+## [0.20.2] 2018-02-12
+### Changed
+- Improve the speed at which files are excluded by ignoring them earlier.
+- Allow dictionaries to stay on a single line if they only have one entry
+### Fixed
+- Use tabs when constructing a continuation line when `USE_TABS` is enabled.
+- A dictionary entry may not end in a colon, but may be an "unpacking"
+ operation: `**foo`. Take that into accound and don't split after the
+ unpacking operator.
+
+## [0.20.1] 2018-01-13
+### Fixed
+- Don't treat 'None' as a keyword if calling a function on it, like '__ne__()'.
+- use_tabs=True always uses a single tab per indentation level; spaces are
+ used for aligning vertically after that.
+- Relax the split of a paren at the end of an if statement. With
+ `dedent_closing_brackets` option requires that it be able to split there.
+
+## [0.20.0] 2017-11-14
+### Added
+- Improve splitting of comprehensions and generators. Add
+ `SPLIT_PENALTY_COMPREHENSION` knob to control preference for keeping
+ comprehensions on a single line and `SPLIT_COMPLEX_COMPREHENSION` to enable
+ splitting each clause of complex comprehensions onto its own line.
+### Changed
+- Take into account a named function argument when determining if we should
+ split before the first argument in a function call.
+- Split before the first argument in a function call if the arguments contain a
+ dictionary that doesn't fit on a single line.
+- Improve splitting of elements in a tuple. We want to split if there's a
+ function call in the tuple that doesn't fit on the line.
+### Fixed
+- Enforce spaces between ellipses and keywords.
+- When calculating the split penalty for a "trailer", process the child nodes
+ afterwards because their penalties may change. For example if a list
+ comprehension is an argument.
+- Don't enforce a split before a comment after the opening of a container if it
+ doesn't it on the current line. We try hard not to move such comments around.
+- Use a TextIOWrapper when reading from stdin in Python3. This is necessary for
+ some encodings, like cp936, used on Windows.
+- Remove the penalty for a split before the first argument in a function call
+ where the only argument is a generator expression.
+
+## [0.19.0] 2017-10-14
+### Added
+- Added `SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN` that enforces a split
+ after the opening paren of an expression that's surrounded by parens.
+### Changed
+- Split before the ending bracket of a comma-terminated tuple / argument list
+ if it's not a single element tuple / arg list.
+### Fixed
+- Prefer to split after a comma in an argument list rather than in the middle
+ of an argument.
+- A non-multiline string may have newlines if it contains continuation markers
+ itself. Don't add a newline after the string when retaining the vertical
+ space.
+- Take into account the "async" keyword when determining if we must split
+ before the first argument.
+- Increase affinity for "atom" arguments in function calls. This helps prevent
+ lists from being separated when they don't need to be.
+- Don't place a dictionary argument on its own line if it's the last argument
+ in the function call where that function is part of a builder-style call.
+- Append the "var arg" type to a star in a star_expr.
+
+## [0.18.0] 2017-09-18
+### Added
+- Option `ALLOW_SPLIT_BEFORE_DICT_VALUE` allows a split before a value. If
+ False, then it won't be split even if it goes over the column limit.
+### Changed
+- Use spaces around the '=' in a typed name argument to align with 3.6 syntax.
+### Fixed
+- Allow semicolons if the line is disabled.
+- Fix issue where subsequent comments at decreasing levels of indentation
+ were improperly aligned and/or caused output with invalid syntax.
+- Fix issue where specifying a line range removed a needed line before a
+ comment.
+- Fix spacing between unary operators if one is 'not'.
+- Indent the dictionary value correctly if there's a multi-line key.
+- Don't remove needed spacing before a comment in a dict when in "chromium"
+ style.
+- Increase indent for continuation line with same indent as next logical line
+ with 'async with' statement.
+
+## [0.17.0] 2017-08-20
+### Added
+- Option `NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS` prevents adding spaces
+ around selected binary operators, in accordance with the current style guide.
+### Changed
+- Adjust blank lines on formatting boundaries when using the `--lines` option.
+- Return 1 if a diff changed the code. This is in line with how GNU diff acts.
+- Add `-vv` flag to print out file names as they are processed
+### Fixed
+- Corrected how `DEDENT_CLOSING_BRACKETS` and `COALESCE_BRACKETS` interacted.
+- Fix return value to return a boolean.
+- Correct vim plugin not to clobber edited code if yapf returns an error.
+- Ensured comma-terminated tuples with multiple elements are split onto separate lines.
+
+## [0.16.3] 2017-07-13
+### Changed
+- Add filename information to a ParseError exception.
+### Fixed
+- A token that ends in a continuation marker may have more than one newline in
+ it, thus changing its "lineno" value. This can happen if multiple
+ continuation markers are used with no intervening tokens. Adjust the line
+ number to account for the lines covered by those markers.
+- Make sure to split after a comment even for "pseudo" parentheses.
+
+## [0.16.2] 2017-05-19
+### Fixed
+- Treat expansion operators ('*', '**') in a similar way to function calls to
+ avoid splitting directly after the opening parenthesis.
+- Increase the penalty for splitting after the start of a tuple.
+- Increase penalty for excess characters.
+- Check that we have enough children before trying to access them all.
+- Remove trailing whitespaces from comments.
+- Split before a function call in a list if the full list isn't able to fit on
+ a single line.
+- Trying not to split around the '=' of a named assign.
+- Changed split before the first argument behavior to ignore compound
+ statements like if and while, but not function declarations.
+- Changed coalesce brackets not to line split before closing bracket.
+
+## [0.16.1] 2017-03-22
+### Changed
+- Improved performance of cloning the format decision state object. This
+ improved the time in one *large* case from 273.485s to 234.652s.
+- Relax the requirement that a named argument needs to be on one line. Going
+ over the column limit is more of an issue to pylint than putting named args
+ on multiple lines.
+- Don't make splitting penalty decisions based on the original formatting. This
+ can and does lead to non-stable formatting, where yapf will reformat the same
+ code in different ways.
+### Fixed
+- Ensure splitting of arguments if there's a named assign present.
+- Prefer to coalesce opening brackets if it's not at the beginning of a
+ function call.
+- Prefer not to squish all of the elements in a function call over to the
+ right-hand side. Split the arguments instead.
+- We need to split a dictionary value if the first element is a comment anyway,
+ so don't force the split here. It's forced elsewhere.
+- Ensure tabs are used for continued indentation when USE_TABS is True.
+
+## [0.16.0] 2017-02-05
+### Added
+- The `EACH_DICT_ENTRY_ON_SEPARATE_LINE` knob indicates that each dictionary
+ entry should be in separate lines if the full dictionary isn't able to fit on
+ a single line.
+- The `SPLIT_BEFORE_DICT_SET_GENERATOR` knob splits before the `for` part of a
+ dictionary/set generator.
+- The `BLANK_LINE_BEFORE_CLASS_DOCSTRING` knob adds a blank line before a
+ class's docstring.
+- The `ALLOW_MULTILINE_DICTIONARY_KEYS` knob allows dictionary keys to span
+ more than one line.
+### Fixed
+- Split before all entries in a dict/set or list maker when comma-terminated,
+ even if there's only one entry.
+- Will now try to set O_BINARY mode on stdout under Windows and Python 2.
+- Avoid unneeded newline transformation when writing formatted code to
+ output on (affects only Python 2)
+
+## [0.15.2] 2017-01-29
+### Fixed
+- Don't perform a global split when a named assign is part of a function call
+ which itself is an argument to a function call. I.e., don't cause 'a' to
+ split here:
+
+ func(a, b, c, d(x, y, z=42))
+- Allow splitting inside a subscript if it's a logical or bitwise operating.
+ This should keep the subscript mostly contiguous otherwise.
+
+## [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
+ multiple 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(<create pre-defined style>)` 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.
diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
new file mode 100644
index 0000000..0b113c0
--- /dev/null
+++ b/CONTRIBUTING.rst
@@ -0,0 +1,44 @@
+Want 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
+<https://developers.google.com/open-source/cla/individual?csw=1>`_ (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
+<https://www.chromium.org/chromium-os/python-style-guidelines>`_. 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.
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
new file mode 100644
index 0000000..62e2a5f
--- /dev/null
+++ b/CONTRIBUTORS
@@ -0,0 +1,15 @@
+# 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 <email address>
+
+Bill Wendling <morbo@google.com>
+Eli Bendersky <eliben@google.com>
+Sam Clegg <sbc@google.com>
+Łukasz Langa <ambv@fb.com>
diff --git a/HACKING.rst b/HACKING.rst
new file mode 100644
index 0000000..cc27c5a
--- /dev/null
+++ b/HACKING.rst
@@ -0,0 +1,32 @@
+Running 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 current 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.6]
+
+* 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
+
+* Build release: python setup.py sdist bdist_wheel
+
+* Push to PyPI: twine upload dist/*
+
+* Test in a clean virtualenv that 'pip install yapf' works with the new version
+
+* Commit the version bump; add tag with git tag v<VERSION_NUM>; git push --tags
+
+TODO: discuss how to use tox to make virtualenv testing easier.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+ 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.
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..5c70a55
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,4 @@
+include HACKING.rst LICENSE AUTHORS CHANGELOG CONTRIBUTING.rst CONTRIBUTORS
+include .coveragerc .editorconfig .flake8 plugins/README.rst
+include plugins/vim/autoload/yapf.vim plugins/vim/plugin/yapf.vim pylintrc
+include .style.yapf tox.ini .travis.yml .vimrc
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..0124a46
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,3 @@
+yim@google.com
+yuexima@google.com
+# Will perform annual update
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..19ef0c2
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,710 @@
+====
+YAPF
+====
+
+.. image:: https://badge.fury.io/py/yapf.svg
+ :target: https://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.
+
+Try out YAPF with this `online demo <https://yapf.now.sh>`_.
+
+.. 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:: shell
+
+ $ pip install yapf
+
+(optional) If you are using Python 2.7 and want to enable multiprocessing:
+
+.. code-block:: shell
+
+ $ 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:: shell
+
+ $ PYTHONPATH=DIR python DIR/yapf [options] ...
+
+
+Python versions
+===============
+
+YAPF supports Python 2.7 and 3.6.4+. (Note that some Python 3 features may fail
+to parse with Python versions before 3.6.4.)
+
+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]
+ [-vv]
+ [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 the same
+ directory as the source or one of its parent
+ directories (for stdin, the current directory is
+ used).
+ --style-help show style settings and exit; this output can be saved
+ to .style.yapf to make your settings permanent
+ --no-local-style don't search for local style definition
+ -p, --parallel Run yapf in parallel when formatting multiple files.
+ Requires concurrent.futures in Python 2.X
+ -vv, --verbose Print out file names while processing
+
+
+------------
+Return Codes
+------------
+
+Normally YAPF returns zero on successful program termination and non-zero otherwise.
+
+If ``--diff`` is supplied, YAPF returns zero when no changes were necessary, non-zero
+otherwise (including program error). You can use this in a CI workflow to test that code
+has been YAPF-formatted.
+
+
+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:: ini
+
+ [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:: shell
+
+ --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.yapflib.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 ``<unknown>``.
+
+``FormatFile`` returns reformatted code from the passed file along with its encoding:
+
+.. code-block:: python
+
+ >>> from yapf.yapflib.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.
+
+``ALLOW_MULTILINE_DICTIONARY_KEYS``
+ Allow dictionary keys to exist on multiple lines. For example:
+
+ .. code-block:: python
+
+ x = {
+ ('this is the first element of a tuple',
+ 'this is the second element of a tuple'):
+ value,
+ }
+
+``ALLOW_SPLIT_BEFORE_DICT_VALUE``
+ Allow splits before the dictionary value.
+
+``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
+
+``BLANK_LINE_BEFORE_MODULE_DOCSTRING``
+ Insert a blank line before a module docstring.
+
+``BLANK_LINE_BEFORE_CLASS_DOCSTRING``
+ Insert a blank line before a class-level docstring.
+
+``BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION``
+ Sets the number of desired blank lines surrounding top-level function and
+ class definitions. For example:
+
+ .. code-block:: python
+
+ class Foo:
+ pass
+ # <------ having two blank lines here
+ # <------ is the default setting
+ class Bar:
+ 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_ALIGN_STYLE``
+ The style for continuation alignment. Possible values are:
+
+ - SPACE: Use spaces for continuation alignment. This is default behavior.
+ - FIXED: Use fixed number (CONTINUATION_INDENT_WIDTH) of columns
+ (ie: CONTINUATION_INDENT_WIDTH/INDENT_WIDTH tabs) for continuation
+ alignment.
+ - VALIGN-RIGHT: Vertically align continuation lines with indent characters.
+ Slightly right (one more indent character) if cannot vertically align
+ continuation lines with indent characters.
+
+ For options ``FIXED``, and ``VALIGN-RIGHT`` are only available when
+ ``USE_TABS`` is enabled.
+
+``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
+
+``DISABLE_ENDING_COMMA_HEURISTIC``
+ Disable the heuristic which places each list element on a separate line if
+ the list is comma-terminated.
+
+``EACH_DICT_ENTRY_ON_SEPARATE_LINE``
+ Place each dictionary entry onto its own 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 ``**``.
+
+``NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS``
+ Do not include spaces around selected binary operators. For example:
+
+ .. code-block:: python
+
+ 1 + 2 * 3 - 4 / 5
+
+ will be formatted as follows when configured with ``*,/``:
+
+ .. code-block:: python
+
+ 1 + 2*3 - 4/5
+
+``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_ALL_COMMA_SEPARATED_VALUES``
+ If a comma separated list (dict, list, tuple, or function def) is on a
+ line that is too long, split such that all elements are on a single line.
+
+``SPLIT_BEFORE_BITWISE_OPERATOR``
+ Set to ``True`` to prefer splitting before ``&``, ``|`` or ``^`` rather
+ than after.
+
+``SPLIT_BEFORE_CLOSING_BRACKET``
+ Split before the closing bracket if a list or dict literal doesn't fit on
+ a single line.
+
+``SPLIT_BEFORE_DICT_SET_GENERATOR``
+ Split before a dictionary or set generator (comp_for). For example, note
+ the split before the ``for``:
+
+ .. code-block:: python
+
+ foo = {
+ variable: 'Hello world, have a nice day!'
+ for variable in bar if variable != 42
+ }
+
+``SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN``
+ Split after the opening paren which surrounds an expression if it doesn't
+ fit on a single line.
+
+``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_COMPLEX_COMPREHENSION``
+ For list comprehensions and generator expressions with multiple clauses
+ (e.g multiple "for" calls, "if" filter expressions) and which need to be
+ reflowed, split each clause onto its own line. For example:
+
+ .. code-block:: python
+
+ result = [
+ a_var + b_var for a_var in xrange(1000) for b_var in xrange(1000)
+ if a_var % b_var]
+
+ would reformat to something like:
+
+ .. code-block:: python
+
+ result = [
+ a_var + b_var
+ for a_var in xrange(1000)
+ for b_var in xrange(1000)
+ if a_var % b_var]
+
+``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_COMPREHENSION``
+ The penalty for splitting a list comprehension or generator expression.
+
+``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 reasons for this are manyfold. In short, 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!
diff --git a/plugins/README.rst b/plugins/README.rst
new file mode 100644
index 0000000..f7657cc
--- /dev/null
+++ b/plugins/README.rst
@@ -0,0 +1,115 @@
+===========
+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. Copy ``plugin`` and
+``autoload`` directories into your ~/.vim or use ``:packadd`` in Vim 8. Or use
+a plugin manager like Plug or Vundle:
+
+.. code-block:: vim
+
+ " Plug
+ Plug 'google/yapf', { 'rtp': 'plugins/vim', 'for': 'python' }
+
+ " Vundle
+ Plugin 'google/yapf', { 'rtp': 'plugins/vim' }
+
+
+You can add key bindings in the ``.vimrc`` file:
+
+.. code-block:: vim
+
+ map <C-Y> :call yapf#YAPF()<cr>
+ imap <C-Y> <c-o>:call yapf#YAPF()<cr>
+
+Alternatively, you can call the command ``YAPF``. If you omit the range, it
+will reformat the whole buffer.
+
+example:
+
+.. code-block:: vim
+
+ :YAPF " formats whole buffer
+ :'<,'>YAPF " formats lines selected in visual mode
+
+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
+
+===================
+git Pre-Commit Hook
+===================
+
+The ``git`` pre-commit hook automatically formats your Python files before they
+are committed to your local repository. Any changes ``yapf`` makes to the files
+will stay unstaged so that you can diff them manually.
+
+To install, simply download the raw file and copy it into your git hooks
+directory:
+
+.. code-block:: bash
+
+ # From the root of your git project.
+ curl -o pre-commit.sh https://raw.githubusercontent.com/google/yapf/master/plugins/pre-commit.sh
+ chmod a+x pre-commit.sh
+ mv pre-commit.sh .git/hooks/pre-commit
+
+==========
+Textmate 2
+==========
+
+Plugin for ``Textmate 2`` requires ``yapf`` Python package installed on your
+system:
+
+.. code-block:: shell
+
+ pip install yapf
+
+Also, you will need to activate ``Python`` bundle from ``Preferences >>
+Bundles``.
+
+Finally, create a ``~/Library/Application
+Support/TextMate/Bundles/Python.tmbundle/Commands/YAPF.tmCommand`` file with
+the following content:
+
+.. code-block:: xml
+
+ <?xml version="1.0" encoding="UTF-8"?>
+ <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+ <plist version="1.0">
+ <dict>
+ <key>beforeRunningCommand</key>
+ <string>saveActiveFile</string>
+ <key>command</key>
+ <string>#!/bin/bash
+
+ TPY=${TM_PYTHON:-python}
+
+ "$TPY" "/usr/local/bin/yapf" "$TM_FILEPATH"</string>
+ <key>input</key>
+ <string>document</string>
+ <key>name</key>
+ <string>YAPF</string>
+ <key>scope</key>
+ <string>source.python</string>
+ <key>uuid</key>
+ <string>297D5A82-2616-4950-9905-BD2D1C94D2D4</string>
+ </dict>
+ </plist>
+
+You will see a new menu item ``Bundles > Python > YAPF``.
diff --git a/plugins/pre-commit.sh b/plugins/pre-commit.sh
new file mode 100644
index 0000000..896f0ff
--- /dev/null
+++ b/plugins/pre-commit.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+
+# Git pre-commit hook to check staged Python files for formatting issues with
+# yapf.
+#
+# INSTALLING: Copy this script into `.git/hooks/pre-commit`, and mark it as
+# executable.
+#
+# This requires that yapf is installed and runnable in the environment running
+# the pre-commit hook.
+#
+# When running, this first checks for unstaged changes to staged files, and if
+# there are any, it will exit with an error. Files with unstaged changes will be
+# printed.
+#
+# If all staged files have no unstaged changes, it will run yapf against them,
+# leaving the formatting changes unstaged. Changed files will be printed.
+#
+# BUGS: This does not leave staged changes alone when used with the -a flag to
+# git commit, due to the fact that git stages ALL unstaged files when that flag
+# is used.
+
+# Find all staged Python files, and exit early if there aren't any.
+PYTHON_FILES=(`git diff --name-only --cached --diff-filter=AM | \
+ grep --color=never '.py$'`)
+if [ ! "$PYTHON_FILES" ]; then
+ exit 0
+fi
+
+########## PIP VERSION #############
+# Verify that yapf is installed; if not, warn and exit.
+if [ -z $(which yapf) ]; then
+ echo 'yapf not on path; can not format. Please install yapf:'
+ echo ' pip install yapf'
+ exit 2
+fi
+######### END PIP VERSION ##########
+
+########## PIPENV VERSION ##########
+# if [ -z $(pipenv run which yapf) ]; then
+# echo 'yapf not on path; can not format. Please install yapf:'
+# echo ' pipenv install yapf'
+# exit 2
+# fi
+###### END PIPENV VERSION ##########
+
+
+# Check for unstaged changes to files in the index.
+CHANGED_FILES=(`git diff --name-only ${PYTHON_FILES[@]}`)
+if [ "$CHANGED_FILES" ]; then
+ echo 'You have unstaged changes to some files in your commit; skipping '
+ echo 'auto-format. Please stage, stash, or revert these changes. You may '
+ echo 'find `git stash -k` helpful here.'
+ echo
+ echo 'Files with unstaged changes:'
+ for file in ${CHANGED_FILES[@]}; do
+ echo " $file"
+ done
+ exit 1
+fi
+
+# Format all staged files, then exit with an error code if any have uncommitted
+# changes.
+echo 'Formatting staged Python files . . .'
+
+########## PIP VERSION #############
+yapf -i -r ${PYTHON_FILES[@]}
+######### END PIP VERSION ##########
+
+########## PIPENV VERSION ##########
+# pipenv run yapf -i -r ${PYTHON_FILES[@]}
+###### END PIPENV VERSION ##########
+
+
+CHANGED_FILES=(`git diff --name-only ${PYTHON_FILES[@]}`)
+if [ "$CHANGED_FILES" ]; then
+ echo 'Reformatted staged files. Please review and stage the changes.'
+ echo
+ echo 'Files updated:'
+ for file in ${CHANGED_FILES[@]}; do
+ echo " $file"
+ done
+ exit 1
+else
+ exit 0
+fi
diff --git a/plugins/vim/autoload/yapf.vim b/plugins/vim/autoload/yapf.vim
new file mode 100644
index 0000000..ad3e7fc
--- /dev/null
+++ b/plugins/vim/autoload/yapf.vim
@@ -0,0 +1,49 @@
+" 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 <C-Y> :call yapf#YAPF()<cr>
+" imap <C-Y> <c-o>:call yapf#YAPF()<cr>
+"
+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
+ if exists('*systemlist')
+ let l:formatted_text = systemlist(l:cmd, join(getline(1, '$'), "\n") . "\n")
+ else
+ let l:formatted_text =
+ \ split(system(l:cmd, join(getline(1, '$'), "\n") . "\n"), "\n")
+ endif
+
+ if v:shell_error
+ echohl ErrorMsg
+ echomsg printf('"%s" returned error: %s', l:cmd, l:formatted_text[-1])
+ echohl None
+ return
+ endif
+
+ " Update the buffer.
+ execute '1,' . string(line('$')) . 'delete'
+ call setline(1, l:formatted_text)
+
+ " Reset cursor to first line of the formatted range.
+ call cursor(a:firstline, 1)
+endfunction
diff --git a/plugins/vim/plugin/yapf.vim b/plugins/vim/plugin/yapf.vim
new file mode 100644
index 0000000..e2cc7fd
--- /dev/null
+++ b/plugins/vim/plugin/yapf.vim
@@ -0,0 +1,25 @@
+" 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 command for YAPF support
+"
+" Place this script in your ~/.vim/plugin directory. You can call the
+" command YAPF. If you omit the range, it will reformat the whole
+" buffer.
+"
+" example:
+" :YAPF " formats whole buffer
+" :'<,'>YAPF " formats lines selected in visual mode
+
+command! -range=% YAPF <line1>,<line2>call yapf#YAPF()
diff --git a/pylintrc b/pylintrc
new file mode 100644
index 0000000..9e8a554
--- /dev/null
+++ b/pylintrc
@@ -0,0 +1,444 @@
+[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*(# )?<?https?://\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
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..2a9acf1
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,2 @@
+[bdist_wheel]
+universal = 1
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..21e9470
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+# 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.
+
+import codecs
+import sys
+import unittest
+
+from setuptools import setup, Command
+
+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.6',
+ 'Topic :: Software Development :: Libraries :: Python Modules',
+ 'Topic :: Software Development :: Quality Assurance',
+ ],
+ entry_points={
+ 'console_scripts': ['yapf = yapf:run_main'],
+ },
+ cmdclass={
+ 'test': RunTests,
+ },
+ )
diff --git a/tox.ini b/tox.ini
new file mode 100644
index 0000000..dca30d2
--- /dev/null
+++ b/tox.ini
@@ -0,0 +1,6 @@
+[tox]
+envlist=py27,py34,py35,py36
+
+[testenv]
+commands=
+ python setup.py test
diff --git a/yapf/__init__.py b/yapf/__init__.py
new file mode 100644
index 0000000..22ab014
--- /dev/null
+++ b/yapf/__init__.py
@@ -0,0 +1,321 @@
+# 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.
+"""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.22.0'
+
+
+def main(argv):
+ """Main program.
+
+ Arguments:
+ argv: command-line arguments, such as sys.argv (including the program name
+ in argv[0]).
+
+ Returns:
+ Zero on successful program termination, non-zero otherwise.
+ With --diff: zero 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 the same '
+ 'directory as the source or one of its parent directories '
+ '(for stdin, the current directory is used).' %
+ (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(
+ '-vv',
+ '--verbose',
+ action='store_true',
+ help='Print out file names while processing')
+
+ parser.add_argument(
+ 'files', nargs='*', help='Reads from stdin when no files are specified.')
+ args = parser.parse_args(argv[1:])
+
+ if args.version:
+ print('yapf {}'.format(__version__))
+ return 0
+
+ style_config = args.style
+
+ if args.style_help:
+ if style_config is None and not args.no_local_style:
+ style_config = file_resources.GetDefaultStyleForDir(os.getcwd())
+ style.SetGlobalStyle(style.CreateStyleFromConfig(style_config))
+ print('[style]')
+ for option, docstring in sorted(style.Help().items()):
+ for line in docstring.splitlines():
+ print('#', line and ' ' or '', line, sep='')
+ 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:
+ if sys.stdin.closed:
+ break
+ 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
+
+ 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, _ = yapf_api.FormatCode(
+ py3compat.unicode('\n'.join(source) + '\n'),
+ filename='<stdin>',
+ style_config=style_config,
+ lines=lines,
+ verify=args.verify)
+ file_resources.WriteReformattedCode('<stdout>', 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')
+
+ changed = 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,
+ verbose=args.verbose)
+ return 1 if changed and args.diff else 0
+
+
+def FormatFiles(filenames,
+ lines,
+ style_config=None,
+ no_local_style=False,
+ in_place=False,
+ print_diff=False,
+ verify=False,
+ parallel=False,
+ verbose=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.
+ verbose: (bool) True if should print out filenames while processing.
+
+ 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, verbose)
+ 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, verbose)
+ return changed
+
+
+def _FormatFile(filename,
+ lines,
+ style_config=None,
+ no_local_style=False,
+ in_place=False,
+ print_diff=False,
+ verify=False,
+ verbose=False):
+ if verbose:
+ print('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, encoding,
+ in_place)
+ 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()
diff --git a/yapf/__main__.py b/yapf/__main__.py
new file mode 100644
index 0000000..f1d0e32
--- /dev/null
+++ b/yapf/__main__.py
@@ -0,0 +1,18 @@
+# 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.
+"""Main entry point."""
+# pylint: disable=invalid-name
+import yapf
+
+yapf.run_main()
diff --git a/yapf/yapflib/__init__.py b/yapf/yapflib/__init__.py
new file mode 100644
index 0000000..e7522b2
--- /dev/null
+++ b/yapf/yapflib/__init__.py
@@ -0,0 +1,13 @@
+# 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.
diff --git a/yapf/yapflib/blank_line_calculator.py b/yapf/yapflib/blank_line_calculator.py
new file mode 100644
index 0000000..c239ee7
--- /dev/null
+++ b/yapf/yapflib/blank_line_calculator.py
@@ -0,0 +1,176 @@
+# 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.
+"""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 yapf.yapflib import py3compat
+from yapf.yapflib import pytree_utils
+from yapf.yapflib import pytree_visitor
+from yapf.yapflib import style
+
+_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 = pytree_utils.FirstLeafNode(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 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION')
+ 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 (pytree_utils.FirstLeafNode(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')
diff --git a/yapf/yapflib/comment_splicer.py b/yapf/yapflib/comment_splicer.py
new file mode 100644
index 0000000..af999d2
--- /dev/null
+++ b/yapf/yapflib/comment_splicer.py
@@ -0,0 +1,354 @@
+# 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.
+"""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.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 before it if the ancestor is
+ # on a DEDENT node and after it otherwise.
+ #
+ # 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.
+
+ # Split into groups of comments at decreasing levels of indentation
+ comment_groups = []
+ comment_column = None
+ for cmt in comment_prefix.split('\n'):
+ col = cmt.find('#')
+ if col < 0:
+ if comment_column is None:
+ # Skip empty lines at the top of the first comment group
+ comment_lineno += 1
+ continue
+ elif comment_column is None or col < comment_column:
+ comment_column = col
+ comment_indent = cmt[:comment_column]
+ comment_groups.append((comment_column, comment_indent, []))
+ comment_groups[-1][-1].append(cmt)
+
+ # Insert a node for each group
+ for comment_column, comment_indent, comment_group in comment_groups:
+ ancestor_at_indent = _FindAncestorAtIndent(child, comment_indent)
+ if ancestor_at_indent.type == token.DEDENT:
+ InsertNodes = pytree_utils.InsertNodesBefore # pylint: disable=invalid-name
+ else:
+ InsertNodes = pytree_utils.InsertNodesAfter # pylint: disable=invalid-name
+ InsertNodes(
+ _CreateCommentsFromPrefix(
+ '\n'.join(comment_group) + '\n',
+ comment_lineno,
+ comment_column,
+ standalone=True), ancestor_at_indent)
+ comment_lineno += len(comment_group)
+ 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].strip())
+ index += 1
+
+ if comment_block:
+ new_lineno = comment_lineno + index - 1
+ comment_block[0] = comment_block[0].strip()
+ comment_block[-1] = comment_block[-1].strip()
+ 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 _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)
diff --git a/yapf/yapflib/continuation_splicer.py b/yapf/yapflib/continuation_splicer.py
new file mode 100644
index 0000000..b86188c
--- /dev/null
+++ b/yapf/yapflib/continuation_splicer.py
@@ -0,0 +1,52 @@
+# 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.
+"""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 function 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)
diff --git a/yapf/yapflib/errors.py b/yapf/yapflib/errors.py
new file mode 100644
index 0000000..3946275
--- /dev/null
+++ b/yapf/yapflib/errors.py
@@ -0,0 +1,23 @@
+# 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.
+"""YAPF error object."""
+
+
+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
diff --git a/yapf/yapflib/file_resources.py b/yapf/yapflib/file_resources.py
new file mode 100644
index 0000000..6e7202d
--- /dev/null
+++ b/yapf/yapflib/file_resources.py
@@ -0,0 +1,191 @@
+# 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.
+"""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,
+ encoding='',
+ in_place=False):
+ """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.
+ encoding: (unicode) The encoding of the file.
+ in_place: (bool) If True, then write the reformatted code to the file.
+ """
+ if in_place:
+ with py3compat.open_with_encoding(
+ filename, mode='w', encoding=encoding, newline='') 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."""
+ if exclude and any(e.startswith('./') for e in exclude):
+ raise errors.YapfError("path in '--exclude' should not start with ./")
+
+ python_files = []
+ for filename in filenames:
+ if filename != '.' and exclude and IsIgnored(filename, exclude):
+ continue
+ if os.path.isdir(filename):
+ if recursive:
+ # TODO(morbo): Look into a version of os.walk that can handle recursion.
+ excluded_dirs = []
+ for dirpath, _, filelist in os.walk(filename):
+ if dirpath != '.' and exclude and IsIgnored(dirpath, exclude):
+ excluded_dirs.append(dirpath)
+ continue
+ elif any(dirpath.startswith(e) for e in excluded_dirs):
+ continue
+ for f in filelist:
+ filepath = os.path.join(dirpath, f)
+ if exclude and IsIgnored(filepath, exclude):
+ continue
+ if IsPythonFile(filepath):
+ python_files.append(filepath)
+ else:
+ raise errors.YapfError(
+ "directory specified without '--recursive' flag: %s" % filename)
+ elif os.path.isfile(filename):
+ python_files.append(filename)
+
+ return python_files
+
+
+def IsIgnored(path, exclude):
+ """Return True if filename matches any patterns in exclude."""
+ path = path.lstrip('/')
+ while path.startswith('./'):
+ path = path[2:]
+ return any(fnmatch.fnmatch(path, e.rstrip('/')) for e in exclude)
+
+
+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.readline(256)
+ except IOError:
+ return False
+
+ return re.match(r'^#!.*\bpython[23]?\b', first_line)
+
+
+def FileEncoding(filename):
+ """Return the file's encoding."""
+ with open(filename, 'rb') as fd:
+ return tokenize.detect_encoding(fd.readline)[0]
diff --git a/yapf/yapflib/format_decision_state.py b/yapf/yapflib/format_decision_state.py
new file mode 100644
index 0000000..bff8ea3
--- /dev/null
+++ b/yapf/yapflib/format_decision_state.py
@@ -0,0 +1,1011 @@
+# 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.
+"""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.
+"""
+
+from yapf.yapflib import format_token
+from yapf.yapflib import object_state
+from yapf.yapflib import split_penalty
+from yapf.yapflib import style
+from yapf.yapflib import unwrapped_line
+
+
+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 {}.
+ 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.
+ comp_stack: A stack (of ComprehensionState) keeping track of properties
+ applying to comprehensions.
+ 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.lowest_level_on_line = 0
+ self.ignore_stack_for_comparison = False
+ self.stack = [_ParenState(first_indent, first_indent)]
+ self.comp_stack = []
+ self.first_indent = first_indent
+ self.newline = False
+ self.previous = None
+ self.column_limit = style.Get('COLUMN_LIMIT')
+
+ def Clone(self):
+ """Clones a FormatDecisionState object."""
+ new = FormatDecisionState(self.line, self.first_indent)
+ new.next_token = self.next_token
+ new.column = self.column
+ new.line = self.line
+ new.paren_level = self.paren_level
+ new.line.depth = self.line.depth
+ new.lowest_level_on_line = self.lowest_level_on_line
+ new.ignore_stack_for_comparison = self.ignore_stack_for_comparison
+ new.first_indent = self.first_indent
+ new.newline = self.newline
+ new.previous = self.previous
+ new.stack = [state.Clone() for state in self.stack]
+ new.comp_stack = [state.Clone() for state in self.comp_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.line.depth == other.line.depth 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 and self.comp_stack == other.comp_stack))
+
+ def __ne__(self, other):
+ return not self == other
+
+ def __hash__(self):
+ return hash((self.next_token, self.column, self.paren_level,
+ self.line.depth, 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, must_split):
+ """Determine if we can split before the next token.
+
+ Arguments:
+ must_split: (bool) A newline was required before this token.
+
+ Returns:
+ True if the line can be split before the next token.
+ """
+ current = self.next_token
+ previous = current.previous_token
+
+ if current.is_pseudo_paren:
+ return False
+
+ if (not must_split and
+ format_token.Subtype.DICTIONARY_KEY_PART in current.subtypes and
+ format_token.Subtype.DICTIONARY_KEY not in current.subtypes and
+ not style.Get('ALLOW_MULTILINE_DICTIONARY_KEYS')):
+ # In some situations, a dictionary may be multiline, but pylint doesn't
+ # like it. So don't allow it unless forced to.
+ return False
+
+ if (not must_split and
+ format_token.Subtype.DICTIONARY_VALUE in current.subtypes and
+ not style.Get('ALLOW_SPLIT_BEFORE_DICT_VALUE')):
+ return False
+
+ if previous and previous.value == '(' and current.value == ')':
+ # Don't split an empty function call list if we aren't splitting before
+ # dict values.
+ token = previous.previous_token
+ while token:
+ prev = token.previous_token
+ if not prev or prev.name not in {'NAME', 'DOT'}:
+ break
+ token = token.previous_token
+ if token and format_token.Subtype.DICTIONARY_VALUE in token.subtypes:
+ if not style.Get('ALLOW_SPLIT_BEFORE_DICT_VALUE'):
+ return False
+
+ if previous and previous.value == '.' and current.value == '.':
+ 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 not previous:
+ return False
+
+ if style.Get('SPLIT_ALL_COMMA_SEPARATED_VALUES') and previous.value == ',':
+ return True
+
+ if (self.stack[-1].split_before_closing_bracket and
+ current.value in '}]' and style.Get('SPLIT_BEFORE_CLOSING_BRACKET')):
+ # Split before the closing bracket if we can.
+ return current.node_split_penalty != split_penalty.UNBREAKABLE
+
+ if (current.value == ')' and previous.value == ',' and
+ not _IsSingleElementTuple(current.matching_bracket)):
+ return True
+
+ # Prevent splitting before the first argument in compound statements
+ # with the exception of function declarations.
+ if (style.Get('SPLIT_BEFORE_FIRST_ARGUMENT') and
+ _IsCompoundStatement(self.line.first) and
+ not _IsFunctionDef(self.line.first)):
+ return False
+
+ ###########################################################################
+ # List Splitting
+ if (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():
+ # Prefer to keep all opening brackets together.
+ 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):
+ # Split before the first element if the whole list can't fit on a
+ # single line.
+ self.stack[-1].split_before_closing_bracket = True
+ return True
+
+ elif style.Get('DEDENT_CLOSING_BRACKETS') and current.ClosesScope():
+ # Split before and dedent the closing bracket.
+ return self.stack[-1].split_before_closing_bracket
+
+ if (style.Get('SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN') and
+ current.is_name):
+ # An expression that's surrounded by parens gets split after the opening
+ # parenthesis.
+ def SurroundedByParens(token):
+ """Check if it's an expression surrounded by parentheses."""
+ while token:
+ if token.value == ',':
+ return False
+ if token.value == ')':
+ return not token.next_token
+ if token.OpensScope():
+ token = token.matching_bracket.next_token
+ else:
+ token = token.next_token
+ return False
+
+ if (previous.value == '(' and not previous.is_pseudo_paren and
+ not unwrapped_line.IsSurroundedByBrackets(previous)):
+ pptoken = previous.previous_token
+ if (pptoken and not pptoken.is_name and not pptoken.is_keyword and
+ SurroundedByParens(current)):
+ return True
+
+ if (current.is_name or current.is_string) and previous.value == ',':
+ # If the list has function calls in it and the full list itself cannot
+ # fit on the line, then we want to split. Otherwise, we'll get something
+ # like this:
+ #
+ # X = [
+ # Bar(xxx='some string',
+ # yyy='another long string',
+ # zzz='a third long string'), Bar(
+ # xxx='some string',
+ # yyy='another long string',
+ # zzz='a third long string')
+ # ]
+ #
+ # or when a string formatting syntax.
+ func_call_or_string_format = False
+ tok = current.next_token
+ if current.is_name:
+ while tok and (tok.is_name or tok.value == '.'):
+ tok = tok.next_token
+ func_call_or_string_format = tok and tok.value == '('
+ elif current.is_string:
+ while tok and tok.is_string:
+ tok = tok.next_token
+ func_call_or_string_format = tok and tok.value == '%'
+ if func_call_or_string_format:
+ open_bracket = unwrapped_line.IsSurroundedByBrackets(current)
+ if open_bracket:
+ if open_bracket.value in '[{':
+ if not self._FitsOnLine(open_bracket,
+ open_bracket.matching_bracket):
+ return True
+ elif tok.value == '(':
+ if not self._FitsOnLine(current, tok.matching_bracket):
+ return True
+
+ ###########################################################################
+ # Dict/Set Splitting
+ if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') and
+ format_token.Subtype.DICTIONARY_KEY in current.subtypes and
+ not current.is_comment):
+ # Place each dictionary entry onto 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) and
+ previous.matching_bracket.next_token and
+ (not opening.matching_bracket.next_token or
+ opening.matching_bracket.next_token.value != '.') and
+ _ScopeHasNoCommas(previous)):
+ # Don't split before the key if:
+ # - The dictionary fits on a line, and
+ # - The function call isn't part of a builder-style call and
+ # - The dictionary has one entry and no trailing comma
+ return False
+ return True
+
+ if (style.Get('SPLIT_BEFORE_DICT_SET_GENERATOR') and
+ format_token.Subtype.DICT_SET_GENERATOR in current.subtypes):
+ # Split before a dict/set generator.
+ return True
+
+ if (format_token.Subtype.DICTIONARY_VALUE in current.subtypes or
+ (previous.is_pseudo_paren and previous.value == '(' and
+ not current.is_comment)):
+ # Split before the dictionary value if we can't fit every dictionary
+ # entry on its own line.
+ if not current.OpensScope():
+ opening = _GetOpeningBracket(current)
+ if not self._EachDictEntryFitsOnOneLine(opening):
+ return style.Get('ALLOW_SPLIT_BEFORE_DICT_VALUE')
+
+ if previous.value == '{':
+ # Split if the dict/set cannot fit on one line and ends in a comma.
+ 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
+
+ ###########################################################################
+ # Argument List Splitting
+ 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 ':=,)' and not _IsFunctionDefinition(previous)):
+ # 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 a function definition.
+ if previous.value == '(':
+ # 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)
+ if (self._FitsOnLine(previous, previous.matching_bracket) and
+ unwrapped_line.IsSurroundedByBrackets(previous)):
+ # An argument to a function is a function call with named
+ # assigns.
+ return False
+
+ column = self.column - self.stack[-1].last_space
+ return 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 (current.value not in '{)' and previous.value == '(' and
+ self._ArgumentListHasDictionaryEntry(current)):
+ return True
+
+ 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 ((current.is_name or current.value in {'*', '**'}) 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 or
+ opening.previous_token.value in {'*', '**'})):
+ is_func_call = False
+ opening = current
+ while opening:
+ if opening.value == '(':
+ is_func_call = True
+ break
+ if (not (opening.is_name or opening.value in {'*', '**'}) and
+ opening.value != '.'):
+ break
+ opening = opening.next_token
+
+ if is_func_call:
+ if (not self._FitsOnLine(current, opening.matching_bracket) or
+ (opening.matching_bracket.next_token and
+ opening.matching_bracket.next_token.value != ',' and
+ not opening.matching_bracket.next_token.ClosesScope())):
+ return True
+
+ pprevious = previous.previous_token
+ if (current.is_name and pprevious and pprevious.is_name and
+ previous.value == '('):
+ if (not self._FitsOnLine(previous, previous.matching_bracket) and
+ _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. E.g.:
+ #
+ # outer_function_call(inner_function_call(
+ # inner_arg1, inner_arg2),
+ # outer_arg1, outer_arg2)
+ #
+ # Instead, enforce a split before that argument to keep things looking
+ # good.
+ return True
+
+ if (previous.OpensScope() and not current.OpensScope() and
+ not current.is_comment and
+ format_token.Subtype.SUBSCRIPT_BRACKET not in previous.subtypes):
+ 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
+ elif not self._FitsOnLine(previous, previous.matching_bracket):
+ if len(previous.container_elements) == 1:
+ return False
+
+ elements = previous.container_elements + [previous.matching_bracket]
+ i = 1
+ while i < len(elements):
+ if (not elements[i - 1].OpensScope() and
+ not self._FitsOnLine(elements[i - 1], elements[i])):
+ return True
+ i += 1
+
+ if (self.column_limit - self.column) / float(self.column_limit) < 0.3:
+ # Try not to squish all of the arguments off to the right.
+ return True
+ else:
+ # Split after the opening of a container if it doesn't fit on the
+ # current line.
+ if not self._FitsOnLine(previous, previous.matching_bracket):
+ return True
+
+ ###########################################################################
+ # Original Formatting Splitting
+ # These checks rely upon the original formatting. This is in order to
+ # attempt to keep hand-written code in the same condition as it was before.
+ # However, this may cause the formatter to fail to be idempotent.
+ 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
+
+ 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)
+
+ penalty += self._CalculateComprehensionState(newline)
+
+ 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:
+ indent_level = self.line.depth
+ spaces = self.column
+ if spaces:
+ spaces -= indent_level * style.Get('INDENT_WIDTH')
+ current.AddWhitespacePrefix(
+ newlines_before=1, spaces=spaces, indent_level=indent_level)
+
+ if not current.is_comment:
+ self.stack[-1].last_space = self.column
+ 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 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)
+
+ if current.OpensScope() and previous.OpensScope():
+ # Prefer to keep opening brackets coalesced (unless it's at the beginning
+ # of a function call).
+ pprev = previous.previous_token
+ if not pprev or not pprev.is_name:
+ penalty += 10
+
+ return penalty + 10
+
+ 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():
+ if format_token.Subtype.DICTIONARY_KEY_PART in current.subtypes:
+ self.stack[-2].last_space = self.stack[-2].indent
+ else:
+ 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 not current.is_pytype_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 _CalculateComprehensionState(self, newline):
+ """Makes required changes to comprehension state.
+
+ Args:
+ newline: Whether the current token is to be added on a newline.
+
+ Returns:
+ The penalty for the token-newline combination given the current
+ comprehension state.
+ """
+ current = self.next_token
+ previous = current.previous_token
+ top_of_stack = self.comp_stack[-1] if self.comp_stack else None
+ penalty = 0
+
+ if top_of_stack is not None:
+ # Check if the token terminates the current comprehension.
+ if current == top_of_stack.closing_bracket:
+ last = self.comp_stack.pop()
+ # Lightly penalize comprehensions that are split across multiple lines.
+ if last.has_interior_split:
+ penalty += style.Get('SPLIT_PENALTY_COMPREHENSION')
+
+ return penalty
+
+ if newline:
+ top_of_stack.has_interior_split = True
+
+ if (format_token.Subtype.COMP_EXPR in current.subtypes and
+ format_token.Subtype.COMP_EXPR not in previous.subtypes):
+ self.comp_stack.append(object_state.ComprehensionState(current))
+ return penalty
+
+ if (current.value == 'for' and
+ format_token.Subtype.COMP_FOR in current.subtypes):
+ if top_of_stack.for_token is not None:
+ # Treat nested comprehensions like normal comp_if expressions.
+ # Example:
+ # my_comp = [
+ # a.qux + b.qux
+ # for a in foo
+ # --> for b in bar <--
+ # if a.zut + b.zut
+ # ]
+ if (style.Get('SPLIT_COMPLEX_COMPREHENSION') and
+ top_of_stack.has_split_at_for != newline and
+ (top_of_stack.has_split_at_for or
+ not top_of_stack.HasTrivialExpr())):
+ penalty += split_penalty.UNBREAKABLE
+ else:
+ top_of_stack.for_token = current
+ top_of_stack.has_split_at_for = newline
+
+ # Try to keep trivial expressions on the same line as the comp_for.
+ if (style.Get('SPLIT_COMPLEX_COMPREHENSION') and newline and
+ top_of_stack.HasTrivialExpr()):
+ penalty += split_penalty.CONNECTED
+
+ if (format_token.Subtype.COMP_IF in current.subtypes and
+ format_token.Subtype.COMP_IF not in previous.subtypes):
+ # Penalize breaking at comp_if when it doesn't match the newline structure
+ # in the rest of the comprehension.
+ if (style.Get('SPLIT_COMPLEX_COMPREHENSION') and
+ top_of_stack.has_split_at_for != newline and
+ (top_of_stack.has_split_at_for or not top_of_stack.HasTrivialExpr())):
+ penalty += split_penalty.UNBREAKABLE
+
+ return penalty
+
+ 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 (_IsCompoundStatement(self.line.first) 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 _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 calculation. 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 _ArgumentListHasDictionaryEntry(self, token):
+ """Check if the function argument list has a dictionary as an arg."""
+ if _IsArgumentToFunction(token):
+ while token:
+ if token.value == '{':
+ length = token.matching_bracket.total_length - token.total_length
+ return length + self.stack[-2].indent > self.column_limit
+ if token.ClosesScope():
+ break
+ if token.OpensScope():
+ token = token.matching_bracket
+ token = token.next_token
+ return False
+
+
+_COMPOUND_STMTS = frozenset(
+ {'for', 'while', 'if', 'elif', 'with', 'except', 'def', 'class'})
+
+
+def _IsCompoundStatement(token):
+ if token.value == 'async':
+ token = token.next_token
+ return token.value in _COMPOUND_STMTS
+
+
+def _IsFunctionDef(token):
+ if token.value == 'async':
+ token = token.next_token
+ return token.value == 'def'
+
+
+def _IsFunctionCallWithArguments(token):
+ while token:
+ if token.value == '(':
+ token = token.next_token
+ return token and token.value != ')'
+ elif token.name not in {'NAME', 'DOT', 'EQUAL'}:
+ break
+ token = token.next_token
+ return False
+
+
+def _IsArgumentToFunction(token):
+ bracket = unwrapped_line.IsSurroundedByBrackets(token)
+ if not bracket or bracket.value != '(':
+ return False
+ previous = bracket.previous_token
+ return previous and previous.is_name
+
+
+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):
+ """Get the opening bracket containing the current token."""
+ 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
+
+
+def _IsSingleElementTuple(token):
+ """Check if it's a single-element tuple."""
+ close = token.matching_bracket
+ token = token.next_token
+ num_commas = 0
+ while token != close:
+ if token.value == ',':
+ num_commas += 1
+ if token.OpensScope():
+ token = token.matching_bracket
+ else:
+ token = token.next_token
+ return num_commas == 1
+
+
+def _ScopeHasNoCommas(token):
+ """Check if the scope has no commas."""
+ close = token.matching_bracket
+ token = token.next_token
+ while token != close:
+ if token.value == ',':
+ return False
+ if token.OpensScope():
+ token = token.matching_bracket
+ else:
+ token = token.next_token
+ 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 Clone(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))
diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py
new file mode 100644
index 0000000..79dced4
--- /dev/null
+++ b/yapf/yapflib/format_token.py
@@ -0,0 +1,339 @@
+# 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.
+"""Pytree nodes with extra formatting information.
+
+This is a thin wrapper around a pytree.Leaf node.
+"""
+
+import keyword
+import re
+
+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
+
+
+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_KEY_PART = 12
+ DICTIONARY_VALUE = 13
+ DICT_SET_GENERATOR = 14
+ COMP_EXPR = 21
+ COMP_FOR = 15
+ COMP_IF = 16
+ FUNC_DEF = 17
+ DECORATOR = 18
+ TYPED_NAME = 19
+ TYPED_NAME_ARG_LIST = 20
+
+
+def _TabbedContinuationAlignPadding(spaces, align_style, tab_width,
+ continuation_indent_width):
+ """Build padding string for continuation alignment in tabbed indentation.
+
+ Arguments:
+ spaces: (int) The number of spaces to place before the token for alignment.
+ align_style: (str) The alignment style for continuation lines.
+ tab_width: (int) Number of columns of each tab character.
+ continuation_indent_width: (int) Indent columns for line continuations.
+
+ Returns:
+ A padding string for alignment with style specified by align_style option.
+ """
+ if align_style == 'FIXED':
+ if spaces > 0:
+ return '\t' * int(continuation_indent_width / tab_width)
+ return ''
+ elif align_style == 'VALIGN-RIGHT':
+ return '\t' * int((spaces + tab_width - 1) / tab_width)
+ return ' ' * spaces
+
+
+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.
+ container_opening: If the object is in a container, this points to its
+ opening bracket.
+ container_elements: If this is the start of a container, a list of the
+ elements in the container.
+ 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.container_opening = None
+ self.container_elements = []
+ 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.
+ """
+ if style.Get('USE_TABS'):
+ if newlines_before > 0:
+ indent_before = '\t' * indent_level + _TabbedContinuationAlignPadding(
+ spaces, style.Get('CONTINUATION_ALIGN_STYLE'),
+ style.Get('INDENT_WIDTH'), style.Get('CONTINUATION_INDENT_WIDTH'))
+ else:
+ indent_before = '\t' * indent_level + ' ' * spaces
+ else:
+ indent_before = (
+ ' ' * 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 not previous:
+ return
+
+ if previous.is_pseudo_paren:
+ previous = previous.previous_token
+ if not previous:
+ 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):
+ """A multiline string."""
+ if py3compat.PY3:
+ prefix = '('
+ prefix += 'r|u|R|U|f|F|fr|Fr|fR|FR|rf|rF|Rf|RF' # strings
+ prefix += '|b|B|br|Br|bR|BR|rb|rB|Rb|RB' # bytes
+ prefix += ')?'
+ else:
+ prefix = '[uUbB]?[rR]?'
+
+ regex = r'^{prefix}(?P<delim>"""|\'\'\').*(?P=delim)$'.format(prefix=prefix)
+ return (self.is_string and
+ re.match(regex, 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)
+
+ @property
+ def is_pytype_comment(self):
+ return self.is_comment and re.match(r'#.*\bpytype:\s*(disable|enable)=',
+ self.value)
diff --git a/yapf/yapflib/identify_container.py b/yapf/yapflib/identify_container.py
new file mode 100644
index 0000000..5c5fc5b
--- /dev/null
+++ b/yapf/yapflib/identify_container.py
@@ -0,0 +1,67 @@
+# Copyright 2018 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.
+"""Identify containers for lib2to3 trees.
+
+This module identifies containers and the elements in them. Each element points
+to the opening bracket and vice-versa.
+
+ IdentifyContainers(): the main function exported by this module.
+"""
+
+from yapf.yapflib import pytree_utils
+from yapf.yapflib import pytree_visitor
+
+
+def IdentifyContainers(tree):
+ """Run the identify containers visitor over the tree, modifying it in place.
+
+ Arguments:
+ tree: the top-level pytree node to annotate with subtypes.
+ """
+ identify_containers = _IdentifyContainers()
+ identify_containers.Visit(tree)
+
+
+class _IdentifyContainers(pytree_visitor.PyTreeVisitor):
+ """_IdentifyContainers - see file-level docstring for detailed description."""
+
+ def Visit_trailer(self, node): # pylint: disable=invalid-name
+ for child in node.children:
+ self.Visit(child)
+
+ if len(node.children) != 3:
+ return
+ if pytree_utils.NodeName(node.children[0]) != 'LPAR':
+ return
+
+ if pytree_utils.NodeName(node.children[1]) == 'arglist':
+ for child in node.children[1].children:
+ pytree_utils.SetOpeningBracket(
+ pytree_utils.FirstLeafNode(child), node.children[0])
+ else:
+ pytree_utils.SetOpeningBracket(
+ pytree_utils.FirstLeafNode(node.children[1]), node.children[0])
+
+ def Visit_atom(self, node): # pylint: disable=invalid-name
+ for child in node.children:
+ self.Visit(child)
+
+ if len(node.children) != 3:
+ return
+ if pytree_utils.NodeName(node.children[0]) != 'LPAR':
+ return
+
+ for child in node.children[1].children:
+ pytree_utils.SetOpeningBracket(
+ pytree_utils.FirstLeafNode(child), node.children[0])
diff --git a/yapf/yapflib/line_joiner.py b/yapf/yapflib/line_joiner.py
new file mode 100644
index 0000000..84346c2
--- /dev/null
+++ b/yapf/yapflib/line_joiner.py
@@ -0,0 +1,109 @@
+# 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.
+"""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')
diff --git a/yapf/yapflib/object_state.py b/yapf/yapflib/object_state.py
new file mode 100644
index 0000000..dded7c4
--- /dev/null
+++ b/yapf/yapflib/object_state.py
@@ -0,0 +1,80 @@
+# Copyright 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.
+"""Represents the state of Python objects being formatted.
+
+Objects (e.g., list comprehensions, dictionaries, etc.) have specific
+requirements on how they're formatted. These state objects keep track of these
+requirements.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+class ComprehensionState(object):
+ """Maintains the state of list comprehension formatting decisions.
+
+ A stack of ComprehensionState objects are kept to ensure that list
+ comprehensions are wrapped with well-defined rules.
+
+ Attributes:
+ expr_token: The first token in the comprehension.
+ for_token: The first 'for' token of the comprehension.
+ has_split_at_for: Whether there is a newline immediately before the
+ for_token.
+ has_interior_split: Whether there is a newline within the comprehension.
+ That is, a split somewhere after expr_token or before closing_bracket.
+ """
+
+ def __init__(self, expr_token):
+ self.expr_token = expr_token
+ self.for_token = None
+ self.has_split_at_for = False
+ self.has_interior_split = False
+
+ def HasTrivialExpr(self):
+ """Returns whether the comp_expr is "trivial" i.e. is a single token."""
+ return self.expr_token.next_token.value == 'for'
+
+ @property
+ def opening_bracket(self):
+ return self.expr_token.previous_token
+
+ @property
+ def closing_bracket(self):
+ return self.opening_bracket.matching_bracket
+
+ def Clone(self):
+ clone = ComprehensionState(self.expr_token)
+ clone.for_token = self.for_token
+ clone.has_split_at_for = self.has_split_at_for
+ clone.has_interior_split = self.has_interior_split
+ return clone
+
+ def __repr__(self):
+ return ('[opening_bracket::%s, for_token::%s, has_split_at_for::%s,'
+ ' has_interior_split::%s, has_trivial_expr::%s]' %
+ (self.opening_bracket, self.for_token, self.has_split_at_for,
+ self.has_interior_split, self.HasTrivialExpr()))
+
+ 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.expr_token, self.for_token, self.has_split_at_for,
+ self.has_interior_split))
diff --git a/yapf/yapflib/py3compat.py b/yapf/yapflib/py3compat.py
new file mode 100644
index 0000000..c66d6c6
--- /dev/null
+++ b/yapf/yapflib/py3compat.py
@@ -0,0 +1,118 @@
+# 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.
+"""Utilities for Python2 / Python3 compatibility."""
+
+import io
+import os
+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
+
+ def raw_input():
+ wrapper = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8')
+ return wrapper.buffer.raw.readall().decode('utf-8')
+
+ 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(s.encode(encoding))
+ elif sys.platform == 'win32':
+ # On python 2 and Windows universal newline transformation will be in
+ # effect on stdout. Python 2 will not let us avoid the easily because
+ # it happens based on whether the file handle is opened in O_BINARY or
+ # O_TEXT state. However we can tell Windows itself to change the current
+ # mode, and python 2 will follow suit. However we must take care to change
+ # the mode on the actual external stdout not just the current sys.stdout
+ # which may have been monkey-patched inside the python environment.
+ import msvcrt # pylint: disable=g-import-not-at-top
+ if sys.__stdout__ is sys.stdout:
+ msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+ sys.stdout.write(s.encode(encoding))
+ else:
+ sys.stdout.write(s.encode(encoding))
+
+
+if PY3:
+ basestring = str
+ unicode = str # pylint: disable=redefined-builtin,invalid-name
+else:
+ basestring = basestring
+
+ def unicode(s): # pylint: disable=invalid-name
+ """Force conversion of s to unicode."""
+ 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)
diff --git a/yapf/yapflib/pytree_unwrapper.py b/yapf/yapflib/pytree_unwrapper.py
new file mode 100644
index 0000000..0d371ae
--- /dev/null
+++ b/yapf/yapflib/pytree_unwrapper.py
@@ -0,0 +1,386 @@
+# 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.
+"""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 style
+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_decorator(self, node): # pylint: disable=invalid-name
+ for child in node.children:
+ self.Visit(child)
+ if (pytree_utils.NodeName(child) == 'COMMENT' and
+ child == node.children[0]):
+ self._StartNewLine()
+
+ 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():
+ # 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()
+
+ for bracket in bracket_stack:
+ if id(pytree_utils.GetOpeningBracket(token.node)) == id(bracket.node):
+ bracket.container_elements.append(token)
+ token.container_opening = bracket
+
+
+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 style.Get('DISABLE_ENDING_COMMA_HEURISTIC'):
+ return
+ if not _ContainsComments(node):
+ token = next(node.parent.leaves())
+ if token.value == '(':
+ 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."""
+ pytree_utils.SetNodeAnnotation(
+ pytree_utils.FirstLeafNode(node), pytree_utils.Annotation.MUST_SPLIT,
+ True)
diff --git a/yapf/yapflib/pytree_utils.py b/yapf/yapflib/pytree_utils.py
new file mode 100644
index 0000000..999ba88
--- /dev/null
+++ b/yapf/yapflib/pytree_utils.py
@@ -0,0 +1,334 @@
+# 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.
+"""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]
+
+
+def FirstLeafNode(node):
+ if isinstance(node, pytree.Leaf):
+ return node
+ return FirstLeafNode(node.children[0])
+
+
+def LastLeafNode(node):
+ if isinstance(node, pytree.Leaf):
+ return node
+ return LastLeafNode(node.children[-1])
+
+
+# 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 GetOpeningBracket(node):
+ """Get opening bracket value from a node.
+
+ Arguments:
+ node: the node.
+
+ Returns:
+ The opening bracket node or None if it couldn't find one.
+ """
+ return getattr(node, _NODE_ANNOTATION_PREFIX + 'container_bracket', None)
+
+
+def SetOpeningBracket(node, bracket):
+ """Set opening bracket value for a node.
+
+ Arguments:
+ node: the node.
+ bracket: opening bracket to set.
+ """
+ setattr(node, _NODE_ANNOTATION_PREFIX + 'container_bracket', bracket)
+
+
+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}, penalty={penalty}]')
+ return fmt.format(
+ name=NodeName(node),
+ value=_PytreeNodeRepr(node),
+ lineno=node.lineno,
+ column=node.column,
+ prefix=repr(node.prefix),
+ penalty=GetNodeAnnotation(node, Annotation.SPLIT_PENALTY, None))
+ 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)
diff --git a/yapf/yapflib/pytree_visitor.py b/yapf/yapflib/pytree_visitor.py
new file mode 100644
index 0000000..49da056
--- /dev/null
+++ b/yapf/yapflib/pytree_visitor.py
@@ -0,0 +1,135 @@
+# 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.
+"""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))
diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py
new file mode 100644
index 0000000..6539e68
--- /dev/null
+++ b/yapf/yapflib/reformatter.py
@@ -0,0 +1,617 @@
+# 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.
+"""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, lines=None):
+ """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.
+ lines: (set of int) The lines which can be modified or None if there is no
+ line range restriction.
+
+ 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)
+ state.MoveStateToNextToken()
+
+ 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.
+ _RetainRequiredVerticalSpacingBetweenTokens(uwline.first,
+ prev_uwline.last, lines)
+ if any(tok.is_comment for tok in uwline.tokens):
+ _RetainVerticalSpacingBeforeComments(uwline)
+
+ if (_LineContainsI18n(uwline) or uwline.disable or
+ _LineHasContinuationMarkers(uwline)):
+ _RetainHorizontalSpacing(uwline)
+ _RetainRequiredVerticalSpacing(uwline, prev_uwline, lines)
+ _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)
+ state.MoveStateToNextToken()
+ _RetainHorizontalSpacing(uwline)
+ _RetainRequiredVerticalSpacing(uwline, prev_uwline, None)
+ _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 _RetainRequiredVerticalSpacing(cur_uwline, prev_uwline, lines):
+ prev_tok = None
+ if prev_uwline is not None:
+ prev_tok = prev_uwline.last
+ for cur_tok in cur_uwline.tokens:
+ _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines)
+ prev_tok = cur_tok
+
+
+def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines):
+ """Retain vertical spacing between two tokens if not in editable range."""
+ 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
+
+ if prev_tok.value.endswith('\\'):
+ prev_lineno += prev_tok.value.count('\n')
+
+ required_newlines = cur_lineno - prev_lineno
+ if cur_tok.is_comment and not prev_tok.is_comment:
+ # Don't adjust between a comment and non-comment.
+ pass
+ elif lines and (cur_lineno in lines or prev_lineno in lines):
+ desired_newlines = cur_tok.whitespace_prefix.count('\n')
+ whitespace_lines = range(prev_lineno + 1, cur_lineno)
+ deletable_lines = len(lines.intersection(whitespace_lines))
+ required_newlines = max(required_newlines - deletable_lines,
+ desired_newlines)
+
+ cur_tok.AdjustNewlinesBefore(required_newlines)
+
+
+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 or previous_token.is_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_pylint_comment or last.is_pytype_comment:
+ 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):
+ """Compose the final output from the finalized lines."""
+ 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
+ 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
+
+ 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.
+ """
+ must_split = previous_node.state.MustSplit()
+ if newline and not previous_node.state.CanSplit(must_split):
+ # Don't add a newline if the token cannot be split.
+ return count
+ 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 _IsClassOrDef(uwline):
+ if uwline.first.value in {'class', 'def'}:
+ return True
+
+ return [t.value for t in uwline.tokens[:2]] == ['async', 'def']
+
+
+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:
+ if (prev_uwline.first.value == 'class' and
+ style.Get('BLANK_LINE_BEFORE_CLASS_DOCSTRING')):
+ # Enforce a blank line before a class's docstring.
+ return ONE_BLANK_LINE
+ elif (prev_uwline.first.value.startswith('#') and
+ style.Get('BLANK_LINE_BEFORE_MODULE_DOCSTRING')):
+ # Enforce a blank line before a module's docstring.
+ return ONE_BLANK_LINE
+ # The docstring shouldn't have a newline before it.
+ 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
+ # appropriate number of blank lines.
+ return 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION')
+ 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(
+ 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION'))
+ if first_token.newlines is not None:
+ pytree_utils.SetNodeAnnotation(
+ first_token.node, pytree_utils.Annotation.NEWLINES, None)
+ return NO_BLANK_LINES
+ elif _IsClassOrDef(prev_uwline):
+ 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
diff --git a/yapf/yapflib/split_penalty.py b/yapf/yapflib/split_penalty.py
new file mode 100644
index 0000000..416eda3
--- /dev/null
+++ b/yapf/yapflib/split_penalty.py
@@ -0,0 +1,612 @@
+# 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.
+"""Computation of split penalties before/between tokens."""
+
+import re
+
+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
+NAMED_ASSIGN = 11000
+DOTTED_NAME = 4000
+VERY_STRONGLY_CONNECTED = 3500
+STRONGLY_CONNECTED = 3000
+CONNECTED = 500
+
+OR_TEST = 1000
+AND_TEST = 1100
+NOT_TEST = 1200
+COMPARISON = 1300
+STAR_EXPR = 1300
+EXPR = 1400
+XOR_EXPR = 1500
+AND_EXPR = 1700
+SHIFT_EXPR = 1800
+ARITH_EXPR = 1900
+TERM = 2000
+FACTOR = 2100
+POWER = 2200
+ATOM = 2300
+ONE_ELEMENT_ARGUMENT = 2500
+
+
+def ComputeSplitPenalties(tree):
+ """Compute split penalties on tokens in the given parse tree.
+
+ Arguments:
+ tree: the top-level pytree node to annotate with penalties.
+ """
+ _SplitPenaltyAssigner().Visit(tree)
+
+
+class _SplitPenaltyAssigner(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 == ','):
+ _SetSplitPenalty(child, style.Get('SPLIT_PENALTY_IMPORT_NAMES'))
+ prev_child = child
+
+ def Visit_classdef(self, node): # pylint: disable=invalid-name
+ # classdef ::= 'class' NAME ['(' [arglist] ')'] ':' suite
+ #
+ # NAME
+ _SetUnbreakable(node.children[1])
+ if len(node.children) > 4:
+ # opening '('
+ _SetUnbreakable(node.children[2])
+ # ':'
+ _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
+ _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
+ _SetUnbreakable(node.children[colon_idx])
+ self.DefaultNodeVisit(node)
+ if arrow_idx > 0:
+ _SetSplitPenalty(
+ pytree_utils.LastLeafNode(node.children[arrow_idx - 1]), 0)
+ _SetUnbreakable(node.children[arrow_idx])
+ _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.
+ allow_multiline_lambdas = style.Get('ALLOW_MULTILINE_LAMBDAS')
+ if not allow_multiline_lambdas:
+ for child in node.children:
+ if pytree_utils.NodeName(child) == 'COMMENT':
+ if re.search(r'pylint:.*disable=.*\bg-long-lambda', child.value):
+ allow_multiline_lambdas = True
+ break
+
+ if allow_multiline_lambdas:
+ _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.
+ _SetUnbreakable(node.children[0])
+ if not style.Get('DEDENT_CLOSING_BRACKETS'):
+ _SetStronglyConnected(node.children[-1])
+
+ def Visit_arglist(self, node): # pylint: disable=invalid-name
+ # arglist ::= argument (',' argument)* [',']
+ self.DefaultNodeVisit(node)
+ index = 1
+ while index < len(node.children):
+ child = node.children[index]
+ if isinstance(child, pytree.Leaf) and child.value == ',':
+ _SetUnbreakable(child)
+ index += 1
+ for child in node.children:
+ if pytree_utils.NodeName(child) == 'atom':
+ _IncreasePenalty(child, CONNECTED)
+
+ def Visit_argument(self, node): # pylint: disable=invalid-name
+ # argument ::= test [comp_for] | test '=' test # Really [keyword '='] test
+ self.DefaultNodeVisit(node)
+ index = 1
+ while index < len(node.children) - 1:
+ child = node.children[index]
+ if isinstance(child, pytree.Leaf) and child.value == '=':
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index]), NAMED_ASSIGN)
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index + 1]), NAMED_ASSIGN)
+ index += 1
+
+ def Visit_tname(self, node): # pylint: disable=invalid-name
+ # tname ::= NAME [':' test]
+ self.DefaultNodeVisit(node)
+ index = 1
+ while index < len(node.children) - 1:
+ child = node.children[index]
+ if isinstance(child, pytree.Leaf) and child.value == ':':
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index]), NAMED_ASSIGN)
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index + 1]), NAMED_ASSIGN)
+ 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.
+ _SetStronglyConnected(child)
+
+ def Visit_trailer(self, node): # pylint: disable=invalid-name
+ # trailer ::= '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+ if node.children[0].value == '.':
+ self._SetUnbreakableOnChildren(node)
+ _SetSplitPenalty(node.children[1], DOTTED_NAME)
+ elif len(node.children) == 2:
+ # Don't split an empty argument list if at all possible.
+ _SetSplitPenalty(node.children[1], VERY_STRONGLY_CONNECTED)
+ elif len(node.children) == 3:
+ name = pytree_utils.NodeName(node.children[1])
+ if name in {'argument', 'comparison'}:
+ # Don't split an argument list with one element if at all possible.
+ _SetStronglyConnected(node.children[1])
+ if (len(node.children[1].children) > 1 and
+ pytree_utils.NodeName(node.children[1].children[1]) == 'comp_for'):
+ # Don't penalize splitting before a comp_for expression.
+ _SetSplitPenalty(pytree_utils.FirstLeafNode(node.children[1]), 0)
+ else:
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[1]),
+ ONE_ELEMENT_ARGUMENT)
+ elif (pytree_utils.NodeName(node.children[0]) == 'LSQB' and
+ len(node.children[1].children) > 2 and
+ (name.endswith('_test') or name.endswith('_expr'))):
+ _SetStronglyConnected(node.children[1].children[0])
+ _SetStronglyConnected(node.children[1].children[2])
+
+ # Still allow splitting around the operator.
+ split_before = ((name.endswith('_test') and
+ style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR')) or
+ (name.endswith('_expr') and
+ style.Get('SPLIT_BEFORE_BITWISE_OPERATOR')))
+ if split_before:
+ _SetSplitPenalty(
+ pytree_utils.LastLeafNode(node.children[1].children[1]), 0)
+ else:
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[1].children[2]), 0)
+
+ # Don't split the ending bracket of a subscript list.
+ _SetVeryStronglyConnected(node.children[-1])
+ elif name not in {
+ 'arglist', 'argument', 'term', 'or_test', 'and_test', 'comparison',
+ 'atom', 'power'
+ }:
+ # Don't split an argument list with one element if at all possible.
+ _SetStronglyConnected(node.children[1], node.children[2])
+
+ if name == 'arglist':
+ _SetStronglyConnected(node.children[-1])
+
+ self.DefaultNodeVisit(node)
+
+ 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 .
+ _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.
+ _SetStronglyConnected(prev_trailer.children[-1])
+ _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:
+ _SetStronglyConnected(
+ pytree_utils.FirstLeafNode(trailer.children[1]))
+
+ last_child_node = pytree_utils.LastLeafNode(trailer)
+ if last_child_node.value.strip().startswith('#'):
+ last_child_node = last_child_node.prev_sibling
+ if not style.Get('DEDENT_CLOSING_BRACKETS'):
+ last = pytree_utils.LastLeafNode(last_child_node.prev_sibling)
+ if last.value != ',':
+ if last_child_node.value == ']':
+ _SetUnbreakable(last_child_node)
+ else:
+ _SetSplitPenalty(last_child_node, VERY_STRONGLY_CONNECTED)
+ else:
+ # If the trailer's children are '()', then make it a strongly
+ # connected region. It's sometimes necessary, though undesirable, to
+ # split the two.
+ _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]
+ _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]
+ _SetSplitPenalty(pytree_utils.FirstLeafNode(node), 0)
+ _SetStronglyConnected(*node.children[1:])
+ self.DefaultNodeVisit(node)
+
+ def Visit_comp_if(self, node): # pylint: disable=invalid-name
+ # comp_if ::= 'if' old_test [comp_iter]
+ _SetSplitPenalty(node.children[0],
+ style.Get('SPLIT_PENALTY_BEFORE_IF_EXPR'))
+ _SetStronglyConnected(*node.children[1:])
+ self.DefaultNodeVisit(node)
+
+ def Visit_or_test(self, node): # pylint: disable=invalid-name
+ # or_test ::= and_test ('or' and_test)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, OR_TEST)
+ index = 1
+ while index + 1 < len(node.children):
+ if style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR'):
+ _DecrementSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index]), OR_TEST)
+ else:
+ _DecrementSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index + 1]), OR_TEST)
+ index += 2
+
+ def Visit_and_test(self, node): # pylint: disable=invalid-name
+ # and_test ::= not_test ('and' not_test)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, AND_TEST)
+ index = 1
+ while index + 1 < len(node.children):
+ if style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR'):
+ _DecrementSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index]), AND_TEST)
+ else:
+ _DecrementSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index + 1]), AND_TEST)
+ index += 2
+
+ def Visit_not_test(self, node): # pylint: disable=invalid-name
+ # not_test ::= 'not' not_test | comparison
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(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):
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[1]), STRONGLY_CONNECTED)
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[2]), STRONGLY_CONNECTED)
+ else:
+ _IncreasePenalty(node, COMPARISON)
+
+ def Visit_star_expr(self, node): # pylint: disable=invalid-name
+ # star_expr ::= '*' expr
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, STAR_EXPR)
+
+ def Visit_expr(self, node): # pylint: disable=invalid-name
+ # expr ::= xor_expr ('|' xor_expr)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, EXPR)
+ index = 1
+ while index < len(node.children) - 1:
+ child = node.children[index]
+ if isinstance(child, pytree.Leaf) and child.value == '|':
+ if style.Get('SPLIT_BEFORE_BITWISE_OPERATOR'):
+ _SetSplitPenalty(child, style.Get('SPLIT_PENALTY_BITWISE_OPERATOR'))
+ else:
+ _SetSplitPenalty(
+ pytree_utils.FirstLeafNode(node.children[index + 1]),
+ style.Get('SPLIT_PENALTY_BITWISE_OPERATOR'))
+ index += 1
+
+ def Visit_xor_expr(self, node): # pylint: disable=invalid-name
+ # xor_expr ::= and_expr ('^' and_expr)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, XOR_EXPR)
+
+ def Visit_and_expr(self, node): # pylint: disable=invalid-name
+ # and_expr ::= shift_expr ('&' shift_expr)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, AND_EXPR)
+
+ def Visit_shift_expr(self, node): # pylint: disable=invalid-name
+ # shift_expr ::= arith_expr (('<<'|'>>') arith_expr)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, SHIFT_EXPR)
+
+ _ARITH_OPS = frozenset({'PLUS', 'MINUS'})
+
+ def Visit_arith_expr(self, node): # pylint: disable=invalid-name
+ # arith_expr ::= term (('+'|'-') term)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, ARITH_EXPR)
+
+ index = 1
+ while index < len(node.children) - 1:
+ child = node.children[index]
+ if pytree_utils.NodeName(child) in self._ARITH_OPS:
+ next_node = pytree_utils.FirstLeafNode(node.children[index + 1])
+ _SetSplitPenalty(next_node, ARITH_EXPR)
+ index += 1
+
+ _TERM_OPS = frozenset({'STAR', 'AT', 'SLASH', 'PERCENT', 'DOUBLESLASH'})
+
+ def Visit_term(self, node): # pylint: disable=invalid-name
+ # term ::= factor (('*'|'@'|'/'|'%'|'//') factor)*
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, TERM)
+
+ index = 1
+ while index < len(node.children) - 1:
+ child = node.children[index]
+ if pytree_utils.NodeName(child) in self._TERM_OPS:
+ next_node = pytree_utils.FirstLeafNode(node.children[index + 1])
+ _SetSplitPenalty(next_node, TERM)
+ index += 1
+
+ def Visit_factor(self, node): # pyline: disable=invalid-name
+ # factor ::= ('+'|'-'|'~') factor | power
+ self.DefaultNodeVisit(node)
+ _IncreasePenalty(node, FACTOR)
+
+ 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[-1].value == ')':
+ if pytree_utils.NodeName(node.parent) == 'if_stmt':
+ _SetSplitPenalty(node.children[-1], STRONGLY_CONNECTED)
+ else:
+ if len(node.children) > 2:
+ _SetSplitPenalty(pytree_utils.FirstLeafNode(node.children[1]), EXPR)
+ _SetSplitPenalty(node.children[-1], ATOM)
+ elif node.children[0].value in '[{' and len(node.children) == 2:
+ # Keep empty containers together if we can.
+ _SetUnbreakable(node.children[-1])
+
+ def Visit_testlist_gexp(self, node): # pylint: disable=invalid-name
+ self.DefaultNodeVisit(node)
+ prev_was_comma = False
+ for child in node.children:
+ if isinstance(child, pytree.Leaf) and child.value == ',':
+ _SetUnbreakable(child)
+ prev_was_comma = True
+ else:
+ if prev_was_comma:
+ _SetSplitPenalty(pytree_utils.FirstLeafNode(child), 0)
+ prev_was_comma = False
+
+ ############################################################################
+ # Helper methods that set the annotations.
+
+ 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)):
+ _SetUnbreakable(node.children[i])
+
+
+def _SetUnbreakable(node):
+ """Set an UNBREAKABLE penalty annotation for the given node."""
+ _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY, UNBREAKABLE)
+
+
+def _SetStronglyConnected(*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 _SetVeryStronglyConnected(*nodes):
+ """Set a VERY_STRONGLY_CONNECTED penalty annotation for the given nodes."""
+ for node in nodes:
+ _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY,
+ VERY_STRONGLY_CONNECTED)
+
+
+def _SetExpressionPenalty(node, penalty):
+ """Set a penalty annotation on children nodes."""
+
+ def RecExpression(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:
+ _SetSplitPenalty(node, penalty)
+ else:
+ for child in node.children:
+ RecExpression(child, first_child_leaf)
+
+ RecExpression(node, pytree_utils.FirstLeafNode(node))
+
+
+def _IncreasePenalty(node, amt):
+ """Increase a penalty annotation on children nodes."""
+
+ def RecExpression(node, first_child_leaf):
+ if node is first_child_leaf:
+ return
+
+ if isinstance(node, pytree.Leaf):
+ if node.value in {'(', 'for', 'if'}:
+ return
+ penalty = pytree_utils.GetNodeAnnotation(
+ node, pytree_utils.Annotation.SPLIT_PENALTY, default=0)
+ _SetSplitPenalty(node, penalty + amt)
+ else:
+ for child in node.children:
+ RecExpression(child, first_child_leaf)
+
+ RecExpression(node, pytree_utils.FirstLeafNode(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 _StronglyConnectedCompOp(op):
+ if (len(op.children[1].children) == 2 and
+ pytree_utils.NodeName(op.children[1]) == 'comp_op' and
+ pytree_utils.FirstLeafNode(op.children[1]).value == 'not' and
+ pytree_utils.LastLeafNode(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 _DecrementSplitPenalty(node, amt):
+ penalty = pytree_utils.GetNodeAnnotation(
+ node, pytree_utils.Annotation.SPLIT_PENALTY, default=amt)
+ penalty = penalty - amt if amt < penalty else 0
+ _SetSplitPenalty(node, penalty)
+
+
+def _SetSplitPenalty(node, penalty):
+ pytree_utils.SetNodeAnnotation(node, pytree_utils.Annotation.SPLIT_PENALTY,
+ penalty)
+
+
+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:
+ _SetSplitPenalty(child, 0)
+ prev_child = child
diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py
new file mode 100644
index 0000000..6144246
--- /dev/null
+++ b/yapf/yapflib/style.py
@@ -0,0 +1,615 @@
+# 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.
+"""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."""),
+ ALLOW_MULTILINE_DICTIONARY_KEYS=textwrap.dedent("""\
+ Allow dictionary keys to exist on multiple lines. For example:
+
+ x = {
+ ('this is the first element of a tuple',
+ 'this is the second element of a tuple'):
+ value,
+ }"""),
+ ALLOW_SPLIT_BEFORE_DICT_VALUE=textwrap.dedent("""\
+ Allow splits before the dictionary value."""),
+ 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():
+ ..."""),
+ BLANK_LINE_BEFORE_CLASS_DOCSTRING=textwrap.dedent("""\
+ Insert a blank line before a class-level docstring."""),
+ BLANK_LINE_BEFORE_MODULE_DOCSTRING=textwrap.dedent("""\
+ Insert a blank line before a module docstring."""),
+ BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=textwrap.dedent("""\
+ Number of blank lines surrounding top-level function and class
+ definitions."""),
+ 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_ALIGN_STYLE=textwrap.dedent("""\
+ The style for continuation alignment. Possible values are:
+
+ - SPACE: Use spaces for continuation alignment. This is default behavior.
+ - FIXED: Use fixed number (CONTINUATION_INDENT_WIDTH) of columns
+ (ie: CONTINUATION_INDENT_WIDTH/INDENT_WIDTH tabs) for continuation
+ alignment.
+ - LESS: Slightly left if cannot vertically align continuation lines with
+ indent characters.
+ - VALIGN-RIGHT: Vertically align continuation lines with indent
+ characters. Slightly right (one more indent character) if cannot
+ vertically align continuation lines with indent characters.
+
+ For options FIXED, and VALIGN-RIGHT are only available when USE_TABS is
+ enabled."""),
+ 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"""),
+ DISABLE_ENDING_COMMA_HEURISTIC=textwrap.dedent("""\
+ Disable the heuristic which places each list element on a separate line
+ if the list is comma-terminated."""),
+ EACH_DICT_ENTRY_ON_SEPARATE_LINE=textwrap.dedent("""\
+ Place each dictionary entry onto its own 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."""),
+ NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=textwrap.dedent("""\
+ Do not include spaces around selected binary operators. For example:
+
+ 1 + 2 * 3 - 4 / 5
+
+ will be formatted as follows when configured with *,/:
+
+ 1 + 2*3 - 4/5
+
+ """),
+ SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=textwrap.dedent("""\
+ Insert a space between the ending comma and closing bracket of a list,
+ etc."""),
+ 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."""),
+ SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=textwrap.dedent("""\
+ Split before arguments if the argument list is terminated by a
+ comma."""),
+ SPLIT_ALL_COMMA_SEPARATED_VALUES=textwrap.dedent("""\
+ Split before arguments"""),
+ SPLIT_BEFORE_BITWISE_OPERATOR=textwrap.dedent("""\
+ Set to True to prefer splitting before '&', '|' or '^' rather than
+ after."""),
+ SPLIT_BEFORE_CLOSING_BRACKET=textwrap.dedent("""\
+ Split before the closing bracket if a list or dict literal doesn't fit on
+ a single line."""),
+ SPLIT_BEFORE_DICT_SET_GENERATOR=textwrap.dedent("""\
+ Split before a dictionary or set generator (comp_for). For example, note
+ the split before the 'for':
+
+ foo = {
+ variable: 'Hello world, have a nice day!'
+ for variable in bar if variable != 42
+ }"""),
+ SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=textwrap.dedent("""\
+ Split after the opening paren which surrounds an expression if it doesn't
+ fit on a single line.
+ """),
+ 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_COMPLEX_COMPREHENSION=textwrap.dedent("""\
+ Set to True to split list comprehensions and generators that have
+ non-trivial expressions and multiple clauses before each of these
+ clauses. For example:
+
+ result = [
+ a_long_var + 100 for a_long_var in xrange(1000)
+ if a_long_var % 10]
+
+ would reformat to something like:
+
+ result = [
+ a_long_var + 100
+ for a_long_var in xrange(1000)
+ if a_long_var % 10]
+ """),
+ 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_COMPREHENSION=textwrap.dedent("""\
+ The penalty for splitting a list comprehension or generator
+ expression."""),
+ 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,
+ ALLOW_MULTILINE_DICTIONARY_KEYS=False,
+ ALLOW_SPLIT_BEFORE_DICT_VALUE=True,
+ BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=False,
+ BLANK_LINE_BEFORE_CLASS_DOCSTRING=False,
+ BLANK_LINE_BEFORE_MODULE_DOCSTRING=False,
+ BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=2,
+ COALESCE_BRACKETS=False,
+ COLUMN_LIMIT=79,
+ CONTINUATION_ALIGN_STYLE='SPACE',
+ CONTINUATION_INDENT_WIDTH=4,
+ DEDENT_CLOSING_BRACKETS=False,
+ DISABLE_ENDING_COMMA_HEURISTIC=False,
+ EACH_DICT_ENTRY_ON_SEPARATE_LINE=True,
+ I18N_COMMENT='',
+ I18N_FUNCTION_CALL='',
+ INDENT_DICTIONARY_VALUE=False,
+ INDENT_WIDTH=4,
+ JOIN_MULTIPLE_LINES=True,
+ SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=True,
+ SPACES_AROUND_POWER_OPERATOR=False,
+ NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=set(),
+ SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=False,
+ SPACES_BEFORE_COMMENT=2,
+ SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=False,
+ SPLIT_ALL_COMMA_SEPARATED_VALUES=False,
+ SPLIT_BEFORE_BITWISE_OPERATOR=True,
+ SPLIT_BEFORE_CLOSING_BRACKET=True,
+ SPLIT_BEFORE_DICT_SET_GENERATOR=True,
+ SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=False,
+ SPLIT_BEFORE_FIRST_ARGUMENT=False,
+ SPLIT_BEFORE_LOGICAL_OPERATOR=True,
+ SPLIT_BEFORE_NAMED_ASSIGNS=True,
+ SPLIT_COMPLEX_COMPREHENSION=False,
+ SPLIT_PENALTY_AFTER_OPENING_BRACKET=30,
+ SPLIT_PENALTY_AFTER_UNARY_OPERATOR=10000,
+ SPLIT_PENALTY_BEFORE_IF_EXPR=0,
+ SPLIT_PENALTY_BITWISE_OPERATOR=300,
+ SPLIT_PENALTY_COMPREHENSION=80,
+ SPLIT_PENALTY_EXCESS_CHARACTER=4500,
+ SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=30,
+ SPLIT_PENALTY_IMPORT_NAMES=0,
+ SPLIT_PENALTY_LOGICAL_OPERATOR=300,
+ USE_TABS=False,
+ )
+
+
+def CreateGoogleStyle():
+ style = CreatePEP8Style()
+ style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False
+ style['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'] = True
+ style['COLUMN_LIMIT'] = 80
+ style['INDENT_WIDTH'] = 4
+ style['I18N_COMMENT'] = r'#\..*'
+ style['I18N_FUNCTION_CALL'] = ['N_', '_']
+ style['SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET'] = False
+ style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False
+ style['SPLIT_BEFORE_DICT_SET_GENERATOR'] = False
+ style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False
+ style['SPLIT_COMPLEX_COMPREHENSION'] = True
+ style['SPLIT_PENALTY_COMPREHENSION'] = 2100
+ return style
+
+
+def CreateChromiumStyle():
+ style = CreateGoogleStyle()
+ style['ALLOW_MULTILINE_DICTIONARY_KEYS'] = True
+ style['INDENT_DICTIONARY_VALUE'] = True
+ style['INDENT_WIDTH'] = 2
+ style['JOIN_MULTIPLE_LINES'] = False
+ style['SPLIT_BEFORE_BITWISE_OPERATOR'] = True
+ style['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = 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['INDENT_DICTIONARY_VALUE'] = True
+ style['JOIN_MULTIPLE_LINES'] = False
+ style['SPACES_BEFORE_COMMENT'] = 2
+ style['SPLIT_PENALTY_AFTER_OPENING_BRACKET'] = 0
+ style['SPLIT_PENALTY_BEFORE_IF_EXPR'] = 30
+ style['SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT'] = 30
+ style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False
+ style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False
+ 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 _ContinuationAlignStyleStringConverter(s):
+ """Option value converter for a continuation align style string."""
+ accepted_styles = ('SPACE', 'FIXED', 'VALIGN-RIGHT')
+ if s:
+ r = s.upper()
+ if r not in accepted_styles:
+ raise ValueError('unknown continuation align style: %r' % (s,))
+ else:
+ r = accepted_styles[0]
+ return r
+
+
+def _StringListConverter(s):
+ """Option value converter for a comma-separated list of strings."""
+ return [part.strip() for part in s.split(',')]
+
+
+def _StringSetConverter(s):
+ """Option value converter for a comma-separated set of strings."""
+ return set(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,
+ ALLOW_MULTILINE_DICTIONARY_KEYS=_BoolConverter,
+ ALLOW_SPLIT_BEFORE_DICT_VALUE=_BoolConverter,
+ BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=_BoolConverter,
+ BLANK_LINE_BEFORE_CLASS_DOCSTRING=_BoolConverter,
+ BLANK_LINE_BEFORE_MODULE_DOCSTRING=_BoolConverter,
+ BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=int,
+ COALESCE_BRACKETS=_BoolConverter,
+ COLUMN_LIMIT=int,
+ CONTINUATION_ALIGN_STYLE=_ContinuationAlignStyleStringConverter,
+ CONTINUATION_INDENT_WIDTH=int,
+ DEDENT_CLOSING_BRACKETS=_BoolConverter,
+ DISABLE_ENDING_COMMA_HEURISTIC=_BoolConverter,
+ EACH_DICT_ENTRY_ON_SEPARATE_LINE=_BoolConverter,
+ I18N_COMMENT=str,
+ I18N_FUNCTION_CALL=_StringListConverter,
+ INDENT_DICTIONARY_VALUE=_BoolConverter,
+ INDENT_WIDTH=int,
+ JOIN_MULTIPLE_LINES=_BoolConverter,
+ NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=_StringSetConverter,
+ 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_ALL_COMMA_SEPARATED_VALUES=_BoolConverter,
+ SPLIT_BEFORE_BITWISE_OPERATOR=_BoolConverter,
+ SPLIT_BEFORE_CLOSING_BRACKET=_BoolConverter,
+ SPLIT_BEFORE_DICT_SET_GENERATOR=_BoolConverter,
+ SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=_BoolConverter,
+ SPLIT_BEFORE_FIRST_ARGUMENT=_BoolConverter,
+ SPLIT_BEFORE_LOGICAL_OPERATOR=_BoolConverter,
+ SPLIT_BEFORE_NAMED_ASSIGNS=_BoolConverter,
+ SPLIT_COMPLEX_COMPREHENSION=_BoolConverter,
+ SPLIT_PENALTY_AFTER_OPENING_BRACKET=int,
+ SPLIT_PENALTY_AFTER_UNARY_OPERATOR=int,
+ SPLIT_PENALTY_BEFORE_IF_EXPR=int,
+ SPLIT_PENALTY_BITWISE_OPERATOR=int,
+ SPLIT_PENALTY_COMPREHENSION=int,
+ SPLIT_PENALTY_EXCESS_CHARACTER=int,
+ SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=int,
+ SPLIT_PENALTY_IMPORT_NAMES=int,
+ SPLIT_PENALTY_LOGICAL_OPERATOR=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()
+ if isinstance(style_config, dict):
+ config = _CreateConfigParserFromConfigDict(style_config)
+ elif isinstance(style_config, py3compat.basestring):
+ 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 _CreateConfigParserFromConfigDict(config_dict):
+ config = py3compat.ConfigParser()
+ config.add_section('style')
+ for key, value in config_dict.items():
+ config.set('style', key, str(value))
+ return 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())
diff --git a/yapf/yapflib/subtype_assigner.py b/yapf/yapflib/subtype_assigner.py
new file mode 100644
index 0000000..8bf3d8d
--- /dev/null
+++ b/yapf/yapflib/subtype_assigner.py
@@ -0,0 +1,428 @@
+# 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.
+"""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.TYPED_NAME,
+ '*': 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
+ unpacking = False
+ for child in node.children:
+ 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 (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.
+ if not unpacking or pytree_utils.FirstLeafNode(child).value == '**':
+ _AppendFirstLeafTokenSubtype(child,
+ format_token.Subtype.DICTIONARY_KEY)
+ _AppendSubtypeRec(child, format_token.Subtype.DICTIONARY_KEY_PART)
+ last_was_colon = pytree_utils.NodeName(child) == 'COLON'
+ if pytree_utils.NodeName(child) == 'DOUBLESTAR':
+ unpacking = True
+ elif last_was_colon:
+ unpacking = False
+
+ 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)
+ _AppendTokenSubtype(child, format_token.Subtype.VARARGS_STAR)
+
+ 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)
+ _SetArgListSubtype(node, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN,
+ format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST)
+
+ def Visit_tname(self, node): # pylint: disable=invalid-name
+ self._ProcessArgLists(node)
+ _SetArgListSubtype(node, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN,
+ format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST)
+
+ 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)
+ _SetArgListSubtype(node, format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN,
+ format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST)
+ tname = False
+ for child in node.children:
+ if pytree_utils.NodeName(child) == 'tname':
+ tname = True
+ _SetArgListSubtype(child, format_token.Subtype.TYPED_NAME,
+ format_token.Subtype.TYPED_NAME_ARG_LIST)
+ if not isinstance(child, pytree.Leaf):
+ continue
+ if child.value == ',':
+ tname = False
+ elif child.value == '=' and tname:
+ _AppendTokenSubtype(child, subtype=format_token.Subtype.TYPED_NAME)
+ tname = False
+
+ 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)
+ # Mark the previous node as COMP_EXPR unless this is a nested comprehension
+ # as these will have the outer comprehension as their previous node.
+ attr = pytree_utils.GetNodeAnnotation(node.parent,
+ pytree_utils.Annotation.SUBTYPE)
+ if not attr or format_token.Subtype.COMP_FOR not in attr:
+ _AppendSubtypeRec(node.parent.children[0], format_token.Subtype.COMP_EXPR)
+ 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 _SetArgListSubtype(node, node_subtype, list_subtype):
+ """Set named assign subtype on elements in a arg list."""
+
+ def HasSubtype(node):
+ """Return True if the arg list has a named assign subtype."""
+ if isinstance(node, pytree.Leaf):
+ if node_subtype in pytree_utils.GetNodeAnnotation(
+ node, pytree_utils.Annotation.SUBTYPE, set()):
+ return True
+ return False
+ has_subtype = False
+ for child in node.children:
+ if pytree_utils.NodeName(child) != 'arglist':
+ has_subtype |= HasSubtype(child)
+ return has_subtype
+
+ if HasSubtype(node):
+ for child in node.children:
+ if pytree_utils.NodeName(child) != 'COMMA':
+ _AppendFirstLeafTokenSubtype(child, list_subtype)
+
+
+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 = pytree_utils.FirstLeafNode(node)
+ last = pytree_utils.LastLeafNode(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 = pytree_utils.FirstLeafNode(node)
+ last = pytree_utils.LastLeafNode(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)
diff --git a/yapf/yapflib/unwrapped_line.py b/yapf/yapflib/unwrapped_line.py
new file mode 100644
index 0000000..92b986e
--- /dev/null
+++ b/yapf/yapflib/unwrapped_line.py
@@ -0,0 +1,540 @@
+# 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.
+"""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
+
+ def Split(self):
+ """Split the line at semicolons."""
+ if not self.has_semicolon or self.disable:
+ return [self]
+
+ uwlines = []
+ uwline = UnwrappedLine(self.depth)
+ for tok in self._tokens:
+ if tok.value == ';':
+ uwlines.append(uwline)
+ uwline = UnwrappedLine(self.depth)
+ else:
+ uwline.AppendToken(tok)
+
+ if uwline.tokens:
+ uwlines.append(uwline)
+
+ for uwline in uwlines:
+ pytree_utils.SetNodeAnnotation(uwline.first.node,
+ pytree_utils.Annotation.MUST_SPLIT, True)
+ uwline.first.previous_token = None
+ uwline.last.next_token = None
+
+ return uwlines
+
+ ############################################################################
+ # 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
+
+ @property
+ def has_semicolon(self):
+ return any(tok.value == ';' for tok in self._tokens)
+
+
+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 (lval == '=' and rval == '.' and
+ format_token.Subtype.DEFAULT_OR_NAMED_ASSIGN not in left.subtypes):
+ # Space between equal and '.' as in "X = ...".
+ 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 (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.TYPED_NAME in left.subtypes or
+ format_token.Subtype.TYPED_NAME in right.subtypes):
+ # A typed argument should have a space after the colon.
+ 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 operator and the unary operator.
+ return True
+ if left.is_keyword and _IsUnaryOperator(right):
+ # Handle things like "not -3 < x".
+ 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 except the blacklisted ones.
+ blacklist = style.Get('NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS')
+ return lval not in blacklist and rval not in blacklist
+ 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.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.
+ return 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 left.is_keyword and rval == '.' or lval == '.' and right.is_keyword:
+ # Add space between keywords and dots.
+ return lval != 'None'
+ 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 separated 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 or (prev_token.previous_token and
+ prev_token.is_pseudo_paren and
+ prev_token.previous_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 previous_token
+ paren_count += 1
+ elif previous_token.value == '{':
+ if brace_count == 0:
+ return previous_token
+ brace_count += 1
+ elif previous_token.value == '[':
+ if sq_bracket_count == 0:
+ return previous_token
+ sq_bracket_count += 1
+
+ previous_token = previous_token.previous_token
+ return None
+
+
+_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
diff --git a/yapf/yapflib/verifier.py b/yapf/yapflib/verifier.py
new file mode 100644
index 0000000..bcbe6fb
--- /dev/null
+++ b/yapf/yapflib/verifier.py
@@ -0,0 +1,93 @@
+# 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.
+"""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'), '<string>', 'exec')
+ except SyntaxError:
+ try:
+ ast.parse(textwrap.dedent(code.lstrip('\n')).lstrip(), '<string>', 'exec')
+ except SyntaxError:
+ try:
+ normalized_code = _NormalizeCode(code)
+ compile(normalized_code.encode('UTF-8'), '<string>', '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(), '<string>', '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'
diff --git a/yapf/yapflib/yapf_api.py b/yapf/yapflib/yapf_api.py
new file mode 100644
index 0000000..282dea3
--- /dev/null
+++ b/yapf/yapflib/yapf_api.py
@@ -0,0 +1,292 @@
+# 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.
+"""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 parse
+
+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 identify_container
+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 successfully 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,
+ encoding, in_place)
+ return None, encoding, changed
+
+ return reformatted_source, encoding, changed
+
+
+def FormatCode(unformatted_source,
+ filename='<unknown>',
+ 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'
+
+ try:
+ tree = pytree_utils.ParseCodeToTree(unformatted_source)
+ except parse.ParseError as e:
+ e.msg = filename + ': ' + e.msg
+ raise
+
+ # Run passes on the tree, modifying it in place.
+ comment_splicer.SpliceComments(tree)
+ continuation_splicer.SpliceContinuations(tree)
+ subtype_assigner.AssignSubtypes(tree)
+ identify_container.IdentifyContainers(tree)
+ split_penalty.ComputeSplitPenalties(tree)
+ blank_line_calculator.CalculateBlankLines(tree)
+
+ uwlines = pytree_unwrapper.UnwrapPyTree(tree)
+ for uwl in uwlines:
+ uwl.CalculateFormattingInformation()
+
+ lines = _LineRangesToSet(lines)
+ _MarkLinesToFormat(uwlines, lines)
+ reformatted_source = reformatter.Reformat(
+ _SplitSemicolons(uwlines), verify, lines)
+
+ 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.strip() != '' # pylint: disable=g-explicit-bool-comparison
+
+ 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:
+ encoding = file_resources.FileEncoding(filename)
+
+ # 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
+
+
+def _SplitSemicolons(uwlines):
+ res = []
+ for uwline in uwlines:
+ res.extend(uwline.Split())
+ return res
+
+
+DISABLE_PATTERN = r'^#.*\byapf:\s*disable\b'
+ENABLE_PATTERN = r'^#.*\byapf:\s*enable\b'
+
+
+def _LineRangesToSet(line_ranges):
+ """Return a set of lines in the range."""
+
+ if line_ranges is None:
+ return None
+
+ line_set = set()
+ for low, high in sorted(line_ranges):
+ line_set.update(range(low, high + 1))
+
+ return line_set
+
+
+def _MarkLinesToFormat(uwlines, lines):
+ """Skip sections of code that we shouldn't reformat."""
+ if lines:
+ for uwline in uwlines:
+ uwline.disable = not lines.intersection(
+ range(uwline.lineno, uwline.last.lineno + 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'
diff --git a/yapftests/__init__.py b/yapftests/__init__.py
new file mode 100644
index 0000000..e7522b2
--- /dev/null
+++ b/yapftests/__init__.py
@@ -0,0 +1,13 @@
+# 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.
diff --git a/yapftests/blank_line_calculator_test.py b/yapftests/blank_line_calculator_test.py
new file mode 100644
index 0000000..2a27a2f
--- /dev/null
+++ b/yapftests/blank_line_calculator_test.py
@@ -0,0 +1,355 @@
+# 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.
+"""Tests for yapf.blank_line_calculator."""
+
+import textwrap
+import unittest
+
+from yapf.yapflib import reformatter
+from yapf.yapflib import style
+from yapf.yapflib import yapf_api
+
+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))
+
+ def testLinesOnRangeBoundary(self):
+ unformatted_code = textwrap.dedent(u"""\
+ def A():
+ pass
+
+ def B(): # 4
+ pass # 5
+
+ def C():
+ pass
+ def D(): # 9
+ pass # 10
+ def E():
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent(u"""\
+ def A():
+ pass
+
+
+ def B(): # 4
+ pass # 5
+
+
+ def C():
+ pass
+
+
+ def D(): # 9
+ pass # 10
+
+
+ def E():
+ pass
+ """)
+ code, changed = yapf_api.FormatCode(
+ unformatted_code, lines=[(4, 5), (9, 10)])
+ self.assertCodeEqual(expected_formatted_code, code)
+ self.assertTrue(changed)
+
+ def testLinesRangeBoundaryNotOutside(self):
+ unformatted_code = textwrap.dedent(u"""\
+ def A():
+ pass
+
+
+
+ def B(): # 6
+ pass # 7
+
+
+
+ def C():
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent(u"""\
+ def A():
+ pass
+
+
+
+ def B(): # 6
+ pass # 7
+
+
+
+ def C():
+ pass
+ """)
+ code, changed = yapf_api.FormatCode(unformatted_code, lines=[(6, 7)])
+ self.assertCodeEqual(expected_formatted_code, code)
+ self.assertFalse(changed)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/comment_splicer_test.py b/yapftests/comment_splicer_test.py
new file mode 100644
index 0000000..aacc888
--- /dev/null
+++ b/yapftests/comment_splicer_test.py
@@ -0,0 +1,334 @@
+# 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.
+"""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 testCommentBeforeDedentThreeLevel(self):
+ code = textwrap.dedent(r'''
+ if foo:
+ if bar:
+ z = 1
+ # comment 2
+ # comment 1
+ # comment 0
+ j = 2
+ ''')
+ tree = pytree_utils.ParseCodeToTree(code)
+ comment_splicer.SpliceComments(tree)
+
+ # comment 0 should go under the tree root
+ self._AssertNodeIsComment(tree.children[1], '# comment 0')
+
+ # comment 1 is in the first if_suite, right before the DEDENT
+ if_suite_1 = self._FindNthChildNamed(tree, 'suite', n=1)
+ self._AssertNodeIsComment(if_suite_1.children[-2], '# comment 1')
+ self._AssertNodeType('DEDENT', if_suite_1.children[-1])
+
+ # comment 2 is in if_suite nested under the first if suite,
+ # right before the DEDENT
+ if_suite_2 = self._FindNthChildNamed(tree, 'suite', n=2)
+ self._AssertNodeIsComment(if_suite_2.children[-2], '# comment 2')
+ self._AssertNodeType('DEDENT', if_suite_2.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()
diff --git a/yapftests/file_resources_test.py b/yapftests/file_resources_test.py
new file mode 100644
index 0000000..70cea46
--- /dev/null
+++ b/yapftests/file_resources_test.py
@@ -0,0 +1,362 @@
+# -*- coding: utf-8 -*-
+# 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.
+"""Tests for yapf.file_resources."""
+
+import contextlib
+import os
+import shutil
+import tempfile
+import unittest
+
+from yapf.yapflib import errors
+from yapf.yapflib import file_resources
+from yapf.yapflib import py3compat
+
+from yapftests import utils
+
+
+@contextlib.contextmanager
+def _restore_working_dir():
+ curdir = os.getcwd()
+ try:
+ yield
+ finally:
+ os.chdir(curdir)
+
+
+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()
+ self.old_dir = os.getcwd()
+
+ def tearDown(self):
+ shutil.rmtree(self.test_tmpdir)
+ os.chdir(self.old_dir)
+
+ def _make_test_dir(self, name):
+ fullpath = os.path.normpath(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'),
+ ]))
+
+ def test_find_with_excluded_hidden_dirs(self):
+ tdir1 = self._make_test_dir('.test1')
+ tdir2 = self._make_test_dir('test_2')
+ tdir3 = self._make_test_dir('test.3')
+ files = [
+ os.path.join(tdir1, 'testfile1.py'),
+ os.path.join(tdir2, 'testfile2.py'),
+ os.path.join(tdir3, 'testfile3.py'),
+ ]
+ _touch_files(files)
+
+ actual = file_resources.GetCommandLineFiles(
+ [self.test_tmpdir], recursive=True, exclude=['*.test1*'])
+
+ self.assertEqual(
+ sorted(actual),
+ sorted([
+ os.path.join(tdir2, 'testfile2.py'),
+ os.path.join(tdir3, 'testfile3.py'),
+ ]))
+
+ def test_find_with_excluded_hidden_dirs_relative(self):
+ """Test find with excluded hidden dirs.
+
+ A regression test against a specific case where a hidden directory (one
+ beginning with a period) is being excluded, but it is also an immediate
+ child of the current directory which has been specified in a relative
+ manner.
+
+ At its core, the bug has to do with overzelous stripping of "./foo" so that
+ it removes too much from "./.foo" .
+ """
+ tdir1 = self._make_test_dir('.test1')
+ tdir2 = self._make_test_dir('test_2')
+ tdir3 = self._make_test_dir('test.3')
+ files = [
+ os.path.join(tdir1, 'testfile1.py'),
+ os.path.join(tdir2, 'testfile2.py'),
+ os.path.join(tdir3, 'testfile3.py'),
+ ]
+ _touch_files(files)
+
+ # We must temporarily change the current directory, so that we test against
+ # patterns like ./.test1/file instead of /tmp/foo/.test1/file
+ with _restore_working_dir():
+
+ os.chdir(self.test_tmpdir)
+ actual = file_resources.GetCommandLineFiles(
+ [os.path.relpath(self.test_tmpdir)],
+ recursive=True,
+ exclude=['*.test1*'])
+
+ self.assertEqual(
+ sorted(actual),
+ sorted([
+ os.path.join(
+ os.path.relpath(self.test_tmpdir), os.path.basename(tdir2),
+ 'testfile2.py'),
+ os.path.join(
+ os.path.relpath(self.test_tmpdir), os.path.basename(tdir3),
+ 'testfile3.py'),
+ ]))
+
+ def test_find_with_excluded_dirs(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)
+
+ os.chdir(self.test_tmpdir)
+
+ found = sorted(
+ file_resources.GetCommandLineFiles(
+ ['test1', 'test2', 'test3'],
+ recursive=True,
+ exclude=[
+ 'test1',
+ 'test2/testinner/',
+ ]))
+
+ self.assertEqual(found, ['test3/foo/bar/bas/xxx/testfile3.py'])
+
+ found = sorted(
+ file_resources.GetCommandLineFiles(
+ ['.'], recursive=True, exclude=[
+ 'test1',
+ 'test3',
+ ]))
+
+ self.assertEqual(found, ['./test2/testinner/testfile2.py'])
+
+ def test_find_with_excluded_current_dir(self):
+ with self.assertRaises(errors.YapfError):
+ file_resources.GetCommandLineFiles([], False, exclude=['./z'])
+
+
+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 IsIgnoredTest(unittest.TestCase):
+
+ def test_root_path(self):
+ self.assertTrue(file_resources.IsIgnored('media', ['media']))
+ self.assertFalse(file_resources.IsIgnored('media', ['media/*']))
+
+ def test_sub_path(self):
+ self.assertTrue(file_resources.IsIgnored('media/a', ['*/a']))
+ self.assertTrue(file_resources.IsIgnored('media/b', ['media/*']))
+ self.assertTrue(file_resources.IsIgnored('media/b/c', ['*/*/c']))
+
+ def test_trailing_slash(self):
+ self.assertTrue(file_resources.IsIgnored('z', ['z']))
+ self.assertTrue(file_resources.IsIgnored('z', ['z/']))
+
+
+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 utils.NamedTempFile(dirname=self.test_tmpdir) as (f, fname):
+ file_resources.WriteReformattedCode(
+ fname, s, in_place=True, encoding='utf-8')
+ f.flush()
+
+ with open(fname) as f2:
+ self.assertEqual(f2.read(), s)
+
+ def test_write_to_stdout(self):
+ s = u'foobar'
+ stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO()
+ with utils.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 utils.stdout_redirector(stream):
+ file_resources.WriteReformattedCode(
+ None, s, in_place=False, encoding='utf-8')
+ self.assertEqual(stream.getvalue(), s)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/format_decision_state_test.py b/yapftests/format_decision_state_test.py
new file mode 100644
index 0000000..6122960
--- /dev/null
+++ b/yapftests/format_decision_state_test.py
@@ -0,0 +1,145 @@
+# 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.
+"""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)
+ state.MoveStateToNextToken()
+ self.assertEqual('f', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+
+ # Add: '('
+ state.AddTokenToState(False, True)
+ self.assertEqual('(', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+ self.assertFalse(state.MustSplit())
+
+ # Add: 'a'
+ state.AddTokenToState(False, True)
+ self.assertEqual('a', state.next_token.value)
+ self.assertTrue(state.CanSplit(False))
+ self.assertFalse(state.MustSplit())
+
+ # Add: ','
+ state.AddTokenToState(False, True)
+ self.assertEqual(',', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+ self.assertFalse(state.MustSplit())
+
+ # Add: 'b'
+ state.AddTokenToState(False, True)
+ self.assertEqual('b', state.next_token.value)
+ self.assertTrue(state.CanSplit(False))
+ self.assertFalse(state.MustSplit())
+
+ # Add: ')'
+ state.AddTokenToState(False, True)
+ self.assertEqual(')', state.next_token.value)
+ self.assertTrue(state.CanSplit(False))
+ self.assertFalse(state.MustSplit())
+
+ # Add: ':'
+ state.AddTokenToState(False, True)
+ self.assertEqual(':', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+ 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)
+ state.MoveStateToNextToken()
+ self.assertEqual('f', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+
+ # Add: '('
+ state.AddTokenToState(True, True)
+ self.assertEqual('(', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+
+ # Add: 'a'
+ state.AddTokenToState(True, True)
+ self.assertEqual('a', state.next_token.value)
+ self.assertTrue(state.CanSplit(False))
+
+ # Add: ','
+ state.AddTokenToState(True, True)
+ self.assertEqual(',', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+
+ # Add: 'b'
+ state.AddTokenToState(True, True)
+ self.assertEqual('b', state.next_token.value)
+ self.assertTrue(state.CanSplit(False))
+
+ # Add: ')'
+ state.AddTokenToState(True, True)
+ self.assertEqual(')', state.next_token.value)
+ self.assertTrue(state.CanSplit(False))
+
+ # Add: ':'
+ state.AddTokenToState(True, True)
+ self.assertEqual(':', state.next_token.value)
+ self.assertFalse(state.CanSplit(False))
+
+ 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()
diff --git a/yapftests/format_token_test.py b/yapftests/format_token_test.py
new file mode 100644
index 0000000..7dfb82a
--- /dev/null
+++ b/yapftests/format_token_test.py
@@ -0,0 +1,86 @@
+# 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.
+"""Tests for yapf.format_token."""
+
+import unittest
+
+from lib2to3 import pytree
+from lib2to3.pgen2 import token
+
+from yapf.yapflib import format_token
+
+
+class TabbedContinuationAlignPaddingTest(unittest.TestCase):
+
+ def testSpace(self):
+ align_style = 'SPACE'
+
+ pad = format_token._TabbedContinuationAlignPadding(0, align_style, 2, 4)
+ self.assertEqual(pad, '')
+
+ pad = format_token._TabbedContinuationAlignPadding(2, align_style, 2, 4)
+ self.assertEqual(pad, ' ' * 2)
+
+ pad = format_token._TabbedContinuationAlignPadding(5, align_style, 2, 4)
+ self.assertEqual(pad, ' ' * 5)
+
+ def testFixed(self):
+ align_style = 'FIXED'
+
+ pad = format_token._TabbedContinuationAlignPadding(0, align_style, 4, 8)
+ self.assertEqual(pad, '')
+
+ pad = format_token._TabbedContinuationAlignPadding(2, align_style, 4, 8)
+ self.assertEqual(pad, '\t' * 2)
+
+ pad = format_token._TabbedContinuationAlignPadding(5, align_style, 4, 8)
+ self.assertEqual(pad, '\t' * 2)
+
+ def testVAlignRight(self):
+ align_style = 'VALIGN-RIGHT'
+
+ pad = format_token._TabbedContinuationAlignPadding(0, align_style, 4, 8)
+ self.assertEqual(pad, '')
+
+ pad = format_token._TabbedContinuationAlignPadding(2, align_style, 4, 8)
+ self.assertEqual(pad, '\t')
+
+ pad = format_token._TabbedContinuationAlignPadding(4, align_style, 4, 8)
+ self.assertEqual(pad, '\t')
+
+ pad = format_token._TabbedContinuationAlignPadding(5, align_style, 4, 8)
+ self.assertEqual(pad, '\t' * 2)
+
+
+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)
+
+ def testIsMultilineString(self):
+ tok = format_token.FormatToken(pytree.Leaf(token.STRING, '"""hello"""'))
+ self.assertTrue(tok.is_multiline_string)
+
+ tok = format_token.FormatToken(pytree.Leaf(token.STRING, 'r"""hello"""'))
+ self.assertTrue(tok.is_multiline_string)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/line_joiner_test.py b/yapftests/line_joiner_test.py
new file mode 100644
index 0000000..6501bc8
--- /dev/null
+++ b/yapftests/line_joiner_test.py
@@ -0,0 +1,82 @@
+# 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.
+"""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()
diff --git a/yapftests/main_test.py b/yapftests/main_test.py
new file mode 100644
index 0000000..138853c
--- /dev/null
+++ b/yapftests/main_test.py
@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+# 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.
+"""Tests for yapf.__init__.main."""
+
+from contextlib import contextmanager
+import sys
+import unittest
+import yapf
+
+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 = py3compat.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:
+ orig_raw_import = yapf.py3compat.raw_input
+ yapf.py3compat.raw_input = patch_raw_input
+ yield
+ finally:
+ yapf.py3compat.raw_input = orig_raw_import
+
+
+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, _):
+ 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, _):
+ 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 (_, _):
+ with self.assertRaisesRegexp(SyntaxError, 'unexpected indent'):
+ yapf.main([])
+
+ def testHelp(self):
+ with captured_output() as (out, _):
+ 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, _):
+ ret = yapf.main(['-', '--version'])
+ self.assertEqual(ret, 0)
+ version = 'yapf {}\n'.format(yapf.__version__)
+ self.assertEqual(version, out.getvalue())
diff --git a/yapftests/pytree_unwrapper_test.py b/yapftests/pytree_unwrapper_test.py
new file mode 100644
index 0000000..f95f366
--- /dev/null
+++ b/yapftests/pytree_unwrapper_test.py
@@ -0,0 +1,356 @@
+# 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.
+"""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=['w','d'], c=[42, 37]):
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self._CheckMatchingBrackets(uwlines, [
+ [(2, 20), (7, 11), (15, 19)],
+ [],
+ ])
+
+ 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()
diff --git a/yapftests/pytree_utils_test.py b/yapftests/pytree_utils_test.py
new file mode 100644
index 0000000..3b9fde7
--- /dev/null
+++ b/yapftests/pytree_utils_test.py
@@ -0,0 +1,205 @@
+# 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.
+"""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()
diff --git a/yapftests/pytree_visitor_test.py b/yapftests/pytree_visitor_test.py
new file mode 100644
index 0000000..1908249
--- /dev/null
+++ b/yapftests/pytree_visitor_test.py
@@ -0,0 +1,120 @@
+# 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.
+"""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()
diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py
new file mode 100644
index 0000000..a3de63d
--- /dev/null
+++ b/yapftests/reformatter_basic_test.py
@@ -0,0 +1,2509 @@
+# Copyright 2016 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 testSplittingAllArgs(self):
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{split_all_comma_separated_values: true, column_limit: 40}'))
+ unformatted_code = textwrap.dedent("""\
+ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120}
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ responseDict = {
+ "timestamp": timestamp,
+ "someValue": value,
+ "whatever": 120
+ }
+ """)
+ unformatted_code = textwrap.dedent("""\
+ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args):
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def foo(long_arg,
+ really_long_arg,
+ really_really_long_arg,
+ cant_keep_all_these_args):
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+ unformatted_code = textwrap.dedent("""\
+ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ foo_tuple = [
+ long_arg,
+ really_long_arg,
+ really_really_long_arg,
+ cant_keep_all_these_args
+ ]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+ unformatted_code = textwrap.dedent("""\
+ foo_tuple = [short, arg]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ foo_tuple = [short, arg]
+ """)
+ 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 testCommentsWithTrailingSpaces(self):
+ unformatted_code = textwrap.dedent("""\
+ # Thing 1
+ # Thing 2
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ # Thing 1
+ # Thing 2
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_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 testListComprehensionPreferOneLine(self):
+ unformatted_code = textwrap.dedent("""\
+ def given(y):
+ long_variable_name = [
+ long_var_name + 1
+ for long_var_name in ()
+ if long_var_name == 2]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def given(y):
+ long_variable_name = [
+ long_var_name + 1 for long_var_name in () if long_var_name == 2
+ ]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testListComprehensionPreferOneLineOverArithmeticSplit(self):
+ unformatted_code = textwrap.dedent("""\
+ def given(used_identifiers):
+ return (sum(len(identifier)
+ for identifier in used_identifiers) / len(used_identifiers))
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def given(used_identifiers):
+ return (sum(len(identifier) for identifier in used_identifiers) /
+ len(used_identifiers))
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testListComprehensionPreferThreeLinesForLineWrap(self):
+ unformatted_code = textwrap.dedent("""\
+ def given(y):
+ long_variable_name = [
+ long_var_name + 1
+ for long_var_name, number_two in ()
+ if long_var_name == 2 and number_two == 3]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def given(y):
+ long_variable_name = [
+ long_var_name + 1
+ for long_var_name, number_two in ()
+ if long_var_name == 2 and number_two == 3
+ ]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testListComprehensionPreferNoBreakForTrivialExpression(self):
+ unformatted_code = textwrap.dedent("""\
+ def given(y):
+ long_variable_name = [
+ long_var_name
+ for long_var_name, number_two in ()
+ if long_var_name == 2 and number_two == 3]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def given(y):
+ long_variable_name = [
+ long_var_name for long_var_name, number_two in ()
+ if long_var_name == 2 and number_two == 3
+ ]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testOpeningAndClosingBrackets(self):
+ unformatted_code = """\
+foo( (1, ) )
+foo( ( 1, 2, 3 ) )
+foo( ( 1, 2, 3, ) )
+"""
+ expected_formatted_code = """\
+foo((1,))
+foo((1, 2, 3))
+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 constructed, 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.
+ unformatted_code = """\
+find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >"
+"""
+ expected_formatted_code = """\
+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 += """<html>This is a really long docstring that goes over the column limit and is multi-line.<br><br>
+ <b>Czar: </b>"""+despot["Nicholas"]+"""<br>
+ <b>Minion: </b>"""+serf["Dmitri"]+"""<br>
+ <b>Residence: </b>"""+palace["Winter"]+"""<br>
+ </body>
+ </html>"""
+ ''')
+ expected_formatted_code = textwrap.dedent('''\
+ def f():
+ email_text += """<html>This is a really long docstring that goes over the column limit and is multi-line.<br><br>
+ <b>Czar: </b>""" + despot["Nicholas"] + """<br>
+ <b>Minion: </b>""" + serf["Dmitri"] + """<br>
+ <b>Residence: </b>""" + palace["Winter"] + """<br>
+ </body>
+ </html>"""
+ ''')
+ 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 = """\
+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 = """\
+urlpatterns = patterns('', url(r'^$', 'homepage_view'),
+ url(r'^/login/$', 'login_view'),
+ url(r'^/login/$', 'logout_view'),
+ url(r'^/user/(?P<username>\\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 testMultipleContinuationMarkers(self):
+ code = textwrap.dedent("""\
+ xyz = \\
+ \\
+ some_thing()
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testContinuationMarkerAfterStringWithContinuation(self):
+ code = """\
+s = 'foo \\
+ bar' \\
+ .format()
+"""
+ 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))
+
+ unformatted_code = textwrap.dedent("""\
+ def _():
+ if True:
+ if True:
+ if contract == allow_contract and attr_dict.get(if_attribute) == has_value:
+ return True
+ """)
+ expected_code = textwrap.dedent("""\
+ def _():
+ if True:
+ if True:
+ if contract == allow_contract and attr_dict.get(
+ if_attribute) == has_value:
+ return True
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_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))
+
+ code = textwrap.dedent("""\
+ def foo():
+ return [
+ Bar(xxx='some string',
+ yyy='another long string',
+ zzz='a third long string')
+ ]
+ """)
+ 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 testMultilineDictionaryKeys(self):
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig('{based_on_style: chromium, '
+ 'allow_multiline_dictionary_keys: true}'))
+ unformatted_code = textwrap.dedent("""\
+ MAP_WITH_LONG_KEYS = {
+ ('lorem ipsum', 'dolor sit amet'):
+ 1,
+ ('consectetur adipiscing elit.', 'Vestibulum mauris justo, ornare eget dolor eget'):
+ 2,
+ ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',):
+ 3
+ }
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ MAP_WITH_LONG_KEYS = {
+ ('lorem ipsum', 'dolor sit amet'):
+ 1,
+ ('consectetur adipiscing elit.',
+ 'Vestibulum mauris justo, ornare eget dolor eget'):
+ 2,
+ ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',):
+ 3
+ }
+ """)
+ 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 testStableInlinedDictionaryFormatting(self):
+ try:
+ style.SetGlobalStyle(style.CreatePEP8Style())
+ unformatted_code = textwrap.dedent("""\
+ def _():
+ url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format(
+ value, urllib.urlencode({'action': 'update', 'parameter': value}))
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def _():
+ url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format(
+ value, urllib.urlencode({
+ 'action': 'update',
+ 'parameter': value
+ }))
+ """)
+
+ 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 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))
+
+ def testNamedAssignNotAtEndOfLine(self):
+ unformatted_code = textwrap.dedent("""\
+ def _():
+ if True:
+ with py3compat.open_with_encoding(filename, mode='w',
+ encoding=encoding) as fd:
+ pass
+ """)
+ expected_code = textwrap.dedent("""\
+ def _():
+ if True:
+ with py3compat.open_with_encoding(
+ filename, mode='w', encoding=encoding) as fd:
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_code, reformatter.Reformat(uwlines))
+
+ def testBlankLineBeforeClassDocstring(self):
+ unformatted_code = textwrap.dedent('''\
+ class A:
+
+ """Does something.
+
+ Also, here are some details.
+ """
+
+ def __init__(self):
+ pass
+ ''')
+ expected_code = textwrap.dedent('''\
+ class A:
+ """Does something.
+
+ Also, here are some details.
+ """
+
+ def __init__(self):
+ pass
+ ''')
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_code, reformatter.Reformat(uwlines))
+
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: chromium, '
+ 'blank_line_before_class_docstring: True}'))
+ unformatted_code = textwrap.dedent('''\
+ class A:
+
+ """Does something.
+
+ Also, here are some details.
+ """
+
+ def __init__(self):
+ pass
+ ''')
+ expected_formatted_code = textwrap.dedent('''\
+ class A:
+
+ """Does something.
+
+ Also, here are some details.
+ """
+
+ def __init__(self):
+ pass
+ ''')
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testBlankLineBeforeModuleDocstring(self):
+ unformatted_code = textwrap.dedent('''\
+ #!/usr/bin/env python
+ # -*- coding: utf-8 name> -*-
+
+ """Some module docstring."""
+
+
+ def foobar():
+ pass
+ ''')
+ expected_code = textwrap.dedent('''\
+ #!/usr/bin/env python
+ # -*- coding: utf-8 name> -*-
+ """Some module docstring."""
+
+
+ def foobar():
+ pass
+ ''')
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_code, reformatter.Reformat(uwlines))
+
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: pep8, '
+ 'blank_line_before_module_docstring: True}'))
+ unformatted_code = textwrap.dedent('''\
+ #!/usr/bin/env python
+ # -*- coding: utf-8 name> -*-
+ """Some module docstring."""
+
+
+ def foobar():
+ pass
+ ''')
+ expected_formatted_code = textwrap.dedent('''\
+ #!/usr/bin/env python
+ # -*- coding: utf-8 name> -*-
+
+ """Some module docstring."""
+
+
+ def foobar():
+ pass
+ ''')
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testTupleCohesion(self):
+ unformatted_code = textwrap.dedent("""\
+ def f():
+ this_is_a_very_long_function_name(an_extremely_long_variable_name, (
+ 'a string that may be too long %s' % 'M15'))
+ """)
+ expected_code = textwrap.dedent("""\
+ def f():
+ this_is_a_very_long_function_name(
+ an_extremely_long_variable_name,
+ ('a string that may be too long %s' % 'M15'))
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_code, reformatter.Reformat(uwlines))
+
+ def testSubscriptExpression(self):
+ code = textwrap.dedent("""\
+ foo = d[not a]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testListWithFunctionCalls(self):
+ unformatted_code = textwrap.dedent("""\
+ def foo():
+ return [
+ Bar(
+ xxx='some string',
+ yyy='another long string',
+ zzz='a third long string'), Bar(
+ xxx='some string',
+ yyy='another long string',
+ zzz='a third long string')
+ ]
+ """)
+ expected_code = textwrap.dedent("""\
+ def foo():
+ return [
+ Bar(xxx='some string',
+ yyy='another long string',
+ zzz='a third long string'),
+ Bar(xxx='some string',
+ yyy='another long string',
+ zzz='a third long string')
+ ]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_code, reformatter.Reformat(uwlines))
+
+ def testEllipses(self):
+ unformatted_code = textwrap.dedent("""\
+ X=...
+ Y = X if ... else X
+ """)
+ expected_code = textwrap.dedent("""\
+ X = ...
+ Y = X if ... else X
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertEqual(expected_code, reformatter.Reformat(uwlines))
+
+ def testSplittingBeforeFirstArgumentOnFunctionCall(self):
+ """Tests split_before_first_argument on a function call."""
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: chromium, split_before_first_argument: True}'))
+ unformatted_code = textwrap.dedent("""\
+ a_very_long_function_name("long string with formatting {0:s}".format(
+ "mystring"))
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ a_very_long_function_name(
+ "long string with formatting {0:s}".format("mystring"))
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testSplittingBeforeFirstArgumentOnFunctionDefinition(self):
+ """Tests split_before_first_argument on a function definition."""
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: chromium, split_before_first_argument: True}'))
+ unformatted_code = textwrap.dedent("""\
+ def _GetNumberOfSecondsFromElements(year, month, day, hours,
+ minutes, seconds, microseconds):
+ return
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def _GetNumberOfSecondsFromElements(
+ year, month, day, hours, minutes, seconds, microseconds):
+ return
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testSplittingBeforeFirstArgumentOnCompoundStatement(self):
+ """Tests split_before_first_argument on a compound statement."""
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: chromium, split_before_first_argument: True}'))
+ unformatted_code = textwrap.dedent("""\
+ if (long_argument_name_1 == 1 or
+ long_argument_name_2 == 2 or
+ long_argument_name_3 == 3 or
+ long_argument_name_4 == 4):
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ if (long_argument_name_1 == 1 or long_argument_name_2 == 2 or
+ long_argument_name_3 == 3 or long_argument_name_4 == 4):
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testCoalesceBracketsOnDict(self):
+ """Tests coalesce_brackets on a dictionary."""
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: chromium, coalesce_brackets: True}'))
+ unformatted_code = textwrap.dedent("""\
+ date_time_values = (
+ {
+ u'year': year,
+ u'month': month,
+ u'day_of_month': day_of_month,
+ u'hours': hours,
+ u'minutes': minutes,
+ u'seconds': seconds
+ }
+ )
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ date_time_values = ({
+ u'year': year,
+ u'month': month,
+ u'day_of_month': day_of_month,
+ u'hours': hours,
+ u'minutes': minutes,
+ u'seconds': seconds
+ })
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testSplitAfterComment(self):
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: chromium, coalesce_brackets: True, '
+ 'dedent_closing_brackets: true}'))
+ code = textwrap.dedent("""\
+ if __name__ == "__main__":
+ with another_resource:
+ account = {
+ "validUntil":
+ int(time() + (6 * 7 * 24 * 60 * 60)) # in 6 weeks time
+ }
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testAsyncAsNonKeyword(self):
+ try:
+ style.SetGlobalStyle(style.CreatePEP8Style())
+
+ # In Python 2, async may be used as a non-keyword identifier.
+ code = textwrap.dedent("""\
+ from util import async
+
+
+ class A(object):
+ def foo(self):
+ async.run()
+
+ def bar(self):
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines, verify=False))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+ def testDisableEndingCommaHeuristic(self):
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig('{based_on_style: chromium,'
+ ' disable_ending_comma_heuristic: True}'))
+
+ code = """\
+x = [1, 2, 3, 4, 5, 6, 7,]
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreateChromiumStyle())
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/reformatter_buganizer_test.py b/yapftests/reformatter_buganizer_test.py
new file mode 100644
index 0000000..6a1c781
--- /dev/null
+++ b/yapftests/reformatter_buganizer_test.py
@@ -0,0 +1,1959 @@
+# Copyright 2016 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 testB77923341(self):
+ code = """\
+def f():
+ if (aaaaaaaaaaaaaa.bbbbbbbbbbbb.ccccc <= 0 and # pytype: disable=attribute-error
+ ddddddddddd.eeeeeeeee == constants.FFFFFFFFFFFFFF):
+ raise "yo"
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB77329955(self):
+ code = """\
+class _():
+
+ @parameterized.named_parameters(
+ ('ReadyExpiredSuccess', True, True, True, None, None),
+ ('SpannerUpdateFails', True, False, True, None, None),
+ ('ReadyNotExpired', False, True, True, True, None),
+ # ('ReadyNotExpiredNotHealthy', False, True, True, False, True),
+ # ('ReadyNotExpiredNotHealthyErrorFails', False, True, True, False, False
+ # ('ReadyNotExpiredNotHealthyUpdateFails', False, False, True, False, True
+ )
+ def _():
+ pass
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB65197969(self):
+ unformatted_code = """\
+class _():
+
+ def _():
+ return timedelta(seconds=max(float(time_scale), small_interval) *
+ 1.41 ** min(num_attempts, 9))
+"""
+ expected_formatted_code = """\
+class _():
+
+ def _():
+ return timedelta(
+ seconds=max(float(time_scale), small_interval) *
+ 1.41**min(num_attempts, 9))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB65546221(self):
+ unformatted_code = """\
+SUPPORTED_PLATFORMS = (
+ "centos-6",
+ "centos-7",
+ "ubuntu-1204-precise",
+ "ubuntu-1404-trusty",
+ "ubuntu-1604-xenial",
+ "debian-7-wheezy",
+ "debian-8-jessie",
+ "debian-9-stretch",)
+"""
+ expected_formatted_code = """\
+SUPPORTED_PLATFORMS = (
+ "centos-6",
+ "centos-7",
+ "ubuntu-1204-precise",
+ "ubuntu-1404-trusty",
+ "ubuntu-1604-xenial",
+ "debian-7-wheezy",
+ "debian-8-jessie",
+ "debian-9-stretch",
+)
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB30500455(self):
+ unformatted_code = """\
+INITIAL_SYMTAB = dict([(name, 'exception#' + name) for name in INITIAL_EXCEPTIONS
+] * [(name, 'type#' + name) for name in INITIAL_TYPES] + [
+ (name, 'function#' + name) for name in INITIAL_FUNCTIONS
+] + [(name, 'const#' + name) for name in INITIAL_CONSTS])
+"""
+ expected_formatted_code = """\
+INITIAL_SYMTAB = dict(
+ [(name, 'exception#' + name) for name in INITIAL_EXCEPTIONS] *
+ [(name, 'type#' + name) for name in INITIAL_TYPES] +
+ [(name, 'function#' + name) for name in INITIAL_FUNCTIONS] +
+ [(name, 'const#' + name) for name in INITIAL_CONSTS])
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB38343525(self):
+ code = """\
+# This does foo.
+@arg.String('some_path_to_a_file', required=True)
+# This does bar.
+@arg.String('some_path_to_a_file', required=True)
+def f():
+ print 1
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB37099651(self):
+ unformatted_code = """\
+_MEMCACHE = lazy.MakeLazy(
+ # pylint: disable=g-long-lambda
+ lambda: function.call.mem.clients(FLAGS.some_flag_thingy, default_namespace=_LAZY_MEM_NAMESPACE, allow_pickle=True)
+ # pylint: enable=g-long-lambda
+)
+"""
+ expected_formatted_code = """\
+_MEMCACHE = lazy.MakeLazy(
+ # pylint: disable=g-long-lambda
+ lambda: function.call.mem.clients(
+ FLAGS.some_flag_thingy,
+ default_namespace=_LAZY_MEM_NAMESPACE,
+ allow_pickle=True)
+ # pylint: enable=g-long-lambda
+)
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB33228502(self):
+ unformatted_code = """\
+def _():
+ success_rate_stream_table = module.Precompute(
+ query_function=module.DefineQueryFunction(
+ name='Response error ratio',
+ expression=((m.Fetch(
+ m.Raw('monarch.BorgTask',
+ '/corp/travel/trips2/dispatcher/email/response'),
+ {'borg_job': module_config.job, 'metric:response_type': 'SUCCESS'}),
+ m.Fetch(m.Raw('monarch.BorgTask', '/corp/travel/trips2/dispatcher/email/response'), {'borg_job': module_config.job}))
+ | m.Window(m.Delta('1h'))
+ | m.Join('successes', 'total')
+ | m.Point(m.VAL['successes'] / m.VAL['total']))))
+"""
+ expected_formatted_code = """\
+def _():
+ success_rate_stream_table = module.Precompute(
+ query_function=module.DefineQueryFunction(
+ name='Response error ratio',
+ expression=(
+ (m.Fetch(
+ m.Raw('monarch.BorgTask',
+ '/corp/travel/trips2/dispatcher/email/response'), {
+ 'borg_job': module_config.job,
+ 'metric:response_type': 'SUCCESS'
+ }),
+ m.Fetch(
+ m.Raw('monarch.BorgTask',
+ '/corp/travel/trips2/dispatcher/email/response'),
+ {'borg_job': module_config.job}))
+ | m.Window(m.Delta('1h'))
+ | m.Join('successes', 'total')
+ | m.Point(m.VAL['successes'] / m.VAL['total']))))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB30394228(self):
+ code = """\
+class _():
+
+ def _(self):
+ return some.randome.function.calling(
+ wf, None, alert.Format(alert.subject, alert=alert, threshold=threshold),
+ alert.Format(alert.body, alert=alert, threshold=threshold),
+ alert.html_formatting)
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB65246454(self):
+ unformatted_code = """\
+class _():
+
+ def _(self):
+ self.assertEqual({i.id
+ for i in successful_instances},
+ {i.id
+ for i in self._statuses.successful_instances})
+"""
+ expected_formatted_code = """\
+class _():
+
+ def _(self):
+ self.assertEqual({i.id for i in successful_instances},
+ {i.id for i in self._statuses.successful_instances})
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB67935450(self):
+ unformatted_code = """\
+def _():
+ return (
+ (Gauge(
+ metric='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ group_by=group_by + ['metric:process_name'],
+ metric_filter={'metric:process_name': process_name_re}),
+ Gauge(
+ metric='bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+ group_by=group_by + ['metric:process_name'],
+ metric_filter={'metric:process_name': process_name_re}))
+ | expr.Join(
+ left_name='start', left_default=0, right_name='end', right_default=0)
+ | m.Point(
+ m.Cond(m.VAL['end'] != 0, m.VAL['end'], k.TimestampMicros() /
+ 1000000L) - m.Cond(m.VAL['start'] != 0, m.VAL['start'],
+ m.TimestampMicros() / 1000000L)))
+"""
+ expected_formatted_code = """\
+def _():
+ return (
+ (Gauge(
+ metric='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ group_by=group_by + ['metric:process_name'],
+ metric_filter={'metric:process_name': process_name_re}),
+ Gauge(
+ metric='bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+ group_by=group_by + ['metric:process_name'],
+ metric_filter={'metric:process_name': process_name_re}))
+ | expr.Join(
+ left_name='start', left_default=0, right_name='end', right_default=0)
+ | m.Point(
+ m.Cond(m.VAL['end'] != 0, m.VAL['end'],
+ k.TimestampMicros() / 1000000L) -
+ m.Cond(m.VAL['start'] != 0, m.VAL['start'],
+ m.TimestampMicros() / 1000000L)))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB66011084(self):
+ unformatted_code = """\
+X = {
+"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": # Comment 1.
+([] if True else [ # Comment 2.
+ "bbbbbbbbbbbbbbbbbbb", # Comment 3.
+ "cccccccccccccccccccccccc", # Comment 4.
+ "ddddddddddddddddddddddddd", # Comment 5.
+ "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", # Comment 6.
+ "fffffffffffffffffffffffffffffff", # Comment 7.
+ "ggggggggggggggggggggggggggg", # Comment 8.
+ "hhhhhhhhhhhhhhhhhh", # Comment 9.
+]),
+}
+"""
+ expected_formatted_code = """\
+X = {
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": # Comment 1.
+ ([] if True else [ # Comment 2.
+ "bbbbbbbbbbbbbbbbbbb", # Comment 3.
+ "cccccccccccccccccccccccc", # Comment 4.
+ "ddddddddddddddddddddddddd", # Comment 5.
+ "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", # Comment 6.
+ "fffffffffffffffffffffffffffffff", # Comment 7.
+ "ggggggggggggggggggggggggggg", # Comment 8.
+ "hhhhhhhhhhhhhhhhhh", # Comment 9.
+ ]),
+}
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB67455376(self):
+ unformatted_code = """\
+sponge_ids.extend(invocation.id() for invocation in self._client.GetInvocationsByLabels(labels))
+"""
+ expected_formatted_code = """\
+sponge_ids.extend(invocation.id()
+ for invocation in self._client.GetInvocationsByLabels(labels))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB35210351(self):
+ unformatted_code = """\
+def _():
+ config.AnotherRuleThing(
+ 'the_title_to_the_thing_here',
+ {'monitorname': 'firefly',
+ 'service': ACCOUNTING_THING,
+ 'severity': 'the_bug',
+ 'monarch_module_name': alerts.TheLabel(qa_module_regexp, invert=True)},
+ fanout,
+ alerts.AlertUsToSomething(
+ GetTheAlertToIt('the_title_to_the_thing_here'),
+ GetNotificationTemplate('your_email_here')))
+"""
+ expected_formatted_code = """\
+def _():
+ config.AnotherRuleThing(
+ 'the_title_to_the_thing_here', {
+ 'monitorname': 'firefly',
+ 'service': ACCOUNTING_THING,
+ 'severity': 'the_bug',
+ 'monarch_module_name': alerts.TheLabel(qa_module_regexp, invert=True)
+ }, fanout,
+ alerts.AlertUsToSomething(
+ GetTheAlertToIt('the_title_to_the_thing_here'),
+ GetNotificationTemplate('your_email_here')))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB34774905(self):
+ unformatted_code = """\
+x=[VarExprType(ir_name=IrName( value='x',
+expr_type=UnresolvedAttrExprType( atom=UnknownExprType(), attr_name=IrName(
+ value='x', expr_type=UnknownExprType(), usage='UNKNOWN', fqn=None,
+ astn=None), usage='REF'), usage='ATTR', fqn='<attr>.x', astn=None))]
+"""
+ expected_formatted_code = """\
+x = [
+ VarExprType(
+ ir_name=IrName(
+ value='x',
+ expr_type=UnresolvedAttrExprType(
+ atom=UnknownExprType(),
+ attr_name=IrName(
+ value='x',
+ expr_type=UnknownExprType(),
+ usage='UNKNOWN',
+ fqn=None,
+ astn=None),
+ usage='REF'),
+ usage='ATTR',
+ fqn='<attr>.x',
+ astn=None))
+]
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB65176185(self):
+ code = """\
+xx = zip(*[(a, b) for (a, b, c) in yy])
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB35210166(self):
+ unformatted_code = """\
+def _():
+ query = (
+ m.Fetch(n.Raw('monarch.BorgTask', '/proc/container/memory/usage'), { 'borg_user': borguser, 'borg_job': jobname })
+ | o.Window(m.Align('5m')) | p.GroupBy(['borg_user', 'borg_job', 'borg_cell'], q.Mean()))
+"""
+ expected_formatted_code = """\
+def _():
+ query = (
+ m.Fetch(
+ n.Raw('monarch.BorgTask', '/proc/container/memory/usage'), {
+ 'borg_user': borguser,
+ 'borg_job': jobname
+ })
+ | o.Window(m.Align('5m'))
+ | p.GroupBy(['borg_user', 'borg_job', 'borg_cell'], q.Mean()))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB32167774(self):
+ unformatted_code = """\
+X = (
+ 'is_official',
+ 'is_cover',
+ 'is_remix',
+ 'is_instrumental',
+ 'is_live',
+ 'has_lyrics',
+ 'is_album',
+ 'is_compilation',)
+"""
+ expected_formatted_code = """\
+X = (
+ 'is_official',
+ 'is_cover',
+ 'is_remix',
+ 'is_instrumental',
+ 'is_live',
+ 'has_lyrics',
+ 'is_album',
+ 'is_compilation',
+)
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB66912275(self):
+ unformatted_code = """\
+def _():
+ with self.assertRaisesRegexp(errors.HttpError, 'Invalid'):
+ patch_op = api_client.forwardingRules().patch(
+ project=project_id,
+ region=region,
+ forwardingRule=rule_name,
+ body={'fingerprint': base64.urlsafe_b64encode('invalid_fingerprint')}).execute()
+"""
+ expected_formatted_code = """\
+def _():
+ with self.assertRaisesRegexp(errors.HttpError, 'Invalid'):
+ patch_op = api_client.forwardingRules().patch(
+ project=project_id,
+ region=region,
+ forwardingRule=rule_name,
+ body={
+ 'fingerprint': base64.urlsafe_b64encode('invalid_fingerprint')
+ }).execute()
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB67312284(self):
+ code = """\
+def _():
+ self.assertEqual(
+ [u'to be published 2', u'to be published 1', u'to be published 0'],
+ [el.text for el in page.first_column_tds])
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB65241516(self):
+ unformatted_code = """\
+checkpoint_files = gfile.Glob(os.path.join(TrainTraceDir(unit_key, "*", "*"), embedding_model.CHECKPOINT_FILENAME + "-*"))
+"""
+ expected_formatted_code = """\
+checkpoint_files = gfile.Glob(
+ os.path.join(
+ TrainTraceDir(unit_key, "*", "*"),
+ embedding_model.CHECKPOINT_FILENAME + "-*"))
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB37460004(self):
+ code = textwrap.dedent("""\
+ assert all(s not in (_SENTINEL, None) for s in nested_schemas
+ ), 'Nested schemas should never contain None/_SENTINEL'
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB36806207(self):
+ code = """\
+def _():
+ linearity_data = [[row] for row in [
+ "%.1f mm" % (np.mean(linearity_values["pos_error"]) * 1000.0),
+ "%.1f mm" % (np.max(linearity_values["pos_error"]) * 1000.0),
+ "%.1f mm" % (np.mean(linearity_values["pos_error_chunk_mean"]) * 1000.0),
+ "%.1f mm" % (np.max(linearity_values["pos_error_chunk_max"]) * 1000.0),
+ "%.1f deg" % math.degrees(np.mean(linearity_values["rot_noise"])),
+ "%.1f deg" % math.degrees(np.max(linearity_values["rot_noise"])),
+ "%.1f deg" % math.degrees(np.mean(linearity_values["rot_drift"])),
+ "%.1f deg" % math.degrees(np.max(linearity_values["rot_drift"])),
+ "%.1f%%" % (np.max(linearity_values["pos_discontinuity"]) * 100.0),
+ "%.1f%%" % (np.max(linearity_values["rot_discontinuity"]) * 100.0)
+ ]]
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB36215507(self):
+ code = textwrap.dedent("""\
+ class X():
+
+ def _():
+ aaaaaaaaaaaaa._bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(
+ mmmmmmmmmmmmm, nnnnn, ooooooooo,
+ _(ppppppppppppppppppppppppppppppppppppp),
+ *(qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq),
+ **(qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq))
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testB35212469(self):
+ unformatted_code = textwrap.dedent("""\
+ def _():
+ X = {
+ 'retain': {
+ 'loadtest': # This is a comment in the middle of a dictionary entry
+ ('/some/path/to/a/file/that/is/needed/by/this/process')
+ }
+ }
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def _():
+ X = {
+ 'retain': {
+ 'loadtest': # This is a comment in the middle of a dictionary entry
+ ('/some/path/to/a/file/that/is/needed/by/this/process')
+ }
+ }
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB31063453(self):
+ unformatted_code = textwrap.dedent("""\
+ def _():
+ while ((not mpede_proc) or ((time_time() - last_modified) < FLAGS_boot_idle_timeout)):
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def _():
+ while ((not mpede_proc) or
+ ((time_time() - last_modified) < FLAGS_boot_idle_timeout)):
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB35021894(self):
+ unformatted_code = textwrap.dedent("""\
+ def _():
+ labelacl = Env(qa={
+ 'read': 'name/some-type-of-very-long-name-for-reading-perms',
+ 'modify': 'name/some-other-type-of-very-long-name-for-modifying'
+ },
+ prod={
+ 'read': 'name/some-type-of-very-long-name-for-reading-perms',
+ 'modify': 'name/some-other-type-of-very-long-name-for-modifying'
+ })
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def _():
+ labelacl = Env(
+ qa={
+ 'read': 'name/some-type-of-very-long-name-for-reading-perms',
+ 'modify': 'name/some-other-type-of-very-long-name-for-modifying'
+ },
+ prod={
+ 'read': 'name/some-type-of-very-long-name-for-reading-perms',
+ 'modify': 'name/some-other-type-of-very-long-name-for-modifying'
+ })
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testB34682902(self):
+ unformatted_code = textwrap.dedent("""\
+ logging.info("Mean angular velocity norm: %.3f", np.linalg.norm(np.mean(ang_vel_arr, axis=0)))
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ logging.info("Mean angular velocity norm: %.3f",
+ np.linalg.norm(np.mean(ang_vel_arr, axis=0)))
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ 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 = """\
+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 '<session %s on %s>' % (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 testB30087363(self):
+ code = textwrap.dedent("""\
+ if False:
+ bar()
+ # This is a comment
+ # This is another comment
+ elif True:
+ 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 = """\
+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 = """\
+call(a=1,
+ b=2,
+)
+"""
+ expected_formatted_code = """\
+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))
+
+ def testB67935687(self):
+ code = textwrap.dedent("""\
+ Fetch(
+ Raw('monarch.BorgTask', '/union/row_operator_action_delay'),
+ {'borg_user': self.borg_user})
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ unformatted_code = textwrap.dedent("""\
+ shelf_renderer.expand_text = text.translate_to_unicode(
+ expand_text % {
+ 'creator': creator
+ })
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ shelf_renderer.expand_text = text.translate_to_unicode(
+ expand_text % {'creator': creator})
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/reformatter_facebook_test.py b/yapftests/reformatter_facebook_test.py
new file mode 100644
index 0000000..289aa85
--- /dev/null
+++ b/yapftests/reformatter_facebook_test.py
@@ -0,0 +1,432 @@
+# Copyright 2016 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):
+ unformatted_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
+ """)
+ expected_formatted_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(unformatted_code)
+ self.assertCodeEqual(expected_formatted_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))
+
+ def testIfStmtClosingBracket(self):
+ unformatted_code = """\
+if (isinstance(value , (StopIteration , StopAsyncIteration )) and exc.__cause__ is value_asdfasdfasdfasdfsafsafsafdasfasdfs):
+ return False
+"""
+ expected_formatted_code = """\
+if (
+ isinstance(value, (StopIteration, StopAsyncIteration)) and
+ exc.__cause__ is value_asdfasdfasdfasdfsafsafsafdasfasdfs
+):
+ return False
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/reformatter_pep8_test.py b/yapftests/reformatter_pep8_test.py
new file mode 100644
index 0000000..a6f736f
--- /dev/null
+++ b/yapftests/reformatter_pep8_test.py
@@ -0,0 +1,436 @@
+# Copyright 2016 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 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 testContinuedNonOutdentedLine(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())
+
+ def testSplittingExpressionsInsideSubscripts(self):
+ unformatted_code = textwrap.dedent("""\
+ def foo():
+ df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def foo():
+ df = df[(df['campaign_status'] == 'LIVE')
+ & (df['action_status'] == 'LIVE')]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testSplitListsAndDictSetMakersIfCommaTerminated(self):
+ unformatted_code = textwrap.dedent("""\
+ DJANGO_TEMPLATES_OPTIONS = {"context_processors": []}
+ DJANGO_TEMPLATES_OPTIONS = {"context_processors": [],}
+ x = ["context_processors"]
+ x = ["context_processors",]
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ DJANGO_TEMPLATES_OPTIONS = {"context_processors": []}
+ DJANGO_TEMPLATES_OPTIONS = {
+ "context_processors": [],
+ }
+ x = ["context_processors"]
+ x = [
+ "context_processors",
+ ]
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testSplitAroundNamedAssigns(self):
+ unformatted_code = textwrap.dedent("""\
+ class a():
+ def a(): return a(
+ aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ class a():
+ def a():
+ return a(
+ aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+ )
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testUnaryOperator(self):
+ unformatted_code = textwrap.dedent("""\
+ if not -3 < x < 3:
+ pass
+ if -3 < x < 3:
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ if not -3 < x < 3:
+ pass
+ if -3 < x < 3:
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testNoSplitBeforeDictValue(self):
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig('{based_on_style: pep8, '
+ 'allow_split_before_dict_value: false, '
+ 'coalesce_brackets: true, '
+ 'dedent_closing_brackets: true, '
+ 'each_dict_entry_on_separate_line: true, '
+ 'split_before_logical_operator: true}'))
+
+ unformatted_code = textwrap.dedent("""\
+ some_dict = {
+ 'title': _("I am example data"),
+ 'description': _("Lorem ipsum dolor met sit amet elit, si vis pacem para bellum "
+ "elites nihi very long string."),
+ }
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ some_dict = {
+ 'title': _("I am example data"),
+ 'description': _(
+ "Lorem ipsum dolor met sit amet elit, si vis pacem para bellum "
+ "elites nihi very long string."
+ ),
+ }
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+
+ unformatted_code = textwrap.dedent("""\
+ X = {'a': 1, 'b': 2, 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()}
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ X = {
+ 'a': 1,
+ 'b': 2,
+ 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()
+ }
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+
+ unformatted_code = textwrap.dedent("""\
+ attrs = {
+ 'category': category,
+ 'role': forms.ModelChoiceField(label=_("Role"), required=False, queryset=category_roles, initial=selected_role, empty_label=_("No access"),),
+ }
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ attrs = {
+ 'category': category,
+ 'role': forms.ModelChoiceField(
+ label=_("Role"),
+ required=False,
+ queryset=category_roles,
+ initial=selected_role,
+ empty_label=_("No access"),
+ ),
+ }
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+
+ unformatted_code = textwrap.dedent("""\
+ css_class = forms.CharField(
+ label=_("CSS class"),
+ required=False,
+ help_text=_("Optional CSS class used to customize this category appearance from templates."),
+ )
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ css_class = forms.CharField(
+ label=_("CSS class"),
+ required=False,
+ help_text=_(
+ "Optional CSS class used to customize this category appearance from templates."
+ ),
+ )
+ """)
+ 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()
diff --git a/yapftests/reformatter_python3_test.py b/yapftests/reformatter_python3_test.py
new file mode 100644
index 0000000..9be6528
--- /dev/null
+++ b/yapftests/reformatter_python3_test.py
@@ -0,0 +1,383 @@
+# Copyright 2016 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 testNoSpacesAroundPowerOperator(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 testNoneKeyword(self):
+ code = """\
+None.__ne__()
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(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 testAsyncFunctionsNested(self):
+ if sys.version_info[1] < 5:
+ return
+ code = textwrap.dedent("""\
+ async def outer():
+ async def inner():
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(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))
+
+ def testContinuationIndentWithAsync(self):
+ if sys.version_info[1] < 5:
+ return
+ unformatted_code = textwrap.dedent("""\
+ async def start_websocket():
+ async with session.ws_connect(
+ r"ws://a_really_long_long_long_long_long_long_url") as ws:
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ async def start_websocket():
+ async with session.ws_connect(
+ r"ws://a_really_long_long_long_long_long_long_url") as ws:
+ pass
+ """)
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testSplittingArguments(self):
+ if sys.version_info[1] < 5:
+ return
+ try:
+ style.SetGlobalStyle(
+ style.CreateStyleFromConfig(
+ '{based_on_style: pep8, '
+ 'dedent_closing_brackets: true, '
+ 'coalesce_brackets: false, '
+ 'space_between_ending_comma_and_closing_bracket: false, '
+ 'split_arguments_when_comma_terminated: true, '
+ 'split_before_first_argument: true}'))
+ unformatted_code = """\
+async def open_file(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
+ pass
+
+async def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None):
+ pass
+
+def open_file(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
+ pass
+
+def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None):
+ pass
+"""
+ expected_formatted_code = """\
+async def open_file(
+ file,
+ mode='r',
+ buffering=-1,
+ encoding=None,
+ errors=None,
+ newline=None,
+ closefd=True,
+ opener=None
+):
+ pass
+
+
+async def run_sync_in_worker_thread(
+ sync_fn, *args, cancellable=False, limiter=None
+):
+ pass
+
+
+def open_file(
+ file,
+ mode='r',
+ buffering=-1,
+ encoding=None,
+ errors=None,
+ newline=None,
+ closefd=True,
+ opener=None
+):
+ pass
+
+
+def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None):
+ pass
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code,
+ reformatter.Reformat(uwlines))
+ finally:
+ style.SetGlobalStyle(style.CreatePEP8Style())
+
+ def testDictUnpacking(self):
+ if sys.version_info[1] < 5:
+ return
+ unformatted_code = """\
+class Foo:
+ def foo(self):
+ foofoofoofoofoofoofoofoo('foofoofoofoofoo', {
+
+ 'foo': 'foo',
+
+ **foofoofoo
+ })
+"""
+ expected_formatted_code = """\
+class Foo:
+ def foo(self):
+ foofoofoofoofoofoofoofoo('foofoofoofoofoo', {
+ 'foo': 'foo',
+ **foofoofoo
+ })
+"""
+ uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
+ self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
+
+ def testMultilineFormatString(self):
+ if sys.version_info[1] < 6:
+ return
+ code = """\
+# yapf: disable
+(f'''
+ ''')
+# yapf: enable
+"""
+ # https://github.com/google/yapf/issues/513
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+ def testEllipses(self):
+ if sys.version_info[1] < 6:
+ return
+ code = """\
+def dirichlet(x12345678901234567890123456789012345678901234567890=...) -> None:
+ return
+"""
+ # https://github.com/google/yapf/issues/533
+ uwlines = yapf_test_helper.ParseAndUnwrap(code)
+ self.assertCodeEqual(code, reformatter.Reformat(uwlines))
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/reformatter_style_config_test.py b/yapftests/reformatter_style_config_test.py
new file mode 100644
index 0000000..5afd805
--- /dev/null
+++ b/yapftests/reformatter_style_config_test.py
@@ -0,0 +1,81 @@
+# Copyright 2016 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))
+
+ def testOperatorStyle(self):
+ try:
+ sympy_style = style.CreatePEP8Style()
+ sympy_style['NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS'] = \
+ style._StringSetConverter('*,/')
+ style.SetGlobalStyle(sympy_style)
+ unformatted_code = textwrap.dedent("""\
+ a = 1+2 * 3 - 4 / 5
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ a = 1 + 2*3 - 4/5
+ """)
+
+ 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
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/reformatter_verify_test.py b/yapftests/reformatter_verify_test.py
new file mode 100644
index 0000000..1b3d5b0
--- /dev/null
+++ b/yapftests/reformatter_verify_test.py
@@ -0,0 +1,108 @@
+# Copyright 2016 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()
diff --git a/yapftests/split_penalty_test.py b/yapftests/split_penalty_test.py
new file mode 100644
index 0000000..7d500da
--- /dev/null
+++ b/yapftests/split_penalty_test.py
@@ -0,0 +1,259 @@
+# 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.
+"""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
+
+
+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', None),
+ ('for', 0),
+ ('a', STRONGLY_CONNECTED),
+ ('in', STRONGLY_CONNECTED),
+ ('foo', STRONGLY_CONNECTED),
+ ('if', 0),
+ ('a', STRONGLY_CONNECTED),
+ ('.', UNBREAKABLE),
+ ('x', DOTTED_NAME),
+ ('==', STRONGLY_CONNECTED),
+ ('37', STRONGLY_CONNECTED),
+ (']', None),
+ ])
+
+ def testFuncCalls(self):
+ code = 'foo(1, 2, 3)\n'
+ tree = self._ParseAndComputePenalties(code)
+ self._CheckPenalties(tree, [
+ ('foo', None),
+ ('(', UNBREAKABLE),
+ ('1', None),
+ (',', UNBREAKABLE),
+ ('2', None),
+ (',', UNBREAKABLE),
+ ('3', None),
+ (')', 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', None),
+ (',', UNBREAKABLE),
+ ('2', None),
+ (',', UNBREAKABLE),
+ ('3', None),
+ (')', VERY_STRONGLY_CONNECTED),
+ ])
+
+ # Test single generator argument.
+ code = 'max(i for i in xrange(10))\n'
+ tree = self._ParseAndComputePenalties(code)
+ self._CheckPenalties(tree, [
+ ('max', None),
+ ('(', UNBREAKABLE),
+ ('i', 0),
+ ('for', 0),
+ ('i', STRONGLY_CONNECTED),
+ ('in', STRONGLY_CONNECTED),
+ ('xrange', STRONGLY_CONNECTED),
+ ('(', UNBREAKABLE),
+ ('10', STRONGLY_CONNECTED),
+ (')', VERY_STRONGLY_CONNECTED),
+ (')', VERY_STRONGLY_CONNECTED),
+ ])
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/style_test.py b/yapftests/style_test.py
new file mode 100644
index 0000000..7f4a465
--- /dev/null
+++ b/yapftests/style_test.py
@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+# 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.
+"""Tests for yapf.style."""
+
+import shutil
+import tempfile
+import textwrap
+import unittest
+
+from yapf.yapflib import style
+
+from yapftests import utils
+
+
+class UtilsTest(unittest.TestCase):
+
+ def testContinuationAlignStyleStringConverter(self):
+ self.assertEqual(style._ContinuationAlignStyleStringConverter(''), 'SPACE')
+ self.assertEqual(
+ style._ContinuationAlignStyleStringConverter('space'), 'SPACE')
+ self.assertEqual(
+ style._ContinuationAlignStyleStringConverter('fixed'), 'FIXED')
+ self.assertEqual(
+ style._ContinuationAlignStyleStringConverter('valign-right'),
+ 'VALIGN-RIGHT')
+ with self.assertRaises(ValueError) as ctx:
+ style._ContinuationAlignStyleStringConverter('blahblah')
+ self.assertIn("unknown continuation align style: 'blahblah'",
+ str(ctx.exception))
+
+ 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))
+
+
+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(u'''\
+ [style]
+ continuation_indent_width = 20
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ self.assertTrue(_LooksLikePEP8Style(cfg))
+ self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20)
+
+ def testDefaultBasedOnPEP8Style(self):
+ cfg = textwrap.dedent(u'''\
+ [style]
+ based_on_style = pep8
+ continuation_indent_width = 40
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ self.assertTrue(_LooksLikePEP8Style(cfg))
+ self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 40)
+
+ def testDefaultBasedOnChromiumStyle(self):
+ cfg = textwrap.dedent(u'''\
+ [style]
+ based_on_style = chromium
+ continuation_indent_width = 30
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ self.assertTrue(_LooksLikeChromiumStyle(cfg))
+ self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 30)
+
+ def testDefaultBasedOnGoogleStyle(self):
+ cfg = textwrap.dedent(u'''\
+ [style]
+ based_on_style = google
+ continuation_indent_width = 20
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ self.assertTrue(_LooksLikeGoogleStyle(cfg))
+ self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20)
+
+ def testDefaultBasedOnFacebookStyle(self):
+ cfg = textwrap.dedent(u'''\
+ [style]
+ based_on_style = facebook
+ continuation_indent_width = 20
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ self.assertTrue(_LooksLikeFacebookStyle(cfg))
+ self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20)
+
+ def testBoolOptionValue(self):
+ cfg = textwrap.dedent(u'''\
+ [style]
+ based_on_style = chromium
+ SPLIT_BEFORE_NAMED_ASSIGNS=False
+ split_before_logical_operator = true
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ 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(u'''\
+ [style]
+ based_on_style = chromium
+ I18N_FUNCTION_CALL = N_, V_, T_
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ cfg = style.CreateStyleFromConfig(filepath)
+ 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(u'''\
+ [s]
+ indent_width=2
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ with self.assertRaisesRegexp(style.StyleConfigError,
+ 'Unable to find section'):
+ style.CreateStyleFromConfig(filepath)
+
+ def testErrorUnknownStyleOption(self):
+ cfg = textwrap.dedent(u'''\
+ [style]
+ indent_width=2
+ hummus=2
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
+ with self.assertRaisesRegexp(style.StyleConfigError,
+ 'Unknown style option'):
+ style.CreateStyleFromConfig(filepath)
+
+
+class StyleFromDict(unittest.TestCase):
+
+ @classmethod
+ def setUpClass(cls):
+ style.SetGlobalStyle(style.CreatePEP8Style())
+
+ def testDefaultBasedOnStyle(self):
+ config_dict = {
+ 'based_on_style': 'pep8',
+ 'indent_width': 2,
+ 'blank_line_before_nested_class_or_def': True
+ }
+ cfg = style.CreateStyleFromConfig(config_dict)
+ self.assertTrue(_LooksLikeChromiumStyle(cfg))
+ self.assertEqual(cfg['INDENT_WIDTH'], 2)
+
+ def testDefaultBasedOnStyleBadDict(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'})
+
+
+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 testDefaultBasedOnExplicitlyUnicodeTypeString(self):
+ cfg = style.CreateStyleFromConfig(u'{}')
+ self.assertIsInstance(cfg, dict)
+
+ def testDefaultBasedOnDetaultTypeString(self):
+ cfg = style.CreateStyleFromConfig('{}')
+ self.assertIsInstance(cfg, dict)
+
+ 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()
diff --git a/yapftests/subtype_assigner_test.py b/yapftests/subtype_assigner_test.py
new file mode 100644
index 0000000..8daead9
--- /dev/null
+++ b/yapftests/subtype_assigner_test.py
@@ -0,0 +1,200 @@
+# 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.
+"""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.COMP_EXPR}),
+ ('.', {format_token.Subtype.COMP_EXPR}),
+ ('lower', {format_token.Subtype.COMP_EXPR}),
+ ('(', {format_token.Subtype.COMP_EXPR}),
+ (')', {format_token.Subtype.COMP_EXPR}),
+ ('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,
+ format_token.Subtype.VARARGS_STAR}),
+ ('b', [format_token.Subtype.NONE]),
+ (']', [format_token.Subtype.NONE]),],
+ ]) # yapf: disable
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/yapftests/unwrapped_line_test.py b/yapftests/unwrapped_line_test.py
new file mode 100644
index 0000000..90be1a1
--- /dev/null
+++ b/yapftests/unwrapped_line_test.py
@@ -0,0 +1,96 @@
+# 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.
+"""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()
diff --git a/yapftests/utils.py b/yapftests/utils.py
new file mode 100644
index 0000000..268b8c4
--- /dev/null
+++ b/yapftests/utils.py
@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+# Copyright 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 tests."""
+
+import contextlib
+import io
+import os
+import sys
+import tempfile
+
+
+@contextlib.contextmanager
+def stdout_redirector(stream): # pylint: disable=invalid-name
+ old_stdout = sys.stdout
+ sys.stdout = stream
+ try:
+ yield
+ finally:
+ sys.stdout = old_stdout
+
+
+# NamedTemporaryFile is useless because on Windows the temporary file would be
+# created with O_TEMPORARY, which would not allow the file to be opened a
+# second time, even by the same process, unless the same flag is used.
+# Thus we provide a simplified version ourselves.
+#
+# Note: returns a tuple of (io.file_obj, file_path), instead of a file_obj with
+# a .name attribute
+#
+# Note: `buffering` is set to -1 despite documentation of NamedTemporaryFile
+# says None. This is probably a problem with the python documentation.
+@contextlib.contextmanager
+def NamedTempFile(mode='w+b',
+ buffering=-1,
+ encoding=None,
+ errors=None,
+ newline=None,
+ suffix=None,
+ prefix=None,
+ dirname=None,
+ text=False):
+ """Context manager creating a new temporary file in text mode."""
+ if sys.version_info < (3, 5): # covers also python 2
+ if suffix is None:
+ suffix = ''
+ if prefix is None:
+ prefix = 'tmp'
+ (fd, fname) = tempfile.mkstemp(
+ suffix=suffix, prefix=prefix, dir=dirname, text=text)
+ f = io.open(
+ fd,
+ mode=mode,
+ buffering=buffering,
+ encoding=encoding,
+ errors=errors,
+ newline=newline)
+ yield f, fname
+ f.close()
+ os.remove(fname)
+
+
+@contextlib.contextmanager
+def TempFileContents(dirname,
+ contents,
+ encoding='utf-8',
+ newline='',
+ suffix=None):
+ # Note: NamedTempFile properly handles unicode encoding when using mode='w'
+ with NamedTempFile(
+ dirname=dirname,
+ mode='w',
+ encoding=encoding,
+ newline=newline,
+ suffix=suffix) as (f, fname):
+ f.write(contents)
+ f.flush()
+ yield fname
diff --git a/yapftests/yapf_test.py b/yapftests/yapf_test.py
new file mode 100644
index 0000000..6df28b6
--- /dev/null
+++ b/yapftests/yapf_test.py
@@ -0,0 +1,1393 @@
+# -*- coding: utf-8 -*-
+# 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.
+"""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
+
+from yapftests import utils
+
+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 testFormatFile(self):
+ unformatted_code = textwrap.dedent(u"""\
+ if True:
+ pass
+ """)
+ expected_formatted_code_pep8 = textwrap.dedent(u"""\
+ if True:
+ pass
+ """)
+ expected_formatted_code_chromium = textwrap.dedent(u"""\
+ if True:
+ pass
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(expected_formatted_code_pep8, formatted_code)
+
+ formatted_code, _, _ = yapf_api.FormatFile(
+ filepath, style_config='chromium')
+ self.assertCodeEqual(expected_formatted_code_chromium, formatted_code)
+
+ def testDisableLinesPattern(self):
+ unformatted_code = textwrap.dedent(u"""\
+ if a: b
+
+ # yapf: disable
+ if f: g
+
+ if h: i
+ """)
+ expected_formatted_code = textwrap.dedent(u"""\
+ if a: b
+
+ # yapf: disable
+ if f: g
+
+ if h: i
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(expected_formatted_code, formatted_code)
+
+ def testDisableAndReenableLinesPattern(self):
+ unformatted_code = textwrap.dedent(u"""\
+ if a: b
+
+ # yapf: disable
+ if f: g
+ # yapf: enable
+
+ if h: i
+ """)
+ expected_formatted_code = textwrap.dedent(u"""\
+ if a: b
+
+ # yapf: disable
+ if f: g
+ # yapf: enable
+
+ if h: i
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(expected_formatted_code, formatted_code)
+
+ def testDisablePartOfMultilineComment(self):
+ unformatted_code = textwrap.dedent(u"""\
+ 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
+ """)
+
+ expected_formatted_code = textwrap.dedent(u"""\
+ 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
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(expected_formatted_code, formatted_code)
+
+ code = textwrap.dedent(u"""\
+ def foo_function():
+ # some comment
+ # yapf: disable
+
+ foo(
+ bar,
+ baz
+ )
+
+ # yapf: enable
+ """)
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(code, formatted_code)
+
+ def testFormatFileLinesSelection(self):
+ unformatted_code = textwrap.dedent(u"""\
+ if a: b
+
+ if f: g
+
+ if h: i
+ """)
+ expected_formatted_code_lines1and2 = textwrap.dedent(u"""\
+ if a: b
+
+ if f: g
+
+ if h: i
+ """)
+ expected_formatted_code_lines3 = textwrap.dedent(u"""\
+ if a: b
+
+ if f: g
+
+ if h: i
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(
+ filepath, style_config='pep8', lines=[(1, 2)])
+ self.assertCodeEqual(expected_formatted_code_lines1and2, formatted_code)
+ formatted_code, _, _ = yapf_api.FormatFile(
+ filepath, style_config='pep8', lines=[(3, 3)])
+ self.assertCodeEqual(expected_formatted_code_lines3, formatted_code)
+
+ def testFormatFileDiff(self):
+ unformatted_code = textwrap.dedent(u"""\
+ if True:
+ pass
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ diff, _, _ = yapf_api.FormatFile(filepath, print_diff=True)
+ self.assertTrue(u'+ pass' in diff)
+
+ def testFormatFileInPlace(self):
+ unformatted_code = u'True==False\n'
+ formatted_code = u'True == False\n'
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ result, _, _ = yapf_api.FormatFile(filepath, in_place=True)
+ self.assertEqual(result, None)
+ with open(filepath) as fd:
+ if sys.version_info[0] <= 2:
+ self.assertCodeEqual(formatted_code, fd.read().decode('ascii'))
+ else:
+ self.assertCodeEqual(formatted_code, fd.read())
+
+ self.assertRaises(
+ ValueError,
+ yapf_api.FormatFile,
+ filepath,
+ 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(u"""\
+ foo = [# A list of things
+ # bork
+ 'one',
+ # quark
+ 'two'] # yapf: disable
+ """)
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(code, formatted_code)
+
+ def testDisabledHorizontalFormattingOnNewLine(self):
+ code = textwrap.dedent(u"""\
+ # yapf: disable
+ a = [
+ 1]
+ # yapf: enable
+ """)
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(code, formatted_code)
+
+ def testSplittingSemicolonStatements(self):
+ unformatted_code = textwrap.dedent(u"""\
+ def f():
+ x = y + 42 ; z = n * 42
+ if True: a += 1 ; b += 1; c += 1
+ """)
+ expected_formatted_code = textwrap.dedent(u"""\
+ def f():
+ x = y + 42
+ z = n * 42
+ if True:
+ a += 1
+ b += 1
+ c += 1
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(expected_formatted_code, formatted_code)
+
+ def testSemicolonStatementsDisabled(self):
+ unformatted_code = textwrap.dedent(u"""\
+ def f():
+ x = y + 42 ; z = n * 42 # yapf: disable
+ if True: a += 1 ; b += 1; c += 1
+ """)
+ expected_formatted_code = textwrap.dedent(u"""\
+ def f():
+ x = y + 42 ; z = n * 42 # yapf: disable
+ if True:
+ a += 1
+ b += 1
+ c += 1
+ """)
+ with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(expected_formatted_code, formatted_code)
+
+ def testDisabledSemiColonSeparatedStatements(self):
+ code = textwrap.dedent(u"""\
+ # yapf: disable
+ if True: a ; b
+ """)
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
+ self.assertCodeEqual(code, formatted_code)
+
+ def testDisabledMultilineStringInDictionary(self):
+ code = textwrap.dedent(u"""\
+ # yapf: disable
+
+ A = [
+ {
+ "aaaaaaaaaaaaaaaaaaa": '''
+ bbbbbbbbbbb: "ccccccccccc"
+ dddddddddddddd: 1
+ eeeeeeee: 0
+ ffffffffff: "ggggggg"
+ ''',
+ },
+ ]
+ """)
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(
+ filepath, style_config='chromium')
+ self.assertCodeEqual(code, formatted_code)
+
+ def testDisabledWithPrecedingText(self):
+ code = textwrap.dedent(u"""\
+ # TODO(fix formatting): yapf: disable
+
+ A = [
+ {
+ "aaaaaaaaaaaaaaaaaaa": '''
+ bbbbbbbbbbb: "ccccccccccc"
+ dddddddddddddd: 1
+ eeeeeeee: 0
+ ffffffffff: "ggggggg"
+ ''',
+ },
+ ]
+ """)
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(
+ filepath, style_config='chromium')
+ self.assertCodeEqual(code, formatted_code)
+
+ def testCRLFLineEnding(self):
+ code = u'class _():\r\n pass\r\n'
+ with utils.TempFileContents(self.test_tmpdir, code) as filepath:
+ formatted_code, _, _ = yapf_api.FormatFile(
+ filepath, 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,
+ env=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
+ env: dict of environment variables.
+ """
+ cmdline = YAPF_BINARY + (extra_options or [])
+ p = subprocess.Popen(
+ cmdline,
+ stdout=subprocess.PIPE,
+ stdin=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ env=env)
+ reformatted_code, stderrdata = p.communicate(unformatted.encode('utf-8'))
+ self.assertEqual(stderrdata, b'')
+ self.assertMultiLineEqual(reformatted_code.decode('utf-8'), expected)
+
+ def testUnicodeEncodingPipedToFile(self):
+ unformatted_code = textwrap.dedent(u"""\
+ def foo():
+ print('⇒')
+ """)
+ with utils.NamedTempFile(
+ dirname=self.test_tmpdir, suffix='.py') as (out, _):
+ with utils.TempFileContents(
+ self.test_tmpdir, unformatted_code, suffix='.py') as filepath:
+ subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out)
+
+ def testInPlaceReformatting(self):
+ unformatted_code = textwrap.dedent(u"""\
+ def foo():
+ x = 37
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def foo():
+ x = 37
+ """)
+ with utils.TempFileContents(
+ self.test_tmpdir, unformatted_code, suffix='.py') as filepath:
+ p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath])
+ p.wait()
+ with io.open(filepath, 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 utils.TempFileContents(
+ self.test_tmpdir, unformatted_code, suffix='.py') as filepath:
+ p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath])
+ p.wait()
+ with io.open(filepath, mode='r', encoding='utf-8', 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 utils.TempFileContents(
+ self.test_tmpdir, unformatted_code, suffix='.py') as filepath:
+ p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath])
+ p.wait()
+ with io.open(filepath, mode='r', encoding='utf-8', newline='') 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
+ """)
+ style_file = textwrap.dedent(u'''\
+ [style]
+ based_on_style = chromium
+ SPACES_BEFORE_COMMENT = 4
+ ''')
+ with utils.TempFileContents(self.test_tmpdir, style_file) as stylepath:
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(stylepath)])
+
+ 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(u"""\
+ '''The module docstring.'''
+ # -*- coding: utf-8 -*-
+ def f():
+ x = 37
+ """)
+
+ with utils.NamedTempFile(
+ suffix='.py', dirname=self.test_tmpdir) as (out, _):
+ with utils.TempFileContents(
+ self.test_tmpdir, unformatted_code, suffix='.py') as filepath:
+ try:
+ subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out)
+ except subprocess.CalledProcessError as e:
+ self.assertEqual(e.returncode, 1) # Indicates the text changed.
+
+ 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 += """<html>This is a really long docstring that goes over the column limit and is multi-line.<br><br>
+ <b>Czar: </b>"""+despot["Nicholas"]+"""<br>
+ <b>Minion: </b>"""+serf["Dmitri"]+"""<br>
+ <b>Residence: </b>"""+palace["Winter"]+"""<br>
+ </body>
+ </html>"""
+ ''')
+ expected_formatted_code = textwrap.dedent('''\
+ foo = 42
+
+
+ def f():
+ email_text += """<html>This is a really long docstring that goes over the column limit and is multi-line.<br><br>
+ <b>Czar: </b>"""+despot["Nicholas"]+"""<br>
+ <b>Minion: </b>"""+serf["Dmitri"]+"""<br>
+ <b>Residence: </b>"""+palace["Winter"]+"""<br>
+ </body>
+ </html>"""
+ ''')
+ 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 utils.NamedTempFile(dirname=self.test_tmpdir, mode='w') as (f, name):
+ f.write(
+ textwrap.dedent(u'''\
+ [style]
+ column_limit=82
+ coalesce_brackets = True
+ '''))
+ f.flush()
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(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 = """\
+def foo_function():
+ if True:
+ pass
+"""
+ expected_formatted_code = """\
+def foo_function():
+ if True:
+ pass
+"""
+ style_contents = u"""\
+[style]
+based_on_style = chromium
+USE_TABS = true
+INDENT_WIDTH=1
+"""
+ with utils.TempFileContents(self.test_tmpdir, style_contents) as stylepath:
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(stylepath)])
+
+ def testUseTabsWith(self):
+ unformatted_code = """\
+def f():
+ return ['hello', 'world',]
+"""
+ expected_formatted_code = """\
+def f():
+ return [
+ 'hello',
+ 'world',
+ ]
+"""
+ style_contents = u"""\
+[style]
+based_on_style = chromium
+USE_TABS = true
+INDENT_WIDTH=1
+"""
+ with utils.TempFileContents(self.test_tmpdir, style_contents) as stylepath:
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(stylepath)])
+
+ def testUseTabsContinuationAlignStyleFixed(self):
+ unformatted_code = """\
+def foo_function(arg1, arg2, arg3):
+ return ['hello', 'world',]
+"""
+ expected_formatted_code = """\
+def foo_function(arg1, arg2,
+ arg3):
+ return [
+ 'hello',
+ 'world',
+ ]
+"""
+ style_contents = u"""\
+[style]
+based_on_style = chromium
+USE_TABS = true
+COLUMN_LIMIT=32
+INDENT_WIDTH=4
+CONTINUATION_INDENT_WIDTH=8
+CONTINUATION_ALIGN_STYLE = fixed
+"""
+ with utils.TempFileContents(self.test_tmpdir, style_contents) as stylepath:
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(stylepath)])
+
+ def testUseTabsContinuationAlignStyleVAlignRight(self):
+ unformatted_code = """\
+def foo_function(arg1, arg2, arg3):
+ return ['hello', 'world',]
+"""
+ expected_formatted_code = """\
+def foo_function(arg1, arg2,
+ arg3):
+ return [
+ 'hello',
+ 'world',
+ ]
+"""
+ style_contents = u"""\
+[style]
+based_on_style = chromium
+USE_TABS = true
+COLUMN_LIMIT=32
+INDENT_WIDTH=4
+CONTINUATION_INDENT_WIDTH=8
+CONTINUATION_ALIGN_STYLE = valign-right
+"""
+ with utils.TempFileContents(self.test_tmpdir, style_contents) as stylepath:
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(stylepath)])
+
+ def testStyleOutputRoundTrip(self):
+ unformatted_code = textwrap.dedent("""\
+ def foo_function():
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ def foo_function():
+ pass
+ """)
+
+ with utils.NamedTempFile(dirname=self.test_tmpdir) as (stylefile,
+ stylepath):
+ p = subprocess.Popen(
+ YAPF_BINARY + ['--style-help'],
+ stdout=stylefile,
+ stdin=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ _, stderrdata = p.communicate()
+ self.assertEqual(stderrdata, b'')
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style={0}'.format(stylepath)])
+
+ def testSpacingBeforeComments(self):
+ unformatted_code = textwrap.dedent("""\
+ A = 42
+
+
+ # A comment
+ def x():
+ pass
+ def _():
+ pass
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ A = 42
+
+
+ # A comment
+ def x():
+ pass
+ def _():
+ pass
+ """)
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--lines', '1-2'])
+
+ def testSpacingBeforeCommentsInDicts(self):
+ unformatted_code = textwrap.dedent("""\
+ A=42
+
+ X = {
+ # 'Valid' statuses.
+ PASSED: # Passed
+ 'PASSED',
+ FAILED: # Failed
+ 'FAILED',
+ TIMED_OUT: # Timed out.
+ 'FAILED',
+ BORKED: # Broken.
+ 'BROKEN'
+ }
+ """)
+ expected_formatted_code = textwrap.dedent("""\
+ A = 42
+
+ X = {
+ # 'Valid' statuses.
+ PASSED: # Passed
+ 'PASSED',
+ FAILED: # Failed
+ 'FAILED',
+ TIMED_OUT: # Timed out.
+ 'FAILED',
+ BORKED: # Broken.
+ 'BROKEN'
+ }
+ """)
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ extra_options=['--style', 'chromium', '--lines', '1-1'])
+
+ @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6')
+ def testCP936Encoding(self):
+ unformatted_code = 'print("中文")\n'
+ expected_formatted_code = 'print("中文")\n'
+ self.assertYapfReformats(
+ unformatted_code,
+ expected_formatted_code,
+ env={'PYTHONIOENCODING': 'cp936'})
+
+
+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()
diff --git a/yapftests/yapf_test_helper.py b/yapftests/yapf_test_helper.py
new file mode 100644
index 0000000..1f21b36
--- /dev/null
+++ b/yapftests/yapf_test_helper.py
@@ -0,0 +1,89 @@
+# Copyright 2016 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 identify_container
+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)
+ identify_container.IdentifyContainers(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