redcar 0.6.1 → 0.7

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.icon = Redcar::Tab::DEFAULT_ICON
+        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(HtmlTab)
+        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>
+            <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

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

@@ -0,0 +1,112 @@
+
+module Redcar
+  module Macros
+    module Predictive
+      class SequenceFinder
+        MAX_LENGTH = 100
+        
+        attr_reader :super_sequence
+        attr_reader :state
+        
+        def initialize(super_sequence)
+          @super_sequence = super_sequence.reverse
+          @state          = {
+            :search_mode => :fully_repeated, 
+            :length_x => max_possible_repeat_length,
+            :length_y => nil
+          }
+        end
+          
+        def next
+          return nil if done?
+          seq = nil
+          until seq or done?
+            seq = detect_current
+            increment_state
+          end
+          seq
+        end
+        
+        def detect_current
+          case current_search_mode
+          when :fully_repeated
+            detect_fully_repeated_sequence(state[:length_x])
+          when :partially_repeated
+            detect_partially_repeated_sequence(state[:length_x], state[:length_y])
+          end
+        end
+        
+        def done?
+          @done
+        end
+        
+        def current_search_mode
+          @state[:search_mode]
+        end
+        
+        # in XX how long can X be?
+        def max_possible_repeat_length
+          super_sequence.length / 2
+        end
+        
+        # in XYX how long can X be?
+        def max_possible_repeated_portion_length
+          r = super_sequence.length / 2
+          if r*2 == super_sequence.length
+            r - 1
+          else
+            r
+          end
+        end
+        
+        # in XYX how long can Y be, given X?
+        def max_possible_non_repeated_portion_length(repeated_portion_length)
+          super_sequence.length - repeated_portion_length*2
+        end
+        
+        private
+        
+        def detect_fully_repeated_sequence(length)
+          candidate = super_sequence[0..(length - 1)]
+          confirmation = super_sequence[length..(2*length - 1)]
+          if candidate == confirmation
+            ActionSequence.new(candidate.reverse, 0)
+          end
+        end
+        
+        def detect_partially_repeated_sequence(length_x, length_y)
+          candidate_x = super_sequence[0..(length_x - 1)]
+          candidate_y = super_sequence[length_x..(length_x + length_y - 1)]
+          confirmation_x = super_sequence[(length_x + length_y)..(2*length_x + length_y - 1)]
+          if candidate_x == confirmation_x
+            ActionSequence.new(candidate_x.reverse + candidate_y.reverse, candidate_x.length)
+          end
+        end
+        
+        def increment_state
+          case current_search_mode
+          when :fully_repeated
+            if state[:length_x] > 1
+              state[:length_x] -= 1
+            else
+              state[:search_mode] = :partially_repeated
+              state[:length_x]    = max_possible_repeated_portion_length
+              state[:length_y]    = 1
+            end
+          when :partially_repeated
+            if state[:length_y] == max_possible_non_repeated_portion_length(state[:length_x])
+              state[:length_y] = 1
+              if state[:length_x] > 1
+                state[:length_x] -= 1
+              else
+                @done = true
+              end
+            else
+              state[:length_y] += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/macros/plugin.rb

@@ -0,0 +1,9 @@
+
+Plugin.define do
+  name "macros"
+  version "1.0"
+  file "lib", "macros"
+  object "Redcar::Macros"
+  dependencies "application", ">0",
+              "edit_view",   ">0"
+end

data/plugins/macros/spec/macros/predictive/sequence_finder_spec.rb

@@ -0,0 +1,142 @@
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Redcar::Macros::Predictive::SequenceFinder do
+  SequenceFinder = Redcar::Macros::Predictive::SequenceFinder
+  
+  describe "fully repeated sequences (XYXY)" do
+    it "should return nil if there are no repeated sequences" do
+      SequenceFinder.new(%w(a b c)).next.should be_nil
+    end
+    
+    it "should find repeated sequence of length 1" do
+      SequenceFinder.new(%w(a a)).next.actions.should == %w(a)
+    end
+    
+    it "should find repeated sequence of length 2" do
+      SequenceFinder.new(%w(a b a b)).next.actions.should == %w(a b)
+    end
+    
+    it "should find repeated sequence of length 3" do
+      SequenceFinder.new(%w(a b c a b c)).next.actions.should == %w(a b c)
+    end
+    
+    it "should find repeated sequence of length 3 with padding at the front" do
+      SequenceFinder.new(%w(x x a b c a b c)).next.actions.should == %w(a b c)
+    end
+    
+    it "should choose the longest option when there are multiple options" do
+      SequenceFinder.new(%w(a b c c a b c c)).next.actions.should == %w(a b c c)
+    end
+
+    it "should cycle through fully repeated options" do
+      seq_finder = SequenceFinder.new(%w(a b c c a b c c))
+      seq1 = seq_finder.next
+      seq1.actions.should == %w(a b c c)
+      
+      seq2 = seq_finder.next
+      seq2.actions.should == %w(c)
+    end
+  end
+  
+  describe "partially repeated sequences (XYX)" do
+    it "should find partially repeated sequence of length 2, matched by 1" do
+      seq = SequenceFinder.new(%w(a b a)).next
+      seq.actions.should == %w(a b)
+      seq.skip_length.should == 1
+    end
+    
+    it "should find partially repeated sequence of length 3, matched by 1" do
+      seq = SequenceFinder.new(%w(a b c a)).next
+      seq.actions.should == %w(a b c)
+      seq.skip_length.should == 1
+    end
+
+    it "should find partially repeated sequence of length 3, matched by 2" do
+      seq = SequenceFinder.new(%w(a b c a b)).next
+      seq.actions.should == %w(a b c)
+      seq.skip_length.should == 2
+    end
+    
+    it "should find partially repeated sequence of length 3, matched by 2 with padding" do
+      seq = SequenceFinder.new(%w(x x X x X x a b c a b)).next
+      seq.actions.should == %w(a b c)
+      seq.skip_length.should == 2
+    end
+    
+    it "should choose the longest X and shortest Y" do
+      seq = SequenceFinder.new(%w(a b r a c a d a b r a)).next
+      seq.actions.should == %w(a b r a c a d)
+      seq.skip_length.should == 4
+    end
+    
+    it "should cycle through fully repeated options and partially repeated options" do
+      seq_finder = SequenceFinder.new(%w(a b c c a b c c))
+      seq1 = seq_finder.next
+      seq1.actions.should == %w(a b c c)
+      seq1.skip_length.should == 0
+      
+      seq2 = seq_finder.next
+      seq2.actions.should == %w(c)
+      seq2.skip_length.should == 0
+      
+      seq3 = seq_finder.next
+      seq3.actions.should == %w(b c c a)
+      seq3.skip_length.should == 3
+    end
+
+  end
+end
+
+
+
+
+__END__
+  describe "find candidate sequences" do
+    it "should find from 1 length partial repeat" do
+      assert_equal [[1, 2, 3]],
+        Redcar::DynamicMacros.find_repeated_sequences([3, 1, 2, 3, 4, 5])
+    end
+    
+    it "should find two possibilities from 2 length partial repeat" do
+      assert_equal [[1, 2, 3], [3, 1, 2]],
+        Redcar::DynamicMacros.find_repeated_sequences([2, 3, 1, 2, 3])
+    end
+    
+    it "should find three possibilites from complete repetition of length 3 sequence" do
+      assert_equal [[1, 2, 3], [3, 1, 2], [2, 3, 1]],
+        Redcar::DynamicMacros.find_repeated_sequences([1, 2, 3, 1, 2, 3])
+    end
+    
+    it "should find a lot of possibilities from a short repeated sequence"do
+      assert_equal [[2, 1], [1, 2, 1, 2], [2, 1, 2, 1], [1, 2], [1, 2, 1, 2], [1, 2, 1, 2, 1, 2]],
+        Redcar::DynamicMacros.find_repeated_sequences([2, 1, 2, 1, 2, 1, 2, 4])
+    end
+  end
+  
+  it "should find most likely repeated sequence" do
+    assert_equal {:seq => [1, 2, 3], :length => 1, :gap => 2},
+      Redcar::DynamicMacros.find_repeated_sequence([3, 1, 2, 3, 4, 5])
+    assert_equal {:seq => [[1, 2, 3], :length => 2, :gap => 1},
+      Redcar::DynamicMacros.find_repeated_sequence([2, 3, 1, 2, 3])
+    assert_equal {:seq => [[1, 2, 3], :length => 3, :gap => 0},
+      Redcar::DynamicMacros.find_repeated_sequence([1, 2, 3, 1, 2, 3])
+    assert_equal {:seq => [[2, 1], :length => 2, :gap => 0},
+      Redcar::DynamicMacros.find_repeated_sequence([2, 1, 2, 1, 2, 1, 2, 4])
+    assert_equal {:seq => [%w{a b c c}.reverse, :length => 4, :gap => 0},
+      Redcar::DynamicMacros.find_repeated_sequence("abccabcc".split(//).reverse)
+    assert_equal {:seq => [%w{a b r a c a d}.reverse, :length => 4, :gap => 3},
+      Redcar::DynamicMacros.find_repeated_sequence("abracadabra".split(//).reverse)
+  end
+  
+  it "should 3"
+    assert_equal {:seq => %w{a b r a c a d}.reverse, :length => 4, :gap => 3},
+      Redcar::DynamicMacros.find_repeated_sequence("abracadabra".split(//).reverse)
+    assert_equal {:seq => %w{b r a c a d a}.reverse, :length => 3, :gap => 4},
+      Redcar::DynamicMacros.find_repeated_sequence("abracadabra".split(//).reverse, 4, 3)
+    assert_equal {:seq => %w{r a c a d a b}.reverse, :length => 2, :gap => 5},
+      Redcar::DynamicMacros.find_repeated_sequence("abracadabra".split(//).reverse, 3, 4)
+    assert_equal {:seq => %w{a b r}.reverse, :length => 1, :gap => 2},
+      Redcar::DynamicMacros.find_repeated_sequence("abracadabra".split(//).reverse, 2, 5)
+  end
+end