redcar-dev 0.12.17dev

data/lib/redcar.rb

@@ -0,0 +1,307 @@
+
+$:.push(File.expand_path(File.join(File.dirname(__FILE__))))
+$:.push(File.expand_path(File.join(File.dirname(__FILE__), %w{.. vendor spoon lib})))
+$:.push(File.expand_path(File.join(File.dirname(__FILE__), %w{.. vendor ffi lib})))
+
+require 'redcar/usage'
+
+require 'redcar/ruby_extensions'
+require 'redcar/instance_exec'
+require 'redcar/usage'
+require 'redcar/logger'
+require 'regex_replace'
+
+require 'forwardable'
+require 'uri'
+require 'fileutils'
+
+require 'rubygems'
+require 'redcar-icons'
+
+begin
+  if Config::CONFIG["RUBY_INSTALL_NAME"] == "jruby"
+    gem "spoon"
+    require 'spoon'
+    module Redcar; SPOON_AVAILABLE = true; end
+  else
+    module Redcar; SPOON_AVAILABLE = false; end
+  end
+rescue LoadError
+  module Redcar; SPOON_AVAILABLE = false; end
+end
+
+# ## Loading and Initialization
+#
+# Every feature in Redcar is written as a plugin. This module contains a few
+# methods to bootstrap the plugins by loading the PluginManager.
+#
+# Once loaded, bin/redcar will start the gui pump, which will run
+# Redcar.gui.start. This starts the GUI library's event loop and hands over
+# control to the GUI.
+#
+# ## Application
+#
+# The top class of Redcar is a {Redcar::Application}, which handles the creation
+# of Redcar::Windows. {Redcar::Application} is a good place to start
+# to see how the Redcar models are created.
+#
+# {Redcar::ApplicationSWT} is the start point for the SWT GUI, which listens
+# for events from the {Redcar::Application} model and reflects them in the GUI.
+#
+# This structure of a model and a controller that listens to it is repeated for
+# each part of Redcar reflected in the GUI.
+#
+#   * {Redcar::Window} has {Redcar::ApplicationSWT::Window}
+#   * {Redcar::Notebook} has {Redcar::ApplicationSWT::Notebook}
+#   * {Redcar::EditTab} has {Redcar::EditViewSWT::EditTab}
+#
+# and so on.
+module Redcar
+  VERSION         = '0.12.17dev' # also change in the gemspec!
+  VERSION_MAJOR   = 0
+  VERSION_MINOR   = 12
+  VERSION_RELEASE = 0
+  
+  ENVIRONMENTS = [:user, :debug, :test]
+  
+  PROCESS_START_TIME = Time.now
+  
+  def self.icons_directory
+    RedcarIcons.directory
+  end
+
+  def self.environment=(env)
+    unless ENVIRONMENTS.include?(env)
+      raise "environment must be one of #{ENVIRONMENTS.inspect}"
+    end
+    @environment = env
+  end
+  
+  def self.environment
+    raise "no environment set" unless @environment
+    @environment
+  end
+
+  def self.spin_up
+    require 'redcar/runner'
+    runner = Redcar::Runner.new
+    runner.run
+  end
+
+  def self.root
+    File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  end
+
+  def self.plugin_manager
+    @plugin_manager ||= begin
+      m = PluginManager.new
+      add_plugin_sources(m)
+      m
+    end
+  end
+
+  def self.add_plugin_sources(manager)
+    manager.add_plugin_source(File.join(root, "plugins"))
+    manager.add_plugin_source(File.join(user_dir, "plugins"))
+    manager.add_gem_plugin_source
+  end
+
+  def self.load_prerequisites
+    exit if ARGV.include?("--quit-immediately")
+    require 'java'
+    
+    require 'redcar_quick_start'
+    
+    gem "plugin_manager"
+    require 'plugin_manager'
+    
+    $:.push File.expand_path(File.join(Redcar.asset_dir))
+
+    gem "json"
+    require 'json'
+
+    gem "jruby-openssl"
+    require 'openssl'
+    
+    plugin_manager.load("core")
+    
+    gem 'swt'
+    require 'swt/minimal'
+    
+    gui = Redcar::Gui.new("swt")
+    gui.register_event_loop(Swt::EventLoop.new)
+    gui.register_features_runner(Swt::CucumberRunner.new)
+    Redcar.gui = gui
+    
+    plugin_manager.load("splash_screen")
+  end
+  
+  def self.load_useful_libraries
+  end
+
+  def self.load_plugins
+    begin
+      exit if ARGV.include?("--quit-after-splash")
+      
+      plugin_manager.load
+      
+      if plugin_manager.unreadable_definitions.any?
+        puts "Couldn't read definition files:  " + plugin_manager.unreadable_definitions.map {|pd| pd.name}.join(", ")
+      end
+      if plugin_manager.plugins_with_errors.any?
+        puts "There was an error loading plugins:  " + plugin_manager.plugins_with_errors.map {|pd| pd.name}.join(", ")
+      end
+      if ENV["PLUGIN_DEBUG"]
+        puts "Loaded plugins:  " + plugin_manager.loaded_plugins.map {|pd| pd.name}.join(", ")
+        puts
+        puts "Unloaded plugins:  " + plugin_manager.unloaded_plugins.map {|pd| pd.name}.join(", ")
+      end
+    rescue => e
+      puts e.message
+      puts e.backtrace
+    end
+  end
+  
+  # Tells the plugin manager to load plugins, and prints debug output.
+  def self.load_threaded
+    load_prerequisites
+    thread = Thread.new do
+      load_plugins
+      Redcar::Top.start(ARGV)
+    end
+    if no_gui_mode?
+      thread.join
+    end
+  end
+  
+  def self.load_unthreaded
+    load_prerequisites
+    load_plugins
+  end
+  
+  def self.no_gui_mode?
+    @no_gui_mode || ARGV.include?("--no-gui")
+  end
+  
+  def self.no_gui_mode!
+    @no_gui_mode = true
+  end
+  
+  def self.show_splash
+    return if Redcar.no_gui_mode?
+    unless ARGV.include?("--no-splash")
+      SplashScreen.create_splash_screen(plugin_manager.plugins.length + 10)
+    end
+    plugin_manager.on_load do |plugin|
+      Swt.sync_exec do
+        SplashScreen.splash_screen.inc if SplashScreen.splash_screen
+      end
+    end
+  end
+
+  ## Starts the GUI.
+  def self.pump
+    return if Redcar.no_gui_mode?
+    
+    Redcar.gui.start
+  end
+  
+  # Check if redcar was already installed (currently it just looks if the user_dir is present)
+  # 
+  # @return [Bool] true if redcar was installed previously
+  def self.installed?
+    return true if File.directory? user_dir
+    false
+  end
+
+  def self.ensure_user_dir_config
+    FileUtils.mkdir_p(user_dir)
+  end
+  
+  # Platform specific ~/.redcar
+  #
+  # @return [String] expanded path
+  def self.user_dir
+    dirname = {
+      :user => ".redcar",
+      :test => ".redcar_test",
+      :debug => ".redcar_debug"
+    }[Redcar.environment]
+    File.expand_path(File.join(home_dir, dirname))
+  end
+  
+  # Platform specific ~/.redcar/assets
+  def self.asset_dir
+    File.join(home_dir, ".redcar", "assets")
+  end
+  
+  # Platform specific ~/
+  #
+  # @return [String] expanded path
+  def self.home_dir
+    @userdir ||= begin
+      if arg = ARGV.map {|v| v[/^--home-dir=(.*)/, 1] }.compact.first
+        File.expand_path(arg)
+      elsif platform == :windows
+        if ENV['USERPROFILE'].nil?
+          "C:/My Documents/"
+        else
+          ENV['USERPROFILE']
+        end
+      else
+        ENV['HOME'] unless ENV['HOME'].nil?
+      end
+    end
+  end
+  
+  class << self
+    attr_accessor :app
+    attr_reader :gui
+  end
+  
+  # Set the application GUI.
+  def self.gui=(gui)
+    raise "can't set gui twice" if @gui
+    return if Redcar.no_gui_mode?
+    @gui = gui
+  end
+  
+  def self.log
+    @log ||= begin
+      targets = [log_file]
+      targets << STDOUT if show_log?
+      logger = Redcar::Logger.new(*targets)
+      logger.level = custom_log_level
+      at_exit { logger.close }
+      logger
+    end
+  end
+  
+  def self.log_path
+    user_dir + "/#{environment}.log"
+  end
+  
+  def self.log_file
+    File.open(log_path, "a")
+  end
+  
+  def self.show_log?
+    ARGV.include?("--show-log")
+  end
+  
+  def self.custom_log_level
+    ARGV.map {|a| a =~ /--log-level=(info|debug|warn|error)/; $1}.compact.first
+  end
+  
+  def self.process_start_time
+    @process_start_time ||= begin
+      t = ARGV.map {|arg| arg =~ /--start-time=(\d+)$/; $1}.compact.first
+      t ? Time.at(t.to_i) : $redcar_process_start_time
+    end
+  end
+end
+
+usage = Redcar::Usage.new
+usage.version_string
+usage.version_requested
+usage.help_requested

data/lib/redcar/installer.rb

@@ -0,0 +1,178 @@
+
+require 'net/http'
+require 'fileutils'
+
+if Redcar.platform == :windows
+  require "rubygems"
+  require "zip/zipfilesystem"
+end
+
+module Redcar
+  class Installer
+    def initialize
+      if ENV['http_proxy']
+        proxy = URI.parse(ENV['http_proxy'])
+        @connection = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
+      else
+        @connection = Net::HTTP
+      end
+      puts "found latest XULRunner release version: #{xulrunner_version}" if Redcar.platform == :windows
+    end
+
+    def install
+      Redcar.environment = :user
+      puts "Downloading >10MB of necessary assets..."
+      fetch_all_assets
+      precache_textmate_bundles
+      ensure_user_plugins_directory_exists
+      replace_windows_batch_file
+      puts "Success!"
+      puts ""
+      puts "To open just the editor:       redcar"
+      puts "To open the current directory: redcar ."
+      puts "More information:              http://redcareditor.com/"
+    end
+
+    def plugins_dir
+      File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. plugins)))
+    end
+
+    def fetch_all_assets
+      assets = assets_by_platform[:all].merge(assets_by_platform[Redcar.platform])
+      assets.each {|source, target| fetch_asset(source, target) }
+    end
+
+    def assets_by_platform
+      { :all => {
+          "http://redcar.s3.amazonaws.com/jruby/jcodings.jar" => "/jcodings.jar",
+          "http://redcar.s3.amazonaws.com/jruby/jdom.jar" => "/jdom.jar",
+          "http://redcar.s3.amazonaws.com/jruby/joni.jar" => "/joni.jar",
+          "http://redcar.s3.amazonaws.com/jruby/bcmail-jdk14-139-redcar1.jar" => "/bcmail-jdk14-139.jar",
+          "http://redcar.s3.amazonaws.com/jruby/bcprov-jdk14-139-redcar1.jar" => "/bcprov-jdk14-139.jar",
+          "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" => "/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/tmatesoft/svnkit/svnkit/1.3.4/svnkit-1.3.4.jar" => "/svnkit.jar",
+          # "http://mirrors.ibiblio.org/pub/mirrors/maven2/rhino/js/1.7R2/js-1.7R2.jar" => "/js.jar",
+          "http://redcar.s3.amazonaws.com/deps/rhino-js-1.7R2.jar" => "/js.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",
+        },
+        :linux => {
+        },
+        :osx => {
+        }
+      }
+    end
+
+    def fetch_asset(source, target)
+      relative_target   = target || implicit_target(source)
+      absolute_target   = File.join(Redcar.asset_dir, relative_target)
+      if File.exist?(absolute_target)
+        unless source =~ /dev\.jar/
+          return
+        end
+      end
+      download_file_to(source, absolute_target)
+      unzip_file(absolute_target) if absolute_target =~ /\.zip$/
+    end
+    
+    def replace_windows_batch_file
+      if RUBY_PLATFORM.downcase =~ /mswin|mingw|win32/
+        require 'rbconfig'
+        bin_dir = Config::CONFIG["bindir"]
+        ruby_path = File.join(bin_dir,
+                                  "rubyw.exe")
+        script_path = File.join(bin_dir,"redcar.bat")
+        File.open script_path, 'w' do |file|
+          file.puts <<-TEXT
+@Echo Off
+IF NOT "%~f0" == "~f0" GOTO :WinNT
+@"#{ruby_path}" "#{File.join(bin_dir,"redcar")}" %1 %2 %3 %4 %5 %6 %7 %8 %9
+GOTO :EOF
+:WinNT
+SET STARTUP=%*
+SET RUBY="rubyw.exe"
+
+:LOOP
+if "%1"=="--with-windows-console" GOTO USERUBY
+if "%1"=="" GOTO STARTREDCAR
+shift
+GOTO LOOP
+
+:USERUBY
+SET RUBY="ruby.exe"
+
+:STARTREDCAR
+IF NOT "X"%STARTUP% == "X" SET STARTUP=%STARTUP:"="""%
+start "RedCar" %RUBY% "#{File.join(bin_dir,"redcar")}" %STARTUP%
+TEXT
+        end
+      end
+    end
+
+    def implicit_target(source)
+      URI.parse(source).path.gsub(/^\//, "")
+    end
+
+    def download_file_to(uri, destination_file)
+      print "  downloading #{uri}... "; $stdout.flush
+      temporary_target  = destination_file + ".part"
+      FileUtils.mkdir_p(File.dirname(destination_file))
+      File.open(temporary_target, "wb") do |write_out|
+        write_out.print @connection.get(URI.parse(uri))
+      end
+
+      if File.open(temporary_target).read(200) =~ /Access Denied/
+        puts "\n\n*** Error downloading #{uri}, got Access Denied from S3."
+        FileUtils.rm_rf(temporary_target)
+        exit
+      end
+
+      FileUtils.cp(temporary_target, destination_file)
+      FileUtils.rm_rf(temporary_target)
+      puts "done!"
+    end
+
+    # unzip a .zip file into the directory it is located
+    def unzip_file(path)
+      print "unzipping #{path}..."; $stdout.flush
+      source = File.expand_path(path)
+      Dir.chdir(File.dirname(source)) do
+        Zip::ZipFile.open(source) do |zipfile|
+          zipfile.entries.each do |entry|
+            FileUtils.mkdir_p(File.dirname(entry.name))
+            begin
+              entry.extract
+            rescue Zip::ZipDestinationFileExistsError
+            end
+          end
+        end
+      end
+    end
+
+    def precache_textmate_bundles
+      puts "Precaching textmate bundles..."
+      Runner.new.construct_command(["--no-gui", "--compute-textmate-cache-and-quit", "--multiple-instance"]) do |cmd|
+        %x{#{cmd.join(' ')}}
+      end
+    end
+
+    def ensure_user_plugins_directory_exists
+      FileUtils.mkpath File.join(Redcar.user_dir, 'plugins')
+    end
+
+    # Xulrunner releases don't hang around very long, so we scrape their site to figure out
+    # which one to download this time.
+    def xulrunner_version
+      @xulrunner_version ||= begin
+        html = @connection.get(URI.parse("http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/"))
+        html.scan(/\d\.\d\.\d\.\d+/).sort.reverse.first
+      end
+    end
+  end
+end