yorm.bases.mappable.patch_methods() - Code Metrics - jacebrowning/yorm - Measure and Improve Code Quality continuously with Scrutinizer

yorm.bases.mappable.patch_methods() B
last analyzed 2018-12-09 21:40 UTC

↳ Parent: yorm.bases.mappable

Complexity

Conditions

Size

Total Lines	23
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	7

Importance

Changes

Metric	Value
cc	7
eloc	19
nop	1
dl	0
loc	23
ccs	17
cts	17
cp	1
crap	7
rs	8
c	0
b	0
f	0

"""Base classes for mapping."""

import abc
import functools
import logging

from .. import common

log = logging.getLogger(__name__)


def load_before(method):

    """Decorate methods that should load before call."""

    if getattr(method, '_load_before', False):
        return method

    @functools.wraps(method)
    def wrapped(self, *args, **kwargs):
        __tracebackhide__ = True  # pylint: disable=unused-variable

        if not _private_call(method, args):
            mapper = common.get_mapper(self)
            if mapper and mapper.modified:
                log.debug("Loading before call: %s", method.__name__)
                mapper.load()
                if mapper.auto_save_after_load:
                    mapper.save()
                    mapper.modified = False

        return method(self, *args, **kwargs)

    setattr(wrapped, '_load_before', True)

    return wrapped


def save_after(method):

    """Decorate methods that should save after call."""

    if getattr(method, '_save_after', False):
        return method

    @functools.wraps(method)
    def wrapped(self, *args, **kwargs):
        __tracebackhide__ = True  # pylint: disable=unused-variable

        result = method(self, *args, **kwargs)

        if not _private_call(method, args):
            mapper = common.get_mapper(self)
            if mapper and mapper.auto_save:
                log.debug("Saving after call: %s", method.__name__)
                mapper.save()

        return result

    setattr(wrapped, '_save_after', True)

    return wrapped


def _private_call(method, args, prefix='_'):
    """Determine if a call's first argument is a private variable name."""
    if method.__name__ in ('__getattribute__', '__setattr__'):
        assert isinstance(args[0], str)
        return args[0].startswith(prefix)
    else:
        return False


class Mappable(metaclass=abc.ABCMeta):
    """Base class for objects with attributes mapped to file."""

    # pylint: disable=no-member

    @load_before
    def __getattribute__(self, name):
        return object.__getattribute__(self, name)

    @save_after
    def __setattr__(self, name, value):
        super().__setattr__(name, value)

    @load_before
    def __iter__(self):
        return super().__iter__()

    @load_before
    def __getitem__(self, key):
        return super().__getitem__(key)

    @save_after
    def __setitem__(self, key, value):
        super().__setitem__(key, value)

    @save_after
    def __delitem__(self, key):
        super().__delitem__(key)

    @save_after
    def append(self, *args, **kwargs):
        super().append(*args, **kwargs)

    @save_after
    def extend(self, *args, **kwargs):
        super().extend(*args, **kwargs)

    @save_after
    def insert(self, *args, **kwargs):
        super().insert(*args, **kwargs)

    @save_after
    def remove(self, *args, **kwargs):
        super().remove(*args, **kwargs)

    @save_after
    def pop(self, *args, **kwargs):
        super().pop(*args, **kwargs)

    @save_after
    def clear(self, *args, **kwargs):
        super().clear(*args, **kwargs)

    @save_after
    def sort(self, *args, **kwargs):
        super().sort(*args, **kwargs)

    @save_after
    def reverse(self, *args, **kwargs):
        super().reverse(*args, **kwargs)

    @save_after
    def popitem(self, *args, **kwargs):
        super().popitem(*args, **kwargs)

    @save_after
    def update(self, *args, **kwargs):
        super().update(*args, **kwargs)


_LOAD_BEFORE_METHODS = [
    '__getattribute__',
    '__iter__',
    '__getitem__',
]
_SAVE_AFTER_METHODS = [
    '__setattr__',
    '__setitem__',
    '__delitem__',
    'append',
    'extend',
    'insert',
    'remove',
    'pop',
    'clear',
    'sort',
    'reverse',
    'popitem',
    'update',
]


def patch_methods(instance):
    log.debug("Patching methods on: %r", instance)
    cls = instance.__class__

    for name in _LOAD_BEFORE_METHODS:
        try:
            method = getattr(cls, name)
        except AttributeError:
            log.trace("No method: %s", name)
        else:
            modified_method = load_before(method)
            setattr(cls, name, modified_method)
            log.trace("Patched to load before call: %s", name)

    for name in _SAVE_AFTER_METHODS:
        try:
            method = getattr(cls, name)
        except AttributeError:
            log.trace("No method: %s", name)
        else:
            modified_method = save_after(method)
            setattr(cls, name, modified_method)
            log.trace("Patched to save after call: %s", name)


1			"""Base classes for mapping."""
2
3	1		import abc
4	1		import functools
5	1		import logging
6
7	1		from .. import common
8
9	1		log = logging.getLogger(__name__)
10
11
12	1	View Code Duplication	def load_before(method):
			0 ignored issues – show Duplication introduced 2017-05-31 22:21 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
13			"""Decorate methods that should load before call."""
14
15	1		if getattr(method, '_load_before', False):
16	1		return method
17
18	1		@functools.wraps(method)
19			def wrapped(self, args, *kwargs):
20			__tracebackhide__ = True # pylint: disable=unused-variable
21	1
22			if not _private_call(method, args):
23	1		mapper = common.get_mapper(self)
24	1		if mapper and mapper.modified:
25	1		log.debug("Loading before call: %s", method.__name__)
26	1		mapper.load()
27	1		if mapper.auto_save_after_load:
28	1		mapper.save()
29	1		mapper.modified = False
30	1
31			return method(self, args, *kwargs)
32	1
33			setattr(wrapped, '_load_before', True)
34	1
35			return wrapped
36	1
37
38		View Code Duplication	def save_after(method):
			0 ignored issues – show Duplication introduced 2016-09-11 21:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
39	1		"""Decorate methods that should save after call."""
40
41			if getattr(method, '_save_after', False):
42	1		return method
43	1
44			@functools.wraps(method)
45	1		def wrapped(self, args, *kwargs):
46			__tracebackhide__ = True # pylint: disable=unused-variable
47
48	1		result = method(self, args, *kwargs)
49
50	1		if not _private_call(method, args):
51			mapper = common.get_mapper(self)
52	1		if mapper and mapper.auto_save:
53	1		log.debug("Saving after call: %s", method.__name__)
54	1		mapper.save()
55	1
56	1		return result
57
58	1		setattr(wrapped, '_save_after', True)
59
60	1		return wrapped
61
62	1
63			def _private_call(method, args, prefix='_'):
64			"""Determine if a call's first argument is a private variable name."""
65	1		if method.__name__ in ('__getattribute__', '__setattr__'):
66			assert isinstance(args[0], str)
67	1		return args[0].startswith(prefix)
68	1		else:
69	1		return False
70
71	1
72			class Mappable(metaclass=abc.ABCMeta):
73			"""Base class for objects with attributes mapped to file."""
74	1
75			# pylint: disable=no-member
76
77			@load_before
78			def __getattribute__(self, name):
79	1		return object.__getattribute__(self, name)
80
81	1		@save_after
82			def __setattr__(self, name, value):
83	1		super().__setattr__(name, value)
84
85	1		@load_before
86			def __iter__(self):
87	1		return super().__iter__()
88
89	1		@load_before
90			def __getitem__(self, key):
91	1		return super().__getitem__(key)
92
93	1		@save_after
94			def __setitem__(self, key, value):
95	1		super().__setitem__(key, value)
96
97	1		@save_after
98			def __delitem__(self, key):
99	1		super().__delitem__(key)
100
101	1		@save_after
102			def append(self, args, *kwargs):
103	1		super().append(args, *kwargs)
104
105	1		@save_after
106			def extend(self, args, *kwargs):
107	1		super().extend(args, *kwargs)
108
109			@save_after
110			def insert(self, args, *kwargs):
111	1		super().insert(args, *kwargs)
112
113	1		@save_after
114			def remove(self, args, *kwargs):
115	1		super().remove(args, *kwargs)
116
117			@save_after
118			def pop(self, args, *kwargs):
119	1		super().pop(args, *kwargs)
120
121			@save_after
122			def clear(self, args, *kwargs):
123	1		super().clear(args, *kwargs)
124
125	1		@save_after
126			def sort(self, args, *kwargs):
127	1		super().sort(args, *kwargs)
128
129			@save_after
130			def reverse(self, args, *kwargs):
131	1		super().reverse(args, *kwargs)
132
133			@save_after
134			def popitem(self, args, *kwargs):
135	1		super().popitem(args, *kwargs)
136
137			@save_after
138			def update(self, args, *kwargs):
139	1		super().update(args, *kwargs)
140
141	1
142			_LOAD_BEFORE_METHODS = [
143			'__getattribute__',
144	1		'__iter__',
145			'__getitem__',
146			]
147			_SAVE_AFTER_METHODS = [
148			'__setattr__',
149	1		'__setitem__',
150			'__delitem__',
151			'append',
152			'extend',
153			'insert',
154			'remove',
155			'pop',
156			'clear',
157			'sort',
158			'reverse',
159			'popitem',
160			'update',
161			]
162
163
164			def patch_methods(instance):
165			log.debug("Patching methods on: %r", instance)
166	1		cls = instance.__class__
167	1
168	1		for name in _LOAD_BEFORE_METHODS:
169			try:
170	1		method = getattr(cls, name)
171	1		except AttributeError:
172	1		log.trace("No method: %s", name)
173	1		else:
174	1		modified_method = load_before(method)
175			setattr(cls, name, modified_method)
176	1		log.trace("Patched to load before call: %s", name)
177	1
178	1		for name in _SAVE_AFTER_METHODS:
179			try:
180	1		method = getattr(cls, name)
181	1		except AttributeError:
182	1		log.trace("No method: %s", name)
183	1		else:
184	1		modified_method = save_after(method)
185			setattr(cls, name, modified_method)
186			log.trace("Patched to save after call: %s", name)
187

jacebrowning / yorm

yorm.bases.mappable.patch_methods() B last analyzed 2018-12-09 21:40 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

yorm.bases.mappable.patch_methods() B
last analyzed 2018-12-09 21:40 UTC