SkinSectionAutoCompleter.get_key_context_completion() - Code Metrics - Inspection of "Refactored key and value compiler into own module..." - thatsIch/sublime-rainmeter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 115f31...f9d160 )

by thatsIch

created 2017-01-11 13:04 UTC

get_key_context_completion() B

↳ Parent: SkinSectionAutoCompleter

Complexity

Conditions

Size

Total Lines

Duplication

Lines	22
Ratio	100 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	4
c	3
b	0
f	0
dl	22
loc	22
rs	8.9197

"""This module handles the skin section auto completion.

This provides the means to automatically add the base rainmeter sections
upon auto complete request with:

* [Rainmeter]
* [Metadata]
* [Variables]
* [Measure]
* [Meter]
* [MeterStyle]

This only activates if the file is empty or at least 2 new lines above the current caret.
"""

import yaml

import sublime

from .. import logger

from .levenshtein import levenshtein
from .compiler import compile_keys
from .yaml_content_reader import YamlContentReader


class SkinSectionAutoCompleter(YamlContentReader):  # pylint: disable=R0903; only provide one method

    """Ths class is the logical state holder for the auto completion suggestions.

    Upon the request the respective yaml file is parsed and converted into a logical
    representation of the completions. Depending on the prior information the completions
    can be filtered containing less entries.
    """

    def __get_completions(self):
        """IO access to the yaml file.

        Uses a yaml loader to parse it into a python object.
        """
        try:
            section_content = self._get_yaml_content("completion/", "section.yaml")
            section = yaml.load(section_content)

            return section

        except yaml.YAMLError as error:
            logger.error(error)
            return []

    def __lazy_initialize_completions(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        # use lazy initialization because else the API is not available yet
        if not self.all_completions:
            self.all_completions = self.__get_completions()
            self.all_key_completions = compile_keys(self.all_completions)

    def __filter_completions_by_sec(self, sections):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        # filter by already existing keys
        completions = []

        settings = sublime.load_settings("Rainmeter.sublime-settings")
        allow_duplicates = settings.get("allow_completion_section_duplicates", False)

        for completion in self.all_key_completions:
            # trigger is not used here
            section_id, display, content, unique = completion

            # we only need to search for duplicates
            # if we are having a unique section like [Rainmeter]
            # and not allow duplicates
            if unique and not allow_duplicates:
                contained = 0
                # value not used here
                for section in sections:
                    if section.casefold() == section_id.casefold():
                        contained = 1
                        break

                if contained == 0:
                    completions.append((display, content))
            else:
                completions.append((display, content))

        return completions

    # only show our completion list because nothing else makes sense in this context
    flags = sublime.INHIBIT_EXPLICIT_COMPLETIONS | sublime.INHIBIT_WORD_COMPLETIONS

    all_completions = None
    all_key_completions = None

    def get_key_context_completion(self, prefix, line_content, sections):
        """Provide all possible sections without duplicates of unique ones."""
        # if section.casefold() != "Metadata".casefold():
        #     return None

        self.__lazy_initialize_completions()
        completions = self.__filter_completions_by_sec(sections)
        # no results, means all keys are used up
        if not completions:
            return None

        # only show sorted by distance if something was already typed
        # because distance to empty string makes no sense
        if line_content != "":
            # sort by levenshtein distance
            sorted_completions = sorted(
                completions,
                key=lambda completion: levenshtein(completion[1], prefix)
            )
            return sorted_completions, self.flags
        else:
            return completions, self.flags


1		"""This module handles the skin section auto completion.
2
3		This provides the means to automatically add the base rainmeter sections
4		upon auto complete request with:
5
6		* [Rainmeter]
7		* [Metadata]
8		* [Variables]
9		* [Measure]
10		* [Meter]
11		* [MeterStyle]
12
13		This only activates if the file is empty or at least 2 new lines above the current caret.
14		"""
15
16		import yaml
17
18		import sublime
19
20		from .. import logger
		0 ignored issues – show Bug introduced 2016-12-10 14:36 UTC by Report Bug Copy Issue Report The name `logger` does not seem to exist in module `completion`. Loading history...
21		from .levenshtein import levenshtein
22		from .compiler import compile_keys
23		from .yaml_content_reader import YamlContentReader
24
25
26	View Code Duplication	class SkinSectionAutoCompleter(YamlContentReader): # pylint: disable=R0903; only provide one method
		0 ignored issues – show Duplication introduced 2016-12-18 19:14 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
27		"""Ths class is the logical state holder for the auto completion suggestions.
28
29		Upon the request the respective yaml file is parsed and converted into a logical
30		representation of the completions. Depending on the prior information the completions
31		can be filtered containing less entries.
32		"""
33
34		def __get_completions(self):
35		"""IO access to the yaml file.
36
37		Uses a yaml loader to parse it into a python object.
38		"""
39		try:
40		section_content = self._get_yaml_content("completion/", "section.yaml")
41		section = yaml.load(section_content)
42
43		return section
44
45		except yaml.YAMLError as error:
46		logger.error(error)
47		return []
48
49		def __lazy_initialize_completions(self):
		0 ignored issues – show Coding Style introduced 2016-12-10 16:00 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
50		# use lazy initialization because else the API is not available yet
51		if not self.all_completions:
52		self.all_completions = self.__get_completions()
53		self.all_key_completions = compile_keys(self.all_completions)
54
55		def __filter_completions_by_sec(self, sections):
		0 ignored issues – show Coding Style introduced 2016-12-10 16:00 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
56		# filter by already existing keys
57		completions = []
58
59		settings = sublime.load_settings("Rainmeter.sublime-settings")
60		allow_duplicates = settings.get("allow_completion_section_duplicates", False)
61
62		for completion in self.all_key_completions:
63		# trigger is not used here
64		section_id, display, content, unique = completion
65
66		# we only need to search for duplicates
67		# if we are having a unique section like [Rainmeter]
68		# and not allow duplicates
69		if unique and not allow_duplicates:
70		contained = 0
71		# value not used here
72		for section in sections:
73		if section.casefold() == section_id.casefold():
74		contained = 1
75		break
76
77		if contained == 0:
78		completions.append((display, content))
79		else:
80		completions.append((display, content))
81
82		return completions
83
84		# only show our completion list because nothing else makes sense in this context
85		flags = sublime.INHIBIT_EXPLICIT_COMPLETIONS \| sublime.INHIBIT_WORD_COMPLETIONS
86
87		all_completions = None
88		all_key_completions = None
89
90		def get_key_context_completion(self, prefix, line_content, sections):
91		"""Provide all possible sections without duplicates of unique ones."""
92		# if section.casefold() != "Metadata".casefold():
93		# return None
94
95		self.__lazy_initialize_completions()
96		completions = self.__filter_completions_by_sec(sections)
97		# no results, means all keys are used up
98		if not completions:
99		return None
100
101		# only show sorted by distance if something was already typed
102		# because distance to empty string makes no sense
103		if line_content != "":
104		# sort by levenshtein distance
105		sorted_completions = sorted(
106		completions,
107		key=lambda completion: levenshtein(completion[1], prefix)
108		)
109		return sorted_completions, self.flags
110		else:
111		return completions, self.flags
112

thatsIch / sublime-rainmeter

GitHub Access Token became invalid

Push — master ( 115f31...f9d160 )

get_key_context_completion() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like