flake8-elegant-objects 1.0.0__tar.gz

flake8_elegant_objects-1.0.0/.github/workflows/lint.yml

@@ -0,0 +1,33 @@
+name: Lint
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+    branches: [master, main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install 3.10
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run ruff check
+        run: uv run ruff check
+
+      - name: Run ruff format check
+        run: uv run ruff format --check
+
+      - name: Run type checking
+        run: uv run mypy .

flake8_elegant_objects-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:  # Allow manual triggering
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: publish  # Use environment for additional security
+    permissions:
+      id-token: write  # For trusted publishing
+      contents: read
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v3
+      with:
+        version: "latest"
+
+    - name: Set up Python
+      run: uv python install 3.12
+
+    - name: Install dependencies
+      run:  < /dev/null | 
+        uv sync --dev
+        uv add --dev twine
+
+    - name: Run tests
+      run: |
+        uv run python -m pytest tests/ -v
+        uv run mypy flake8_elegant_objects/
+        uv run ruff check flake8_elegant_objects/
+
+    - name: Build package
+      run: uv build
+
+    - name: Publish to TestPyPI
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.TEST_PYPI_API_TOKEN }}
+      run: |
+        uv run twine upload --repository testpypi dist/* --skip-existing
+
+    - name: Publish to PyPI
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        uv run twine upload dist/*

flake8_elegant_objects-1.0.0/.github/workflows/test.yml

@@ -0,0 +1,44 @@
+name: Build and Test
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+    branches: [master, main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: 'latest'
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run linting
+        run: uv run ruff check .
+
+      - name: Run formatting check
+        run: uv run ruff format --check .
+
+      - name: Run type checking
+        run: uv run mypy .
+
+      - name: Run unit tests
+        run: uv run pytest tests/ -v
+
+      - name: Build package
+        run: uv build

flake8_elegant_objects-1.0.0/.gitignore

@@ -0,0 +1,161 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Ruff
+.ruff_cache/
+
+# IDE / Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+*.bak
+*.orig

flake8_elegant_objects-1.0.0/CLAUDE.md

@@ -0,0 +1,59 @@
+# CLAUDE.md
+
+## Development Commands
+
+```bash
+# Testing
+python -m pytest tests/ -v
+
+# Code Quality  
+mypy flake8_elegant_objects/
+ruff check flake8_elegant_objects/
+ruff format flake8_elegant_objects/
+
+# Plugin Usage
+python -m flake8_elegant_objects --show-source path/to/files/*.py
+flake8 --select=EO path/to/files/
+```
+
+## Architecture
+
+Flake8 plugin enforcing Elegant Objects principles (14 error codes EO001-EO014).
+
+**Core Components:**
+- `__init__.py`: ElegantObjectsPlugin orchestrating analysis
+- `base.py`: Principles base class, Violations type, ErrorCodes
+- `naming.py`: NoErNamePrinciple (EO001-EO004) 
+- `core.py`: CorePrinciples (EO005-EO008)
+- `advanced.py`: AdvancedPrinciples (EO009-EO014)
+
+**Pattern:** Plugin uses Principles which provides Violations (no None)
+
+## Elegant Objects Principles
+
+**MUST follow:**
+- No null (None) - use empty lists instead
+- No code in constructors  
+- No getters/setters
+- No mutable objects
+- NO "-ER" NAMES: Manager, Controller, Helper, Handler, Parser, etc
+- No static methods
+- No instanceof/type casting  
+- No public methods without contracts
+- No statements in test methods except assertThat
+- No ORM/ActiveRecord
+- No implementation inheritance
+
+**Philosophy:**
+- Objects are living partners, not data containers
+- Declarative over imperative (`new Sorted(apples)` not `new Sorter().sort(apples)`)
+- Fail fast with exceptions, not null checks
+- Composition over inheritance
+- Immutability implied by design, not keywords
+
+## Code Style
+
+- No useless comments
+- Types: `Violations = list[Violation]`
+- Return empty lists `[]` instead of `None`
+- Extend lists instead of checking for None

flake8_elegant_objects-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Anton Prokopyev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flake8_elegant_objects-1.0.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: flake8-elegant-objects
+Version: 1.0.0
+Summary: Flake8 plugin enforcing Elegant Objects principles: no -er naming, no null, no getters/setters, immutable objects
+Project-URL: Homepage, https://github.com/AntonProkopyev/flake8-elegant-objects
+Project-URL: Repository, https://github.com/AntonProkopyev/flake8-elegant-objects.git
+Project-URL: Issues, https://github.com/AntonProkopyev/flake8-elegant-objects/issues
+Project-URL: Documentation, https://github.com/AntonProkopyev/flake8-elegant-objects#readme
+Author: Flake8 Elegant Objects Contributors
+License: MIT
+License-File: LICENSE
+Keywords: code-quality,elegant-objects,flake8,linting,object-oriented,python,static-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: Flake8
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Flake8 ElegantObjects Plugin
+
+[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](https://github.com/AntonProkopyev/flake8-elegant-objects)
+[![Coverage](https://img.shields.io/badge/coverage-86%25-brightgreen.svg)](https://github.com/AntonProkopyev/flake8-elegant-objects)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Type checked: mypy](https://img.shields.io/badge/type_checked-mypy-blue.svg)](https://mypy.readthedocs.io/)
+[![Flake8](https://img.shields.io/badge/flake8-plugin-orange.svg)](https://flake8.pycqa.org/)
+
+Detects violations of core Elegant Objects principles including the "-er" naming principle, null usage, mutable objects, code in constructors, and getter/setter patterns.
+
+## Error Codes
+
+- `EO001`: Class name violates -er principle
+- `EO002`: Method name violates -er principle
+- `EO003`: Variable name violates -er principle
+- `EO004`: Function name violates -er principle
+- `EO005`: Null (None) usage violates EO principle
+- `EO006`: Code in constructor violates EO principle
+- `EO007`: Getter/setter method violates EO principle
+- `EO008`: Mutable object violation
+- `EO009`: Static method violates EO principle (no static methods allowed)
+- `EO010`: isinstance/type casting violates EO principle (avoid type discrimination)
+- `EO011`: Public method without contract (Protocol/ABC) violates EO principle
+- `EO012`: Test method contains non-assertThat statements (only assertThat allowed)
+- `EO013`: ORM/ActiveRecord pattern violates EO principle
+- `EO014`: Implementation inheritance violates EO principle
+
+## Installation
+
+```bash
+pip install flake8-elegant-objects
+```
+
+## Usage
+
+**Standalone:**
+
+```bash
+python -m flake8_elegant_objects path/to/files/*.py
+python -m flake8_elegant_objects --show-source path/to/files/*.py
+```
+
+**As flake8 plugin:**
+
+```bash
+flake8 --select=EO path/to/files/
+```
+
+The plugin is automatically registered when the package is installed.
+
+## Philosophy
+
+Based on Yegor Bugayenko's Elegant Objects principles, this plugin enforces object-oriented design that treats objects as living, thinking entities rather than data containers or procedure executors.
+
+### 1. No "-er" Entities (EO001-EO004)
+
+**Why?** Names ending in "-er" describe what objects _do_ rather than what they _are_, reducing them to mechanical task performers instead of equal partners in your design.
+
+- ❌ `class DataProcessor` → ✅ `class ProcessedData`
+- ❌ `def analyze()` → ✅ `def analysis()`
+- ❌ `parser = ArgumentParser()` → ✅ `arguments = ArgumentParser()`
+
+### 2. No Null/None (EO005)
+
+**Why?** Null references break object-oriented thinking by representing "absence of object" - but absence cannot participate in object interactions. They lead to defensive programming and unclear contracts.
+
+- ❌ `return None` → ✅ Return null objects with safe default behavior
+- ❌ `if user is None:` → ✅ Use null object pattern or throw exceptions
+
+### 3. No Code in Constructors (EO006)
+
+**Why?** Constructors should be about object assembly, not computation. Complex logic in constructors violates the principle that objects should be lazy and do work only when asked.
+
+- ❌ `self.name = name.upper()` → ✅ `self.name = name` (transform on access)
+- ❌ `self.items = [process(x) for x in data]` → ✅ `self.data = data` (process lazily)
+
+### 4. No Getters/Setters (EO007)
+
+**Why?** Getters and setters expose internal state, breaking encapsulation. They encourage "tell, don't ask" violations and treat objects as data containers rather than behavioral entities.
+
+- ❌ `def get_value()` / `def set_value()` → ✅ Objects should expose behavior, not data
+- ❌ `user.getName()` → ✅ `user.introduce_yourself()` or `user.greet(visitor)`
+
+### 5. No Mutable Objects (EO008)
+
+**Why?** Mutable objects introduce temporal coupling and make reasoning about code difficult. Immutable objects are thread-safe, predictable, and easier to test.
+
+- ❌ `@dataclass class Data` → ✅ `@dataclass(frozen=True) class Data`
+- ❌ `items = []` → ✅ `items: tuple = ()`
+
+### 6. No Static Methods (EO009)
+
+**Why?** Static methods belong to classes, not objects, breaking object-oriented design. They can't be overridden, can't be mocked easily, and promote procedural thinking. Every static method is a candidate for a new class.
+
+- ❌ `@staticmethod def process()` → ✅ Create dedicated objects for behavior
+- ❌ `Math.sqrt(x)` → ✅ `SquareRoot(x).value()`
+
+### 7. No Type Discrimination (EO010)
+
+**Why?** Using `isinstance`, type casting, or reflection is a form of object discrimination. It violates polymorphism by treating objects unequally based on their type rather than their behavior contracts.
+
+- ❌ `isinstance(obj, str)` → ✅ Design common interfaces and use polymorphism
+- ❌ `if type(x) == int:` → ✅ Let objects decide how to behave
+
+### 8. No Public Methods Without Contracts (EO011)
+
+**Why?** Public methods without explicit contracts (Protocol/ABC) create implicit dependencies and unclear expectations. Contracts make object collaboration explicit and testable.
+
+- ❌ `class Service:` with ad-hoc public methods → ✅ `class Service(Protocol):` with defined contracts
+- ❌ Implicit interfaces → ✅ Explicit protocols that can be tested and verified
+
+### 9. Test Methods: Only assertThat (EO012)
+
+**Why?** Test methods should contain only one assertion statement (preferably `assertThat`). Multiple statements create complex tests that are hard to understand and maintain. Each test should verify one specific behavior.
+
+- ❌ `x = 5; y = calculate(x); assert y > 0` → ✅ `assertThat(calculate(5), is_(greater_than(0)))`
+- ❌ Multiple assertions per test → ✅ One focused assertion per test
+
+### 10. No ORM/ActiveRecord (EO013)
+
+**Why?** ORM and ActiveRecord patterns mix data persistence concerns with business logic, violating single responsibility. They create anemic domain models and tight coupling to databases.
+
+- ❌ `user.save()`, `Model.find()` → ✅ Separate repository objects
+- ❌ Mixing persistence with business logic → ✅ Clean separation of concerns
+
+### 11. No Implementation Inheritance (EO014)
+
+**Why?** Implementation inheritance creates tight coupling between parent and child classes, making code fragile and hard to test. It violates composition over inheritance and creates deep hierarchies that are difficult to understand.
+
+- ❌ `class UserList(list):` → ✅ `class UserList:` with composition
+- ❌ Inheriting concrete implementations → ✅ Inherit only from abstractions (ABC/Protocol)
+
+The plugin detects the "hall of shame" naming patterns: Manager, Controller, Helper, Handler, Writer, Reader, Converter, Validator, Router, Dispatcher, Observer, Listener, Sorter, Encoder, Decoder, Analyzer, etc.
+
+## Configuration
+
+The plugin is integrated with flake8. Add to your `.flake8` config:
+
+```ini
+[flake8]
+select = E,W,F,EO
+per-file-ignores =
+    tests/*:EO012  # Allow non-assertThat in tests if needed
+```
+
+## Development
+
+### Testing
+
+Run all tests:
+
+```bash
+python -m pytest tests/ -v
+```
+
+### Code Quality
+
+```bash
+# Type checking
+mypy flake8_elegant_objects/
+
+# Linting and formatting
+ruff check flake8_elegant_objects/
+ruff format flake8_elegant_objects/
+```
+
+### Project Structure
+
+```
+flake8_elegant_objects/
+├── __init__.py          # Main plugin entry point
+├── base.py              # Base classes and utilities
+├── no_er_name.py        # EO001-EO004: No "-er" names
+├── no_null.py           # EO005: No None usage
+├── no_constructor_code.py # EO006: No code in constructors
+├── no_getters_setters.py  # EO007: No getters/setters
+├── no_mutable_objects.py  # EO008: No mutable objects
+├── no_static.py         # EO009: No static methods
+├── no_type_discrimination.py # EO010: No isinstance/type casting
+├── no_public_methods_without_contracts.py # EO011: Contracts required
+├── no_impure_tests.py   # EO012: Only assertThat in tests
+├── no_orm.py            # EO013: No ORM/ActiveRecord
+└── no_implementation_inheritance.py # EO014: No implementation inheritance
+```