redcar 0.3.4.3 → 0.3.5

data/plugins/core/spec/core/task_queue_spec.rb

@@ -0,0 +1,202 @@
+
+require 'java'
+
+require File.join(File.dirname(__FILE__), *%w".. spec_helper")
+
+TaskQueue = Redcar::TaskQueue
+Task      = Redcar::Task
+
+describe TaskQueue do
+  before do
+    $started_tasks = []
+    @q = TaskQueue.new
+  end
+  
+  after do
+    @q.stop
+  end
+  
+  describe "running tasks" do
+    it "should accept tasks and call them" do
+      @q.submit(QuickTask.new(101)).get
+      $started_tasks.should == [101]
+    end
+    
+    it "should call tasks in order" do
+      @q.submit(QuickTask.new(101))
+      @q.submit(QuickTask.new(102))
+      @q.submit(QuickTask.new(103)).get
+      $started_tasks.should == [101, 102, 103]
+    end
+    
+    it "should return the result of the Task execute method" do
+      @q.submit(QuickTask.new(103)).get.should == :hiho
+    end
+  end
+  
+  describe "cancelling tasks" do
+    before do
+      $wait_task_finish = false
+    end
+    
+    class WaitTask < QuickTask
+      def execute
+        super
+        1 until $wait_task_finish
+      end
+    end
+    
+    it "can be cancelled" do
+      @q.submit(QuickTask.new(101))
+      @q.submit(WaitTask.new(102))
+      @q.submit(task = QuickTask.new(103))
+      task.cancel
+      $wait_task_finish = true
+      sleep 0.1
+      $started_tasks.should == [101, 102]
+      @q.pending.should be_empty
+      task.should be_cancelled
+    end
+    
+    it "can cancel all pending tasks" do
+      @q.submit(WaitTask.new(102))
+      @q.submit(task1 = QuickTask.new(103))
+      @q.submit(task2 = QuickTask.new(104))
+      1 until $started_tasks.include?(102)
+      @q.cancel_all
+      $wait_task_finish = true
+      $started_tasks.should == [102]
+    end
+  end
+  
+  describe "information" do
+    describe "about pending tasks" do
+      it "should tell you about tasks that have not been started yet" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        @q.pending.include?(t2).should be_true
+      end
+      
+      it "should not include in process tasks" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:a)
+        @q.pending.include?(t1).should be_false
+      end
+      
+      it "should not include completed tasks" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        @q.pending.include?(t1).should be_false
+      end
+      
+      it "should tell you when it was enqueued" do
+        @q.submit(t1 = QuickTask.new(:a))
+        t1.enqueue_time.should be_an_instance_of(Time)
+      end
+      
+      it "should tell you it is pending" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:a)
+        t2.should be_pending
+        t2.should_not be_completed
+        t2.should_not be_in_process
+      end
+    end
+    
+    describe "in process tasks" do
+      it "should tell you which task is in process" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        1 until $started_tasks.include?(:a)
+        @q.in_process.should == t1
+      end
+      
+      it "should tell you when it was started" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        1 until $started_tasks.include?(:a)
+        t1.start_time.should be_an_instance_of(Time)
+      end
+      
+      it "should tell you they are in process" do
+        @q.submit(t1 = BlockingTask.new(:a))
+        1 until $started_tasks.include?(:a)
+        t1.should be_in_process
+        t1.should_not be_pending
+        t1.should_not be_completed
+      end
+    end
+    
+    describe "completed tasks" do
+      it "should tell you which tasks have completed" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        @q.completed.include?(t1).should be_true
+      end
+      
+      it "should not include in process tasks" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        @q.completed.include?(t2).should be_false
+      end
+      
+      it "should not include in pending tasks" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        @q.submit(t3 = BlockingTask.new(:c))
+        1 until $started_tasks.include?(:b)
+        @q.completed.include?(t3).should be_false
+      end
+      
+      it "should tell you when it was completed" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        t1.completed_time.should be_an_instance_of(Time)
+      end
+      
+      it "should tell you they are completed" do
+        @q.submit(t1 = QuickTask.new(:a))
+        @q.submit(t2 = BlockingTask.new(:b))
+        1 until $started_tasks.include?(:b)
+        t1.should be_completed
+        t1.should_not be_pending
+        t1.should_not be_in_process
+      end
+    end
+  end
+  
+  describe "errored tasks" do
+    class ErrorTask < QuickTask
+      def execute
+        $started_tasks << @id
+        raise 'error'
+      end
+    end
+    
+    it "should be in completed task list" do
+      @q.submit(t1 = ErrorTask.new(:a))
+      @q.submit(t2 = BlockingTask.new(:b))
+      1 until $started_tasks.include?(:b)
+      @q.completed.should == [t1]
+    end
+    
+    it "should have the error" do
+      @q.submit(t1 = ErrorTask.new(:a))
+      @q.submit(t2 = BlockingTask.new(:b))
+      1 until $started_tasks.include?(:b)
+      @q.completed.first.error.should be_an_instance_of(RuntimeError)
+    end
+  end
+end
+
+
+
+
+
+
+
+

data/plugins/core/spec/spec_helper.rb

@@ -2,4 +2,26 @@ $:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
 
 require 'redcar'
 Redcar.environment = :test
-Redcar.load
+Redcar.load
+
+class QuickTask < Redcar::Task
+  def initialize(id=nil)
+    @id = id
+  end
+  
+  def execute
+    $started_tasks << @id
+    :hiho
+  end
+  
+  def inspect
+    "<#{self.class} #{@id}>"
+  end
+end
+
+class BlockingTask < QuickTask
+  def execute
+    $started_tasks << @id
+    loop { break if java.lang.Thread.interrupted }
+  end
+end

data/plugins/declarations/TODO

@@ -0,0 +1,3 @@
+* automagicaly match word under cursor
+* automagically update tags file (watchr / gtags)
+* automagically create tags file? (when shift+ctrl+T pressed first time)

data/plugins/declarations/lib/declarations.rb

@@ -0,0 +1,144 @@
+
+require 'declarations/completion_source'
+require 'declarations/file'
+require 'declarations/parser'
+require 'declarations/select_tag_dialog'
+require 'tempfile'
+
+module Redcar
+  class Declarations
+    def self.menus
+      Menu::Builder.build do
+        sub_menu "Project" do
+          item "Go to declaration", Declarations::GoToTagCommand
+        end
+      end
+    end
+
+    def self.keymaps
+      linwin = Keymap.build("main", [:linux, :windows]) do
+        link "Ctrl+G", Declarations::GoToTagCommand
+      end
+
+      osx = Keymap.build("main", :osx) do
+        link "Cmd+G", Declarations::GoToTagCommand
+      end
+
+      [linwin, osx]
+    end
+
+    def self.autocompletion_source_types
+      [] #[Declarations::CompletionSource]
+    end
+
+    def self.file_path(project)
+      ::File.join(project.path, 'tags')
+    end
+    
+    class ProjectRefresh < Task
+      def initialize(project)
+        @file_list   = project.file_list
+        @project     = project
+      end
+      
+      def description
+        "#{@project.path}: reparse files for declarations"
+      end
+      
+      def execute
+        file = Declarations::File.new(Declarations.file_path(@project))
+        file.update_files(@file_list)
+        file.dump
+        Declarations.clear_tags_for_path(file.path)
+      end
+    end
+    
+    def self.project_refresh_task_type
+      ProjectRefresh
+    end
+
+    def self.tags_for_path(path)
+      @tags_for_path ||= {}
+      @tags_for_path[path] ||= begin
+        tags = {}
+        ::File.read(path).each_line do |line|
+          key, file, *match = line.split("\t")
+          if [key, file, match].all? { |el| !el.nil? && !el.empty? }
+            tags[key] ||= []
+            tags[key] << { :file => file, :match => match.join("\t").chomp }
+          end
+        end
+        tags
+      rescue Errno::ENOENT
+        {}
+      end
+    end
+    
+    def self.clear_tags_for_path(path)
+      @tags_for_path ||= {}
+      @tags_for_path.delete(path)
+    end
+
+    def self.go_to_definition(match)
+      path = match[:file]
+      Project::Manager.open_file(path)
+      regexp = Regexp.new(Regexp.escape(match[:match]))
+      Redcar::Top::FindNextRegex.new(regexp, true).run
+    end
+
+    class GoToTagCommand < EditTabCommand
+
+      def execute
+        if doc.selection?
+          handle_tag(doc.selected_text)
+        else
+          line = doc.get_line(doc.cursor_line)
+          left = doc.cursor_line_offset - 1
+          right = doc.cursor_line_offset
+          left_range = 0
+          right_range = 0
+          offset = doc.cursor_offset
+          
+          until left == -1 || AutoCompleter::WORD_CHARACTERS !~ (line[left].chr)
+            left -= 1
+            left_range -= 1
+          end
+          until right == line.length || AutoCompleter::WORD_CHARACTERS !~ (line[right].chr)
+            right += 1
+            right_range += 1
+          end
+          handle_tag(doc.get_slice(doc.cursor_offset+left_range, doc.cursor_offset+right_range))
+        end
+      end
+
+      def handle_tag(token = '')
+        tags_path = Declarations.file_path(Project::Manager.focussed_project)
+        unless ::File.exist?(tags_path)
+          Application::Dialog.message_box("The declarations file 'tags' has not been generated yet.")
+          return
+        end
+        matches = find_tag(tags_path, token)
+        case matches.size
+        when 0
+          Application::Dialog.message_box("There is no declaration for '#{token}' in the 'tags' file.")
+        when 1
+          Redcar::Declarations.go_to_definition(matches.first)
+        else
+          open_select_tag_dialog(matches)
+        end
+      end
+
+      def find_tag(tags_path, tag)
+        Declarations.tags_for_path(tags_path)[tag] || []
+      end
+
+      def open_select_tag_dialog(matches)
+        Declarations::SelectTagDialog.new(matches).open
+      end
+
+      def log(message)
+        puts("==> Ctags: #{message}")
+      end
+    end
+  end
+end

data/plugins/declarations/lib/declarations/completion_source.rb

@@ -0,0 +1,22 @@
+module Redcar
+  class Declarations
+    class CompletionSource
+      def initialize(_, project)
+        @project = project
+      end
+      
+      def alternatives(prefix)
+        if @project
+          word_list = AutoCompleter::WordList.new
+          tags = Declarations.tags_for_path(Declarations.file_path(@project))
+          tags.keys.each do |tag| 
+            if tag[0..(prefix.length-1)] == prefix
+              word_list.add_word(tag, 10000)
+            end
+          end
+          word_list
+        end
+      end
+    end
+  end
+end

data/plugins/declarations/lib/declarations/file.rb

@@ -0,0 +1,68 @@
+
+module Redcar
+  class Declarations
+    class File
+      attr_reader   :tags, :path
+      attr_accessor :last_updated
+      
+      def initialize(path)
+        @path = path
+        @tags = []
+        load
+      end
+      
+      def load
+        @tags = []
+        @last_updated = Time.at(0)
+        if ::File.exist?(path)
+          first_line = true
+          ::File.read(path).each_line do |line|
+            if first_line
+              first_line = false
+              @last_updated = Time.at(line.chomp.to_i)
+            end
+            key, path, *match = line.split("\t")
+            if [key, path, match].all? { |el| !el.nil? && !el.empty? }
+              @tags << [key, path, match.join("\t").chomp]
+            end
+          end
+        end
+      end
+      
+      def update_files(file_list)
+        changed_files = file_list.changed_since(last_updated)
+        changed_files.delete(@path)
+        @tags = @tags.select do |_, path, _|
+          file_list.contains?(path) and !changed_files[path]
+        end
+        add_tags_for_paths(changed_files.keys)
+        @last_updated = Time.now
+      end
+      
+      def add_tags_for_paths(add_paths)
+        parser = Declarations::Parser.new
+        parser.parse(add_paths)
+        add_tags(parser.tags)
+      end
+      
+      def add_tags(tags)
+        @tags += tags
+      end
+      
+      def dump
+        @tags.sort!
+        tags_file_path = nil
+        Tempfile.open('tags') do |tags_file|
+          tags_file.puts(@last_updated.to_i.to_s)
+          @tags.each do |id, path, declaration|
+            tags_file.puts "#{id}\t#{path}\t#{declaration}"
+          end
+          tags_file.flush
+          tags_file_path = tags_file.path
+        end
+        FileUtils.cp(tags_file_path, path)
+        FileUtils.rm(tags_file_path)
+      end
+    end
+  end
+end