redcar-dev 0.12.17dev

data/plugins/runnables/lib/runnables.rb

@@ -0,0 +1,180 @@
+require 'runnables/command_output_controller'
+require 'runnables/commands'
+require 'runnables/output_processor'
+require 'runnables/running_process_checker'
+require 'runnables/tree_mirror/nodes/runnable'
+require 'runnables/tree_mirror/nodes/runnable_group'
+require 'runnables/tree_mirror/nodes/runnable_type_group'
+require 'runnables/tree_mirror/tree_controller'
+require 'runnables/tree_mirror/tree_mirror'
+
+module Redcar
+  class Runnables
+    TREE_TITLE          = "Runnables"
+    PARAMS              = "__PARAMS__"
+    DISPLAY_PARAMS      = "__?__"
+    DISPLAY_NEXT_PARAMS = "_____"
+    LINE_HOLDER         = "__LINE__"
+    PATH_HOLDER         = "__PATH__"
+    NAME_HOLDER         = "__NAME__"
+
+    def self.run_process(path, command, title, output = "tab")
+      window = Redcar.app.focussed_window
+      command = Runnables.substitute_variables(window,command)
+      return unless command
+      if Runnables.storage['save_project_before_running'] == true
+        window.notebooks.each do |notebook|
+          notebook.tabs.each do |tab|
+            tab.edit_view.document.save! if tab.is_a?(EditTab) and tab.edit_view.document.modified?
+          end
+        end
+      end
+      controller = CommandOutputController.new(path, command, title)
+      if output == "none"
+        controller.run
+      else
+        if tab = previous_tab_for(command)
+          tab.html_view.controller.run
+          tab.focus
+        else
+          if output == "window"
+            Redcar.app.new_window
+          end
+          tab = window.new_tab(HtmlTab)
+          tab.html_view.controller = controller
+          tab.icon = :cog
+          tab.focus
+        end
+      end
+    end
+
+    # Replaces placeholders in commands with values, like __PATH__,
+    # __LINE__, __NAME__ and __PARAMS__
+    def self.substitute_variables(window,command)
+      tab = window.focussed_notebook_tab
+      if tab and tab.is_a?(EditTab)
+        if command.include?(PATH_HOLDER)
+          path = tab.edit_view.document.path
+          command.gsub!(PATH_HOLDER, path)
+          if command.include?(LINE_HOLDER)
+            line = tab.edit_view.document.cursor_line + 1
+            command.gsub!(LINE_HOLDER, line.to_s)
+          end
+        end
+        if command.include?(NAME_HOLDER)
+          name = File.basename(tab.edit_view.document.path)
+          idx  = name.rindex(".") if name.include?(".")
+          name = name[0,idx] if idx
+          command.gsub!(NAME_HOLDER, name.to_s)
+        end
+      end
+      while command.include?(PARAMS)
+        msg = command.sub(PARAMS,DISPLAY_PARAMS)
+        msg = msg.gsub(PARAMS,DISPLAY_NEXT_PARAMS)
+        msg = "" if msg == DISPLAY_PARAMS
+        msg_title = "Enter Command Parameters"
+        out = Redcar::Application::Dialog.input(msg_title,msg)
+        params = out[:value] || ""
+        return if out[:button] == :cancel
+        command = command.sub(PARAMS,params)
+      end
+      command
+    end
+
+    def self.file_mappings(project)
+      file_runners = []
+      if project
+        runnable_file_paths = project.config_files("runnables/*.json")
+        runnable_file_paths.each do |path|
+          json = File.read(path)
+          this_file_runners = JSON(json)["file_runners"]
+          file_runners += this_file_runners || []
+        end
+      end
+      file_runners
+    end
+
+    def self.previous_tab_for(command)
+      Redcar.app.all_tabs.detect do |t|
+        t.respond_to?(:html_view) &&
+        t.html_view.controller.is_a?(CommandOutputController) &&
+        t.html_view.controller.cmd == command
+      end
+    end
+
+    def self.keymaps
+      linwin = Keymap.build("main", [:linux, :windows]) do
+        link "Ctrl+Alt+Shift+R", Runnables::ShowRunnables
+        link "Ctrl+R", Runnables::RunEditTabCommand
+        link "Ctrl+Alt+R", Runnables::RunAlternateEditTabCommand
+      end
+
+      osx = Keymap.build("main", :osx) do
+        link "Cmd+Alt+Shift+R", Runnables::ShowRunnables
+        link "Cmd+R", Runnables::RunEditTabCommand
+        link "Cmd+Alt+R", Runnables::RunAlternateEditTabCommand
+      end
+      [linwin,osx]
+    end
+
+    def self.menus
+      Menu::Builder.build do
+        sub_menu "Project" do
+          group(:priority => 15) {
+            separator
+            item "Runnables", Runnables::ShowRunnables
+            item "Run Tab",   Runnables::RunEditTabCommand
+            item "Alternate Run Tab", Runnables::RunAlternateEditTabCommand
+            separator
+          }
+        end
+      end
+    end
+
+    def self.runnables_context_menus(node)
+      Menu::Builder.build do
+        if not node.nil? and node.is_a?(Runnable)
+          item("Run with parameters") do
+            AppendParamsAndRunCommand.new(node).run
+          end
+        end
+      end
+    end
+
+    def self.toolbars
+      ToolBar::Builder.build do
+        item "Runnables", :command => Runnables::ShowRunnables, :icon => File.join(Redcar.icons_directory,"cog.png"), :barname => :project
+        item "Run Tab", :command => Runnables::RunEditTabCommand, :icon => File.join(Redcar.icons_directory, "control.png"), :barname => :project
+      end
+    end
+
+    def self.storage
+      @storage ||= begin
+        storage = Plugin::Storage.new('runnables')
+        storage.set_default('save_project_before_running', false)
+        storage
+      end
+    end
+
+    def self.quit_guard
+      Runnables::RunningProcessChecker.new(
+        Redcar.app.all_tabs.select {|t| t.is_a?(HtmlTab)},
+        "Kill all and quit?"
+      ).check
+    end
+
+    def self.close_window_guard(win)
+      Runnables::RunningProcessChecker.new(
+        win.notebooks.map(&:tabs).flatten.select {|t| t.is_a?(HtmlTab)},
+        "Kill them and close the window?"
+      ).check
+    end
+
+    def self.project_closed(project,window)
+        rtree = window.treebook.trees.detect { |t|
+          t.tree_mirror.is_a? Runnables::TreeMirror
+        }
+        rtree.close if rtree
+      end
+  end
+end

data/plugins/runnables/lib/runnables/command_output_controller.rb

@@ -0,0 +1,183 @@
+
+module Redcar
+  class Runnables
+    class CommandOutputController
+      include Redcar::HtmlController
+      
+      attr_accessor :cmd
+
+      def initialize(path, cmd, title)
+        @path = path
+        @cmd = cmd
+        @title = title
+        @output_id = 0
+      end
+      
+      def title
+        @title
+      end
+      
+      def ask_before_closing
+        if @pid
+          "This tab contains an unfinished process. \n\nKill the process and close?"
+        end
+      end
+      
+      def close
+        if @pid
+          Process.kill(9, @pid.to_i + 1)
+        end
+      end
+      
+      def run
+        case Redcar.platform
+        when :osx, :linux
+          cmd = "sh -c \"cd #{@path}; #{@cmd}\""
+        when :windows
+          cmd = "cd \"#{@path.gsub('/', '\\')}\" & #{@cmd}"
+        end
+        run_command(cmd)
+      end
+      
+      def copy_output(text)
+        Redcar.app.clipboard << text
+      end
+
+      def stylesheet_link_tag(*files)
+        files.map do |file|
+          path = File.join(Redcar.root, %w(plugins runnables views) + [file.to_s + ".css"])
+          url = "file://" + File.expand_path(path)
+          %Q|<link href="#{url}" rel="stylesheet" type="text/css" />|
+        end.join("\n")
+      end
+      
+      def process(text)
+        @processor ||= OutputProcessor.new
+        @processor.process(text)
+      end
+      
+      def output_thread(type, output)
+        Thread.new(output) do
+          instance_variable_set("@#{type}_thread_started", true)
+          begin
+            while line = output.gets
+              append_output %Q|<div class="#{type}">#{process(line)}</div>|
+            end
+          rescue => e
+            puts e.class
+            puts e.message
+            puts e.backtrace
+          end
+        end
+      end
+      
+      def run_command(cmd)
+        Thread.new do
+          execute <<-JS
+            $('.actions').hide();
+            $('.output').slideUp().prev('.header').addClass('up');
+          JS
+          
+          # TODO: Find browser's onload rather than sleeping
+          sleep 1
+          start_output_block
+          Redcar.log.info "Running: #{cmd}"
+          
+          # JRuby-specific
+          @pid, input, output, error = IO.popen4(cmd)
+          @stdout_thread = output_thread(:stdout, output)
+          @stderr_thread = output_thread(:stderr, error)
+          
+          Thread.new do
+            sleep 0.1 until finished?
+            @pid = nil
+            end_output_block
+          end
+        end
+      end
+      
+      def finished?
+        @stdout_thread_started && @stderr_thread_started &&
+          !@stdout_thread.alive? && !@stderr_thread.alive?
+      end
+      
+      def format_time(time)
+        time.strftime("%I:%M:%S %p").downcase
+      end
+
+      def start_output_block
+        @start = Time.now
+        @output_id += 1
+        append_to_container <<-HTML
+          <div class="process running">
+            <div id="header#{@output_id}" class="header" onclick="$(this).toggleClass('up').next().slideToggle();">
+              <span class="in-progress-message">Started at #{format_time(@start)}</span>
+            </div>
+            <div id="output#{@output_id}" class="output"></div>
+          </div>
+        HTML
+      end
+
+      def end_output_block
+        @end = Time.now
+        append_to(header_container, <<-HTML)
+          <span class="completed-message">
+            Completed at #{format_time(@end)}. (Took #{@end - @start} seconds)
+          </span>
+        HTML
+        execute <<-JS
+          $('<a href="#" class="copy">Copy output to clipboard</a>').click(function () {
+            Controller.copyOutput($("#{output_container}").text());
+            return false;
+          }).appendTo('#{header_container}');
+          $("#{output_container}").parent().removeClass("running");
+          $('.actions').show();
+          $("html, body").attr({ scrollTop: $("body").attr("scrollHeight") });
+        JS
+      end
+
+      def scroll_to_end(container)
+        execute <<-JS
+          $("html, body").attr({ scrollTop: $("body").attr("scrollHeight") });
+        JS
+      end
+      
+      def append_to(container, html)
+        execute(<<-JS)
+          $(#{html.inspect}).appendTo("#{container}");
+        JS
+      end
+
+      def append_to_container(html)
+        append_to("#container", html)
+        scroll_to_end("#container")
+      end
+
+      def header_container
+        "#header#{@output_id}"
+      end
+
+      def output_container
+        "#output#{@output_id}"
+      end
+
+      def append_output(output)
+        append_to(output_container, output)
+        scroll_to_end(output_container)
+      end
+
+      def open_file(file, line)
+        Project::Manager.open_file(File.join(Project::Manager.focussed_project.path, file))
+        Redcar.app.focussed_window.focussed_notebook_tab.edit_view.document.scroll_to_line(line.to_i)
+      end
+      
+      def index
+        rhtml = ERB.new(File.read(File.join(File.dirname(__FILE__), "..", "..", "views", "command_output.html.erb")))
+        command = @cmd
+        run
+        rhtml.result(binding)
+      end
+    end
+  end
+end
+

data/plugins/runnables/lib/runnables/commands.rb

@@ -0,0 +1,82 @@
+
+module Redcar
+  class Runnables
+    class AppendParamsAndRunCommand < Redcar::Command
+      def initialize(node)
+        @node = node
+      end
+
+      def execute
+        command = @node.command
+        command = "#{command} #{PARAMS}" unless command =~ /#{PARAMS}$/
+        Runnables.run_process(@node.path, command, @node.text, @node.output)
+      end
+    end
+
+    class ShowRunnables < Redcar::Command
+      sensitize :open_project
+      def execute
+        if tree = win.treebook.trees.detect {|tree| tree.tree_mirror.title == TREE_TITLE }
+          tree.refresh
+          win.treebook.focus_tree(tree)
+        else
+          project = Project::Manager.in_window(win)
+          tree = Tree.new(
+              TreeMirror.new(project),
+              TreeController.new(project,TREE_TITLE)
+            )
+          win.treebook.add_tree(tree)
+        end
+      end
+    end
+
+    class RunEditTabCommand < Redcar::DocumentCommand
+      sensitize :open_project, :focussed_committed_mirror
+      def execute
+        project = Project::Manager.in_window(win)
+        f = Runnables.file_mappings(project).detect do |file_mapping|
+          regex = Regexp.new(file_mapping["regex"])
+          doc.mirror.path =~ regex
+        end
+        run_tab(project.home_dir,tab, f) if f
+      end
+
+      def run_tab(project_path,tab, file_mapping)
+        command = file_mapping["command"]
+        output = file_mapping["output"]
+        path = tab.edit_view.document.mirror.path
+        output = "tab" if output.nil?
+        Runnables.run_process(project_path,command, "Running #{File.basename(path)}", output)
+      end
+    end
+
+    class RunAlternateEditTabCommand < RunEditTabCommand
+      sensitize :open_project
+      def initialize
+        @default   = nil
+        @alternate = nil
+      end
+
+      def execute
+        project = Project::Manager.in_window(win)
+        i = 0
+        Runnables.file_mappings(project).each do |f|
+          regex = Regexp.new(f["regex"])
+          if tab.edit_view.document.mirror.path =~ regex
+            if i == 0
+              @default = f
+            elsif i == 1
+              @alternate = f
+            end
+            i = i + 1 #increment only for matches
+          end
+        end
+        if @alternate
+          run_tab(project.home_dir,tab, @alternate)
+        elsif @default
+          run_tab(project.home_dir,tab, @default)
+        end
+      end
+    end
+  end
+end

data/plugins/runnables/lib/runnables/output_processor.rb

@@ -0,0 +1,74 @@
+module Redcar
+  class Runnables
+    class OutputProcessor
+      # From TextMate's Support/lib/escape.rb
+      # Make string suitable for display as HTML, preserve spaces. Set :no_newline_after_br => true
+      # to cause “\n” to be substituted by “<br>” instead of “<br>\n”
+      def process(str, opts = {})
+        str = str.to_s.gsub("&", "&amp;").gsub("<", "&lt;")
+        str = process_ansi(str)
+        str = process_file_line_numbers(str)
+        str = str.gsub(/\t+/, '<span style="white-space:pre;">\0</span>')
+        str = str.reverse.gsub(/ (?= |$)/, ';psbn&').reverse
+        if opts[:no_newline_after_br].nil?
+          str = str.gsub("\n", "<br>\n")
+        else
+          str = str.gsub("\n", "<br>")
+        end
+      end
+      
+      def process_file_line_numbers(str)
+        file_number_regex = /(\S+)\:(\d+)/
+        if str =~ file_number_regex
+          str.gsub(file_number_regex,
+            %{<a class="file_line_link" href="javascript:Controller.openFile('#{$1}', '#{$2}');">#{$1}:#{$2}</a>})
+        else
+          str
+        end
+      end
+    
+      def initialize
+        @ansi_stack = []
+        @ansi_colors = %w(black red green yellow blue purple cyan gray)
+      end
+      
+      def color(num)
+        @ansi_colors[num.to_i]
+      end
+
+      def close_ansi_spans(clear = false)
+        stack_length = @ansi_stack.size
+        @ansi_stack = [] if clear
+        "</span>" * stack_length
+      end
+
+      def ansi_span(style)
+        %Q|<span class="#{style}">|
+      end
+
+      def restart_ansi_spans
+        @ansi_stack.map do |style|
+          ansi_span(style)
+        end.join('')
+      end
+
+      def process_ansi(str)
+        restart_ansi_spans + str.gsub(/\e\[(([0,1]);?)?((\d)(\d))?m/) do |m|
+          match = $~
+          if match[2] == "0" && match[4].nil?
+            close_ansi_spans(:clear)
+          else
+            style = ""
+            style << "ansi-regular "               if match[2] == "0"
+            style << "ansi-bold "                  if match[2] == "1"
+            style << "ansi-light "                 if match[4] == "9"
+            style << "ansi-on-#{color(match[5])} " if match[4] == "4"
+            style << "ansi-#{color(match[5])}"     if match[4] == "3" || match[4] == "9"
+            @ansi_stack << style unless style.empty?
+            ansi_span(style)
+          end
+        end + close_ansi_spans
+      end
+    end
+  end
+end