RainmeterOpenPathsCommand.is_visible() - Code Metrics - thatsIch/sublime-rainmeter - Measure and Improve Code Quality continuously with Scrutinizer

RainmeterOpenPathsCommand.is_visible() A
last analyzed 2018-05-21 11:23 UTC

↳ Parent: RainmeterOpenPathsCommand

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

"""Module for opening paths containing Rainmeter-specific or Windows environment variables."""

import os
import re
import threading

import sublime
import sublime_plugin

from . import rainmeter
from . import logger


# Files to open with sublime instead of the system default
SETTINGS = sublime.load_settings("Rainmeter.sublime-settings")
DEF_EXTS = SETTINGS.get("rainmeter_default_open_sublime_extensions", "")

if DEF_EXTS is not None:
    DEF_EXTS = DEF_EXTS.strip().strip(r"|").strip()
else:
    DEF_EXTS = ""

ADD_EXTS = SETTINGS.get("rainmeter_open_sublime_extensions", "")

if ADD_EXTS is not None:
    ADD_EXTS = ADD_EXTS.strip().strip(r"|").strip()
else:
    ADD_EXTS = ""

SUBLIME_FILES = re.compile("(?i).*\\.(" + ADD_EXTS + "|" + DEF_EXTS + ")\\b")


def open_path(path, transient=False):
    """Try to open a path.

    A path could be opened either as:

    * a file or folder path or
    * URL in the system default application, or
    * in Sublime if it's a text file.

    Use transient=True to open a file in Sublime without assigning it a tab.
    A tab will be created once the buffer is modified.

    Will return False if the path doesn't exist in the file system, and
    True otherwise.
    """
    if not path:
        return False

    if not os.path.exists(path):
        return False

    sublime.set_timeout(lambda: sublime.status_message("Opening " + path), 10)
    if SUBLIME_FILES.search(path):
        if transient:
            sublime.set_timeout(
                lambda: sublime.active_window().open_file(path,
                                                          sublime.TRANSIENT),
                10)
        else:
            sublime.set_timeout(
                lambda: sublime.active_window().open_file(path),
                10)
    else:
        os.startfile(path)

    return True


def open_url(url):
    """Try opening a url with the system default for urls.

    Will return False if it's not a url, and True otherwise.
    """
    if re.match(r"(?i)(https?|ftp)://", url.strip()):
        os.startfile(url)
        sublime.set_timeout(lambda: sublime.status_message("Opening " + url),
                            10)
        return True
    else:
        return False


class TryOpenThread(threading.Thread):
    """A wrapper method to handle threading for opening line embedded URLs."""

    def __init__(self, line, region, opn):
        """Construct a thread for opening URL embedded in a line."""
        self.line = line
        self.region = region
        self.opn = opn
        threading.Thread.__init__(self)

    def __find_prior_quotation_mark(self):
        lastquote = self.region.a - 1
        while lastquote >= 0 and self.line[lastquote] != "\"":
            lastquote -= 1

        return lastquote

    def __open_selected_text(self):
        # 1. Selected text
        selected = self.line[self.region.a:self.region.b]
        if self.opn(selected):
            logger.info("Open selected text")
            return True

    def __find_next_quotation_mark(self):
        nextquote = self.region.b
        while nextquote == len(self.line) or self.line[nextquote] != "\"":
            nextquote += 1

        return nextquote

    def __open_enclosed_string(self):
        # 2. String enclosed in double quotes
        # Find the quotes before the current point (if any)
        lastquote = self.__find_prior_quotation_mark()

        if not lastquote < 0 and self.line[lastquote] == "\"":
            # Find the quote after the current point (if any)
            nextquote = self.__find_next_quotation_mark()

            if not nextquote == len(self.line) \
                    and self.line[nextquote] == "\"":
                string = self.line[lastquote: nextquote].strip("\"")
                if self.opn(string):
                    logger.info("Open string enclosed in quotes: " + string)
                    return True

    def __find_front_nearest_whitespace(self):
        # Find the space before the current point (if any)
        lastspace = self.region.a - 1
        while lastspace >= 0 \
                and self.line[lastspace] != " " \
                and self.line[lastspace] != "\t":
            lastspace -= 1

        # Set to zero if nothing was found until the start of the line
        lastspace = max(lastspace, 0)

        return lastspace

    def __find_back_nearest_whitespace(self):
        # Find the space after the current point (if any)
        nextspace = self.region.b
        while nextspace < len(self.line) \
                and self.line[nextspace] != " " \
                and self.line[nextspace] != "\t":
            nextspace += 1

        return nextspace

    def __is_front_space(self, lastspace):
        return lastspace == 0 \
            or self.line[lastspace] == " " \
            or self.line[lastspace] == "\t"

    def __is_back_space(self, nextspace):
        return nextspace >= len(self.line) \
            or self.line[nextspace] == " " \
            or self.line[nextspace] == "\t"

    def __open_whitespaced_region(self):
        # 3. Region from last whitespace to next whitespace

        lastspace = self.__find_front_nearest_whitespace()
        if self.__is_front_space(lastspace):

            nextspace = self.__find_back_nearest_whitespace()
            if self.__is_back_space(nextspace):
                string = self.line[lastspace: nextspace].strip()
                if self.opn(string):
                    logger.info("Open string enclosed in whitespace: " + string)
                    return True

    def __open_after_equals_sign(self):
        # 4. Everything after the first \"=\" until the end
        # of the line (strip quotes)
        mtch = re.search(r"=\s*(.*)\s*$", self.line)
        if mtch and self.opn(mtch.group(1).strip("\"")):
            logger.info("Open text after \"=\": " + mtch.group(1).strip("\""))
            return True

    def __open_whole_line(self):
        # 5. Whole line (strip comment character at start)
        stripmatch = re.search(r"^[ \t;]*?([^ \t;].*)\s*$", self.line)
        if self.opn(stripmatch.group(1)):
            logger.info("Open whole line: " + stripmatch.group(1))
            return

    def run(self):
        """Run the thread."""
        return self.__open_selected_text() or \
            self.__open_enclosed_string() or \
            self.__open_whitespaced_region() or \
            self.__open_after_equals_sign() or \
            self.__open_whole_line()


class RainmeterOpenPathsCommand(sublime_plugin.TextCommand):
    """Try to open paths on lines in the current selection.

    Will try to open paths to files, folders or URLs on each line in the
    current selection. To achieve this, the following substrings of each line
    intersecting the selection are tested:

    1. The string inside the selection
    2. The string between possible quotes preceding and following the
       selection, if any
    3. The string between the preceding and following whitespace
    4. Everything after the first "=" on the line until the end of the line
    5. The whole line, stripped of preceding semicolons
    """

    def __split_selection_by_new_lines(self, selection):
        # Split all regions into individual segments on lines (using nicely
        # confusing python syntax).
        return [
            j for i in [
                self.view.split_by_newlines(region)
                for region in selection
            ]
            for j in i
        ]

    def __open_each_line_by_thread(self, lines):
        """Identify segments in selected lines and tries to open them each in a new thread.

        This can be resource intensive.
        """
        fnm = self.view.file_name()

        def opn(string):
            """Simple callback method to apply multiple opening operations.

            An URL can be either external or internal and thus is opened differently.
            """
            opened = open_path(rainmeter.make_path(string, fnm)) or open_url(string)
            if opened:
                logger.info("found file or url '" + string + "' to open")

        for linereg in lines:
            wholeline = self.view.line(linereg)
            thread = TryOpenThread(self.view.substr(wholeline),
                                   sublime.Region(linereg.a - wholeline.a,
                                                  linereg.b - wholeline.a),
                                   opn)
            thread.start()

    def run(self, _):
        """Detect various scenarios of file paths and try to open them one after the other.

        :param _: _ edit unused
        """
        selection = self.view.sel()
        lines = self.__split_selection_by_new_lines(selection)

        loaded_settings = sublime.load_settings("Rainmeter.sublime-settings")
        max_open_lines = loaded_settings.get("rainmeter_max_open_lines", 40)

        # Refuse if too many lines selected to avoid freezing

        if len(lines) > max_open_lines:
            accept = sublime.ok_cancel_dialog(
                "You are trying to open " +
                str(len(lines)) + " lines.\n" +
                "That's a lot, and could take some time. Try anyway?")
            if not accept:
                return

        self.__open_each_line_by_thread(lines)

    def is_enabled(self):
        """Check if current syntax is rainmeter."""
        israinmeter = self.view.score_selector(self.view.sel()[0].a,
                                               "source.rainmeter")

        return israinmeter > 0

    def is_visible(self):
        """It is visible if it is in Rainmeter scope."""
        return self.is_enabled()


1			"""Module for opening paths containing Rainmeter-specific or Windows environment variables."""
2
3			import os
4			import re
5			import threading
6
7			import sublime
8			import sublime_plugin
9
10			from . import rainmeter
11			from . import logger
12
13
14			# Files to open with sublime instead of the system default
15			SETTINGS = sublime.load_settings("Rainmeter.sublime-settings")
16			DEF_EXTS = SETTINGS.get("rainmeter_default_open_sublime_extensions", "")
17
18			if DEF_EXTS is not None:
19			DEF_EXTS = DEF_EXTS.strip().strip(r"\|").strip()
20			else:
21			DEF_EXTS = ""
22
23			ADD_EXTS = SETTINGS.get("rainmeter_open_sublime_extensions", "")
24
25			if ADD_EXTS is not None:
26			ADD_EXTS = ADD_EXTS.strip().strip(r"\|").strip()
27			else:
28			ADD_EXTS = ""
29
30			SUBLIME_FILES = re.compile("(?i).*\\.(" + ADD_EXTS + "\|" + DEF_EXTS + ")\\b")
31
32
33			def open_path(path, transient=False):
34			"""Try to open a path.
35
36			A path could be opened either as:
37
38			* a file or folder path or
39			* URL in the system default application, or
40			* in Sublime if it's a text file.
41
42			Use transient=True to open a file in Sublime without assigning it a tab.
43			A tab will be created once the buffer is modified.
44
45			Will return False if the path doesn't exist in the file system, and
46			True otherwise.
47			"""
48			if not path:
49			return False
50
51			if not os.path.exists(path):
52			return False
53
54			sublime.set_timeout(lambda: sublime.status_message("Opening " + path), 10)
55			if SUBLIME_FILES.search(path):
56			if transient:
57			sublime.set_timeout(
58			lambda: sublime.active_window().open_file(path,
59			sublime.TRANSIENT),
60			10)
61			else:
62			sublime.set_timeout(
63			lambda: sublime.active_window().open_file(path),
64			10)
65			else:
66			os.startfile(path)
67
68			return True
69
70
71			def open_url(url):
72			"""Try opening a url with the system default for urls.
73
74			Will return False if it's not a url, and True otherwise.
75			"""
76			if re.match(r"(?i)(https?\|ftp)://", url.strip()):
77			os.startfile(url)
78			sublime.set_timeout(lambda: sublime.status_message("Opening " + url),
79			10)
80			return True
81			else:
82			return False
83
84
85			class TryOpenThread(threading.Thread):
86			"""A wrapper method to handle threading for opening line embedded URLs."""
87
88			def __init__(self, line, region, opn):
89			"""Construct a thread for opening URL embedded in a line."""
90			self.line = line
91			self.region = region
92			self.opn = opn
93			threading.Thread.__init__(self)
94
95			def __find_prior_quotation_mark(self):
96			lastquote = self.region.a - 1
97			while lastquote >= 0 and self.line[lastquote] != "\"":
98			lastquote -= 1
99
100			return lastquote
101
102			def __open_selected_text(self):
103			# 1. Selected text
104			selected = self.line[self.region.a:self.region.b]
105			if self.opn(selected):
106			logger.info("Open selected text")
107			return True
108
109			def __find_next_quotation_mark(self):
110			nextquote = self.region.b
111			while nextquote == len(self.line) or self.line[nextquote] != "\"":
112			nextquote += 1
113
114			return nextquote
115
116			def __open_enclosed_string(self):
117			# 2. String enclosed in double quotes
118			# Find the quotes before the current point (if any)
119			lastquote = self.__find_prior_quotation_mark()
120
121			if not lastquote < 0 and self.line[lastquote] == "\"":
122			# Find the quote after the current point (if any)
123			nextquote = self.__find_next_quotation_mark()
124
125			if not nextquote == len(self.line) \
126			and self.line[nextquote] == "\"":
127			string = self.line[lastquote: nextquote].strip("\"")
128			if self.opn(string):
129			logger.info("Open string enclosed in quotes: " + string)
130			return True
131
132			def __find_front_nearest_whitespace(self):
133			# Find the space before the current point (if any)
134			lastspace = self.region.a - 1
135			while lastspace >= 0 \
136			and self.line[lastspace] != " " \
137			and self.line[lastspace] != "\t":
138			lastspace -= 1
139
140			# Set to zero if nothing was found until the start of the line
141			lastspace = max(lastspace, 0)
142
143			return lastspace
144
145			def __find_back_nearest_whitespace(self):
146			# Find the space after the current point (if any)
147			nextspace = self.region.b
148			while nextspace < len(self.line) \
149			and self.line[nextspace] != " " \
150			and self.line[nextspace] != "\t":
151			nextspace += 1
152
153			return nextspace
154
155			def __is_front_space(self, lastspace):
156			return lastspace == 0 \
157			or self.line[lastspace] == " " \
158			or self.line[lastspace] == "\t"
159
160			def __is_back_space(self, nextspace):
161			return nextspace >= len(self.line) \
162			or self.line[nextspace] == " " \
163			or self.line[nextspace] == "\t"
164
165			def __open_whitespaced_region(self):
166			# 3. Region from last whitespace to next whitespace
167
168			lastspace = self.__find_front_nearest_whitespace()
169			if self.__is_front_space(lastspace):
170
171			nextspace = self.__find_back_nearest_whitespace()
172			if self.__is_back_space(nextspace):
173			string = self.line[lastspace: nextspace].strip()
174			if self.opn(string):
175			logger.info("Open string enclosed in whitespace: " + string)
176			return True
177
178			def __open_after_equals_sign(self):
179			# 4. Everything after the first \"=\" until the end
180			# of the line (strip quotes)
181			mtch = re.search(r"=\s(.)\s*$", self.line)
182			if mtch and self.opn(mtch.group(1).strip("\"")):
183			logger.info("Open text after \"=\": " + mtch.group(1).strip("\""))
184			return True
185
186			def __open_whole_line(self):
187			# 5. Whole line (strip comment character at start)
188			stripmatch = re.search(r"^[ \t;]?([^ \t;].)\s*$", self.line)
189			if self.opn(stripmatch.group(1)):
190			logger.info("Open whole line: " + stripmatch.group(1))
191			return
192
193			def run(self):
194			"""Run the thread."""
195			return self.__open_selected_text() or \
196			self.__open_enclosed_string() or \
197			self.__open_whitespaced_region() or \
198			self.__open_after_equals_sign() or \
199			self.__open_whole_line()
200
201
202			class RainmeterOpenPathsCommand(sublime_plugin.TextCommand):
203			"""Try to open paths on lines in the current selection.
204
205			Will try to open paths to files, folders or URLs on each line in the
206			current selection. To achieve this, the following substrings of each line
207			intersecting the selection are tested:
208
209			1. The string inside the selection
210			2. The string between possible quotes preceding and following the
211			selection, if any
212			3. The string between the preceding and following whitespace
213			4. Everything after the first "=" on the line until the end of the line
214			5. The whole line, stripped of preceding semicolons
215			"""
216
217			def __split_selection_by_new_lines(self, selection):
218			# Split all regions into individual segments on lines (using nicely
219			# confusing python syntax).
220			return [
221			j for i in [
222			self.view.split_by_newlines(region)
223			for region in selection
224			]
225			for j in i
226			]
227
228			def __open_each_line_by_thread(self, lines):
229			"""Identify segments in selected lines and tries to open them each in a new thread.
230
231			This can be resource intensive.
232			"""
233			fnm = self.view.file_name()
234
235			def opn(string):
236			"""Simple callback method to apply multiple opening operations.
237
238			An URL can be either external or internal and thus is opened differently.
239			"""
240			opened = open_path(rainmeter.make_path(string, fnm)) or open_url(string)
241			if opened:
242			logger.info("found file or url '" + string + "' to open")
243
244			for linereg in lines:
245			wholeline = self.view.line(linereg)
246			thread = TryOpenThread(self.view.substr(wholeline),
247			sublime.Region(linereg.a - wholeline.a,
248			linereg.b - wholeline.a),
249			opn)
250			thread.start()
251
252			def run(self, _):
253			"""Detect various scenarios of file paths and try to open them one after the other.
254
255			:param _: _ edit unused
256			"""
257			selection = self.view.sel()
258			lines = self.__split_selection_by_new_lines(selection)
259
260			loaded_settings = sublime.load_settings("Rainmeter.sublime-settings")
261			max_open_lines = loaded_settings.get("rainmeter_max_open_lines", 40)
262
263			# Refuse if too many lines selected to avoid freezing
264
265			if len(lines) > max_open_lines:
266			accept = sublime.ok_cancel_dialog(
267			"You are trying to open " +
268			str(len(lines)) + " lines.\n" +
269			"That's a lot, and could take some time. Try anyway?")
270			if not accept:
271			return
272
273			self.__open_each_line_by_thread(lines)
274
275			def is_enabled(self):
276			"""Check if current syntax is rainmeter."""
277			israinmeter = self.view.score_selector(self.view.sel()[0].a,
278			"source.rainmeter")
279
280			return israinmeter > 0
281
282			def is_visible(self):
283			"""It is visible if it is in Rainmeter scope."""
284			return self.is_enabled()
285

thatsIch / sublime-rainmeter

GitHub Access Token became invalid

RainmeterOpenPathsCommand.is_visible() A last analyzed 2018-05-21 11:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RainmeterOpenPathsCommand.is_visible() A
last analyzed 2018-05-21 11:23 UTC