SkinSectionAutoCompleter.__str_equal_case_ignore() - Code Metrics - Inspection of "Define not self referencing methods as module meth..." - thatsIch/sublime-rainmeter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( edc1a5...89ec84 )

by thatsIch

created 2017-02-02 07:31 UTC

SkinSectionAutoCompleter.__str_equal_case_ignore() A

↳ Parent: SkinSectionAutoCompleter.__lazy_initialize_completions()

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
dl	0
loc	2
rs	10
c	1
b	0
f	0

"""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


def str_equal_case_ignore(str1, str2):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    return str1.casefold() == str2.casefold()

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 __sections_contain_section_id(self, sections, section_id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        # value not used here
        for section in sections:
            if str_equal_case_ignore(section, section_id):
                return True

        return False

    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 = self.__sections_contain_section_id(sections, section_id)

                if not contained:
                    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			def str_equal_case_ignore(str1, str2):
			0 ignored issues – show Coding Style introduced 2017-02-02 07:32 UTC by Report Bug Copy Issue Report This function 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...
27			return str1.casefold() == str2.casefold()
28
29			class SkinSectionAutoCompleter(YamlContentReader): # pylint: disable=R0903; only provide one method
30			"""Ths class is the logical state holder for the auto completion suggestions.
31
32			Upon the request the respective yaml file is parsed and converted into a logical
33			representation of the completions. Depending on the prior information the completions
34			can be filtered containing less entries.
35			"""
36
37			def __get_completions(self):
38			"""IO access to the yaml file.
39
40			Uses a yaml loader to parse it into a python object.
41			"""
42			try:
43			section_content = self._get_yaml_content("completion/", "section.yaml")
44			section = yaml.load(section_content)
45
46			return section
47
48			except yaml.YAMLError as error:
49			logger.error(error)
50			return []
51
52			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...
53			# use lazy initialization because else the API is not available yet
54			if not self.all_completions:
55			self.all_completions = self.__get_completions()
56			self.all_key_completions = compile_keys(self.all_completions)
57
58			def __sections_contain_section_id(self, sections, section_id):
			0 ignored issues – show Coding Style introduced 2017-02-02 07:04 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... Coding Style introduced 2017-02-02 07:32 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
59			# value not used here
60			for section in sections:
61			if str_equal_case_ignore(section, section_id):
62			return True
63
64			return False
65
66			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...
67			# filter by already existing keys
68			completions = []
69
70			settings = sublime.load_settings("Rainmeter.sublime-settings")
71			allow_duplicates = settings.get("allow_completion_section_duplicates", False)
72
73			for completion in self.all_key_completions:
74			# trigger is not used here
75			section_id, display, content, unique = completion
76
77			# we only need to search for duplicates
78			# if we are having a unique section like [Rainmeter]
79			# and not allow duplicates
80			if unique and not allow_duplicates:
81			contained = self.__sections_contain_section_id(sections, section_id)
82
83			if not contained:
84			completions.append((display, content))
85			else:
86			completions.append((display, content))
87
88			return completions
89
90			# only show our completion list because nothing else makes sense in this context
91			flags = sublime.INHIBIT_EXPLICIT_COMPLETIONS \| sublime.INHIBIT_WORD_COMPLETIONS
92
93			all_completions = None
94			all_key_completions = None
95
96			def get_key_context_completion(self, prefix, line_content, sections):
97			"""Provide all possible sections without duplicates of unique ones."""
98			# if section.casefold() != "Metadata".casefold():
99			# return None
100
101			self.__lazy_initialize_completions()
102			completions = self.__filter_completions_by_sec(sections)
103			# no results, means all keys are used up
104			if not completions:
105			return None
106
107			# only show sorted by distance if something was already typed
108			# because distance to empty string makes no sense
109			if line_content != "":
110			# sort by levenshtein distance
111			sorted_completions = sorted(
112			completions,
113			key=lambda completion: levenshtein(completion[1], prefix)
114			)
115			return sorted_completions, self.flags
116			else:
117			return completions, self.flags
118

thatsIch / sublime-rainmeter

GitHub Access Token became invalid

Push — master ( edc1a5...89ec84 )

SkinSectionAutoCompleter.__str_equal_case_ignore() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like