redcar 0.3.10.1dev → 0.4

data/plugins/redcar_debug/lib/redcar_debug.rb

@@ -18,6 +18,13 @@ module Redcar
       end
     end
     
+    def self.loaded
+      if ARGV.include?('--profile')
+        # #run causes errors since we're still loading.
+        StartProfilingCommand.new.execute
+      end
+    end
+    
     class << self
       attr_accessor :profiling_result
     end

data/plugins/runnables/features/command_tree.feature

@@ -0,0 +1,25 @@
+Feature: Showing commands in a command tree
+
+  Background:
+    When I will choose "plugins/runnables/features/fixtures" from the "open_directory" dialog
+    And I open a directory
+
+  Scenario: Shows grouped commands from .redcar/runnables/*.json in the project
+    When I open the runnables tree
+    Then I should see "fixture_runnables" in the tree
+  
+  Scenario: Shows individual commands in groups
+    When I open the runnables tree
+    And I expand the tree row "fixture_runnables"
+    Then I should see "An app" in the tree
+
+  Scenario: I can manually refresh the tree
+    When I open the runnables tree
+    And I change the command to "A changed app"
+    And I open the runnables tree
+    And I expand the tree row "fixture_runnables"
+    Then I should see "A changed app" in the tree
+
+  # TODO: Refresh on window changes
+  # TODO: preserve expanding when refreshing
+  # Example of these are available in refresh_directory_tree.feature

data/plugins/runnables/features/run_command_tab.feature

@@ -0,0 +1,46 @@
+Feature: Running commands in a tab
+
+  Background:
+    When I will choose "plugins/runnables/features/fixtures" from the "open_directory" dialog
+    And I open a directory
+
+  Scenario: Running a command from the tree
+    When I open the runnables tree
+    And I expand the tree row "fixture_runnables"
+    And I activate the "An app" node in the tree
+    Then my active tab should be "An app"
+    And the HTML tab should say "hello world"
+    
+  Scenario: Running a command based on a file name
+    Given I have opened "plugins/runnables/features/fixtures/runnable_app.rb"
+    And I run the command Redcar::Runnables::RunEditTabCommand
+    Then my active tab should be "Running runnable_app.rb"
+    And the HTML tab should say "hello world"
+
+  Scenario: Running a command without output
+    Given I have opened "plugins/runnables/features/fixtures/runnable_app.rb"
+    And I open the runnables tree
+    And I expand the tree row "fixture_runnables"
+    And I activate the "A silent app" node in the tree
+    Then my active tab should be "runnable_app.rb"
+  
+  Scenario: Running a command with windowed output
+    Given I open the runnables tree
+    And I expand the tree row "fixture_runnables"
+    And I note the number of windows
+    And I activate the "A windowed app" node in the tree
+    Then I should see 1 more window
+    And the HTML tab should say "hello world"
+  
+  Scenario: Re-running a command with windowed output
+    Given I open the runnables tree
+    And I expand the tree row "fixture_runnables"
+    And I note the number of windows
+    And I activate the "A windowed app" node in the tree
+    And the HTML tab says "hello world"
+    And I go back to the "fixtures" window
+    And I activate the "A windowed app" node in the tree
+    Then I should see 1 more window
+    And the HTML tab should say "hello world"
+    
+  

data/plugins/runnables/features/step_definitions/runnable_steps.rb

@@ -0,0 +1,22 @@
+When /^I open the runnables tree$/ do
+  Redcar::Runnables::ShowRunnables.new.run
+end
+
+When /^I change the command to "([^"]*)"$/ do |name|
+  current = File.read(runnable_config)
+  File.open(runnable_config, 'w') do |f|
+    f.print current.gsub("An app", name)
+  end
+end
+
+When /^I go back to the "([^"]*)" window$/ do |title|
+  Redcar.app.windows.detect { |w| w.title == title }.focus
+end
+
+When /^I note the number of windows$/ do
+  @windows = Redcar.app.windows.size
+end
+
+Then /^I should see (\d+) more windows?$/ do |window_count|
+  Redcar.app.windows.size.should == (@windows + window_count.to_i)
+end

data/plugins/runnables/features/support/env.rb

@@ -0,0 +1,67 @@
+RequireSupportFiles File.dirname(__FILE__) + "/../../../edit_view/features/"
+RequireSupportFiles File.dirname(__FILE__) + "/../../../project/features/"
+RequireSupportFiles File.dirname(__FILE__) + "/../../../html_view/features/"
+
+def runnable_fixtures
+  File.expand_path(File.dirname(__FILE__) + "/../fixtures")
+end
+
+def runnable_config
+  "#{runnable_fixtures}/.redcar/runnables/fixture_runnables.json"
+end
+
+def reset_runnable_fixtures
+  # Not sure why this is needed, perhaps next test is starting before full deletion?
+  FileUtils.rm_rf runnable_fixtures
+  FileUtils.mkdir runnable_fixtures
+  FileUtils.mkdir_p File.dirname(runnable_config)
+  
+  File.open("#{runnable_fixtures}/runnable_app.rb", 'w') do |f|
+    f.puts %Q|puts "hello world"|
+  end
+  
+  File.open(runnable_config, 'w') do |f|
+    f.print <<-EOS
+      {
+        "commands":[
+          {
+            "name":        "An app",
+            "command":     "ruby runnable_app.rb",
+            "description": "Runs the app",
+            "type":        "task/ruby"
+            },
+          {
+            "name":        "A silent app",
+            "command":     "ruby runnable_app.rb",
+            "description": "Runs the app silently",
+            "type":        "task/ruby",
+            "output":      "none"
+          },
+          {
+            "name":        "A windowed app",
+            "command":     "ruby runnable_app.rb",
+            "description": "Runs the app in a window",
+            "type":        "task/ruby",
+            "output":      "window"
+          }
+        ],
+        "file_runners":[
+          {
+            "regex":   ".*\\.rb",
+            "name":    "Run as ruby",
+            "command": "ruby __PATH__",
+            "type":    "app/ruby"
+          }
+        ]
+      }
+    EOS
+  end
+end
+
+Before do
+  reset_runnable_fixtures
+end
+
+After do
+  FileUtils.rm_rf runnable_fixtures
+end

data/plugins/runnables/lib/runnables.rb

@@ -23,17 +23,37 @@ module Redcar
       end
       controller = CommandOutputController.new(path, command, title)
       if output == "none"
-        controller.run
-      else #default to new tab
-        if output == "window"
-          Project::Manager.open_project_for_path(".")
-        end
-        tab = Redcar.app.focussed_window.new_tab(HtmlTab)
-        tab.html_view.controller = controller
-        tab.focus
+        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 = Redcar.app.focussed_window.new_tab(HtmlTab)
+          tab.html_view.controller = controller
+          tab.focus
+        end        
+      end
+    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
+      map = Keymap.build("main", [:osx, :linux, :windows]) do
+        link "Ctrl+R", Runnables::RunEditTabCommand
+      end
+      [map, map]
+    end
+
     def self.menus
       Menu::Builder.build do
         sub_menu "Project", :priority => 15 do
@@ -49,9 +69,25 @@ module Redcar
     class TreeMirror
       include Redcar::Tree::Mirror
       
+      attr_accessor :last_loaded
+
       def initialize(project)
-        runnable_file_paths = project.config_files("runnables/*.json")
-        
+        @project = project
+      end
+
+      def runnable_file_paths
+        @project.config_files("runnables/*.json")
+      end
+
+      def last_updated
+        runnable_file_paths.map{ |p| File.mtime(p) }.max
+      end
+
+      def changed?
+        !last_loaded || last_loaded < last_updated
+      end
+
+      def load
         groups = {}
         runnable_file_paths.each do |path|
           runnables = []
@@ -63,20 +99,20 @@ module Redcar
         end
 
         if groups.any?
-          @top = groups.map do |name, runnables|
+          groups.map do |name, runnables|
             RunnableGroup.new(name,runnables)
           end
         else
-          @top = [HelpItem.new]
+          [HelpItem.new]
         end
       end
-      
+
       def title
         TREE_TITLE
       end
-      
+
       def top
-        @top
+        load
       end
     end
 
@@ -193,6 +229,7 @@ module Redcar
     class ShowRunnables < Redcar::Command
       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)
@@ -229,9 +266,9 @@ module Redcar
             if output.nil?
 	            output = "tab"
             end
-            command = command_schema.gsub("__PATH__", tab.edit_view.document.mirror.path)
-            puts command
-            Runnables.run_process(project.home_dir,command, "Run File", output)
+            path = tab.edit_view.document.mirror.path
+            command = command_schema.gsub("__PATH__", path)
+            Runnables.run_process(project.home_dir,command, "Running #{File.basename(path)}", output)
           end
         end
       end

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

@@ -4,10 +4,13 @@ module Redcar
     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
@@ -27,6 +30,10 @@ module Redcar
       end
       
       def run
+        execute <<-JS
+          $('.output').slideUp().prev('.header').addClass('up');
+        JS
+
         case Redcar.platform
         when :osx, :linux
           run_posix
@@ -50,60 +57,107 @@ module Redcar
       
       def run_windows
         @thread = Thread.new do
-          output = `cd #{@path} & #{@cmd} 2>&1`
-          html=<<-HTML
-          <div class="stdout">
+          begin
+            start_output_block
+            output = `cd #{@path} & #{@cmd} 2>&1`
+            append_output <<-HTML
+            <div class="stdout">
             #{process(output)}
-          </div>
-          HTML
-          execute(<<-JAVASCRIPT)
-            $("#output").append(#{html.inspect});
-            $("html, body").attr({ scrollTop: $("#output").attr("scrollHeight") }); 
-          JAVASCRIPT
+            </div>
+            HTML
+            end_output_block
+          rescue => e
+            puts e.class
+            puts e.message
+            puts e.backtrace
+          end
         end
       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
+          $("#{output_container}").parent().removeClass("running");
+        JS
+      end
+
+      def scroll_to_end(container)
+        execute <<-JS
+          $("html, body").attr({ scrollTop: $("#{container}").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 run_posix
         @thread = Thread.new do
           sleep 1
           @shell = Session::Shell.new
           @shell.outproc = lambda do |out|
-            html=<<-HTML
+            append_output <<-HTML
               <div class="stdout">
                 #{process(out)}
               </div>
             HTML
-            execute(<<-JAVASCRIPT)
-              $("#output").append(#{html.inspect});
-              $("html, body").attr({ scrollTop: $("#output").attr("scrollHeight") }); 
-           JAVASCRIPT
           end
           @shell.errproc = lambda do |err|
-            html=<<-HTML
+            append_output <<-HTML
               <div class="stderr">
-                <pre>#{err}</pre>
+                #{process(err)}
               </div>
             HTML
-            execute(<<-JAVASCRIPT)
-              $("#output").append(#{html.inspect});
-              $("html, body").attr({ scrollTop: $("#output").attr("scrollHeight") }); 
-            JAVASCRIPT
           end
           begin
+            start_output_block
             @shell.execute("cd #{@path}; " + @cmd)
+            end_output_block
           rescue => e
             puts e.class
             puts e.message
             puts e.backtrace
           end
-          html=<<-HTML
-          <hr />
-          <small><strong>Process finished</strong></small>
-          HTML
-          execute(<<-JAVASCRIPT)
-            $("#output").append(#{html.inspect});
-            $("html, body").attr({ scrollTop: $("#output").attr("scrollHeight") }); 
-          JAVASCRIPT
           @shell = nil
           @thread = nil
         end