redcar 0.5.6dev → 0.6

data/CHANGES

@@ -1,5 +1,29 @@
-Version 0.5 (TBA)
-=================
+Version 0.6 (21 September 2010)
+===============================
+
+Enhancements
+
+ * Now we have a toolbar in the Redcar (Alex Lourie)
+ * Line Tools advanced editing commands (Delisa Mason)
+ * Added a 'Open Directory as new project' context menu item (Delisa Mason)
+ * Added a 'Tidy File' menu option which will try to reindent complete file (Alex Lourie)
+ * find-in-project: Search spinner, remember search settings, wrap long lines, styling updates (Kieran Pilkington)
+ * Align assignments command (Stefan Natchev)
+ * Groovy REPL! (Delisa Mason)
+ * Sort lines command (Erik Lundqvist)
+ * Runnables: copy output to clipboard (Mat Schaffer)
+ * Runnables: 'run again' button (Mat Schaffer)
+
+Bugfixes:
+
+ * find-in-project: results are now sorted from a-z, instead of backwards (Kieran Pilkington)
+
+New internal APIs
+
+ * Toolbar items APIs (Alex Lourie)
+
+Version 0.5 (7 September 2010)
+==============================
 
 Enhancements
 
@@ -15,7 +39,8 @@ Enhancements
  * Installer doesn't need to be run as root anymore. (Dan Lucraft)
  * Splash screen (Dan Lucraft)
  * Installer loads Redcar, therefore putting all the Redcar files in the OS disk cache (Dan Lucraft)
- * Read installed JVM options and use 32bit client vm if available (Dan Lucraft)
+ * Read installed JVM options and use 32bit client vm if available (Dan Lucraft & Alex Lourie)
+ * Edit views now have right-click menu, with hooks for plugins (Delisa Mason)
 
 New internal APIs
 

data/Rakefile

@@ -1,4 +1,4 @@
-REDCAR_VERSION = "0.5.6dev" # also change in lib/redcar.rb!
+REDCAR_VERSION = "0.6" # also change in lib/redcar.rb!
 require 'rubygems'
 require 'fileutils'
 require 'spec/rake/spectask'
@@ -129,6 +129,7 @@ spec = Gem::Specification.new do |s|
   s.files             = %w(CHANGES LICENSE Rakefile README.md) + 
                           Dir.glob("bin/redcar") + 
                           Dir.glob("config/**/*") + 
+                          Dir.glob("share/**/*") + 
                           remove_gitignored_files(Dir.glob("lib/**/*")) + 
                           remove_matching_files(remove_gitignored_files(Dir.glob("plugins/**/*")), "redcar-bundles") + 
                           Dir.glob("plugins/textmate/vendor/redcar-bundles/Bundles/*.tmbundle/Syntaxes/**/*") + 
@@ -214,6 +215,7 @@ task :app_bundle => :build do
     f << '#!/bin/sh
           DIR=$(cd "$(dirname "$0")"; pwd)
           REDCAR=$(cd "$(dirname "${DIR}/../Resources/bin/redcar")"; pwd)
+          $REDCAR/redcar install
           $REDCAR/redcar --ignore-stdin $@'
   end
   File.chmod 0777, File.join(macos_dir, "redcar")
@@ -223,9 +225,6 @@ task :app_bundle => :build do
     FileUtils.cp_r f, File.join(resources_dir, f), :remove_destination => true
   end
 
-  p "Running #{File.join(resources_dir, "bin", "redcar")} install"
-  system "#{File.join(resources_dir, "bin", "redcar")} install"
-
   FileUtils.cp_r File.join(resources_dir, "plugins", "application", "icons", redcar_icon), 
       resources_dir, :remove_destination => true
 end

data/lib/redcar.rb

@@ -51,9 +51,9 @@ end
 #
 # and so on.
 module Redcar
-  VERSION         = '0.5.6dev' # also change in the Rakefile!
+  VERSION         = '0.6' # also change in the Rakefile!
   VERSION_MAJOR   = 0
-  VERSION_MINOR   = 5
+  VERSION_MINOR   = 6
   VERSION_RELEASE = 0
   
   ENVIRONMENTS = [:user, :debug, :test]

data/lib/redcar/installer.rb

@@ -57,9 +57,10 @@ module Redcar
           "http://redcar.s3.amazonaws.com/jruby/jopenssl-redcar1.jar"         => "/jopenssl.jar",
           "http://redcar.s3.amazonaws.com/java-mateview-#{Redcar::VERSION}.jar" => nil,
           "http://redcar.s3.amazonaws.com/application_swt-#{Redcar::VERSION}.jar" => nil,
-          "http://redcar.s3.amazonaws.com/clojure-1.2beta1.jar" => nil,
-          "http://redcar.s3.amazonaws.com/clojure-contrib-1.2beta1.jar" => nil,
-          "http://redcar.s3.amazonaws.com/org-enclojure-repl-server.jar" => nil
+          "http://redcar.s3.amazonaws.com/clojure-1.2beta1.jar" => "/clojure.jar",
+          "http://redcar.s3.amazonaws.com/clojure-contrib-1.2beta1.jar" => "/clojure-contrib.jar",
+          "http://redcar.s3.amazonaws.com/org-enclojure-repl-server.jar" => nil,
+          "http://mirrors.ibiblio.org/pub/mirrors/maven2/org/codehaus/groovy/groovy-all/1.7.4/groovy-all-1.7.4.jar" => "/groovy-all.jar"
         },
         :windows => {
           "http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/#{xulrunner_version}/runtimes/xulrunner-#{xulrunner_version}.en-US.win32.zip" => "xulrunner-#{xulrunner_version}.en-US.win32.zip",

data/lib/redcar/runner.rb

@@ -2,7 +2,7 @@ module Redcar
   # Cribbed from ruby-processing. Many thanks!
   class Runner
     def run
-      forking = ARGV.include?("--fork")
+      forking = ARGV.include?("--fork") and ARGV.first != "install"
       no_runner = ARGV.include?("--no-sub-jruby")
       jruby = Config::CONFIG["RUBY_INSTALL_NAME"] == "jruby"
       osx = (not [:linux, :windows].include?(Redcar.platform))

data/plugins/application/lib/application.rb

@@ -13,6 +13,11 @@ require 'application/dialogs/filter_list_dialog'
 require 'application/event_spewer'
 require 'application/keymap'
 require 'application/keymap/builder'
+require 'application/toolbar'
+require 'application/toolbar/item'
+require 'application/toolbar/lazy_toolbar'
+require 'application/toolbar/builder'
+require 'application/toolbar/builder/group'
 require 'application/menu'
 require 'application/menu/item'
 require 'application/menu/lazy_menu'
@@ -71,7 +76,7 @@ module Redcar
       ]
     end
     
-    attr_reader :clipboard, :keymap, :menu, :history, :task_queue
+    attr_reader :clipboard, :keymap, :menu, :toolbar, :history, :task_queue, :show_toolbar
     
     # Create an application instance with a Redcar::Clipboard and a Redcar::History.
     def initialize
@@ -81,6 +86,14 @@ module Redcar
       create_history
       @event_spewer = EventSpewer.new
       @task_queue   = TaskQueue.new
+      
+      # Don't show the toolbar by default on Mac OS X
+      if Redcar.platform == :osx
+        Application.storage['show_toolbar'] = false
+      end
+      
+      # Otherwise, use previous setting
+      @show_toolbar = !!Application.storage['show_toolbar']
     end
     
     def events
@@ -109,6 +122,7 @@ module Redcar
       notify_listeners(:new_window, new_window)
       attach_window_listeners(new_window)
       new_window.refresh_menu
+      new_window.refresh_toolbar
       new_window.show
       set_focussed_window(new_window)
       #puts "App#new_window took #{Time.now - s}s"
@@ -137,6 +151,7 @@ module Redcar
       @storage ||= begin
          storage = Plugin::Storage.new('application_plugin')
          storage.set_default('stay_resident_after_last_window_closed', false)
+         storage.set_default('show_toolbar', true)
          storage
       end
     end
@@ -187,6 +202,13 @@ module Redcar
       notify_listeners(:refresh_menu)
     end
     
+    # Redraw the main toolbar, reloading all the ToolBars and Keymaps from the plugins.
+    def refresh_toolbar!
+      @main_toolbar = nil
+      windows.each {|window| window.refresh_toolbar }
+      controller.refresh_toolbar
+    end
+    
     # Generate the main menu by combining menus from all plugins.
     #
     # @return [Redcar::Menu]
@@ -200,6 +222,19 @@ module Redcar
       end
     end
     
+    # Generate the toolbar combining toolbars from all plugins.
+    #
+    # @return [Redcar::ToolBar]
+    def main_toolbar
+      @main_toolbar ||= begin
+        toolbar = ToolBar.new
+        Redcar.plugin_manager.objects_implementing(:toolbars).each do |object|
+          toolbar.merge(object.toolbars)
+        end
+        toolbar
+      end
+    end
+    
     # Generate the main keymap by merging the keymaps from all plugins.
     #
     # @return [Redcar::Keymap]
@@ -301,6 +336,20 @@ module Redcar
     def create_history
       @history = Command::History.new
     end
+
+    public 
+
+    def show_toolbar?
+      @show_toolbar
+    end
+
+    def show_toolbar=(bool)
+      Application.storage['show_toobar'] = @show_toolbar = bool
+    end
+
+    def toggle_show_toolbar
+      Application.storage['show_toolbar'] = @show_toolbar = !Application.storage['show_toolbar']
+    end
   end
 end
 

data/plugins/application/lib/application/toolbar.rb

@@ -0,0 +1,83 @@
+
+module Redcar
+  class ToolBar
+    include Enumerable
+    include Redcar::Model
+    
+    # Default priority for all toolbar's and items if they aren't explicitly provided
+    DEFAULT_PRIORITY = 50
+    
+    attr_reader :text, :entries, :priority
+  
+    # A ToolBar will initially have nothing in it.
+    def initialize(text=nil, options={})
+      @text, @entries, @priority = text || "", [], options[:priority]
+    end
+  
+    # Iterate over each entry, sorted by priority
+    def each
+      sorted = {:first => [], :last => []}
+      entries.each {|e| (sorted[e.priority || ToolBar::DEFAULT_PRIORITY] ||= []) << e}
+      
+      # Get the nasty Symbols out of the hash so we can sort it
+      first = sorted.delete(:first)
+      last = sorted.delete(:last)
+      
+      # Yield up the results
+      first.each {|val| yield val }
+      sorted.keys.sort.each {|i| sorted[i].each {|val| yield val }}
+      last.each {|val| yield val }
+    end
+  
+    # Add a Redcar::ToolItem or a Redcar::ToolBar
+    def <<(entry)
+      entries << entry
+      self
+    end
+  
+    # Number of entries in the toolbar
+    def length
+      entries.length
+    end
+    
+    def entry(text)
+      detect {|e| e.text == text }
+    end
+    
+    # Append items using the same syntax as ToolBar::Builder
+    def build(&block)
+      ToolBar::Builder.new(self, &block)
+    end
+    
+    def ==(other)
+      return false unless length == other.length
+      return false unless text == other.text
+      entries.zip(other.entries) do |here, there|
+        return false unless here.class == there.class and here == there
+      end
+      true
+    end
+    
+    def is_unique?
+      false
+    end
+    
+    # Merge two ToolBar trees together. Modifies this ToolBar.
+    #
+    # @param [ToolBar] another ToolBar
+    def merge(other)
+      @priority = @priority || other.priority
+      other.entries.each do |other_entry|
+        if here = entry(other_entry.text) and not other_entry.is_unique?
+          if here.class == other_entry.class
+            here.merge(other_entry)
+          else
+            entries[entries.index(here)] = other_entry
+          end
+        else
+          self << other_entry
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/builder.rb

@@ -0,0 +1,80 @@
+
+module Redcar
+  class ToolBar
+    # A DSL for building toolbars simply. An example of usage
+    #
+    #     builder = ToolBar::Builder.new "Edit" do
+    #       item "Select All", SelectAllCommand
+    #       sub_toolbar "Indent" do
+    #         item "Increase", IncreaseIndentCommand
+    #         item("Decrease") { puts "decrease selected" }
+    #       end
+    #     end
+    #
+    # This is equivalent to:
+    # 
+    #     toolbar = Redcar::ToolBar.new("Edit")
+    #     toolbar << Redcar::ToolBar::Item.new("Select All", SelectAllCommand)
+    #     indent_toolbar = Redcar::ToolBar.new("Indent") 
+    #     indent_toolbar << Redcar::ToolBar::Item.new("Increase", IncreaseIndentCommand)
+    #     indent_toolbar << Redcar::ToolBar::Item.new("Decrease") do
+    #       puts "decrease selected"
+    #     end
+    #     toolbar << indent_toolbar
+    class Builder
+      attr_reader :toolbar
+      
+      def self.build(name=nil, &block)
+        new(name, &block).toolbar
+      end
+      
+      def initialize(toolbar_or_text=nil, &block)
+        case toolbar_or_text
+        when String, nil
+          @toolbar = Redcar::ToolBar.new(toolbar_or_text||"")
+        when ToolBar
+          @toolbar = toolbar_or_text
+        end
+        @current_toolbar = @toolbar
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+      
+      def item(text, options={}, &block)
+        @current_toolbar << Item.new(text, options, &block)
+      end
+      
+      def separator(options={})
+        @current_toolbar << Item::Separator.new(options)
+      end
+      
+      def sub_toolbar(text, options={}, &block)
+        new_toolbar = ToolBar.new(text, options)
+        @current_toolbar << new_toolbar
+        old_toolbar, @current_toolbar = @current_toolbar, new_toolbar
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+        @current_toolbar = old_toolbar
+      end
+      
+      def lazy_sub_toolbar(text, options={}, &block)
+        new_toolbar = LazyToolBar.new(block, text, options)
+        @current_toolbar << new_toolbar
+      end
+      
+      def group(options={}, &block)
+        Builder::Group.new(self, options, &block)
+      end
+      
+      def append(item)
+        @current_toolbar << item
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/builder/group.rb

@@ -0,0 +1,47 @@
+
+module Redcar
+  class ToolBar
+    class Builder
+      # An extension to the Builder to allow groups of toolbar object to inherit options.
+      #
+      # This is supported for all options, even options that don't exist yet!
+      #
+      # Currently, this is only useful in a practical sense to apply a :priority to a 
+      # set of objects
+      class Group
+        
+        def initialize(builder, options={}, &block)
+          @builder = builder
+          @defaults = options
+          
+          if block.arity == 1
+            block.call(self)
+          else
+            instance_eval(&block)
+          end
+        end
+        
+        def item(text, options={}, &block)
+          options = {:command => options} if not options.respond_to?('[]')
+          @builder.item(text, @defaults.merge(options), &block)
+        end
+        
+        def separator(options={})
+          @builder.separator(@defaults.merge(options))
+        end
+        
+        def sub_toolbar(text, options={}, &block)
+          @builder.sub_toolbar(text, @defaults.merge(options), &block)
+        end
+        
+        def lazy_sub_toolbar(text, options={}, &block)
+          @builder.lazy_sub_toolbar(text, @defaults.merge(options), &block)
+        end
+
+        def append(item)
+          @builder.append(item)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/item.rb

@@ -0,0 +1,71 @@
+
+module Redcar
+  class ToolBar
+    class Item
+      class Separator < Item
+        def initialize(options={})
+          super(nil, options)
+        end
+        
+        def is_unique?
+          true
+        end
+      end
+
+      attr_reader :text, :command, :priority, :value, :icon, :barname
+ 
+      # Create a new Item, with the given text to display in the toolbar, and
+      # either:
+      #   the Redcar::Command that is run when the item is selected.
+      #   or a block to run when the item is selected
+      def initialize(text, options={}, &block)
+        @text = text
+        
+        if options.respond_to?('[]')
+          @command = options[:command] || block
+	        @priority = options[:priority] # Currently not utilized
+          @value = options[:value]
+          @icon = options[:icon]
+          @barname = options[:barname]
+        # This branch is for compatibility with old code. Please use :command 
+        # option in new code
+        # FIXME: Should this be removed at some point?
+        else
+          @command = options || block
+        end
+        
+        @priority ||= ToolBar::DEFAULT_PRIORITY
+      end
+      
+      # Call this to signal that the toolbar item has been selected by the user.
+      def selected(with_key=false)
+        if @value
+          @command.new.run(:value => @value)
+        else  
+          @command.new.run#(:with_key => with_key)
+        end
+      end
+      
+      def type
+        @type
+      end
+      
+      def type
+        @type
+      end
+      
+      def merge(other)
+        @command = other.command
+        @priority = other.priority
+      end
+      
+      def ==(other)
+        text == other.text and command == other.command
+      end
+      
+      def is_unique?
+        false
+      end
+    end
+  end
+end