gulp.py

import sublime
import sublime_plugin
import traceback
import codecs
import os
from datetime import datetime
from threading import Thread
import json
import webbrowser

is_sublime_text_3 = int(sublime.version()) >= 3000

if is_sublime_text_3:
    from .base_command import BaseCommand
    from .settings import Settings
    from .progress_notifier import ProgressNotifier
    from .cross_platform_process import CrossPlatformProcess
    from .hasher import Hasher
    from .gulp_version import GulpVersion
    from .plugins import PluginList, PluginRegistryCall
    from .caches import ProcessCache, CacheFile
    from .status_bar import StatusBar
    from .timeout import set_timeout, defer, defer_sync, async
else:
    from base_command import BaseCommand
    from settings import Settings
    from progress_notifier import ProgressNotifier
    from cross_platform_process import CrossPlatformProcess
    from hasher import Hasher
    from gulp_version import GulpVersion
    from plugins import PluginList, PluginRegistryCall
    from caches import ProcessCache, CacheFile
    from status_bar import StatusBar
    from timeout import set_timeout, defer, defer_sync, async


#
# Commands
#


class GulpCommand(BaseCommand):
    log_file_name = 'sublime-gulp.log'
    allowed_extensions = [".babel.js", ".js"]

    def work(self):
        self.folders = []
        self.gulp_files = []
        self.list_gulp_files()

    def list_gulp_files(self):
        self.append_paths()

        if not self.check_for_gulpfile:
            self.gulp_files = self.folders

        if len(self.gulp_files) > 0:
            self.choose_file()
        else:
            sufix = "on:\n- %s" % "\n- ".join(self.searchable_folders) if len(self.searchable_folders) > 0 else ""
            if not self.settings.get("recursive_gulpfile_search", False):
                sufix += '\n\nCheck the recursive_gulpfile_search setting for nested gulpfiles'
            self.error_message("gulpfile not found %s" % sufix)

    def append_paths(self):
        gulpfile_paths = self.settings.get("gulpfile_paths", [])
        ignored_gulpfile_folders = self.settings.get("ignored_gulpfile_folders", [])

        if self.settings.get("recursive_gulpfile_search", False):
            for folder_path in self.searchable_folders:
                for dir, dirnames, files in os.walk(folder_path):
                    dirnames[:] = [dirname for dirname in dirnames if dirname not in ignored_gulpfile_folders]
                    self.append_to_gulp_files(dir)
        else:
            for folder_path in self.searchable_folders:
                self.append_to_gulp_files(folder_path)
                for inner_folder in gulpfile_paths:
                    if(os.name == 'nt'):
                        inner_folder = inner_folder.replace("/", "\\")
                    self.append_to_gulp_files(os.path.join(folder_path, inner_folder))

    def append_to_gulp_files(self, folder_path):
        gulpfile_path = self.get_gulpfile_path(folder_path)
        self.folders.append(folder_path)
        if os.path.exists(gulpfile_path) and gulpfile_path not in self.gulp_files:
            self.gulp_files.append(gulpfile_path)

    def choose_file(self):
        if len(self.gulp_files) == 1:
            self.show_tasks_from_gulp_file(0)
        else:
            self.show_quick_panel(self.gulp_files, self.show_tasks_from_gulp_file)

    def show_tasks_from_gulp_file(self, file_index):
        if file_index > -1:
            self.working_dir = self.gulp_files[file_index]
            if self.task_name is not None:
                self.run_gulp_task()
            else:
                defer(self.show_tasks)

    def show_tasks(self):
        self.tasks = self.list_tasks()
        if self.tasks is not None:
            self.show_quick_panel(self.tasks, self.task_list_callback)

    def list_tasks(self):
        try:
            self.callcount = 0
            json_result = self.fetch_json()
        except TypeError as e:
            self.error_message("Could not read available tasks.\nMaybe the JSON cache (.sublime-gulp.cache) is malformed?")
        except Exception as e:
            print(traceback.format_exc())
            self.error_message(str(e))
        else:
            tasks = [[name, self.dependencies_text(task)] for name, task in json_result.items()]
            return sorted(tasks, key=lambda task: task)

    def dependencies_text(self, task):
        return "Dependencies: " + task['dependencies'] if task['dependencies'] else ""

    def fetch_json(self):
        cache_file = CacheFile(self.working_dir)
        gulpfile = self.get_gulpfile_path(self.working_dir)
        data = None

        if cache_file.exists():
            filesha1 = Hasher.sha1(gulpfile)
            data = cache_file.read()

            if gulpfile in data and data[gulpfile]["sha1"] == filesha1:
                return data[gulpfile]["tasks"]

        self.callcount += 1

        if self.callcount == 1:
            return self.write_to_cache()

        if data is None:
            raise Exception("Could not write to cache gulpfile.")

        if gulpfile in data:
            raise Exception("Sha1 from gulp cache ({0}) is not equal to calculated ({1}).\nTry erasing the cache and running Gulp again.".format(data[gulpfile]["sha1"], filesha1))
        else:
            raise Exception("Have you renamed a folder?.\nSometimes Sublime doesn't update the project path, try removing the folder from the project and adding it again.")

    def write_to_cache(self):
        process = CrossPlatformProcess(self.working_dir)
        (stdout, stderr) = process.run_sync(r'node "%s/write_tasks_to_cache.js"' % self.settings.package_path())

        if process.failed:
            try:
                self.write_to_cache_without_js()
            except:
                if process.returncode() == 127:
                    raise Exception("\"node\" command not found.\nPlease be sure to have nodejs installed on your system and in your PATH (more info in the README).")
                elif stderr:
                    self.log_errors(stderr)
                    raise Exception("There was an error running gulp, make sure gulp is running correctly in your project.\nFor more info check the sublime-gulp.log file")

        return self.fetch_json()

    def write_to_cache_without_js(self):
        process = CrossPlatformProcess(self.working_dir)
        (stdout, stderr) = process.run_sync(r'gulp -v')

        if process.failed or not GulpVersion(stdout).supports_tasks_simple():
            raise Exception("Gulp: Could not get the current gulp version or your gulp CLI version is lower than 3.7.0")

        (stdout, stderr) = process.run_sync(r'gulp --tasks-simple')

        gulpfile = self.get_gulpfile_path(self.working_dir)

        if not stdout:
            raise Exception("Gulp: The result of `gulp --tasks-simple` was empty")

        CacheFile(self.working_dir).write({
            gulpfile: {
                "sha1": Hasher.sha1(gulpfile),
                "tasks": dict((task, { "name": task, "dependencies": "" }) for task in stdout.split("\n") if task)
            }
        })

    def get_gulpfile_path(self, base_path):
        for extension in GulpCommand.allowed_extensions:
            gulpfile_path = os.path.join(base_path, "gulpfile" + extension)
            if os.path.exists(gulpfile_path):
                return os.path.normpath(gulpfile_path)
        return gulpfile_path

    def log_errors(self, text):
        if not self.settings.get("log_errors", True):
            return
        log_path = os.path.join(self.working_dir, GulpCommand.log_file_name)
        header = "Remember that you can report errors and get help in https://github.com/nicosantangelo/sublime-gulp" if not os.path.isfile(log_path) else ""
        timestamp = str(datetime.now().strftime("%m-%d-%Y %H:%M"))

        with codecs.open(log_path, "a", "utf-8", errors='replace') as log_file:
            log_file.write(header + "\n\n" + timestamp + ":\n" + text)

    def task_list_callback(self, task_index):
        if task_index > -1:
            self.task_name = self.tasks[task_index][0]
            self.task_flag = self.get_flag_from_task_name()
            self.run_gulp_task()

    def run_gulp_task(self):
        task = self.construct_gulp_task()
        Thread(target=self.run_process, args=(task, )).start()

    def construct_gulp_task(self):
        self.show_running_status_in_output_panel()
        return r"gulp %s %s" % (self.task_name, self.task_flag)

    def run_process(self, task):
        process = CrossPlatformProcess(self.working_dir)
        process.run(task)
        self.status_bar.update()
        stdout, stderr = process.communicate(self.append_to_output_view_in_main_thread)
        defer_sync(lambda: self.finish(stdout, stderr))

    def finish(self, stdout, stderr):
        finish_message = "gulp %s %s finished %s" % (self.task_name or '', self.task_flag, "with some errors." if stderr else "!")
        self.status_message(finish_message)
        self.status_bar.update()
        if not self.silent:
            self.set_output_close_on_timeout()
        elif stderr and self.settings.get("show_silent_errors", False):
            self.silent = False
            self.show_running_status_in_output_panel()
            self.append_to_output_view(stdout)
            self.append_to_output_view(stderr)
            self.silent = True

    def show_running_status_in_output_panel(self):
        with_flag_text = (' with %s' % self.task_flag) if self.task_flag else ''
        self.show_output_panel("Running '%s'%s...\n" % (self.task_name, with_flag_text))


class GulpArbitraryCommand(GulpCommand):
    def show_tasks_from_gulp_file(self, file_index):
        if file_index > -1:
            self.working_dir = self.gulp_files[file_index]
            self.show_input_panel(caption="gulp", on_done=self.after_task_input)

    def after_task_input(self, task_name=None):
        if task_name:
            self.task_name = task_name
            self.task_flag = ''
            self.run_gulp_task()


class GulpLastCommand(BaseCommand):
    def work(self):
        if ProcessCache.last_task_name:
            task_name = ProcessCache.last_task_name
            self.window.run_command("gulp", { "task_name": task_name })
        else:
            self.status_message("You need to run a task first")


class GulpKillTaskCommand(BaseCommand):
    def work(self):
        ProcessCache.refresh()

        if ProcessCache.empty():
            self.status_message("There are no running tasks")
        else:
            self.procs = ProcessCache.get()
            quick_panel_list = [[process.last_command, process.working_dir, 'PID: %d' % process.pid] for process in self.procs]
            self.show_quick_panel(quick_panel_list, self.kill_process, font=0)

    def kill_process(self, index=-1):
        if index >= 0 and index < len(self.procs):
            process = self.procs[index]
            try:
                process.kill()
            except ProcessLookupError as e:
                print('Process %d seems to be dead already' % process.pid)

            self.show_output_panel('')
            self.append_to_output_view("\n%s killed! # %s | PID: %d\n" % process.to_tuple())


class GulpKillCommand(BaseCommand):
    def work(self):
        ProcessCache.refresh()

        if ProcessCache.empty():
            self.status_message("There are no running tasks")
        else:
            self.append_processes_to_output_view()
            ProcessCache.kill_all()
            self.append_to_output_view("\nAll running tasks killed!\n")

    def append_processes_to_output_view(self):
        self.show_output_panel("\nFinishing the following running tasks:\n")
        ProcessCache.each(lambda process: self.append_to_output_view("$ %s # %s | PID: %d\n" % process.to_tuple()))


class GulpShowPanelCommand(BaseCommand):
    def work(self):
        self.show_panel()


class GulpHidePanelCommand(BaseCommand):
    def work(self):
        self.close_panel()


class GulpPluginsCommand(BaseCommand):
    def work(self):
        self.plugins = None
        self.request_plugin_list()

    def request_plugin_list(self):
        progress = ProgressNotifier("%s: Working" % Settings.PACKAGE_NAME)
        thread = PluginRegistryCall()
        thread.start()
        self.handle_thread(thread, progress)

    def handle_thread(self, thread, progress):
        if thread.is_alive() and not thread.error:
            set_timeout(lambda: self.handle_thread(thread, progress), 100)
        else:
            progress.stop()
            if thread.result:
                plugin_response = json.loads(thread.result.decode('utf-8'))
                self.plugins = PluginList(plugin_response)
                self.show_quick_panel(self.plugins.quick_panel_list(), self.open_in_browser, font=0)
            else:
                self.error_message(self.error_text_for(thread))

    def error_text_for(self, thread):
        error_tuple = (
            "The plugin repository seems to be down.",
            "If http://gulpjs.com/plugins is working, please report this issue at the Sublime Gulp repo (https://github.com/nicosantangelo/sublime-gulp).",
            "Thanks!",
            thread.error
        )
        return "\n\n%s\n\n%s\n\n%s\n\n%s" % error_tuple

    def open_in_browser(self, index=-1):
        if index >= 0 and index < self.plugins.length:
            webbrowser.open_new(self.plugins.get(index).get('homepage'))


class GulpDeleteCacheCommand(GulpCommand):
    def choose_file(self):
        if len(self.gulp_files) == 1:
            self.delete_cache(0)
        else:
            self.show_quick_panel(self.gulp_files, self.delete_cache)

    def delete_cache(self, file_index):
        if file_index > -1:
            self.working_dir = self.gulp_files[file_index]
            try:
                cache_file = CacheFile(self.working_dir)
                if cache_file.exists():
                    cache_file.remove()
                    self.status_message('Cache removed successfully')
            except Exception as e:
                self.status_message("Could not remove cache: %s" % str(e))


class GulpExitCommand(sublime_plugin.WindowCommand):
    def run(self):
        try:
            self.window.run_command("gulp_kill")
        finally:
            self.window.run_command("exit")


class GulpUpdateStatusBarCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        if self.view.settings().get('is_widget'):
            return

        window = self.view.window()
        if not window or \
            (self.view.file_name() and
                self.view == window.transient_view_in_group(window.active_group())):
            # it means it is an transient view of a regular file
            return

        StatusBar(window).update()


def plugin_loaded():
    def load_process_cache():
        for process in ProcessCache.get_from_storage():
            ProcessCache.add(
                CrossPlatformProcess(process['working_dir'], process['last_command'], process['pid'])
            )

    async(load_process_cache, 200, silent=True)


if not is_sublime_text_3:
    plugin_loaded()