redcar 0.3.4.3 → 0.3.5

data/plugins/auto_completer/lib/auto_completer.rb

@@ -3,52 +3,61 @@ module Redcar
   class ApplicationSWT
     class Menu
       def move(x, y)
-      	@menu_bar.setLocation(x, y)
+        @menu_bar.setLocation(x, y)
       end
     end
   end
 end
 
+require 'auto_completer/current_document_completion_source'
 require 'auto_completer/document_controller'
 require 'auto_completer/word_iterator'
 require 'auto_completer/word_list'
 
 module Redcar
   class AutoCompleter
-    WORD_CHARACTERS = /:|@|\w/ # /(\s|\t|\.|\r|\(|\)|,|;)/
+    WORD_CHARACTERS = /\w|_/ # /(\s|\t|\.|\r|\(|\)|,|;)/
     
     def self.document_controller_types
       [AutoCompleter::DocumentController]
     end
     
+    def self.autocompletion_source_types
+      [AutoCompleter::CurrentDocumentCompletionSource]
+    end
+    
+    def self.all_autocompletion_source_types
+      result = []
+      Redcar.plugin_manager.objects_implementing(:autocompletion_source_types).each do |object|
+        result += object.autocompletion_source_types
+      end
+      result
+    end
+    
     class AutoCompleteCommand < Redcar::EditTabCommand
       
       def execute
         controller = doc.controllers(AutoCompleter::DocumentController).first
         controller.start_modification
-
+        
         if controller.in_completion?
           doc.delete(doc.cursor_offset - controller.length_of_previous, controller.length_of_previous)
-          word = controller.word
+          prefix = controller.prefix
           left = controller.left
           right = controller.right
           word_list = controller.word_list
         else
-          word, left, right = touched_word
-          if word
-            iterator = WordIterator.new(doc, WORD_CHARACTERS)
-            word_list = WordList.new
-            iterator.each_word_with_offset(word) do |matching_word, offset|
-              distance = (offset - doc.cursor_offset).abs
-              word_list.add_word(matching_word, distance)
-            end
+          prefix, left, right = touched_prefix
+          if prefix
+            word_list = alternatives(prefix)
             controller.word_list = word_list
-            controller.word      = word
+            controller.prefix    = prefix
             controller.left      = left
             controller.right     = right
           end
         end
-        if word
+        
+        if prefix
           index = (controller.index || 0) + 1
           if word_list.completions.length == index
             index = 0
@@ -57,12 +66,12 @@ module Redcar
           controller.index = index
           
           start_offset = right
-          doc.insert(right, completion[word.length..-1])
-          word_end_offset = right + completion.length - word.length
+          doc.insert(right, completion[prefix.length..-1])
+          word_end_offset = right + completion.length - prefix.length
           doc.cursor_offset = word_end_offset
-  
-          controller.length_of_previous = completion.length - word.length
-  
+          
+          controller.length_of_previous = completion.length - prefix.length
+          
           controller.start_completion
         end
         controller.end_modification
@@ -70,18 +79,29 @@ module Redcar
       
       private
       
-      # returns the word that is being touched by the cursor and an array 
-      # containing [left, right] document offsets of the word.
-      def touched_word
+      def alternatives(prefix)
+        sources = AutoCompleter.all_autocompletion_source_types.map do |t| 
+          t.new(doc, Project::Manager.focussed_project)
+        end
+        word_list = WordList.new
+        sources.each do |source|
+          if alts = source.alternatives(prefix)
+            word_list.merge!(alts)
+          end
+        end
+        word_list
+      end
+      
+      # returns the prefix that is being touched by the cursor and an array 
+      # containing [left, right] document offsets of the prefix.
+      def touched_prefix
         line = doc.get_line(doc.cursor_line)
         left, right = word_range(line)
-        word = doc.get_range(left, right - left)
-        return nil if word.length == 0
-        return word, left, right
+        prefix = doc.get_range(left, right - left)
+        return nil if prefix.length == 0
+        return prefix, left, right
       end
       
-      private
-      
       # returns the range that holds the current word (depending on WORD_CHARACTERS)
       def word_range(line)
         left = doc.cursor_line_offset - 1
@@ -95,60 +115,47 @@ module Redcar
           left_range -= 1
         end
         
-#        until right == line.length || WORD_CHARACTERS !~ (line[right].chr)
-#          right += 1
-#          right_range += 1
-#        end
         return [offset+left_range, offset+right_range]
       end
     end
     
     class MenuAutoCompleterCommand < AutoCompleteCommand
-    
+      
       def execute
         controller = doc.controllers(AutoCompleter::DocumentController).first
         input_word = ""
         word_list = controller.word_list
-        word, left, right = touched_word
-        if word
-          iterator = WordIterator.new(doc, WORD_CHARACTERS)
-          word_list = WordList.new
-          iterator.each_word_with_offset(word) do |matching_word, offset|
-            distance = (offset - doc.cursor_offset).abs
-            unless (distance - matching_word.length) == 0
-	            word_list.add_word(matching_word, distance)
-	          else
-	          	input_word = matching_word
-	          end
-          end
+        prefix, left, right = touched_prefix
+        if prefix
+          word_list = alternatives(prefix)
           controller.word_list = word_list
-          controller.word      = word
+          controller.prefix    = prefix
           controller.left      = left
           controller.right     = right
+          
+          cur_doc = doc
+          builder = Menu::Builder.new do
+            word_list.words.each do |current_word, word_distance|
+              item(current_word) do
+                offset = cur_doc.cursor_offset - prefix.length
+                text   = current_word[input_word.length..current_word.length]
+                cur_doc.replace(offset, prefix.length, text)
+              end
+            end
+          end
+          
+          window = Redcar.app.focussed_window
+          location = window.focussed_notebook.focussed_tab.controller.edit_view.mate_text.viewer.getTextWidget.getLocationAtOffset(window.focussed_notebook.focussed_tab.controller.edit_view.cursor_offset)
+          absolute_x = location.x
+          absolute_y = location.y
+          location = window.focussed_notebook.focussed_tab.controller.edit_view.mate_text.viewer.getTextWidget.toDisplay(0,0)
+          absolute_x += location.x
+          absolute_y += location.y
+          menu = ApplicationSWT::Menu.new(window.controller, builder.menu, nil, Swt::SWT::POP_UP)
+          menu.move(absolute_x, absolute_y)
+          menu.show
         end
-
-		    cur_doc = doc
-      	builder = Menu::Builder.new do
-      	  word_list.words.each do |current_word, word_distance|
-      	  	item(current_word) do
-      	  		cur_doc.insert(cur_doc.cursor_offset, current_word[input_word.length..current_word.length])
-      	  		cur_doc.cursor_offset = cur_doc.cursor_offset + current_word[input_word.length..current_word.length].length
-      	  	end
-      	  end
-      	end
-      	
-      	window = Redcar.app.focussed_window
-      	location = window.focussed_notebook.focussed_tab.controller.edit_view.mate_text.viewer.getTextWidget.getLocationAtOffset(window.focussed_notebook.focussed_tab.controller.edit_view.cursor_offset)
-      	absolute_x = location.x
-      	absolute_y = location.y
-      	location = window.focussed_notebook.focussed_tab.controller.edit_view.mate_text.viewer.getTextWidget.toDisplay(0,0)
-      	absolute_x += location.x
-      	absolute_y += location.y
-      	menu = ApplicationSWT::Menu.new(window.controller, builder.menu, nil, Swt::SWT::POP_UP)
-        menu.move(absolute_x, absolute_y)
-        menu.show
       end
-
     end
   end
 end

data/plugins/auto_completer/lib/auto_completer/current_document_completion_source.rb

@@ -0,0 +1,19 @@
+module Redcar
+  class AutoCompleter
+    class CurrentDocumentCompletionSource
+      def initialize(document, _)
+        @document = document
+      end
+      
+      def alternatives(prefix)
+        iterator = WordIterator.new(@document, WORD_CHARACTERS)
+        word_list = WordList.new
+        iterator.each_word_with_offset(prefix) do |matching_word, offset|
+          distance = (offset - @document.cursor_offset).abs
+          word_list.add_word(matching_word, distance)
+        end
+        word_list
+      end
+    end
+  end
+end

data/plugins/auto_completer/lib/auto_completer/document_controller.rb

@@ -30,7 +30,7 @@ module Redcar
       
       attr_accessor :index
       attr_accessor :length_of_previous
-      attr_accessor :word_list, :word, :left, :right
+      attr_accessor :word_list, :prefix, :left, :right
       
       def before_modify(*_)
       end
@@ -41,7 +41,7 @@ module Redcar
           @index         = 0
           @length_of_previous = nil
           @word_list = nil
-          @word = nil
+          @prefix = nil
           @left = nil
           @right = nil
         end

data/plugins/auto_completer/lib/auto_completer/word_list.rb

@@ -11,7 +11,6 @@ module Redcar
       
       def initialize
         @words = Hash.new
-        @offset = 0
       end
       
       # adds a new word, iff it doesn't yet exist.
@@ -35,6 +34,14 @@ module Redcar
       def each
         @words.each {|word,distance| yield word, distance }
       end
+      
+      def merge!(other)
+        @words.merge!(other.words)
+      end
+      
+      def inspect
+        "<WordList: " + @words.map {|k,v| "#{k}:#{v}"}.join(" ") + ">"
+      end
     end
   end
 end

data/plugins/auto_indenter/features/ruby_style_indentation.feature

@@ -0,0 +1,24 @@
+Feature: Indents Ruby code correctly
+
+  Background:
+    Given the indentation rules are like Ruby's
+    When I open a new edit tab
+    And tabs are hard
+    
+  Scenario: It should increase indentation after 'def's
+    When I insert "def f" at the cursor
+    And I move the cursor to 5
+    And I insert "\n" at the cursor
+    Then the contents should be "def f\n\t"
+    
+  Scenario: It should decrease indentation on 'end' line
+    When I insert "def f\n\t1\n\ten" at the cursor
+    And I move the cursor to 12
+    And I insert "d" at the cursor
+    Then the contents should be "def f\n\t1\nend"
+    
+  Scenario: It should keep indentation the same if no change
+    When I insert "\tfoo" at the cursor
+    And I move the cursor to 4
+    And I insert "\n" at the cursor
+    Then the contents should be "\tfoo\n\t"

data/plugins/auto_indenter/features/step_definitions/indentation_steps.rb

@@ -0,0 +1,6 @@
+
+Given /^the indentation rules are like Ruby's$/ do
+  Redcar::AutoIndenter.test_rules = Redcar::AutoIndenter::Rules.new(/def/, /end/)
+end
+
+

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

@@ -0,0 +1,2 @@
+
+RequireSupportFiles File.dirname(__FILE__) + "/../../../edit_view/features/"

data/plugins/auto_indenter/lib/auto_indenter.rb

@@ -1,5 +1,8 @@
 
+require 'auto_indenter/analyzer'
+require 'auto_indenter/commands'
 require 'auto_indenter/document_controller'
+require 'auto_indenter/rules'
 
 module Redcar
   class AutoIndenter
@@ -7,5 +10,88 @@ module Redcar
     def self.document_controller_types
       [AutoIndenter::DocumentController]
     end
+    
+    class << self
+      attr_accessor :test_rules
+    end
+
+    def self.cache
+      @cache ||= {}
+    end
+    
+    def self.best_match(hash, current_scope)
+      matches = hash.map do |scope_name, value|
+        if match = JavaMateView::ScopeMatcher.get_match(scope_name, current_scope)
+          [scope_name, match, value]
+        end
+      end.compact
+      
+      ranked_matches = matches.sort do |a, b|
+        JavaMateView::ScopeMatcher.compare_match(current_scope, a[1], b[1])
+      end
+      
+      if best_match = ranked_matches.last
+        best_match[2]
+      end
+    end
+    
+    def self.rules_for_scope(current_scope)
+      return unless current_scope
+      if rules = AutoIndenter.test_rules
+        return rules
+      end
+      cache[current_scope] ||= begin
+        if inc_best_match = best_match(indentation_rules[:increase], current_scope)
+          inc_best_match = Regexp.new(inc_best_match)
+        end
+        if dec_best_match = best_match(indentation_rules[:decrease], current_scope)
+          dec_best_match = Regexp.new(dec_best_match)
+        end
+        if indent_next_best_match = best_match(indentation_rules[:indent_next], current_scope)
+          indent_next_best_match = Regexp.new(indent_next_best_match)
+        end
+        if unindented_match = best_match(indentation_rules[:unindented], current_scope)
+          unindented_match = Regexp.new(unindented_match)
+        end
+        Rules.new(inc_best_match, dec_best_match, indent_next_best_match, unindented_match)
+      end
+    end
+    
+    def self.initialize_rules(settings, rules)
+      settings.each do |setting|
+        if setting.scope
+          rules[setting.scope] = setting.pattern
+        else
+          puts "indent setting without scope! #{setting.inspect}"
+        end
+      end
+    end
+    
+    def self.indentation_rules
+      @indentation_rules ||= begin
+        increase_rules = Hash.new {|h, k| h[k] = {}}
+        decrease_rules = Hash.new {|h, k| h[k] = {}}
+        indent_next_rules = Hash.new {|h, k| h[k] = {}}
+        unindented_rules = Hash.new {|h, k| h[k] = {}}
+        increase_settings = Textmate.settings(Textmate::IncreaseIndentPatternSetting)
+        decrease_settings = Textmate.settings(Textmate::DecreaseIndentPatternSetting)
+        indent_next_settings = Textmate.settings(Textmate::IndentNextLinePatternSetting)
+        unindented_settings = Textmate.settings(Textmate::UnIndentedLinePatternSetting)
+        initialize_rules(increase_settings, increase_rules)
+        initialize_rules(decrease_settings, decrease_rules)
+        initialize_rules(indent_next_settings, indent_next_rules)
+        initialize_rules(unindented_settings, unindented_rules)
+        increase_rules.default = nil
+        decrease_rules.default = nil
+        indent_next_rules.default = nil
+        unindented_rules.default = nil
+        { 
+          :increase => increase_rules, 
+          :decrease => decrease_rules,
+          :indent_next => indent_next_rules,
+          :unindented => unindented_rules
+        }
+      end
+    end
   end
 end

data/plugins/auto_indenter/lib/auto_indenter/analyzer.rb

@@ -0,0 +1,91 @@
+
+module Redcar
+  class AutoIndenter
+    class Analyzer
+      attr_reader :rules
+      
+      def initialize(rules, doc, tab_width, soft_tabs)
+        @rules, @doc, @tab_width, @soft_tabs = rules, doc, tab_width, soft_tabs
+        @indentation = doc.indentation
+      end
+      
+      def calculate_for_line(line_ix, typing=false)
+        return 0 if line_ix == 0
+        #p [:line_ix, line_ix]
+        current_line  = @doc.get_line(line_ix)
+        previous_ix, indent_next_line = index_of_previous_normally_indented(line_ix)
+        #p [:previous_ix, previous_ix, indent_next_line]
+        previous_line = @doc.get_line(previous_ix)
+        current_level = @indentation.get_level(previous_ix)
+        new_level     = current_level
+        #p [:previous_line, previous_line]
+        #p [:current_line, current_line]
+        #p [:current_level, current_level]
+
+        if !typing and rules.unindented_line?(current_line)
+          #p [:unindented_line]
+          return @indentation.get_level(line_ix)
+        end
+
+        if rules.increase_indent?(previous_line)
+          #p [:inc_indent]
+          new_level += 1
+        end
+        if rules.decrease_indent?(current_line)
+          #p [:dec_indent]
+          new_level -= 1
+        end
+        if !typing and indent_next_line and !rules.increase_indent?(current_line)
+          #p [:indent_next_line]
+          new_level += 1
+        end
+
+        #p [:new_level, new_level]
+        new_level
+      end
+      
+      def index_of_previous_normally_indented(line_ix)
+        current = line_ix - 1
+        indent_next_line = nil
+        loop do
+          if current == 0
+            return 0, indent_next_line
+          end
+          line = @doc.get_line(current)
+          if rules.unindented_line?(line)
+            current -= 1
+          else
+            if indent_next_line == nil
+              #p [:indent_next_line?, line, rules.indent_next_line?(line)]
+              indent_next_line = rules.indent_next_line?(line)
+            end
+            previous_ix = index_of_previous_non_unindented_line(current)
+            if previous_ix < 0
+              return current, indent_next_line
+            else
+              previous_line = @doc.get_line(previous_ix)
+            
+              if rules.indent_next_line?(previous_line) and !rules.increase_indent?(line)
+                current -= 1
+              else
+                return current, indent_next_line
+              end
+            end
+          end
+        end
+      end
+      
+      def index_of_previous_non_unindented_line(line_ix)
+        current = line_ix - 1
+        while current >= 0 and 
+              line = @doc.get_line(current) and 
+              rules.unindented_line?(line)
+          current -= 1
+        end
+        #p [:index_of_previous_non_unindented_line, line_ix, current]
+        current
+      end
+      
+    end
+  end
+end