redcar-dev 0.12.17dev

data/plugins/snippets/lib/snippets/explorer.rb

@@ -0,0 +1,48 @@
+module Redcar
+  class Snippets
+    class Explorer < FilterListDialog
+      def initialize(document)
+        @document = document
+        super()
+      end
+      
+      def update_list(query)
+        return [] if query == ""
+        matching_snippets = filter_and_rank_by(all_snippets, query, 1000) do |s| 
+          display(s)
+        end
+        current_scope = Redcar.update_gui { @document.cursor_scope }
+        @last_list = matching_snippets.select do |snippet|
+          if snippet.scope
+            !!JavaMateView::ScopeMatcher.get_match(snippet.scope, current_scope)
+          else
+            true
+          end
+        end
+        @last_list.map {|s| display(s) }
+      end
+      
+      def selected(_, ix)
+        if @last_list
+          close
+          insert_snippet(@last_list[ix])
+        end
+      end
+      
+      private
+      
+      def display(snippet)
+        "#{snippet.bundle_name} / #{snippet.name} (#{snippet.tab_trigger}↦)"
+      end
+      
+      def all_snippets
+        Snippets.registry.snippets
+      end
+      
+      def insert_snippet(snippet)
+        controller = @document.controllers(Snippets::DocumentController).first
+        controller.start_snippet!(snippet)
+      end
+    end
+  end
+end

data/plugins/snippets/lib/snippets/tab_handler.rb

@@ -0,0 +1,117 @@
+
+module Redcar
+  class Snippets
+    class TabHandler
+      def self.priority
+        10
+      end
+
+      def self.handle(edit_view, modifiers)
+        controller = edit_view.document.controllers(Snippets::DocumentController).first
+        if controller.in_snippet?
+          if modifiers == ["Shift"]
+            controller.move_backward_tab_stop
+            true
+          elsif modifiers == []
+            controller.move_forward_tab_stop
+            true
+          else
+            false
+          end
+        else
+          return false if modifiers.any?
+          find_snippet(edit_view)
+        end
+      end
+
+      def self.activate_snippet(edit_view, snippet)
+        controller = edit_view.document.controllers(Snippets::DocumentController).first
+        doc = edit_view.document
+        edit_view.compound do
+          doc.delete(doc.cursor_offset - snippet.tab_trigger.length, snippet.tab_trigger.length)
+          controller.start_snippet!(snippet)
+        end
+      end
+
+      # Decides whether a snippet can be inserted at this location. If so
+      # returns the snippet, if not returns false.
+      def self.find_snippet(edit_view)
+        document = edit_view.document
+        @word, @offset, @start_word_offset = nil, nil, nil
+        @word = word_before_cursor(edit_view)
+        if @word
+          @offset = document.cursor_offset
+          @start_word_offset = document.cursor_offset - @word.length
+          options = find_snippet_options(document.cursor_scope, @word)
+          if options.any?
+            choose_snippet(edit_view, options)
+          end
+        end
+      end
+
+      #search for snippet matches inside a word block in an intelligent way
+      def self.find_snippet_options(scope,word)
+        search_word = word
+        options = search_registry(scope,word)
+        if not options.any? and word.match(/\W/) and word.match(/\w/)
+
+          #most likely, there is just one symbol preceding the snippet
+          if not options.any? and char = word.index(/\w/,word.index(/\W/))
+            search_word   = word[char,word.split(//).length]
+            options = search_registry(scope, search_word)
+          end
+
+          #otherwise, search from the end
+          if not options.any?
+            offset = -1
+            while not options.any? and
+            (offset * -1) < word.split(//).length and
+            symbol_idx = word.rindex(/\W/,offset) and
+            char = word.index(/\w/,symbol_idx)
+              search_word   = word[char,word.split(//).length]
+              options       = search_registry(scope, search_word)
+              offset        = offset - 1
+            end
+          end
+        end
+        options
+      end
+
+      def self.search_registry(scope,word)
+        Snippets.registry.find_by_scope_and_tab_trigger(scope,word)
+      end
+
+      def self.word_before_cursor(edit_view)
+        document = edit_view.document
+        line = document.get_slice(document.cursor_line_start_offset, document.cursor_offset).reverse
+        if !line.empty? && !(line[0].chr =~ /\s/) && line =~ /([\S]+)(\s|$|\.)/
+          word = $1.reverse
+        end
+        word
+      end
+
+      def self.choose_snippet(edit_view, snippets)
+        if not snippets or snippets.length == 0
+          false
+        elsif snippets.length == 1
+          activate_snippet(edit_view, snippets.first)
+          true
+        else
+          builder = Menu::Builder.new do
+            snippets.group_by {|s| s.bundle_name }.each do |_, bsnippets|
+              bsnippets.each_with_index do |snippet, i|
+                item(snippet.name||"<untitled>") do
+                  Snippets::TabHandler.activate_snippet(edit_view, snippet)
+                end
+              end
+              separator
+            end
+          end
+          Redcar.app.focussed_window.popup_menu_with_numbers(builder.menu)
+          true
+        end
+      end
+
+    end
+  end
+end

data/plugins/snippets/plugin.rb

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

data/plugins/splash_screen/plugin.rb

@@ -0,0 +1,8 @@
+
+Plugin.define do
+  name    "splash_screen"
+  version "1.0"
+  file    "splash_screen"
+  object  "Redcar::SplashScreen"
+  dependencies "core", ">0"
+end

data/plugins/splash_screen/splash_screen.rb

@@ -0,0 +1,62 @@
+module Redcar
+  class SplashScreen
+    class << self
+      attr_reader :splash_screen
+    end
+    
+    def self.create_splash_screen(maximum)
+      @splash_screen = SplashScreen.new(maximum)
+      splash_screen.show
+    end
+
+    attr_reader :max
+    
+    def initialize(max)
+      @max = max
+      @current = 0
+    end
+    
+    def show
+      @image = Swt::Graphics::Image.new(Swt.display, Redcar.icons_directory + "/redcar-splash.png")
+      @splash = Swt::Widgets::Shell.new(Swt::SWT::NO_TRIM)
+      @bar = Swt::Widgets::ProgressBar.new(@splash, Swt::SWT::NONE)
+      @bar.setMaximum(max)
+      label = Swt::Widgets::Label.new(@splash, Swt::SWT::NONE)
+      label.setImage(@image)
+      layout = Swt::Layout::FormLayout.new
+      @splash.setLayout(layout)
+      labelData = Swt::Layout::FormData.new
+      labelData.right  = Swt::Layout::FormAttachment.new(100, 0)
+      labelData.bottom = Swt::Layout::FormAttachment.new(100, 0)
+      label.setLayoutData(labelData)
+      progressData = Swt::Layout::FormData.new
+      progressData.left   = Swt::Layout::FormAttachment.new(0, 70)
+      progressData.right  = Swt::Layout::FormAttachment.new(100, -32)
+      progressData.bottom = Swt::Layout::FormAttachment.new(100, -30)
+      @bar.setLayoutData(progressData)
+      @splash.pack
+      
+      primary = Swt.display.getPrimaryMonitor
+      bounds = primary.getBounds
+      rect = @splash.getBounds
+      x = bounds.x + (bounds.width - rect.width) / 2;
+      y = bounds.y + (bounds.height - rect.height) / 2;
+    
+      @splash.setLocation(x, y)
+      @splash.open
+      Redcar.log.debug("opened splash")
+    end
+    
+    def inc(val = 1)
+      @current += val
+      @bar.setSelection([@current, @max].min)
+    end
+    
+    def close
+      @splash.close
+      @image.dispose
+      Swt.instance_variable_set(:@splashscreen, nil)
+      Redcar.log.debug("closed splash")
+    end
+  end
+end

data/plugins/strip_trailing_spaces/features/fixtures/test.txt

@@ -0,0 +1,3 @@
+Hi 
+ 
+ Foo 

data/plugins/strip_trailing_spaces/features/strip_trailing_spaces.feature

@@ -0,0 +1,34 @@
+Feature: Strip Trailing Spaces
+  As a user
+  I sometimes want my editor to split trailing spaces on save
+
+  Background:
+    Given I will choose "plugins/strip_trailing_spaces/features/fixtures/test.txt" from the "open_file" dialog
+    And I open a file
+    And I replace the contents with "Hi \n \n Foo \n"
+
+  Scenario: Strip spaces on save
+    When I click "Enabled" from the "Plugins/Strip Trailing Spaces" menu
+    When I click "Strip Blank Lines" from the "Plugins/Strip Trailing Spaces" menu
+    And I save the tab
+    Then I should see "Hi\n\n Foo\n" in the edit tab
+
+  Scenario: Keep cursor position on save
+    When I move the cursor to 8
+    And I save the tab
+    Then the contents should be "Hi\n\n F<c>oo\n"
+
+  Scenario: Keep closest cursor position on save
+    When I move the cursor to 5
+    And I save the tab
+    Then the contents should be "Hi\n<c>\n Foo\n"
+
+  Scenario: Strip spaces, but not newlines on save
+    When I click "Strip Blank Lines" from the "Plugins/Strip Trailing Spaces" menu
+    And I save the tab
+    Then I should see "Hi\n \n Foo\n" in the edit tab
+
+  Scenario: Strip nothing on save
+    When I click "Enabled" from the "Plugins/Strip Trailing Spaces" menu
+    And I save the tab
+    Then I should see "Hi \n \n Foo \n" in the edit tab

data/plugins/strip_trailing_spaces/lib/strip_trailing_spaces.rb

@@ -0,0 +1,60 @@
+
+module Redcar
+  class StripTrailingSpaces
+    def self.enabled?
+      Redcar::StripTrailingSpaces.storage['enabled']
+    end
+
+    def self.enabled=(bool)
+      Redcar::StripTrailingSpaces.storage['enabled'] = bool
+    end
+
+    def self.strip_blank_lines?
+      Redcar::StripTrailingSpaces.storage['strip_blank_lines']
+    end
+
+    def self.strip_blank_lines=(bool)
+      Redcar::StripTrailingSpaces.storage['strip_blank_lines'] = bool
+    end
+
+    def self.storage
+      @storage ||= begin
+        storage = Plugin::Storage.new('strip_trailing_spaces_plugin')
+        storage.set_default('enabled', false)
+        storage.set_default('strip_blank_lines', false)
+        storage
+      end
+    end
+
+    def self.menus
+      Menu::Builder.build do
+        sub_menu "Plugins" do
+          sub_menu "Strip Trailing Spaces", :priority => 195 do
+            item "Enabled", :command => ToggleStripTrailingSpaces, :type => :check, :active => StripTrailingSpaces.enabled?
+            item "Strip Blank Lines", :command => ToggleStripBlankLines, :type => :check, :active => StripTrailingSpaces.strip_blank_lines?
+          end
+        end
+      end
+    end
+
+    def self.before_save(doc)
+      if (doc.mirror.is_a?(Redcar::Project::FileMirror) && StripTrailingSpaces.enabled?)
+        regex         = /[\t ]*$/ if StripTrailingSpaces.strip_blank_lines?
+        regex       ||= /([^\s]+)[\t ]+$/
+        doc.text = doc.get_all_text.gsub(regex, "\\1")
+      end
+    end
+
+    class ToggleStripTrailingSpaces < Redcar::Command
+      def execute
+        StripTrailingSpaces.enabled = !StripTrailingSpaces.enabled?
+      end
+    end
+
+    class ToggleStripBlankLines < Redcar::Command
+      def execute
+        StripTrailingSpaces.strip_blank_lines = !StripTrailingSpaces.strip_blank_lines?
+      end
+    end
+  end
+end

data/plugins/strip_trailing_spaces/plugin.rb

@@ -0,0 +1,8 @@
+Plugin.define do
+  name    "Strip Trailing Spaces"
+  version "0.3"
+  file     "lib", "strip_trailing_spaces"
+  object  "Redcar::StripTrailingSpaces"
+  dependencies "redcar", ">0",
+               "edit_view", ">0"
+end

data/plugins/syntax_check/README

@@ -0,0 +1,6 @@
+== Abstract Syntax checking Redcar
+
+Get redcar from github.com/redcar/redcar and do a git clone in your 
+$HOME/.redcar/plugins of this repository. You will also need a
+concrete syntax checker for your language, Ruby is currently supported
+in timfel/redcar_syntax_check_ruby

data/plugins/syntax_check/features/step_definitions/syntax_check_steps.rb

@@ -0,0 +1,11 @@
+Given /^I have (not )?suppressed syntax checking message dialogs$/ do |negate|
+  if negate
+    Redcar::SyntaxCheck.storage['supress_message_dialogs'] = true
+  else
+    Redcar::SyntaxCheck.storage['supress_message_dialogs'] = false
+  end
+end
+
+Given /^I excluded "(.*)" files from being checked for syntax errors$/ do |grammar|
+  Redcar::SyntaxCheck.storage['excluded_grammars'] << grammar.downcase
+end

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

@@ -0,0 +1,3 @@
+Before do
+  Redcar::SyntaxCheck.storage['excluded_grammars'] = []
+end

data/plugins/syntax_check/lib/syntax_check.rb

@@ -0,0 +1,100 @@
+require 'syntax_check/checker'
+require 'syntax_check/annotation'
+
+module Redcar
+  module SyntaxCheck
+    def self.remove_syntax_error_annotations(edit_view)
+      edit_view.remove_all_annotations :type => Annotation.type
+      edit_view.remove_all_annotations :type => Warning.type
+      edit_view.remove_all_annotations :type => Error.type
+    end
+
+    def self.menus
+      Redcar::Menu::Builder.build do
+        sub_menu "Plugins" do
+          lazy_sub_menu "Syntax Checking" do
+            item "Enabled", :type => :check, :active => SyntaxCheck.enabled?, :command => ToggleSyntaxChecking
+            separator
+            Checker.checkers.each do |checker|
+              grammar = checker[0]
+              item "#{grammar}", :type => :check, :active => SyntaxCheck.check_type?(grammar), :command => ToggleGrammarChecking, :value => grammar
+            end
+          end
+        end
+      end
+    end
+
+    def self.enabled=(state)
+      SyntaxCheck.storage['suppress_syntax_checking'] = !state
+    end
+
+    def self.enabled?
+      if SyntaxCheck.storage['suppress_syntax_checking']
+        false
+      else
+        true
+      end
+    end
+
+    def self.check_type?(grammar)
+      excluded = SyntaxCheck.storage['excluded_grammars']
+      unless grammar and (excluded.include? grammar or
+        excluded.include? grammar.downcase)
+        true
+      end
+    end
+
+    def self.set_check_type(grammar,value)
+      if grammar
+        excluded = SyntaxCheck.storage['excluded_grammars']
+        if check_type?(grammar)
+          excluded << grammar.downcase
+        else
+          excluded = excluded - [grammar,grammar.downcase]
+        end
+        SyntaxCheck.storage['excluded_grammars'] = excluded
+      end
+    end
+
+    def self.storage
+      @storage ||= begin
+        storage = Plugin::Storage.new('syntax_checking')
+        storage.set_default('suppress_message_dialogs',false)
+        storage.set_default('suppress_syntax_checking',false)
+        storage.set_default('excluded_grammars',[])
+        storage
+      end
+    end
+
+    def self.message(message,type)
+      unless SyntaxCheck.storage['suppress_message_dialogs']
+        Redcar::Application::Dialog.message_box(
+        message,{:type => type})
+      end
+    end
+
+    def self.after_save(doc)
+      grammar  = doc.edit_view.grammar
+      remove_syntax_error_annotations(doc.edit_view)
+      if SyntaxCheck.enabled? and SyntaxCheck.check_type?(grammar)
+        checker = Checker[doc.edit_view.grammar]
+        checker.new(doc).check if checker
+      end
+    end
+
+    class ToggleGrammarChecking < Redcar::Command
+      def execute(options)
+        if grammar = options[:value]
+          value = !SyntaxCheck.check_type?(grammar)
+          SyntaxCheck.set_check_type(grammar,value)
+        end
+      end
+    end
+
+    class ToggleSyntaxChecking < Redcar::Command
+      def execute
+        SyntaxCheck.enabled = !SyntaxCheck.enabled?
+      end
+    end
+  end
+end