redcar-dev 0.12.17dev

data/plugins/macros/features/step_definitions/prediction_steps.rb

@@ -0,0 +1,8 @@
+When /^I press predict$/ do
+  Redcar::Macros::PredictCommand.new.run
+end
+
+When /^I press alternate predict$/ do
+  Redcar::Macros::AlternatePredictCommand.new.run
+end
+

data/plugins/macros/lib/macros.rb

@@ -0,0 +1,167 @@
+
+require 'macros/action_sequence'
+require 'macros/commands'
+require 'macros/macro'
+require 'macros/manager_controller'
+
+require 'macros/predictive/sequence_finder'
+require 'macros/predictive/document_controller'
+
+module Redcar
+  module Macros
+    DONT_RECORD_COMMANDS = [StartStopRecordingCommand, RunLastCommand, NameLastMacroCommand]
+    
+    def self.recording
+      @recording ||= {}
+    end
+    
+    def self.session_macros
+      @session_macros ||= []
+    end
+      
+    def self.saved_macros
+      @saved_macros ||= storage['saved_macros']
+    end
+    
+    def self.save_macro(macro)
+      saved_macros << macro
+      update_storage
+    end
+    
+    def self.update_storage
+      storage['saved_macros'] = saved_macros
+    end
+    
+    class << self
+      attr_accessor :last_run
+      attr_accessor :last_run_or_recorded
+    end
+    
+    def self.storage
+      @storage ||= begin
+        storage = Plugin::Storage.new('macros')
+        storage.set_default('saved_macros', [])
+        storage
+      end
+    end
+    
+    def self.name_macro(macro_name, msg)
+      if macro = Macros.session_macros.detect {|m| m.name == macro_name }
+        result = Application::Dialog.input("Macro Name", 
+              msg, macro.name)
+        if result[:button] == :ok
+          macro.name = result[:value]
+          Macros.session_macros.delete(macro)
+          Macros.save_macro(macro)
+          Redcar.app.repeat_event(:macro_named)
+        end
+      end
+    end
+    
+    def self.rename_macro(macro_name)
+      if macro = Macros.saved_macros.detect {|m| m.name == macro_name }
+        result = Application::Dialog.input("Macro Name", 
+              "Rename macro:", macro.name)
+        if result[:button] == :ok
+          macro.name = result[:value]
+          update_storage
+          Redcar.app.repeat_event(:macro_named)
+        end
+      end
+    end
+    
+    def self.delete_macro(macro_name)
+      if macro = Macros.saved_macros.detect {|m| m.name == macro_name }
+        Macros.saved_macros.delete(macro)
+        update_storage
+      elsif macro = Macros.session_macros.detect {|m| m.name == macro_name }
+        Macros.session_macros.delete(macro)
+      end
+    end
+    
+    def self.menus
+      Menu::Builder.build do
+        sub_menu "Plugins" do
+          sub_menu "Macros" do
+            item lambda {
+                if Macros.recording[EditView.focussed_edit_view]
+                  "Stop Recording"
+                else
+                  "Start Recording"
+                end
+              }, StartStopRecordingCommand
+            item "Run Last", RunLastCommand
+            item "Name and Save Last Recorded", NameLastMacroCommand
+            separator
+            item "Macro Manager", MacroManagerCommand
+            lazy_sub_menu "New" do
+              Macros.session_macros.reverse.each do |macro|
+                item(macro.name) { macro.run }
+              end
+            end
+            lazy_sub_menu "Saved" do
+              Macros.saved_macros.reverse.each do |macro|
+                item(macro.name) { macro.run }
+              end
+            end
+            separator
+            item "Predict", PredictCommand
+            item "Change Prediction", AlternatePredictCommand
+          end
+        end
+      end
+    end
+    
+    def self.keymaps
+      osx = Redcar::Keymap.build("main", :osx) do
+        link "Cmd+Alt+M", StartStopRecordingCommand
+        link "Cmd+Shift+M", RunLastCommand
+        link "Cmd+Alt+Shift+M", NameLastMacroCommand
+        link "Cmd+P", PredictCommand
+        link "Cmd+Alt+P", AlternatePredictCommand
+      end
+      
+      linwin = Redcar::Keymap.build("main", [:linux, :windows]) do
+        link "Ctrl+Alt+M", StartStopRecordingCommand
+        link "Ctrl+Shift+M", RunLastCommand
+        link "Ctrl+Alt+Shift+M", NameLastMacroCommand
+        link "Ctrl+P", PredictCommand
+        link "Ctrl+Alt+P", AlternatePredictCommand
+      end
+      [osx, linwin]
+    end
+    
+    def self.document_controller_types
+      [Macros::Predictive::DocumentController]
+    end
+    
+    def self.sensitivities
+      [
+        Sensitivity.new(:not_recording_a_macro, Redcar.app, false, [:tab_focussed, :macro_record_changed]) do
+          edit_view = EditView.focussed_edit_view
+          !edit_view or !Macros.recording[edit_view]
+        end,
+        Sensitivity.new(:recording_a_macro, Redcar.app, false, [:tab_focussed, :macro_record_changed]) do
+          edit_view = EditView.focussed_edit_view
+          edit_view and Macros.recording[edit_view]
+        end,
+        Sensitivity.new(:is_last_macro, Redcar.app, false, [:macro_record_changed, :macro_ran]) do
+          Macros.last_run_or_recorded
+        end,
+        Sensitivity.new(:any_macros_recorded_this_session, Redcar.app, false, [:macro_record_changed, :macro_named]) do
+          Macros.session_macros.any?
+        end,
+        Sensitivity.new(:in_prediction_mode, Redcar.app, false, [:tab_focussed, :start_prediction_mode, :end_prediction_mode]) do
+          edit_view = EditView.focussed_edit_view
+          if edit_view
+            if controller = edit_view.document.controllers(Macros::Predictive::DocumentController).first
+              controller.in_prediction_mode?
+            end
+          end
+        end
+      ]
+    end
+  end
+end
+
+

data/plugins/macros/lib/macros/action_sequence.rb

@@ -0,0 +1,30 @@
+
+module Redcar
+  module Macros
+    class ActionSequence
+      attr_reader :actions
+      attr_reader :skip_length
+      
+      def initialize(actions, skip_length)
+        @actions = actions
+        @skip_length = skip_length
+      end
+      
+      def run_in(edit_view, this_skip_length=nil)
+        this_skip_length ||= skip_length
+        edit_view.document.compound do
+          actions[this_skip_length..-1].each do |action|
+            case action
+            when Fixnum
+              edit_view.type_character(action)
+            when Symbol
+              edit_view.invoke_action(action)
+            when DocumentCommand
+              action.run(:env => {:edit_view => edit_view})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/macros/lib/macros/commands.rb

@@ -0,0 +1,108 @@
+
+module Redcar
+  module Macros
+    class StartStopRecordingCommand < Redcar::EditTabCommand
+      def self.unique_session_id
+        @unique_id ||= 0
+        @unique_id += 1
+        @unique_id
+      end
+      
+      def self.new_macro_message
+        "Nameless Macro #{StartStopRecordingCommand.unique_session_id} :("
+      end
+      
+      def execute
+        clear_recordings
+        if info = Macros.recording[edit_view]
+          edit_view.history.unsubscribe(info[:subscriber])
+          if info[:actions].any?
+            macro = Macro.new(StartStopRecordingCommand.new_macro_message, 
+                      info[:actions],
+                      info[:start_in_block_selection_mode?])
+            Macros.session_macros << macro
+            Macros.last_run_or_recorded = macro
+          end
+          Macros.recording.delete(edit_view)
+          tab.update_for_file_changes
+        else
+          ev = edit_view
+          h = ev.history.subscribe do |action|
+            if should_record_action?(action)
+              Macros.recording[ev][:actions] << action
+            end
+          end
+          Macros.recording[ev] = {
+            :subscriber => h, 
+            :actions => [], 
+            :start_in_block_selection_mode? => ev.document.block_selection_mode?
+          }
+          tab.icon = :control_record
+        end
+        Redcar.app.repeat_event(:macro_record_changed)
+      end
+      
+      private
+      
+      def should_record_action?(action)
+        !action.is_a?(Redcar::Command) or action.class.record?
+      end
+      
+      def clear_recordings
+        Macros.recording.keys.each do |ev|
+          unless ev.exists?
+            Macros.recording.delete(ev)
+          end
+        end
+      end
+    end
+    
+    class RunLastCommand < Redcar::DocumentCommand
+      sensitize :not_recording_a_macro, :is_last_macro
+      
+      def execute
+        macro = Macros.last_run_or_recorded
+        macro.run_in(edit_view)
+      end
+    end
+    
+    class NameLastMacroCommand < Redcar::Command
+      sensitize :any_macros_recorded_this_session
+      
+      def execute
+        Macros.name_macro(Macros.session_macros.last.name, 
+          "Assign a name to the last recorded macro:")
+      end
+    end
+    
+    class MacroManagerCommand < Redcar::Command
+      def execute
+        controller = ManagerController.new
+        tab = win.new_tab(ConfigTab)
+        tab.html_view.controller = controller
+        tab.focus
+      end
+    end
+    
+    class PredictCommand < Redcar::EditTabCommand
+      def execute
+        controller = doc.controllers(Macros::Predictive::DocumentController).first
+        controller.predict
+      end
+    end
+    
+    class AlternatePredictCommand < Redcar::EditTabCommand
+      sensitize :in_prediction_mode
+      
+      def execute
+        controller = doc.controllers(Macros::Predictive::DocumentController).first
+        controller.alternate_predict
+      end
+    end
+  end
+end
+
+
+
+
+

data/plugins/macros/lib/macros/macro.rb

@@ -0,0 +1,37 @@
+
+module Redcar
+  class Macro
+    attr_reader :actions
+    attr_writer :name
+    
+    def initialize(name, actions, start_in_block_selection_mode)
+      @actions = actions.reject {|action| action.is_a?(Redcar::Macros::StartStopRecordingCommand)}
+      @name                          = name
+      @start_in_block_selection_mode = start_in_block_selection_mode
+    end
+    
+    def name
+      @name
+    end
+    
+    def start_in_block_selection_mode?
+      @start_in_block_selection_mode
+    end
+    
+    def run
+      run_in EditView.focussed_edit_view
+    end
+    
+    def run_in(edit_view)
+      Macros.last_run = self
+      Macros.last_run_or_recorded = self
+      previous_block_selection_mode = edit_view.document.block_selection_mode?
+      edit_view.document.block_selection_mode = start_in_block_selection_mode?
+      
+      Macros::ActionSequence.new(actions, 0).run_in(edit_view)
+      
+      edit_view.document.block_selection_mode = previous_block_selection_mode
+      Redcar.app.repeat_event(:macro_ran)
+    end
+  end
+end

data/plugins/macros/lib/macros/manager_controller.rb

@@ -0,0 +1,67 @@
+
+module Redcar
+  module Macros
+    class ManagerController
+      include Redcar::HtmlController
+
+      def title
+        "Macro Manager"
+      end
+      
+      def index
+        rhtml = ERB.new(File.read(File.join(File.dirname(__FILE__), "..", "..", "views", "macro_manager.html.erb")))
+        rhtml.result(binding)
+      end
+      
+      def assign_name(macro_name)
+        Macros.name_macro(macro_name, "Assign a name:")        
+        nil
+      end
+      
+      def rename_macro(macro_name)
+        Macros.rename_macro(macro_name)
+        nil
+      end
+      
+      def delete_macro(macro_name)
+        Macros.delete_macro(macro_name)
+        nil
+      end
+      
+      def macro_steps(macro)
+        html = ""
+        html << <<-HTML
+        <tr style="display: none;" class="macro-actions">
+          <td colspan="4">
+            <table>
+        HTML
+
+        macro.actions.each do |action|
+          case action
+          when Fixnum
+            a = " "
+            a[0] = action
+            s = "Insert: #{a.inspect}"
+          when Symbol
+            s = "Navigation: #{action}"
+          when DocumentCommand
+            s = "Command: #{action.inspect.gsub("<", "&lt;").gsub(">", "&gt;")}"
+          else
+            raise "don't know what kind of action #{action.inspect} is"
+          end
+          html << <<-HTML
+            <tr><td>#{s}</td></tr>
+          HTML
+        end
+        
+        html << <<-HTML
+            </table>
+          </td>
+        </tr>
+        HTML
+        
+        html
+      end
+    end
+  end
+end

data/plugins/macros/lib/macros/predictive/document_controller.rb

@@ -0,0 +1,69 @@
+
+module Redcar
+  module Macros
+    module Predictive
+      class DocumentController
+        include Redcar::Document::Controller
+        
+        def in_prediction
+          @in_prediction = true
+          yield
+          @in_prediction = false
+        end
+        
+        def after_action(action)
+          unless @in_prediction
+            @seq               = nil
+            @sequence_finder   = nil
+            @previous_sequence = nil
+            Redcar.app.repeat_event(:end_prediction_mode)
+          end
+        end
+        
+        def in_prediction_mode?
+          !!@seq
+        end
+        
+        def sequence
+          @seq ||= sequence_finder.next
+        end
+        
+        def previous_sequence
+          @previous_sequence
+        end
+        
+        def next_sequence
+          @seq = sequence_finder.next
+        end
+        
+        def sequence_finder
+          @sequence_finder ||= Predictive::SequenceFinder.new(document.edit_view.history)
+        end
+
+        def predict
+          in_prediction do
+            if sequence
+              skip_length = (@previous_sequence == sequence) ? 0 : nil
+              @previous_sequence = sequence
+              sequence.run_in(document.edit_view, skip_length)
+              Redcar.app.repeat_event(:start_prediction_mode)
+            end
+          end
+        end
+        
+        def alternate_predict
+          in_prediction do
+            document.edit_view.undo
+            next_sequence
+            if sequence
+              skip_length = (@previous_sequence == sequence) ? 0 : nil
+              @previous_sequence = sequence
+              sequence.run_in(document.edit_view, skip_length)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end