Merge pull request ironcladlou#103 from ironcladlou/refactor-settings

Refactor settings system

gotools_build.py

@@ -18,19 +18,15 @@ def run(self, cmd = None, shell_cmd = None, file_regex = "", line_regex = "", wo
           clean = False, task = "build",
           # Catches "path" and "shell"
           **kwargs):
-    self.settings = GoToolsSettings()
-    self.logger = Logger(self.settings)
-    self.runner = ToolRunner(self.settings, self.logger)
-
     if clean:
       self.clean()
 
     if len(file_regex) == 0:
       file_regex = "^(.*\\.go):(\\d+):()(.*)$"
 
-    env["GOPATH"] = self.settings.gopath
-    env["GOROOT"] = self.settings.goroot
-    env["PATH"] = self.settings.ospath
+    env["GOPATH"] = GoToolsSettings.Instance.gopath
+    env["GOROOT"] = GoToolsSettings.Instance.goroot
+    env["PATH"] = GoToolsSettings.Instance.ospath
 
     exec_opts = {
       "cmd": cmd,
@@ -52,60 +48,60 @@ def run(self, cmd = None, shell_cmd = None, file_regex = "", line_regex = "", wo
       self.test_packages(exec_opts, self.find_test_packages())
     elif task == "test_tagged_packages":
       pkgs = []
-      for p in self.settings.tagged_test_packages:
-        pkgs.append(os.path.join(self.settings.project_package, p))
-      self.test_packages(exec_opts=exec_opts, packages=pkgs, tags=self.settings.tagged_test_tags)
+      for p in GoToolsSettings.Instance.tagged_test_packages:
+        pkgs.append(os.path.join(GoToolsSettings.Instance.project_package, p))
+      self.test_packages(exec_opts=exec_opts, packages=pkgs, tags=GoToolsSettings.Instance.tagged_test_tags)
     elif task == "test_at_cursor":
       self.test_at_cursor(exec_opts)
     elif task == "test_current_package":
       self.test_current_package(exec_opts)
     elif task == "test_last":
-      self.logger.log("re-running last test")
+      Logger.log("re-running last test")
       self.window.run_command("exec", self.last_test_exec_opts)
     else:
-      self.logger.log("invalid task: " + task)
+      Logger.log("invalid task: " + task)
 
   def clean(self):
-    self.logger.log("cleaning build output directories")
-    for p in self.settings.gopath.split(":"):
-      pkgdir = os.path.join(p, "pkg", self.settings.goos + "_" + self.settings.goarch)
-      self.logger.log("=> " + pkgdir)
+    Logger.log("cleaning build output directories")
+    for p in GoToolsSettings.Instance.gopath.split(":"):
+      pkgdir = os.path.join(p, "pkg", GoToolsSettings.Instance.goos + "_" + GoToolsSettings.Instance.goarch)
+      Logger.log("=> " + pkgdir)
       if os.path.exists(pkgdir):
         try:
           shutil.rmtree(pkgdir)
         except Exception as e:
-          self.logger.log("WARNING: couldn't clean directory: " + str(e))
+          Logger.log("WARNING: couldn't clean directory: " + str(e))
 
 
   def build(self, exec_opts):
     build_packages = []
-    for p in self.settings.build_packages:
-      build_packages.append(os.path.join(self.settings.project_package, p))
+    for p in GoToolsSettings.Instance.build_packages:
+      build_packages.append(os.path.join(GoToolsSettings.Instance.project_package, p))
 
-    self.logger.log("running build for packages: " + str(build_packages))
+    Logger.log("running build for packages: " + str(build_packages))
 
-    go = GoToolsSettings.find_go_binary(self.settings.ospath)
+    go = GoToolsSettings.Instance.find_go_binary(GoToolsSettings.Instance.ospath)
     exec_opts["cmd"] = [go, "install"] + build_packages
 
     self.window.run_command("exec", exec_opts)
 
   def test_packages(self, exec_opts, packages = [], patterns = [], tags = []):
-    self.logger.log("running tests")
+    Logger.log("running tests")
 
-    self.logger.log("test packages: " + str(packages))
-    self.logger.log("test patterns: " + str(patterns))
+    Logger.log("test packages: " + str(packages))
+    Logger.log("test patterns: " + str(patterns))
 
-    go = GoToolsSettings.find_go_binary(self.settings.ospath)
+    go = GoToolsSettings.Instance.find_go_binary(GoToolsSettings.Instance.ospath)
     cmd = [go, "test"]
 
     if len(tags) > 0:
       cmd += ["-tags", ",".join(tags)]
 
-    if self.settings.verbose_tests:
+    if GoToolsSettings.Instance.verbose_tests:
       cmd.append("-v")
 
-    if self.settings.test_timeout:
-      cmd += ["-timeout", self.settings.test_timeout]
+    if GoToolsSettings.Instance.test_timeout:
+      cmd += ["-timeout", GoToolsSettings.Instance.test_timeout]
 
     cmd += packages
 
@@ -119,71 +115,71 @@ def test_packages(self, exec_opts, packages = [], patterns = [], tags = []):
     self.window.run_command("exec", exec_opts)
 
   def test_current_package(self, exec_opts):
-    self.logger.log("running current package tests")
+    Logger.log("running current package tests")
     view = self.window.active_view()
     pkg = self.current_file_pkg(view)
 
     if len(pkg) == 0:
-      self.logger.log("couldn't determine package for current file: " + view.file_name())
+      Logger.log("couldn't determine package for current file: " + view.file_name())
       return
 
     tags = self.tags_for_buffer(view)
 
-    self.logger.log("running tests for package: " + pkg)
+    Logger.log("running tests for package: " + pkg)
     self.test_packages(exec_opts=exec_opts, packages=[pkg], tags=tags)
 
   def test_at_cursor(self, exec_opts):
-    self.logger.log("running current test under cursor")
+    Logger.log("running current test under cursor")
     view = self.window.active_view()
 
     func_name = GoBuffers.func_name_at_cursor(view)
 
     if len(func_name) == 0:
-      self.logger.log("no function found near cursor")
+      Logger.log("no function found near cursor")
       return
 
     pkg = self.current_file_pkg(view)
 
     if len(pkg) == 0:
-      self.logger.log("couldn't determine package for current file: " + view.file_name())
+      Logger.log("couldn't determine package for current file: " + view.file_name())
       return
 
     tags = self.tags_for_buffer(view)
 
-    self.logger.log("running test: " + pkg + "#" + func_name)
+    Logger.log("running test: " + pkg + "#" + func_name)
     self.test_packages(exec_opts=exec_opts, packages=[pkg], patterns=[func_name], tags=tags)
 
   def current_file_pkg(self, view):
     abs_pkg_dir = os.path.dirname(view.file_name())
     try:
-      return abs_pkg_dir[abs_pkg_dir.index(self.settings.project_package):]
+      return abs_pkg_dir[abs_pkg_dir.index(GoToolsSettings.Instance.project_package):]
     except:
       return ""
 
   def find_test_packages(self):
     proj_package_dir = None
 
-    for gopath in self.settings.gopath.split(":"):
-      d = os.path.join(gopath, "src", self.settings.project_package)
+    for gopath in GoToolsSettings.Instance.gopath.split(":"):
+      d = os.path.join(gopath, "src", GoToolsSettings.Instance.project_package)
       if os.path.exists(d):
         proj_package_dir = d
         break
 
     if proj_package_dir == None:
-      self.logger.log("ERROR: couldn't find project package dir '"
-        + self.settings.project_package + "' in GOPATH: " + self.settings.gopath)
+      Logger.log("ERROR: couldn't find project package dir '"
+        + GoToolsSettings.Instance.project_package + "' in GOPATH: " + GoToolsSettings.Instance.gopath)
       return []
 
     packages = {}
 
-    for pkg_dir in self.settings.test_packages:
+    for pkg_dir in GoToolsSettings.Instance.test_packages:
       abs_pkg_dir = os.path.join(proj_package_dir, pkg_dir)
-      self.logger.log("searching for tests in: " + abs_pkg_dir)
+      Logger.log("searching for tests in: " + abs_pkg_dir)
       for root, dirnames, filenames in os.walk(abs_pkg_dir):
         for filename in fnmatch.filter(filenames, '*_test.go'):
           abs_test_file = os.path.join(root, filename)
           rel_test_file = os.path.relpath(abs_test_file, proj_package_dir)
-          test_pkg = os.path.join(self.settings.project_package, os.path.dirname(rel_test_file))
+          test_pkg = os.path.join(GoToolsSettings.Instance.project_package, os.path.dirname(rel_test_file))
           packages[test_pkg] = None
 
     return list(packages.keys())

gotools_format.py

@@ -11,32 +11,24 @@
 class GotoolsFormatOnSave(sublime_plugin.EventListener):
   def on_pre_save(self, view):
     if not GoBuffers.is_go_source(view): return
-
-    settings = GoToolsSettings()
-    if not settings.format_on_save:
-      return
-
+    if not GoToolsSettings.Instance.format_on_save: return
     view.run_command('gotools_format')
 
 class GotoolsFormat(sublime_plugin.TextCommand):
   def is_enabled(self):
     return GoBuffers.is_go_source(self.view)
 
   def run(self, edit):
-    self.settings = GoToolsSettings()
-    self.logger = Logger(self.settings)
-    self.runner = ToolRunner(self.settings, self.logger)
-
     command = ""
     args = []
-    if self.settings.format_backend == "gofmt":
+    if GoToolsSettings.Instance.format_backend == "gofmt":
       command = "gofmt"
       args = ["-e", "-s"]
-    elif self.settings.format_backend in ["goimports", "both"] :
+    elif GoToolsSettings.Instance.format_backend in ["goimports", "both"] :
       command = "goimports"
       args = ["-e"]
 
-    stdout, stderr, rc = self.runner.run(command, args, stdin=Buffers.buffer_text(self.view))
+    stdout, stderr, rc = ToolRunner.run(command, args, stdin=Buffers.buffer_text(self.view))
 
     # Clear previous syntax error marks
     self.view.erase_regions("mark")
@@ -48,10 +40,10 @@ def run(self, edit):
 
     if rc != 0:
       # Ermmm...
-      self.logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
+      Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
       return
 
-    if self.settings.format_backend == "both":
+    if GoToolsSettings.Instance.format_backend == "both":
       command = "gofmt"
       args = ["-e", "-s"]
       stdout, stderr, rc = self.runner.run(command, args, stdin=stdout.encode('utf-8'))
@@ -66,7 +58,7 @@ def run(self, edit):
 
     if rc != 0:
       # Ermmm...
-      self.logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
+      Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
       return
 
     # Everything's good, hide the syntax error panel
@@ -101,12 +93,12 @@ def show_syntax_errors(self, stderr):
     for error in stderr.splitlines():
       match = re.match("(.*):(\d+):(\d+):", error)
       if not match or not match.group(2):
-        self.logger.log("skipping unrecognizable error:\n" + error + "\nmatch:" + str(match))
+        Logger.log("skipping unrecognizable error:\n" + error + "\nmatch:" + str(match))
         continue
 
       row = int(match.group(2))
       pt = self.view.text_point(row-1, 0)
-      self.logger.log("adding mark at row " + str(row))
+      Logger.log("adding mark at row " + str(row))
       marks.append(sublime.Region(pt))
 
     if len(marks) > 0:

gotools_goto_def.py

@@ -18,9 +18,6 @@ def want_event(self):
     return True
 
   def run(self, edit, event=None):
-    self.settings = GoToolsSettings()
-    self.logger = Logger(self.settings)
-    self.runner = ToolRunner(self.settings, self.logger)
     sublime.set_timeout_async(lambda: self.godef(event), 0)
 
   def godef(self, event):
@@ -31,26 +28,26 @@ def godef(self, event):
     else:
       filename, row, col, offset, offset_end = Buffers.location_at_cursor(self.view)
 
-    backend = self.settings.goto_def_backend if self.settings.goto_def_backend else ""
+    backend = GoToolsSettings.Instance.goto_def_backend if GoToolsSettings.Instance.goto_def_backend else ""
     try:
       if backend == "oracle":
         file, row, col = self.get_oracle_location(filename, offset)
       elif backend == "godef":
         file, row, col = self.get_godef_location(filename, offset)
       else:
-        self.logger.log("Invalid godef backend '" + backend + "' (supported: godef, oracle)")
-        self.logger.status("Invalid godef configuration; see console log for details")
+        Logger.log("Invalid godef backend '" + backend + "' (supported: godef, oracle)")
+        Logger.status("Invalid godef configuration; see console log for details")
         return
     except Exception as e:
-     self.logger.status(str(e))
+     Logger.status(str(e))
      return
 
     if not os.path.isfile(file):
-      self.logger.log("WARN: file indicated by godef not found: " + file)
-      self.logger.status("godef failed: Please enable debugging and check console log")
+      Logger.log("WARN: file indicated by godef not found: " + file)
+      Logger.status("godef failed: Please enable debugging and check console log")
       return
 
-    self.logger.log("opening definition at " + file + ":" + str(row) + ":" + str(col))
+    Logger.log("opening definition at " + file + ":" + str(row) + ":" + str(col))
     w = self.view.window()
     new_view = w.open_file(file + ':' + str(row) + ':' + str(col), sublime.ENCODED_POSITION)
     group, index = w.get_view_index(new_view)
@@ -64,21 +61,21 @@ def get_oracle_location(self, filename, offset):
     # configured.
     # TODO: put into a utility
     package_scope = []
-    for p in self.settings.build_packages:
-      package_scope.append(os.path.join(self.settings.project_package, p))
-    for p in self.settings.test_packages:
-      package_scope.append(os.path.join(self.settings.project_package, p))
-    for p in self.settings.tagged_test_packages:
-      package_scope.append(os.path.join(self.settings.project_package, p))
+    for p in GoToolsSettings.Instance.build_packages:
+      package_scope.append(os.path.join(GoToolsSettings.Instance.project_package, p))
+    for p in GoToolsSettings.Instance.test_packages:
+      package_scope.append(os.path.join(GoToolsSettings.Instance.project_package, p))
+    for p in GoToolsSettings.Instance.tagged_test_packages:
+      package_scope.append(os.path.join(GoToolsSettings.Instance.project_package, p))
 
     if len(package_scope) > 0:
       args = args + package_scope
 
-    location, err, rc = self.runner.run("oracle", args)
+    location, err, rc = ToolRunner.run("oracle", args)
     if rc != 0:
       raise Exception("no definition found")
 
-    self.logger.log("oracle output:\n" + location.rstrip())
+    Logger.log("oracle output:\n" + location.rstrip())
 
     # godef is sometimes returning this junk as part of the output,
     # so just cut anything prior to the first path separator
@@ -94,11 +91,11 @@ def get_oracle_location(self, filename, offset):
     return [file, row, col]
 
   def get_godef_location(self, filename, offset):
-    location, err, rc = self.runner.run("godef", ["-f", filename, "-o", str(offset)])
+    location, err, rc = ToolRunner.run("godef", ["-f", filename, "-o", str(offset)])
     if rc != 0:
       raise Exception("no definition found")
 
-    self.logger.log("godef output:\n" + location.rstrip())
+    Logger.log("godef output:\n" + location.rstrip())
 
     # godef is sometimes returning this junk as part of the output,
     # so just cut anything prior to the first path separator