Initial commit

Author: Toilal

.gitignore

@@ -0,0 +1,4 @@
+*.egg-info/
+*.pyc
+*.pyo
+.tox/

.travis.yml

@@ -0,0 +1,24 @@
+language: python
+services:
+  - docker
+python:
+  - 2.7
+  - 3.5
+  - 3.6
+matrix:
+  include:
+    - python: 3.7
+      dist: xenial
+    - python: 3.8
+      dist: xenial
+install:
+  - pip freeze
+  - pip install -r requirements-dev.txt
+  - pip install coveralls
+  - pip freeze
+script:
+  - pylint chmod_monkey
+  - coverage run --source=chmod_monkey -m pytest
+  - python setup.py build
+after_success:
+  - coveralls

CHANGELOG.md

@@ -0,0 +1,7 @@
+History
+=======
+
+1.0.0 (unreleased)
+-------------------------
+
+- First version

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Rémi Alvergnat
+
+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.

MANIFEST.in

@@ -0,0 +1,13 @@
+include *.in
+include *.ini
+include *.md
+include *.txt
+include *rc
+include LICENSE
+recursive-include .travis *
+recursive-include tests *
+recursive-include chmod_monkey *
+recursive-exclude tests *.pyc
+recursive-exclude tests *.pyo
+recursive-exclude chmod_monkey *.pyc
+recursive-exclude chmod_monkey *.pyo

README.md

@@ -0,0 +1,46 @@
+# python-chmod-monkey
+
+[![PyPI](https://img.shields.io/pypi/v/chmod-monkey)](https://pypi.org/project/chmod-monkey/)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chmod-monkey)
+![PyPI - License](https://img.shields.io/pypi/l/chmod-monkey)
+[![Build Status](https://img.shields.io/travis/Toilal/python-chmod-monkey.svg)](https://travis-ci.org/Toilal/python-chmod-monkey)
+[![Code coverage](https://img.shields.io/coveralls/github/Toilal/python-chmod-monkey)](https://coveralls.io/github/Toilal/python-chmod-monkey)
+
+Add support for `os.chmod('script.sh', 'ug+x')` syntax style.
+
+Almost any expression supported by [GNU Coreutils chmod](https://linux.die.net/man/1/chmod) should be supported by this module.
+
+**`[ugoa]*([-+=]([rwx]*|[ugo]))+|[-+=][0-7]+`**
+
+`Xst` flags are not supported though.
+
+## Install
+
+```
+pip install chmod-monkey
+```
+
+## Usage
+
+There are two ways to use `chmod-monkey`.
+
+### Using os.chmod MonkeyPatch
+
+```python
+import os
+
+import chmod_monkey
+chmod_monkey.install()  # Install monkeypatch because we are evil !
+
+os.chmod('script.sh', 'ug+x')  # Magic :)
+```
+
+### Using to_mode converter
+
+```python
+import os
+
+from chmod_monkey import to_mode
+
+os.chmod('script.sh', to_mode('ug+x'))  # For serious people.
+```

chmod_monkey/__init__.py

@@ -0,0 +1,57 @@
+"""
+Add support for `os.chmod('script.sh', 'ug+x')` syntax style.
+"""
+
+import os
+
+from .parser import parse
+
+_default_chmod = None  # pylint:disable=invalid-name
+
+
+def to_mode(filepath, mode_str):
+    """
+    Convert a string based mode to a bitmask mode ready to give to os.chmod.
+    :param filepath:
+    :param mode_str:
+    :return:
+    """
+    mode = None
+    for parsed in parse(mode_str):
+        mode = parsed.to_mode(filepath, mode)
+    return mode
+
+
+def install():
+    """
+    Monkeypatch os.chmod to support string input.
+    """
+    global _default_chmod  # pylint:disable=global-statement,invalid-name
+    if _default_chmod is None:
+        _default_chmod = os.chmod
+
+        def chmod_monkey(*args, **kwargs):
+            """
+            os.chmod MonkeyPatch decorator function. Invoke to_mode if mode argument is not an int.
+            """
+            if len(args) > 0:  # pylint:disable=len-as-condition
+                path = args[0]
+            else:
+                path = kwargs.get('path')
+
+            if len(args) > 1:
+                mode = args[1]
+            else:
+                mode = kwargs.get('mode')
+
+            if path is not None and not isinstance(mode, int):
+                mode = to_mode(path, mode)
+                if len(args) > 1:
+                    args_list = list(args)
+                    args_list[1] = mode
+                    args = tuple(args_list)
+                else:
+                    kwargs['mode'] = mode
+            return _default_chmod(*args, **kwargs)
+
+        os.chmod = chmod_monkey

chmod_monkey/__version__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# pragma: no cover
+"""
+Version
+"""
+__version__ = '1.0.0.dev0'

chmod_monkey/operation.py

@@ -0,0 +1,140 @@
+"""
+Operation
+"""
+
+import os
+import stat
+
+BITS = "0123456789"
+FLAGS = "rwxXst"
+COPY = "ugo"
+
+_BIT_MAPPING = {
+    "a": {
+        "r": stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH,
+        "w": stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH,
+        "x": stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+    },
+    "u": {
+        "r": stat.S_IRUSR,
+        "w": stat.S_IWUSR,
+        "x": stat.S_IXUSR
+    },
+    "g": {
+        "r": stat.S_IRGRP,
+        "w": stat.S_IWGRP,
+        "x": stat.S_IXGRP
+    },
+    "o": {
+        "r": stat.S_IROTH,
+        "w": stat.S_IWOTH,
+        "x": stat.S_IXOTH
+    }
+}
+
+
+class Operation(object):
+    """
+    An operation to perform on file permissions.
+    """
+
+    def __init__(self, source=None, operator=None, target=None):
+        self.source = source
+        self.operator = operator
+        self.target = target
+
+    @property
+    def target_mode(self):
+        """
+        Retrieve target mode from target
+        """
+        if isinstance(self.target, int):
+            return TARGET_MODE_BITS
+        if self.target is not None and self.target:
+            if self.target[0] in BITS:
+                return TARGET_MODE_BITS
+            if self.target[0] in FLAGS:
+                return TARGET_MODE_FLAGS
+            if self.target[0] in COPY:
+                return TARGET_MODE_COPY
+        return None
+
+    def to_mode(self, filepath=None, mode=None):
+        """
+        Converts the operation to mode ready to apply with os.chmod
+        :param filepath: actual filepath. Used to get actual mode if not given.
+        :param mode: actual mode.
+        """
+        if self.operator != '=':
+            if mode is None:
+                if not filepath:
+                    raise ValueError(
+                        "filepath or mode parameter must be defined for \"%s\" operator" % (self.operator,))
+                mode = stat.S_IMODE(os.lstat(filepath).st_mode)
+        else:
+            mode = 0
+
+        if self.target_mode == TARGET_MODE_FLAGS:
+            return self._flags_to_mode(mode)
+        if self.target_mode == TARGET_MODE_COPY:
+            return self._copy_to_mode(mode)
+        if self.target_mode == TARGET_MODE_BITS:
+            return self._bits_to_mode(mode)
+        raise ValueError("Target mode value is invalid (%i)" % (self.target_mode,))
+
+    def _flags_to_mode(self, mode):
+        for source in self.source:
+            for target in self.target:
+                bit = _BIT_MAPPING[source][target]
+                if self.operator == '-':
+                    mode = mode & ~ bit
+                else:
+                    mode = mode | bit
+        return mode
+
+    def _copy_to_mode(self, mode):
+        for source in self.source:
+            for target in self.target:
+                flags = ''
+                for flag in 'rwx':
+                    try:
+                        target_bit = _BIT_MAPPING[target][flag]
+                        if bool(mode & target_bit):
+                            flags += flag
+                    except KeyError:
+                        continue
+                for flag in flags:
+                    bit = _BIT_MAPPING[source][flag]
+                    if self.operator == '-':
+                        mode = mode & ~ bit
+                    else:
+                        mode = mode | bit
+        return mode
+
+    def _bits_to_mode(self, mode):
+        if self.operator == '-':
+            return mode & ~ self.target  # pylint:disable=invalid-unary-operand-type
+        return mode | self.target
+
+    def clone(self):
+        """
+        Clone the operation
+        """
+        return Operation(source=self.source, operator=self.operator, target=self.target)
+
+    def __repr__(self):
+        return ''.join([x for x in (self.source, self.operator, self.target) if x is not None])
+
+    def __hash__(self):
+        return hash(self.source) + hash(self.operator) + hash(self.target)
+
+    def __eq__(self, other):
+        return self.__class__ == other.__class__ and \
+               self.source == other.source and \
+               self.operator == other.operator and \
+               self.target == other.target
+
+
+TARGET_MODE_COPY = 2
+TARGET_MODE_FLAGS = 1
+TARGET_MODE_BITS = 0