path: root/python-add-trailing-comma.spec

%global _empty_manifest_terminate_build 0
Name:		python-add-trailing-comma
Version:	2.4.0
Release:	1
Summary:	Automatically add trailing commas to calls and literals
License:	MIT
URL:		https://github.com/asottile/add-trailing-comma
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/05/a8/1bfd5ea8add9d7243a63788d132b30bbc706bb9225d45baf1ada5aac5271/add_trailing_comma-2.4.0.tar.gz
BuildArch:	noarch

Requires:	python3-tokenize-rt

%description
A tool (and pre-commit hook) to automatically add trailing commas to calls and
literals.
## Installation
```bash
pip install add-trailing-comma
```
## As a pre-commit hook
See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
Sample `.pre-commit-config.yaml`:
```yaml
-   repo: https://github.com/asottile/add-trailing-comma
    rev: v2.4.0
    hooks:
    -   id: add-trailing-comma
```
## multi-line method invocation style -- why?
```python
# Sample of *ideal* syntax
function_call(
    argument,
    5 ** 5,
    kwarg=foo,
)
```
- the initial paren is at the end of the line
- each argument is indented one level further than the function name
- the last parameter (unless the call contains an unpacking
  (`*args` / `**kwargs`)) has a trailing comma
This has the following benefits:
- arbitrary indentation is avoided:
    ```python
    # I hear you like 15 space indents
    # oh your function name changed? guess you get to reindent :)
    very_long_call(arg,
                   arg,
                   arg)
    ```
- adding / removing a parameter preserves `git blame` and is a minimal diff:
    ```diff
     # with no trailing commas
     x(
    -    arg
    +    arg,
    +    arg2
     )
    ```
    ```diff
     # with trailing commas
     x(
         arg,
    +    arg2,
     )
    ```
## Implemented features
### trailing commas for function calls
```diff
 x(
     arg,
-    arg
+    arg,
 )
```
### trailing commas for function calls with unpackings
If `--py35-plus` is passed, `add-trailing-comma` will also perform the
following change:
```diff
 x(
-    *args
+    *args,
 )
 y(
-    **kwargs
+    **kwargs,
 )
```
Note that this would cause a **`SyntaxError`** in earlier python versions.
### trailing commas for tuple / list / dict / set literals
```diff
 x = [
-    1, 2, 3
+    1, 2, 3,
 ]
```
### trailing commas for function definitions
```diff
 def func(
         arg1,
-        arg2
+        arg2,
 ):
```
```diff
 async def func(
         arg1,
-        arg2
+        arg2,
 ):
```
### trailing commas for function definitions with unpacking arguments
If `--py36-plus` is passed, `add-trailing-comma` will also perform the
following change:
```diff
 def f(
-    *args
+    *args,
 ): pass
 def g(
-    **kwargs
+    **kwargs,
 ): pass
 def h(
-    *, kw=1
+    *, kw=1,
 ): pass
```
Note that this would cause a **`SyntaxError`** in earlier python versions.
### trailing commas for `from` imports
```diff
 from os import (
     path,
-    makedirs
+    makedirs,
 )
```
### trailing comma for class definitions
```diff
 class C(
     Base1,
-    Base2
+    Base2,
 ):
     pass
```
### trailing comma for with statement
```diff
 with (
         open('f1', 'r') as f1,
-        open('f2', 'w') as f2
+        open('f2', 'w') as f2,
 ):
     pass
```
### trailing comma for match statement
```diff
 match x:
     case A(
        1,
-       2
+       2,
     ):
        pass
     case (
        1,
-       2
+       2,
     ):
        pass
     case [
        1,
-       2
+       2,
     ]:
        pass
     case {
        'x': 1,
-       'y': 2
+       'y': 2,
     }:
        pass
```
### unhug trailing paren
```diff
 x(
     arg1,
-    arg2)
+    arg2,
+)
```
### unhug leading paren
```diff
-function_name(arg1,
-              arg2)
+function_name(
+    arg1,
+    arg2,
+)
```
### match closing brace indentation
```diff
 x = [
     1,
     2,
     3,
-    ]
+]
```
### remove unnecessary commas
yes yes, I realize the tool is called `add-trailing-comma` :laughing:
```diff
-[1, 2, 3,]
-[1, 2, 3, ]
+[1, 2, 3]
+[1, 2, 3]
```

%package -n python3-add-trailing-comma
Summary:	Automatically add trailing commas to calls and literals
Provides:	python-add-trailing-comma
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-add-trailing-comma
A tool (and pre-commit hook) to automatically add trailing commas to calls and
literals.
## Installation
```bash
pip install add-trailing-comma
```
## As a pre-commit hook
See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
Sample `.pre-commit-config.yaml`:
```yaml
-   repo: https://github.com/asottile/add-trailing-comma
    rev: v2.4.0
    hooks:
    -   id: add-trailing-comma
```
## multi-line method invocation style -- why?
```python
# Sample of *ideal* syntax
function_call(
    argument,
    5 ** 5,
    kwarg=foo,
)
```
- the initial paren is at the end of the line
- each argument is indented one level further than the function name
- the last parameter (unless the call contains an unpacking
  (`*args` / `**kwargs`)) has a trailing comma
This has the following benefits:
- arbitrary indentation is avoided:
    ```python
    # I hear you like 15 space indents
    # oh your function name changed? guess you get to reindent :)
    very_long_call(arg,
                   arg,
                   arg)
    ```
- adding / removing a parameter preserves `git blame` and is a minimal diff:
    ```diff
     # with no trailing commas
     x(
    -    arg
    +    arg,
    +    arg2
     )
    ```
    ```diff
     # with trailing commas
     x(
         arg,
    +    arg2,
     )
    ```
## Implemented features
### trailing commas for function calls
```diff
 x(
     arg,
-    arg
+    arg,
 )
```
### trailing commas for function calls with unpackings
If `--py35-plus` is passed, `add-trailing-comma` will also perform the
following change:
```diff
 x(
-    *args
+    *args,
 )
 y(
-    **kwargs
+    **kwargs,
 )
```
Note that this would cause a **`SyntaxError`** in earlier python versions.
### trailing commas for tuple / list / dict / set literals
```diff
 x = [
-    1, 2, 3
+    1, 2, 3,
 ]
```
### trailing commas for function definitions
```diff
 def func(
         arg1,
-        arg2
+        arg2,
 ):
```
```diff
 async def func(
         arg1,
-        arg2
+        arg2,
 ):
```
### trailing commas for function definitions with unpacking arguments
If `--py36-plus` is passed, `add-trailing-comma` will also perform the
following change:
```diff
 def f(
-    *args
+    *args,
 ): pass
 def g(
-    **kwargs
+    **kwargs,
 ): pass
 def h(
-    *, kw=1
+    *, kw=1,
 ): pass
```
Note that this would cause a **`SyntaxError`** in earlier python versions.
### trailing commas for `from` imports
```diff
 from os import (
     path,
-    makedirs
+    makedirs,
 )
```
### trailing comma for class definitions
```diff
 class C(
     Base1,
-    Base2
+    Base2,
 ):
     pass
```
### trailing comma for with statement
```diff
 with (
         open('f1', 'r') as f1,
-        open('f2', 'w') as f2
+        open('f2', 'w') as f2,
 ):
     pass
```
### trailing comma for match statement
```diff
 match x:
     case A(
        1,
-       2
+       2,
     ):
        pass
     case (
        1,
-       2
+       2,
     ):
        pass
     case [
        1,
-       2
+       2,
     ]:
        pass
     case {
        'x': 1,
-       'y': 2
+       'y': 2,
     }:
        pass
```
### unhug trailing paren
```diff
 x(
     arg1,
-    arg2)
+    arg2,
+)
```
### unhug leading paren
```diff
-function_name(arg1,
-              arg2)
+function_name(
+    arg1,
+    arg2,
+)
```
### match closing brace indentation
```diff
 x = [
     1,
     2,
     3,
-    ]
+]
```
### remove unnecessary commas
yes yes, I realize the tool is called `add-trailing-comma` :laughing:
```diff
-[1, 2, 3,]
-[1, 2, 3, ]
+[1, 2, 3]
+[1, 2, 3]
```

%package help
Summary:	Development documents and examples for add-trailing-comma
Provides:	python3-add-trailing-comma-doc
%description help
A tool (and pre-commit hook) to automatically add trailing commas to calls and
literals.
## Installation
```bash
pip install add-trailing-comma
```
## As a pre-commit hook
See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
Sample `.pre-commit-config.yaml`:
```yaml
-   repo: https://github.com/asottile/add-trailing-comma
    rev: v2.4.0
    hooks:
    -   id: add-trailing-comma
```
## multi-line method invocation style -- why?
```python
# Sample of *ideal* syntax
function_call(
    argument,
    5 ** 5,
    kwarg=foo,
)
```
- the initial paren is at the end of the line
- each argument is indented one level further than the function name
- the last parameter (unless the call contains an unpacking
  (`*args` / `**kwargs`)) has a trailing comma
This has the following benefits:
- arbitrary indentation is avoided:
    ```python
    # I hear you like 15 space indents
    # oh your function name changed? guess you get to reindent :)
    very_long_call(arg,
                   arg,
                   arg)
    ```
- adding / removing a parameter preserves `git blame` and is a minimal diff:
    ```diff
     # with no trailing commas
     x(
    -    arg
    +    arg,
    +    arg2
     )
    ```
    ```diff
     # with trailing commas
     x(
         arg,
    +    arg2,
     )
    ```
## Implemented features
### trailing commas for function calls
```diff
 x(
     arg,
-    arg
+    arg,
 )
```
### trailing commas for function calls with unpackings
If `--py35-plus` is passed, `add-trailing-comma` will also perform the
following change:
```diff
 x(
-    *args
+    *args,
 )
 y(
-    **kwargs
+    **kwargs,
 )
```
Note that this would cause a **`SyntaxError`** in earlier python versions.
### trailing commas for tuple / list / dict / set literals
```diff
 x = [
-    1, 2, 3
+    1, 2, 3,
 ]
```
### trailing commas for function definitions
```diff
 def func(
         arg1,
-        arg2
+        arg2,
 ):
```
```diff
 async def func(
         arg1,
-        arg2
+        arg2,
 ):
```
### trailing commas for function definitions with unpacking arguments
If `--py36-plus` is passed, `add-trailing-comma` will also perform the
following change:
```diff
 def f(
-    *args
+    *args,
 ): pass
 def g(
-    **kwargs
+    **kwargs,
 ): pass
 def h(
-    *, kw=1
+    *, kw=1,
 ): pass
```
Note that this would cause a **`SyntaxError`** in earlier python versions.
### trailing commas for `from` imports
```diff
 from os import (
     path,
-    makedirs
+    makedirs,
 )
```
### trailing comma for class definitions
```diff
 class C(
     Base1,
-    Base2
+    Base2,
 ):
     pass
```
### trailing comma for with statement
```diff
 with (
         open('f1', 'r') as f1,
-        open('f2', 'w') as f2
+        open('f2', 'w') as f2,
 ):
     pass
```
### trailing comma for match statement
```diff
 match x:
     case A(
        1,
-       2
+       2,
     ):
        pass
     case (
        1,
-       2
+       2,
     ):
        pass
     case [
        1,
-       2
+       2,
     ]:
        pass
     case {
        'x': 1,
-       'y': 2
+       'y': 2,
     }:
        pass
```
### unhug trailing paren
```diff
 x(
     arg1,
-    arg2)
+    arg2,
+)
```
### unhug leading paren
```diff
-function_name(arg1,
-              arg2)
+function_name(
+    arg1,
+    arg2,
+)
```
### match closing brace indentation
```diff
 x = [
     1,
     2,
     3,
-    ]
+]
```
### remove unnecessary commas
yes yes, I realize the tool is called `add-trailing-comma` :laughing:
```diff
-[1, 2, 3,]
-[1, 2, 3, ]
+[1, 2, 3]
+[1, 2, 3]
```

%prep
%autosetup -n add-trailing-comma-2.4.0

%build
%py3_build

%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .

%files -n python3-add-trailing-comma -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 2.4.0-1
- Package Spec generated