Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/mschwager/cohesion
A tool for measuring Python class cohesion.
https://github.com/mschwager/cohesion
class code cohesion flake8 flake8-plugin lint linter-plugin measure module oop python quality
Last synced: 1 day ago
JSON representation
A tool for measuring Python class cohesion.
- Host: GitHub
- URL: https://github.com/mschwager/cohesion
- Owner: mschwager
- License: gpl-3.0
- Created: 2016-08-11T21:09:32.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2023-03-08T16:15:51.000Z (over 1 year ago)
- Last Synced: 2024-10-31T21:35:14.279Z (8 days ago)
- Topics: class, code, cohesion, flake8, flake8-plugin, lint, linter-plugin, measure, module, oop, python, quality
- Language: Python
- Size: 91.8 KB
- Stars: 231
- Watchers: 10
- Forks: 4
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
- awesome-flake8-extensions - cohesion - Extension for measuring Python class cohesion. (Complexity)
README
# Cohesion
[](https://img.shields.io/pypi/pyversions/cohesion.svg)
[](https://img.shields.io/pypi/v/cohesion.svg)
Cohesion is a tool for measuring Python class cohesion.
> In computer programming, cohesion refers to the degree to which the elements
> of a module belong together. Thus, cohesion measures the strength of
> relationship between pieces of functionality within a given module. For
> example, in highly cohesive systems functionality is strongly related.
> - [Wikipedia](https://en.wikipedia.org/wiki/Cohesion_(computer_science))
> When cohesion is high, it means that the methods and variables of the class
> are co-dependent and hang together as a logical whole.
> - Clean Code pg. 140
Some of the advantages of high cohesion, also by Wikipedia:
* Reduced module complexity (they are simpler, having fewer operations).
* Increased system maintainability, because logical changes in the domain
affect fewer modules, and because changes in one module require fewer
changes in other modules.
* Increased module reusability, because application developers will find
the component they need more easily among the cohesive set of operations
provided by the module.
# Installing
```
$ python -m pip install cohesion
$ cohesion -h
```
OR
```
$ git clone https://github.com/mschwager/cohesion.git
$ cd cohesion
$ PYTHONPATH=lib/ python -m cohesion -h
```
# Using
Cohesion measures class and instance variable usage across the methods
of that class.
```
$ cat example.py
class ExampleClass1(object):
class_variable1 = 5
class_variable2 = 6
def func1(self):
self.instance_variable = 6
def inner_func(b):
return b + 5
local_variable = self.class_variable1
return local_variable
def func2(self):
print(self.class_variable2)
@staticmethod
def func3(variable):
return variable + 7
class ExampleClass2(object):
def func1(self):
self.instance_variable1 = 7
```
```
$ cohesion --files example.py --verbose
File: example.py
Class: ExampleClass1 (1:0)
Function: func1 2/3 66.67%
Variable: class_variable1 True
Variable: class_variable2 False
Variable: instance_variable True
Function: func2 1/3 33.33%
Variable: class_variable1 False
Variable: class_variable2 True
Variable: instance_variable False
Function: func3 0/3 0.00%
Variable: class_variable1 False
Variable: class_variable2 False
Variable: instance_variable False
Total: 33.33%
Class: ExampleClass2 (23:0)
Function: func1 1/1 100.00%
Variable: instance_variable1 True
Total: 100.00%
```
The `--below` and `--above` flags can be specified to only show classes with
a cohesion value below or above the specified percentage, respectively.
## Flake8 Support
Cohesion supports being run by `flake8`. First, ensure your installation has
registered `cohesion`:
```
$ flake8 --version
3.2.1 (pyflakes: 1.0.0, cohesion: 0.8.0, pycodestyle: 2.2.0, mccabe: 0.5.3) CPython 2.7.12 on Linux
```
And now use `flake8` to lint your file:
```
$ flake8 example.py
example.py:1:1: H601 class has low cohesion
```
## Python Versions
If you would like to simultaneously run Cohesion on Python 2 and Python 3
code then you will have to install it for both versions. I.e.
```
$ python2 -m pip install cohesion
$ python3 -m pip install cohesion
```
Then use the corresponding version to run the module:
```
$ python2 -m cohesion --files python2_file.py
$ python3 -m cohesion --files python3_file.py
```
# Developing
First, install development packages:
```
$ python -m pip install -r requirements-dev.txt
```
## Testing
```
$ pytest
```
## Linting
```
$ flake8
```
## Coverage
```
$ pytest --cov
```