add builds, fix bugs, add key shortcuts and status

Author: ruby0x1

Context.sublime-menu

@@ -1,5 +1,6 @@
 [
-   { "id": "flow-set-project-window-space", "caption": "-" },
-   { "id": "flow-set-project-window", "command": "flow_set_project_file_window", "caption": "Set flow project ( this window )" },
-   // { "id": "flow-set-project-global", "command": "flow_set_project_file_global", "caption": "Set flow project ( all windows )" },
+   { "id": "flow-set-project-space", "caption": "-" },
+   { "id": "flow-show-status", "command": "flow_show_status", "caption": "flow status" },
+   { "id": "flow-set-project-file", "command": "flow_set_project_file", "caption": "Set as current flow project" },
+   { "id": "flow-set-target-build", "command": "flow_set_target_build", "caption": "Set build target" }
 ]

Default.sublime-keymap

@@ -0,0 +1,39 @@
+[
+    {
+        "keys": ["ctrl+shift+0"],
+        "command": "flow_show_status",
+        "context":
+        [
+            {
+                "key": "selector",
+                "operator": "equal",
+                "operand": "source.haxe,source.flow"
+            }
+        ]
+    },
+    {
+        "keys": ["ctrl+shift+9"],
+        "command": "flow_set_project_file",
+        "context":
+        [
+            {
+                "key": "selector",
+                "operator": "equal",
+                "operand": "source.flow"
+            }
+        ]
+    },
+    {
+        "keys": ["ctrl+shift+8"],
+        "command": "flow_set_target_build",
+        "context":
+        [
+            {
+                "key": "selector",
+                "operator": "equal",
+                "operand": "source.flow,source.haxe"
+            }
+        ]
+    }
+
+]

commands/__init__.py

@@ -1,10 +1,17 @@
 __version__ = "1.0.0"
 __version_info__ = (1, 0, 0)
 
-from .flow_project_set import FlowSetProjectFileWindow
+from .flow_set_project_file import FlowSetProjectFile
+from .flow_set_target_build import FlowSetTargetBuild
+from .flow_show_status import FlowShowStatus
+from .flow_run_build import FlowRunBuild, FlowDoBuild
 
 print("Flow : load commands")
 
 __all__ = [
-    'FlowSetProjectFileWindow'
+    'FlowSetProjectFile',
+    'FlowSetTargetBuild',
+    'FlowRunBuild',
+    'FlowDoBuild',
+    'FlowShowStatus'
 ]

commands/flow_run_build.py

@@ -0,0 +1,89 @@
+import sublime, sublime_plugin
+import sys, os, subprocess
+
+from ..flow import FlowProject, panel
+
+import Default
+stexec = getattr( Default , "exec" )
+ExecCommand = stexec.ExecCommand
+AsyncProcess = stexec.AsyncProcess
+
+
+print('flow / load run build')
+
+class FlowRunBuild( sublime_plugin.WindowCommand ):
+    def run(self):
+        view = self.window.active_view()
+
+        if not FlowProject.flow.flow_file:
+            self.window.run_command('flow_show_status')
+            print("[flow] build : no flow file")
+            return
+
+        _cmd = "run"
+
+        flow_cmd = [
+            "haxelib", "run", "flow",
+            _cmd, FlowProject.flow.target,
+            "--project", FlowProject.flow.flow_file
+        ]
+
+
+        if FlowProject.flow.build_debug:
+            flow_cmd.append('--debug')
+
+        if FlowProject.flow.build_verbose:
+            flow_cmd.append('--log')
+            flow_cmd.append('3')
+
+        print("[flow] build " + " ".join(flow_cmd))
+
+        self.window.run_command("flow_do_build", {
+            "cmd": flow_cmd
+        })
+
+class FlowDoBuild( ExecCommand ):
+
+    def run( self, cmd = [],  shell_cmd = None, file_regex = "", line_regex = "", working_dir = "",
+            encoding = None, env = {}, quiet = False, kill = False, **kwargs):
+
+        if kill:
+            if self.proc:
+                self.proc.kill()
+                self.proc = None
+                self.append_data(None, "[Cancelled]")
+            return
+
+        if encoding is None:
+            encoding = sys.getfilesystemencoding()
+
+        self.output_view = self.window.get_output_panel("exec")
+        self.debug_text = " ".join(cmd)
+        self.encoding = encoding
+        self.quiet = quiet
+        self.proc = None
+
+        if working_dir != "":
+            os.chdir(working_dir)
+
+        if not quiet:
+            print( "Running " + " ".join(cmd) )
+
+        sublime.status_message("Running build...")
+        self.show_output_panel()
+
+        try:
+            self.proc = AsyncProcess( cmd, None, os.environ.copy(), self, **kwargs)
+        except OSError as e:
+            print(e)
+
+    def show_output_panel(self):
+        show_panel_on_build = sublime.load_settings("Preferences.sublime-settings").get("show_panel_on_build", True)
+        if show_panel_on_build:
+            self.window.run_command("show_panel", {"panel": "output.exec"})
+
+    def finish(self, *args, **kwargs):
+
+        super(FlowDoBuild, self).finish(*args, **kwargs)
+        output = self.output_view.substr(sublime.Region(0, self.output_view.size()))
+        print(output)

commands/flow_project_set.py commands/flow_set_project_file.py

@@ -4,7 +4,7 @@
 
 print('flow / load set project file')
 
-class FlowSetProjectFileWindow( sublime_plugin.WindowCommand ):
+class FlowSetProjectFile( sublime_plugin.WindowCommand ):
     def run(self):
         view = self.window.active_view()
         FlowProject.flow.set_flow_file( view.file_name() )
@@ -13,7 +13,7 @@ def is_visible(self):
         view = self.window.active_view()
         pt = view.sel()[0].b
         scope = view.scope_name(pt)
-        print(scope)
+
         if not "source.flow" in scope:
             return False
         else:

commands/flow_set_target_build.py

@@ -0,0 +1,26 @@
+import sublime, sublime_plugin
+
+from ..flow import FlowProject, panel
+
+print('flow / load set build target')
+
+class FlowSetTargetBuild( sublime_plugin.WindowCommand ):
+    def run(self):
+        view = self.window.active_view()
+        panel(self.window, FlowProject.flow.get_targets(), self.on_target_select, 0, 1)
+
+    def on_target_select(self, index):
+        if index > 0:
+            FlowProject.flow.set_flow_target_by_index(index)
+
+    def is_visible(self):
+        view = self.window.active_view()
+        pt = view.sel()[0].b
+        scope = view.scope_name(pt)
+        if "source.flow" in scope:
+            if FlowProject.flow.flow_file:
+                return True
+
+        return False
+
+

commands/flow_show_status.py

@@ -0,0 +1,41 @@
+import sublime, sublime_plugin
+
+from ..flow import FlowProject, panel
+
+print('flow / load show status')
+
+class FlowShowStatus( sublime_plugin.WindowCommand ):
+    def run(self):
+        view = self.window.active_view()
+        panel(self.window, FlowProject.flow.get_status(), self.on_select)
+
+    def on_select(self, index):
+
+            #the flow file
+        if index == 0:
+            if FlowProject.flow.flow_file:
+                self.window.open_file(FlowProject.flow.flow_file)
+
+            #debug flag
+        if index == 2:
+            if FlowProject.flow.build_debug:
+                FlowProject.flow.build_debug = False
+            else:
+                FlowProject.flow.build_debug = True
+
+            #verbose flag
+        if index == 3:
+            if FlowProject.flow.build_verbose:
+                FlowProject.flow.build_verbose = False
+            else:
+                FlowProject.flow.build_verbose = True
+
+    def is_visible(self):
+        view = self.window.active_view()
+        pt = view.sel()[0].b
+        scope = view.scope_name(pt)
+
+        if "source.flow" in scope or "source.haxe" in scope:
+            return True
+        else:
+            return False

flow.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-import sys, os, subprocess, codecs, shutil, json
+import sys, os, subprocess, shutil, json
 
 import sublime, sublime_plugin
 from .haxe_parse_completion_list import *
@@ -17,6 +17,8 @@ def run_process( args ):
     #startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
     return subprocess.Popen(args, stdout=subprocess.PIPE, startupinfo=startupinfo).communicate()[0]
 
+def panel(_window, options, done, flags=0, sel_index=0, on_highlighted=None):
+    sublime.set_timeout(lambda: _window.show_quick_panel(options, done, flags, sel_index, on_highlighted), 10)
 
 
 class FlowCompletionCallbackCommand( sublime_plugin.WindowCommand  ):
@@ -34,9 +36,15 @@ def __init__(self):
 
         self.flow_path = "flow"
         self.flow_file = ""
+        self.target = ""
         self.info_json = None
         self.completion_data = None
 
+        self.system = self.get_system()
+        self.target = self.system
+        self.build_debug = False
+        self.build_verbose = False
+
     def __del__(self):
         print("[flow] __del__")
         FlowProject.flow = None
@@ -46,22 +54,26 @@ def __del__(self):
         del FlowProject.flow
         del self
 
+
     def set_flow_file( self, file_name ):
         print("[flow] set flow file to " + file_name)
         sublime.status_message('set flow file to ' + file_name)
+
         self.flow_file = file_name
         self.refresh_info()
 
+    def set_flow_target_by_index( self, index ):
+        _targets = self.get_targets()
+        _target = _targets[index]
+        self.target = _target[0].lower()
+        print("[flow] set build target to " + self.target)
 
     def refresh_info(self):
         print("[flow] refresh info/hxml on " + self.flow_file)
 
         self.info_json_src = run_process([
-            "haxelib",
-            "run",
-            "flow",
-            "info",
-            "--project", self.flow_file
+            "haxelib", "run", "flow",
+            "info", "--project", self.flow_file
         ]).decode("utf-8");
 
         if self.info_json_src:
@@ -190,7 +202,62 @@ def on_modified_async(self, view):
             fname = view.file_name()
             self.completion(view, fname)
 
+    def get_status(self):
+
+        _result = []
+
+        if self.flow_file:
+            _result.append(['flow file', self.flow_file])
+        else:
+            _result.append(['no flow file', 'specify a flow file first'])
+            return _result
+
+        if self.target:
+            _result.append(['flow target', self.target])
+        else:
+            _result.append(['flow target', self.system])
+
+        _result.append(['Toggle debug build', "currently debug : " + str(self.build_debug).lower() ])
+        _result.append(['Toggle verbose build', "currently verbose : " + str(self.build_verbose).lower() ])
+
+        return _result
+
+    def get_system(self):
+
+        _result = ""
+        _system = sys.platform
+
+        if _system == "win32" or _system == "cygwin":
+            _result = "windows"
+        elif _system == "darwin":
+            _result = "mac"
+        else:
+            _system = "linux"
+
+        return _result
+
+
+    def get_targets(self):
+
+        _result = []
+
+        if not self.flow_file:
+            return _result
+
+        _result.append(['Mac', 'desktop, native mac app'])
+        _result.append(['Linux', 'desktop, native linux app'])
+        _result.append(['Windows', 'desktop, native windows app'])
+        _result.append(['Android', 'mobile, native android app'])
+        _result.append(['iOS', 'mobile, native ios project'])
+        _result.append(['Web', 'web, web based app'])
+
+        _invalid = self.info_json['targets_invalid']
+
+        _result[:] = [_item for _item in _result if not _item[0].lower() in _invalid ]
+
+        _result.insert(0, ['unavailable from ' + self.system, ", ".join(_invalid) ])
 
+        return _result
 
 print("[flow] hello flow")
 from .commands import *

flow.sublime-build

@@ -1,3 +1,3 @@
 {
-    "cmd": ["haxelib","run","flow","run"]
+    "target": "flow_run_build"
 }