redcar-dev 0.12.17dev

data/plugins/auto_indenter/plugin.rb

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

data/plugins/auto_indenter/spec/auto_indenter/analyzer_spec.rb

@@ -0,0 +1,151 @@
+
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+include Redcar
+
+describe AutoIndenter::Analyzer do
+  class FakeDocument
+    def initialize(string, tab_width, soft_tabs)
+      @string = string
+      @tab_width, @soft_tab = tab_width, soft_tabs
+    end
+    
+    def get_line(ix)
+      lines[ix] + "\n"
+    end
+    
+    def lines
+      @string.split("\n")
+    end
+    
+    def indentation
+      Document::Indentation.new(self, @tab_width, @soft_tabs)
+    end
+  end
+  
+  describe "with indentation rules like Ruby's" do
+    def should_indent(src, options)
+      simple_rules = AutoIndenter::Rules.new(/def/, /end/)
+      analyzer = AutoIndenter::Analyzer.new(simple_rules, FakeDocument.new(src, 2, true), 2, true)
+      analyzer.calculate_for_line(options[:line]).should == options[:indent]
+    end
+  
+    it "should indent after an increase indent line" do
+      should_indent(<<RUBY, :line => 1, :indent => 1)
+def foo
+# should be indented
+RUBY
+    end
+    
+    it "should decrease indent for a decrease indent line" do
+      should_indent(<<RUBY, :line => 1, :indent => 1)
+    p :adsf
+    end # should be dedented
+  p :adsf
+RUBY
+    end
+  
+    it "should set indent to match previous line" do
+      should_indent(<<RUBY, :line => 3, :indent => 0)
+def foo
+  
+end
+  p :asdf # should be dedented
+RUBY
+    end
+    
+    it "should set indent to match previous line if an increase cancels out a decrease" do
+      should_indent(<<RUBY, :line => 1, :indent => 0)
+def foo
+  end # should be dedented
+RUBY
+    end
+  end
+  
+  describe "with indentation rules like C's" do
+    def should_indent(options)
+      simple_rules = AutoIndenter::Rules.new(
+                        /\{/, 
+                        /\}/, 
+                        /^(?!.*;\s*\/\/).*[^\s;{}]\s*$/, 
+                        /^\s*(\/\/|#).*$/
+                      )
+      analyzer = AutoIndenter::Analyzer.new(simple_rules, FakeDocument.new(source, 4, false), 4, false)
+      analyzer.calculate_for_line(options[:line]).should == options[:indent]
+    end
+    
+    def source
+      t=<<-CSOURCE
+int main (int argc, char const* argv[]) {
+	while(true) {
+		if(something())
+			break;
+#if 3
+		play_awful_music();
+		#else
+		play_nice_music();
+#endif
+	}
+	return 0;
+}
+ 
+if (foo)
+  break;
+ 
+if (foo)
+{
+  d;
+ 
+CSOURCE
+    end
+    
+    it "should set indentation on the first line to 0" do
+      should_indent(:line => 0, :indent => 0)
+    end
+    
+    it "should increase indent" do
+      should_indent(:line => 1,  :indent => 1)
+    end
+    
+    it "should increase indent (2)" do
+      should_indent(:line => 2,  :indent => 2)
+    end
+    
+    it "should indent next line" do
+      should_indent(:line => 3,  :indent => 3)
+      should_indent(:line => 14,  :indent => 1)
+    end
+    
+    it "should leave unindented lines as they are" do
+      should_indent(:line => 4,  :indent => 0)
+      should_indent(:line => 6,  :indent => 2)
+      should_indent(:line => 8,  :indent => 0)
+    end
+    
+    it "should return to indent after unindented line" do
+      should_indent(:line => 7,  :indent => 2)
+    end
+    
+    it "should return to indent after unindented line, and next-line indent before that" do
+      should_indent(:line => 5,  :indent => 2)
+    end
+    
+    it "should decrease indent" do
+      should_indent(:line => 9, :indent => 1)
+      should_indent(:line => 11, :indent => 0)
+    end
+    
+    it "should match indent" do
+      should_indent(:line => 10, :indent => 1)
+    end
+
+    it "should not indent next lines if the next line matches the increase indent" do
+      should_indent(:line => 17, :indent => 0)
+    end
+
+    it "should still increase the indent after an increase indent line after an increase next line" do
+      should_indent(:line => 18, :indent => 1)
+    end
+  end
+end  
+

data/plugins/auto_indenter/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+
+require 'redcar'
+Redcar.environment = :test
+Redcar.load_unthreaded

data/plugins/auto_pairer/features/auto_pairer.feature

@@ -0,0 +1,92 @@
+Feature: Automatically insert paired characters
+
+  Scenario: Inserts quote marks
+    When I open a new edit tab
+    And I type "\""
+    Then the contents should be "\"<c>\""
+    
+  Scenario: Don't insert quote mark if we're already open
+    When I open a new edit tab
+    And I replace the contents with "foo \" bár q"
+    And I move to the end of the line
+    And I move left
+    When I type "\""
+    Then the contents should be "foo \" bár \"q"
+    
+  Scenario: Inserts parentheses
+    When I open a new edit tab
+    And I type "("
+    Then the contents should be "(<c>)"
+    
+  Scenario: Delete start character (quotes)
+    When I open a new edit tab
+    And I type "\""
+    And I backspace
+    Then the contents should be ""
+
+  Scenario: Delete start character (parentheses)
+    When I open a new edit tab
+    And I type "("
+    And I backspace
+    Then the contents should be ""
+
+  Scenario: Type over ends
+    When I open a new edit tab
+    And I type "("
+    And I type ")"
+    Then the contents should be "()<c>"
+  
+  Scenario: Wrap selected text
+    When I open a new edit tab
+    And I type "Boris"
+    And I select from 0 to 5
+    And I type "("
+    Then the contents should be "(Boris)<c>"
+
+  Scenario: Inserts ending character nested
+    When I open a new edit tab
+    And I type "\""
+    And I type "("
+    Then the contents should be "\"(<c>)\""
+    
+  Scenario: Delete start character nested
+    When I open a new edit tab
+    And I type "\""
+    And I type "("
+    And I backspace
+    Then the contents should be "\"<c>\""
+    When I backspace
+    Then the contents should be ""
+
+  Scenario: Type over ends nested
+    When I open a new edit tab
+    And I type "("
+    And I type "\""
+    And I type "\""
+    And I type ")"
+    Then the contents should be "(\"\")<c>"
+  
+  Scenario: Don't delete start character if moved away
+    When I open a new edit tab
+    And I type "0123456789"
+    And I move to the start of the line
+    And I type "("
+    And I move to the end of the line
+    And I move to the start of the line
+    And I move right
+    And I backspace
+    Then the contents should be "<c>)0123456789"
+
+  Scenario: Don't type over end if moved away
+    When I open a new edit tab
+    And I type "0123456789"
+    And I move to the start of the line
+    And I type "("
+    And I move to the end of the line
+    And I move to the start of the line
+    And I move right
+    And I type ")"
+    Then the contents should be "())0123456789"
+
+  
+  

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

@@ -0,0 +1 @@
+

data/plugins/auto_pairer/lib/auto_pairer.rb

@@ -0,0 +1,12 @@
+
+require 'auto_pairer/document_controller'
+require 'auto_pairer/pairs_for_scope'
+
+module Redcar
+  class AutoPairer
+    def self.document_controller_types
+      [AutoPairer::DocumentController]
+    end
+  end
+end
+

data/plugins/auto_pairer/lib/auto_pairer/document_controller.rb

@@ -0,0 +1,168 @@
+module Redcar
+  class AutoPairer
+    class DocumentController
+      include Redcar::Document::Controller
+      include Redcar::Document::Controller::ModificationCallbacks
+      include Redcar::Document::Controller::CursorCallbacks
+
+      MarkPair ||= Struct.new(:start_mark, :end_mark, :text, :endtext)
+
+      class MarkPair
+        def inspect
+          "<MarkPair start:#{start_mark.inspect} end:#{end_mark.inspect}>"
+        end
+      end
+
+      def initialize
+        @mark_pairs = []
+      end
+
+      def disable
+        increase_ignore
+        yield
+        decrease_ignore
+      end
+
+      alias_method :ignore, :disable
+
+      def ignore?
+        @ignore
+      end
+
+      def increase_ignore
+        @ignore ||= 0
+        @ignore += 1
+      end
+
+      def decrease_ignore
+        @ignore -= 1
+        @ignore = nil if @ignore == 0
+      end
+
+      def add_mark_pair(pair)
+        @mark_pairs << pair
+        if @mark_pairs.length > 10
+          p :Whoah_many_pairs
+        end
+      end
+
+      # Forget about pairs if the cursor moves from within them
+      def invalidate_pairs(offset)
+        @mark_pairs.reject! do |mp|
+          i1 = mp.start_mark.get_offset
+          i2 = mp.end_mark.get_offset
+          if offset < i1 or offset > i2
+            document.delete_mark(mp.start_mark)
+            document.delete_mark(mp.end_mark)
+            true
+          end
+        end
+      end
+
+      def find_mark_pair_by_start(offset)
+        @mark_pairs.find do |mp|
+          mp.start_mark.get_offset == offset
+        end
+      end
+
+      def find_mark_pair_by_end(offset)
+        @mark_pairs.find do |mp|
+          mp.end_mark.get_offset == offset
+        end
+      end
+
+      def before_modify(start_offset, end_offset, text)
+        return if ignore?
+        @start_offset  = start_offset
+        @end_offset    = end_offset
+        @text          = text
+        @selected_text = nil unless @ignore_insert
+        if cursor_scope = document.cursor_scope
+          # Type over ends
+          if @rules = PairsForScope.pairs_for_scope(cursor_scope)
+            inverse_rules = @rules.invert
+            if !@ignore_insert
+              end_mark_pair = find_mark_pair_by_end(start_offset)
+              if end_mark_pair and end_mark_pair.text == text
+                @type_over_end = true
+              end
+            end
+            # Insert matching ends
+            if !@type_over_end and @rules.include?(text) and !@ignore_insert and !@done and
+              line_num = document.line_at_offset(start_offset)
+              line = document.get_line(line_num)
+              offset_of_line = document.offset_at_line(line_num)
+              pre_text = line.chars[0..(start_offset-offset_of_line)].to_s
+              equal_ends = (@rules[text] == text)
+              if !equal_ends or pre_text.scan(text).length % 2 == 0
+                @insert_end = true
+                if document.selection?
+                  @selected_text = document.selected_text
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def after_modify
+        return if ignore?
+        @done = nil
+        document.controllers(AutoIndenter::DocumentController).first.disable do
+          # Deleted start of a mark pair
+          if @end_offset == @start_offset + 1 and !@ignore_delete
+            mark_pair = find_mark_pair_by_start(@start_offset)
+            if mark_pair
+              @ignore_delete = true
+              document.delete(mark_pair.end_mark.get_offset, 1)
+              @ignore_delete = false
+              @mark_pairs.delete(mark_pair)
+              @deletion = nil
+            end
+          end
+
+          # Type over ends
+          if @type_over_end
+            @type_over_end = false
+            @ignore_delete = true
+            document.delete(@end_offset, 1)
+            @ignore_delete = nil
+            document.cursor_offset += 1
+            #@buffer.parser.start_parsing
+            @done = true
+          end
+
+          # Insert matching ends
+          if @insert_end and !@ignore_insert
+            @ignore_insert = true
+            endtext = @rules[@text]
+            document.insert(@start_offset + 1, endtext)
+            mark1 = document.create_mark(@start_offset - 1,     :right)
+            mark2 = document.create_mark(@start_offset, :right)
+            add_mark_pair(MarkPair.new(mark1, mark2, @text, endtext))
+            @ignore_insert = false
+            #@buffer.parser.start_parsing
+            @insert_end = false
+          end
+
+          if @selected_text and !@ignore_insert
+            @ignore_insert = true
+            offset = document.cursor_offset
+            document.insert(@start_offset, @selected_text)
+            document.cursor_offset = offset + @selected_text.length + 1
+            @ignore_insert = false
+            @selected_text = nil
+          end
+        end
+        false
+      end
+
+      def cursor_moved(offset)
+        return if ignore?
+        if !@ignore_mark
+          invalidate_pairs(offset)
+        end
+      end
+    end
+  end
+end