redcar 0.12.1 → 0.13

data/plugins/ruby/lib/ruby/syntax_checker.rb

@@ -1,21 +1,21 @@
 require 'java'
 
+import org.jruby.parser.Parser
+import org.jruby.parser.ParserConfiguration
+import org.jruby.CompatVersion
+
 module Redcar
   class Ruby
     class SyntaxChecker < Redcar::SyntaxCheck::Checker
       supported_grammars "Ruby", "Ruby on Rails", "RSpec"
 
       def check(*args)
-        path    = manifest_path(doc)
-        file    = File.basename(path)
-        runtime = org.jruby.Ruby.global_runtime
-        io      = java.io.FileInputStream.new(java.io.File.new(path))
+        path = manifest_path(doc)
+        file = File.basename(path)
         begin
-          runtime.parse_from_main(io, file)
+          parser.parse(file, doc.to_s.to_java.get_bytes, config_19.scope, config_19)
         rescue SyntaxError => e
           create_syntax_error(doc, e.exception.message, file).annotate
-        ensure
-          io.close
         end
       end
 
@@ -25,6 +25,26 @@ module Redcar
         message  = $2
         Redcar::SyntaxCheck::Error.new(doc, line, message)
       end
+      
+      private
+      
+      def runtime
+        org.jruby.Ruby.global_runtime
+      end
+
+      def parser
+        @parser ||= Parser.new(runtime)
+      end
+      
+      def config_19
+        @config_19 ||= ParserConfiguration.new(runtime, 0, false, CompatVersion::RUBY1_9)
+      end
+
+      def config_18
+        @config_18 ||= ParserConfiguration.new(runtime, 0, false, CompatVersion::RUBY1_8)
+      end
     end
   end
 end
+
+

data/plugins/scm/lib/scm.rb

@@ -126,9 +126,6 @@ module Redcar
       end
 
       def self.project_loaded(project)
-        # for now we only want to attempt to handle the local case
-        return if project.remote?
-
         Redcar.log.debug "SCM #{modules.count} SCM modules loaded."
 
         repo = modules_instance.find do |m|
@@ -149,15 +146,7 @@ module Redcar
         begin
           # associate this repository with a project internally
           project_repositories[project] = {'repo' => repo}
-
-          # load the repository and inject adapter if there is one
           repo.load(project.path)
-          adapter = repo.adapter(project.adapter)
-          if not adapter.nil?
-            Redcar.log.debug "SCM Attaching a custom adapter to the project."
-            project.adapter = adapter
-          end
-
           project_repositories[project]['trees'] = []
         rescue
           # cleanup
@@ -265,7 +254,7 @@ module Redcar
                         end
                       }
 
-                      item branch, :type => :radio, :active => (branch == current), &action
+                      item branch, :type => :radio, :checked => (branch == current), &action
                     end
                   end
                 end

data/plugins/sessions/lib/sessions.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+
+require 'sessions/memory'
+require 'sessions/loader'
+require 'sessions/cursor_saver'
+
+class Sessions
+  def self.project_loaded(project)
+    Sessions::Memory.project_loaded(project)
+    Sessions::Loader.project_loaded(project)
+  end
+
+  def self.project_closed(project, window)
+    Sessions::Memory.project_closed(project, window)
+    Sessions::Loader.project_closed(project, window)
+    Sessions::CursorSaver.project_closed(project, window)
+  end
+  
+  def self.tab_added(tab)
+    Sessions::CursorSaver.tab_added(tab)
+  end
+end

data/plugins/sessions/lib/sessions/cursor_saver.rb

@@ -0,0 +1,162 @@
+class Sessions
+  class CursorSaver
+
+    def self.project_closed(project, window)
+      open_tabs(project, window).each do |tab|
+        tab.remove_listener(tab_close_handlers.delete(tab))
+        save_cursor(tab.document, project)
+      end
+    end
+    
+    def self.tab_added(tab)
+      if document = tab.document
+        document_new_mirror_handlers[tab] = document.add_listener(:new_mirror) do
+          document.remove_listener(document_new_mirror_handlers.delete(document))
+          
+          if tab.document && tab.document.path
+            tab_focus_handlers[tab] = tab.add_listener(:focus) do
+              tab.remove_listener(tab_focus_handlers.delete(tab))
+              CursorSaver.restore_cursor(document)
+            end
+            
+            tab_close_handlers[tab] = tab.add_listener(:before => :close) do
+              tab.remove_listener(tab_close_handlers.delete(tab))
+              CursorSaver.save_cursor(document) if document.path
+            end
+          end
+        end
+      end
+    end
+    
+    def self.save_cursor(document, project = nil)
+      data = {
+        :path          => document.path,
+        :cursor_offset => document.cursor_offset,
+        :timestamp     => document.mirror.timestamp
+      }
+      if document.selection?
+        data[:selection_offset]     = document.selection_offset
+        data[:block_selection_mode] = document.block_selection_mode?
+      end
+      restored_paths.delete(document.path) # FIXME(chrislwade): see note on <restored_paths>
+      Redcar.log.debug("Sessions::CursorSaver: saving cursor data: #{data.inspect}")
+      save_file_data(data, project)
+    end
+    
+    def self.restore_cursor(document)
+      return if restored_paths[document.path] # FIXME(chrislwade): see note on <restored_paths>
+      data = get_file_data(document.path)
+      return if data.nil?
+      restored_paths[document.path] = true # FIXME(chrislwade): see note on <restored_paths>
+      Redcar.log.debug("Sessions::CursorSaver: restoring cursor data: #{data.inspect}")
+      if data[:cursor_offset] > document.length
+        Redcar.log.debug("Sessions::CursorSaver: offset #{data[:cursor_offset]} doesn't exist, truncated file? [max offset = #{document.length}]")
+      elsif user_storage['check_timestamps'] && data[:timestamp] != document.mirror.timestamp
+        Redcar.log.debug("Sessions::CursorSaver: timestamp #{data[:timestamp]} doesn't match! [new timestamp = #{document.mirror.timestamp}]")
+      else
+        if user_storage['restore_selection'] && data.has_key?(:selection_offset) && data[:selection_offset] <= document.length
+          document.set_selection_range(data[:cursor_offset], data[:selection_offset])
+          document.block_selection_mode = data[:block_selection_mode]
+        else
+          document.cursor_offset = data[:cursor_offset]
+        end
+        document.ensure_cursor_visible
+      end
+    end
+    
+    private
+    
+    # FIXME(chrislwade): find a better way to prevent "double restore"
+    # Helps prevent double-restore once Redcar is running.  When files are opened via the
+    # project tree, the tab receives the :focus event twice.  When they are opened programmatically,
+    # the tab only receives a single :focus event.  Unfortunately, removing the :focus handler during
+    # handler itself doesn't prevent a second run!
+    def self.restored_paths
+      @restored_paths ||= {}
+    end
+    
+    def self.document_new_mirror_handlers
+      @document_new_mirror_handlers ||= {}
+    end
+    
+    def self.tab_close_handlers
+      @tab_close_handlers ||= {}
+    end
+    
+    def self.tab_focus_handlers
+      @tab_focus_handlers ||= {}
+    end
+    
+    def self.user_storage
+      @storage ||= begin
+        storage = Redcar::Plugin::Storage.new('cursor_saver')
+        storage.set_default('cursor_positions', [])
+        storage.set_default('files_to_retain', 200)
+        storage.set_default('check_timestamps', true)
+        storage.set_default('restore_selection', true)
+        storage
+      end
+    end
+    
+    def self.project_storage(project)
+      storage = project.storage('cursor_saver')
+      storage.set_default('cursor_positions', [])
+      storage.set_default('files_to_retain', 0)
+      storage
+    end
+    
+    def self.project_for_path(path)
+      Redcar.log.debug("Sessions::CursorSaver: searching for open project for #{path}")
+      project = Redcar::Project::Manager.find_projects_containing_path(path).last
+      Redcar.log.debug("Sessions::CursorSaver: found: #{project.inspect}")
+      project
+    end
+    
+    def self.open_tabs(project, window)
+      window.all_tabs.select do |tab|
+        tab.is_a?(Redcar::EditTab) &&
+        tab.document.path &&
+        tab.document.path.start_with?(project.path)
+      end
+    end
+    
+    def self.trim(storage)
+      if storage['files_to_retain'] && storage['files_to_retain'] > 0
+        while storage['cursor_positions'].length > storage['files_to_retain']
+          storage['cursor_positions'].shift
+        end
+      end
+    end
+    
+    def self.save_file_data(data, project = nil)
+      if project ||= project_for_path(data[:path])
+        storage = project_storage(project)
+        data[:path] = data[:path][(project.path.length + 1) .. data[:path].length]
+        Redcar.log.debug("Sessions::CursorSaver: using project storage to store offset for #{data[:path]}")
+      else
+        storage = user_storage
+        pathname = Pathname.new(data[:path])
+        data[:path] = pathname.absolute? ? pathname.to_s : pathname.expand_path.to_s
+        Redcar.log.debug("Sessions::CursorSaver: using user storage to store offset for #{data[:path]}")
+      end
+      storage['cursor_positions'].delete_if {|obj| obj[:path] == data[:path]}
+      storage['cursor_positions'] << data
+      trim(storage)
+      storage.save
+    end
+    
+    def self.get_file_data(path)
+      if project = project_for_path(path)
+        storage = project_storage(project)
+        scoped_path = path[(project.path.length + 1) .. path.length]
+        Redcar.log.debug("Sessions::CursorSaver: restoring offset from project storage for #{scoped_path}")
+      else
+        storage = user_storage
+        pathname = Pathname.new(path)
+        scoped_path = pathname.absolute? ? pathname.to_s : pathname.expand_path.to_s
+        Redcar.log.debug("Sessions::CursorSaver: restoring offset from user storage for #{scoped_path}")
+      end
+      storage['cursor_positions'].find {|obj| obj[:path] == scoped_path}
+    end
+  end
+end

data/plugins/sessions/lib/sessions/loader.rb

@@ -0,0 +1,99 @@
+class Sessions
+  class Loader
+    def self.loaders
+      @loaders ||= {}
+    end
+    
+    def self.project_loaded(project)
+      loaders[project.path] = loader = self.new(project)
+      loader.restore if restore_files?
+    end
+    
+    def self.project_closed(project, window)
+      loader = loaders.delete(project.path)
+      loader.save if save_files?
+    end
+    
+    def self.storage
+      @storage ||= begin
+        storage = Redcar::Plugin::Storage.new('project_loader')
+        storage.set_default('restore_open_files_on_load', true)
+        storage.set_default('save_open_files_on_close',   true)
+        storage
+      end
+    end
+    
+    def self.restore_files?
+      storage['restore_open_files_on_load']
+    end
+    
+    def self.restore_files=(toggle)
+      storage['restore_open_files_on_load'] = toggle
+    end
+    
+    def self.restore_project_files(project)
+      loaders[project.path].restore
+    end
+    
+    def self.save_files?
+      storage['save_open_files_on_close']
+    end
+    
+    def self.save_files=(toggle)
+      storage['save_open_files_on_close'] = toggle
+    end
+    
+    def self.save_project_files(project)
+      loaders[project.path].save
+    end
+    
+    attr_accessor :project
+    
+    def initialize(project)
+      @project = project
+    end
+    
+    def storage
+      @storage ||= begin
+        storage = project.storage('project_loader')
+        storage.set_default('open_files', [])
+        storage
+      end
+    end
+    
+    def open_files
+      Redcar.app.all_tabs.select do |tab|
+        tab.is_a?(Redcar::EditTab) &&
+        tab.document && tab.document.path &&
+        tab.document.path.start_with?(project.path)
+      end.collect do |tab|
+        path = tab.document.path
+        path = path[project.path.length + 1 .. path.length]
+      end
+    end
+    
+    def saved_files
+      storage['open_files'] ||= []
+    end
+    
+    def saved_files=(files)
+      storage['open_files'] = files
+    end
+    
+    def restore
+      Redcar.log.info("Sessions::Loader: opening files last open for #{project.path}")
+      unless (files = saved_files).empty?
+        paths = files.each do |file|
+          path = Pathname.new(file).expand_path(project.path)
+          Redcar::Project::Manager.open_file(path.to_s) if path.exist?
+        end
+        Redcar::Project::Manager.find_open_file_tab(paths.first).andand.focus
+      end
+    end
+    
+    def save
+      Redcar.log.info("Sessions::Loader: saving files last open for #{project.path}")
+      self.saved_files = open_files
+    end
+  end
+end

data/plugins/sessions/lib/sessions/memory.rb

@@ -0,0 +1,59 @@
+class Sessions
+  class Memory
+    def self.memories
+      @memories ||= []
+    end
+  
+    def self.project_loaded(project)
+      memories << Sessions::Memory.new(project).recall
+    end
+  
+    def self.project_closed(project, window)
+      memories.reject! do |mem|
+        mem.save window if mem.project == project
+      end
+    end
+    
+    attr_reader :project, :storage
+
+    def initialize(project)
+      @project = project
+      @storage = project.storage('sessions')
+    end
+
+    def last_bounds
+      return unless storage["bounds"]
+      rect = storage["bounds"]
+      [rect["x"], rect["y"], rect["width"], rect["height"]]
+    end
+
+    def tree_width
+      return unless storage["tree_width"]
+      storage["tree_width"].to_i
+    end
+
+    def save(window)
+      bs = window.bounds
+      storage["bounds"] = {
+        "x"      => bs[0],
+        "y"      => bs[1],
+        "width"  => bs[2],
+        "height" => bs[3]
+      }
+      storage["tree_width"] = window.treebook_width
+      storage.save
+    end
+
+    def recall
+      if last_bounds
+        project.window.bounds = last_bounds
+      end
+      if tree_width
+        project.window.treebook_width = tree_width
+      end
+      self
+    end
+
+  end
+
+end

data/plugins/sessions/plugin.rb

@@ -0,0 +1,8 @@
+
+Plugin.define do
+  name    "sessions"
+  version "1.0"
+  file    "lib", "sessions"
+  object  "Sessions"
+  dependencies "project", ">0"
+end

data/plugins/strip_trailing_spaces/lib/strip_trailing_spaces.rb

@@ -30,8 +30,8 @@ module Redcar
       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?
+            item "Enabled",           :command => ToggleStripTrailingSpaces, :type => :check, :checked => lambda { StripTrailingSpaces.enabled? }
+            item "Strip Blank Lines", :command => ToggleStripBlankLines,     :type => :check, :checked => lambda { StripTrailingSpaces.strip_blank_lines? }
           end
         end
       end