redcar 0.7 → 0.8

data/plugins/runnables/lib/runnables/tree_mirror/nodes/runnable_group.rb

@@ -2,39 +2,17 @@ module Redcar
   class Runnables
     class RunnableGroup
       include Redcar::Tree::Mirror::NodeMirror
+      attr_reader :text
 
-      def initialize(name,path,runnables)
-        @children = []
-        @name = name
-        if runnables.any?
-          group = []
-          type = nil
-          i = 0
-          runnables.map.sort_by{|r|r["type"]||""}.each do |runnable|
-            if runnable["type"] == nil or runnable["type"] == ""
-              @children << Runnable.new(runnable["name"],path,runnable)
-            elsif type.nil?
-              type = runnable["type"]
-              group << runnable
-            elsif type == runnable["type"]
-              group << runnable
-            end
-            if i == runnables.length - 1 or type != runnable["type"]
-              if type == name
-                group.each {|r| @children << Runnable.new(r["name"],path,r)}
-              else
-                type = type[name.length,type.length] if type =~ /^#{name}/
-                type = type[1,type.length] if type =~ /^\//
-                if type == ""
-                  @children << Runnable.new(runnable["name"],path,runnable)
-                else
-                  @children << RunnableTypeGroup.new(type,path,group) unless group.size == 0
-                end
-              end
-              type = runnable["type"]
-              group = [runnable]
-            end
-            i = i + 1
+      def initialize(name, path, runnables)
+        @text      = name
+        @runnables = []
+        @subgroups = {}
+        runnables.each do |runnable|
+          if runnable["type"].nil? or runnable["type"].empty?
+            @runnables << Runnable.new(runnable["name"], path, runnable)
+          else
+            type_group(runnable["type"]).add_runnable Runnable.new(runnable["name"], path, runnable)
           end
         end
       end
@@ -43,16 +21,24 @@ module Redcar
         false
       end
 
-      def text
-        @name
-      end
-
       def icon
         :file
       end
 
+      # Sort the subgroups first, the runnables after that
       def children
-        @children
+        @children ||= (@subgroups.sort_by(&:first).collect(&:last) + @runnables.sort_by(&:text))
+      end
+
+      # Return the type group that corresponds to the passed name-path, or self, if name is empty
+      # If a child with the specified path does not exist, create it and clear the children cache
+      def type_group(name)
+        names = name.split("/")
+        unless @subgroups[names.first]
+          @children = nil
+          @subgroups[names.first] = RunnableTypeGroup.new(names.first)
+        end
+        @subgroups[names.first].type_group(names[1..-1].join)
       end
     end
   end

data/plugins/runnables/lib/runnables/tree_mirror/nodes/runnable_type_group.rb

@@ -1,32 +1,30 @@
 module Redcar
   class Runnables
-    class RunnableTypeGroup
-      include Redcar::Tree::Mirror::NodeMirror
-
-      def initialize(name,path,runnables)
-        @name = name
-        if runnables.any?
-          @children = runnables.map do |runnable|
-            Runnable.new(runnable["name"],path,runnable)
-          end
-        end
+    class RunnableTypeGroup < RunnableGroup
+      def initialize(name)
+        name_parts = name.split("/")
+        @text = name_parts.first
+        @runnables = []
+        @subgroups = {}
       end
 
-      def leaf?
-        false
+      # Return the type group that corresponds to the passed name-path, or self, if name is empty
+      # If a child with the specified path does not exist, create it and clear the children cache
+      def type_group(name)
+        return super unless name.empty?
+        self
       end
 
-      def text
-        @name
+      # Add a runnable to the children
+      # Tries to avoid re-building the children array
+      def add_runnable(runnable)
+        @children << runnable unless @children.nil?
+        return @runnables << runnable
       end
 
       def icon
         File.join(Redcar::ICONS_DIRECTORY, "folder-open-small-gears.png")
       end
-
-      def children
-        @children
-      end
     end
   end
 end

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

@@ -1,6 +1,3 @@
-RequireSupportFiles File.dirname(__FILE__) + "/../../../application/features/"
-RequireSupportFiles File.dirname(__FILE__) + "/../../../project/features/"
-RequireSupportFiles File.dirname(__FILE__) + "/../../../runnables/features/"
 require File.join(Redcar.asset_dir, "svnkit")
 require 'java'
 import 'org.tmatesoft.svn.core.io.SVNRepositoryFactory'

data/plugins/snippets/features/snippets.feature

@@ -13,6 +13,21 @@ Feature: Snippets
     And I press the Tab key in the edit tab
     Then the contents should be "Daniel Benjamin Lucraft<c>"
 
+  Scenario: Snippet text preceded by other characters and separated by non-word characters
+    Given there is a snippet with tab trigger "ewf" and scope "" and content
+      """
+        Earth, Wind, and Fire
+      """
+    When I replace the contents with "}}ewf<c>"
+    And I press the Tab key in the edit tab
+    Then the contents should be "}}Earth, Wind, and Fire<c>"
+    When I replace the contents with "(1,2,4)}}ewf<c>"
+    And I press the Tab key in the edit tab
+    Then the contents should be "(1,2,4)}}Earth, Wind, and Fire<c>"
+    When I replace the contents with "blank.test1.ewf<c>"
+    And I press the Tab key in the edit tab
+    Then the contents should be "blank.test1.Earth, Wind, and Fire<c>"
+
   Scenario: Simple content snippet in plain text scope
     Given there is a snippet with tab trigger "DBL" and scope "text.plain" and content
       """
@@ -75,7 +90,7 @@ Feature: Snippets
     When I replace the contents with "if<c>"
     And I press the Tab key in the edit tab
     Then the contents should be "if <c>\n\t\nend"
-    
+
   Scenario: Escapes dollars
     Given there is a snippet with tab trigger "DBL" and scope "text.plain" and content
       """
@@ -336,7 +351,7 @@ Feature: Snippets
     Then the contents should be "def <s>fname<c> docstring for fname\"\"\"\n"
     When I replace 4 to 9 with ""
     Then the contents should be "def <c> docstring for \"\"\"\n"
-    
+
   Scenario: Abutting dollars 2
     Given there is a snippet with tab trigger "def" and scope "text.plain" and content
       """

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

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

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

@@ -5,7 +5,7 @@ module Redcar
       def self.priority
         10
       end
-    
+
       def self.handle(edit_view, modifiers)
         controller = edit_view.document.controllers(Snippets::DocumentController).first
         if controller.in_snippet?
@@ -23,31 +23,64 @@ module Redcar
           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
-        doc.delete(doc.cursor_offset - snippet.tab_trigger.length, snippet.tab_trigger.length)
-        controller.start_snippet!(snippet)
+        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 = Snippets.registry.find_by_scope_and_tab_trigger(document.cursor_scope, @word)
+          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
@@ -56,7 +89,7 @@ module Redcar
         end
         word
       end
-      
+
       def self.choose_snippet(edit_view, snippets)
         if not snippets or snippets.length == 0
           false
@@ -64,18 +97,18 @@ module Redcar
           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|
+          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) 
+                  Snippets::TabHandler.activate_snippet(edit_view, snippet)
                 end
-            	end
-            	separator
+              end
+              separator
             end
-        	end
-        	Redcar.app.focussed_window.popup_menu_with_numbers(builder.menu)
-        	true
+          end
+          Redcar.app.focussed_window.popup_menu_with_numbers(builder.menu)
+          true
         end
       end
 

data/plugins/swt/lib/swt/cucumber_patches.rb

@@ -1,88 +1,33 @@
 
 module Cucumber
   module Ast
-    class StepInvocation #:nodoc:# 
+    class StepInvocation #:nodoc:#
       class << self
         attr_accessor :wait_time
       end
-      
-      def invoke(step_mother, options)
-        block = Swt::RRunnable.new do
-          find_step_match!(step_mother)
-          unless @skip_invoke || options[:dry_run] || @exception || @step_collection.exception
-            @skip_invoke = true
-            begin
-              @step_match.invoke(@multiline_arg)
-              step_mother.after_step
-              status!(:passed)
-            rescue Pending => e
-              failed(options, e, false)
-              status!(:pending)
-            rescue Undefined => e
-              failed(options, e, false)
-              status!(:undefined)
-            rescue Exception => e
-              failed(options, e, false)
-              status!(:failed)
-            end
-          end
-        end
-        
-        Redcar::ApplicationSWT.display.syncExec(block)
 
-        if ENV["SLOW_CUKES"]
-          sleep ENV["SLOW_CUKES"].to_f
-        end
+      def invoke_with_swt(step_mother, options)
+        block = Swt::RRunnable.new { invoke_without_swt(step_mother, options) }
+
+        Redcar::ApplicationSWT.display.syncExec(block)
+        sleep ENV["SLOW_CUKES"].to_f if ENV["SLOW_CUKES"]
         sleep(Cucumber::Ast::StepInvocation.wait_time || 0)
         Cucumber::Ast::StepInvocation.wait_time = nil
       end
-    end
-  end
 
-  module RbSupport
-    class RbLanguage
-      def require_support_files(path)
-        @step_mother.load_code_files(Cli::Configuration.code_files_in_paths([path]))
-      end
+      alias_method :invoke_without_swt, :invoke
+      alias_method :invoke, :invoke_with_swt
     end
-    
-    module RbDsl
-      def RequireSupportFiles(path)
-        RbDsl.require_support_files(path)
-      end
-      
-      class << self
-        def require_support_files(path)
-          @rb_language.require_support_files(path)
-        end
-      end
-    end
-    
   end
-  
+
   module Cli
     class Configuration
-      def all_files_to_load
-        requires = @options[:require].empty? ? require_dirs : @options[:require]
-        files = Configuration.code_files_in_paths(requires)
-        remove_excluded_files_from(files)
-        files
+      def require_dirs_with_redcar_plugins
+        require_dirs_without_redcar_plugins + Dir['plugins/*/features']
       end
 
-      class << self
-        def code_files_in_paths(requires)
-          files = requires.map do |path|
-            path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
-            path = path.gsub(/\/$/, '') # Strip trailing slash.
-            File.directory?(path) ? Dir["#{path}/**/*"] : path
-          end.flatten.uniq
-          files.map!    {|f| File.expand_path(f) }
-          files.reject! {|f| !File.file?(f)}
-          files.reject! {|f| File.extname(f) == '.feature' }
-          files.reject! {|f| f =~ /^http/}
-          files
-        end
-      end
+      alias_method :require_dirs_without_redcar_plugins, :require_dirs
+      alias_method :require_dirs, :require_dirs_with_redcar_plugins
     end
   end
 end

data/plugins/swt/lib/swt/cucumber_runner.rb

@@ -11,9 +11,8 @@ module Swt
         begin
           sleep START_DELAY
           main = Cucumber::Cli::Main.new(args)
-          main.execute!(Cucumber::StepMother.new)
+          main.execute!
           Redcar.app.quit
-          Redcar::ApplicationSWT.display.wake
         rescue Object => e
           puts e.message
           puts e.backtrace
@@ -21,4 +20,4 @@ module Swt
       end
     end
   end
-end
+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/lib/syntax_check.rb

@@ -0,0 +1,16 @@
+require 'syntax_check/checker'
+require 'syntax_check/error'
+
+module Redcar
+  module SyntaxCheck
+    def self.remove_syntax_error_annotations(edit_view)
+      edit_view.remove_all_annotations :type => Error::Type
+    end
+
+    def self.after_save(doc)
+      remove_syntax_error_annotations(doc.edit_view)
+      checker = Checker[doc.edit_view.grammar]
+      checker.new(doc).check if checker
+    end
+  end
+end

data/plugins/syntax_check/lib/syntax_check/checker.rb

@@ -0,0 +1,47 @@
+module Redcar
+  module SyntaxCheck
+    class Checker
+      attr_reader :doc
+
+      def self.checkers
+        @checkers ||= {}
+      end
+
+      def self.[] name
+        checkers[name]
+      end
+
+      def self.supported_grammars(*names)
+        if names.any?
+          names.each {|g| Checker.checkers[g] = self }
+          @supported_grammars = supported_grammars + names
+        else
+          @supported_grammars ||= []
+        end
+      end
+
+      def initialize(document)
+        @doc = document
+      end
+
+      def manifest_path(doc = @doc)
+        path = doc.path
+        unless path and File.exist? path
+          Tempfile.open(doc.title) do |f|
+            f << doc.get_all_text
+            path = f.path
+          end
+        end
+        path
+      end
+
+      def supported_grammars
+        raise NotImplementedError, "My subclass #{self.class.name} should have implemented check"
+      end
+
+      def check
+        raise NotImplementedError, "My subclass #{self.class.name} should have implemented check"
+      end
+    end
+  end
+end