redcar 0.2.9dev

data/lib/redcar/install.rb

@@ -0,0 +1,97 @@
+
+require 'rbconfig'
+require 'open-uri'
+require 'fileutils'
+
+# Methods used in gem installation hooks
+#
+# Cribbed from the zerg and zerg_support gems by Victor Costan (big woop!)
+module Redcar
+  class Install
+    
+    # tricks rubygems into believeing that the extension compiled and worked out
+    def emulate_extension_install(extension_name)
+      File.open('Makefile', 'w') { |f| f.write "all:\n\ninstall:\n\n" }
+      File.open('make', 'w') do |f|
+        f.write '#!/bin/sh'
+        f.chmod f.stat.mode | 0111
+      end
+      File.open(extension_name + '.so', 'w') {}
+      File.open(extension_name + '.dll', 'w') {}
+      File.open('nmake.bat', 'w') { |f| }
+    end
+    
+    def plugins_dir
+      File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. plugins)))
+    end
+    
+    ASSET_HOST = "http://redcar.s3.amazonaws.com"
+    
+    JFACE = %w(
+      /jface/org.eclipse.core.commands.jar
+      /jface/org.eclipse.core.runtime_3.5.0.v20090525.jar
+      /jface/org.eclipse.equinox.common.jar
+      /jface/org.eclipse.jface.databinding_1.3.0.I20090525-2000.jar
+      /jface/org.eclipse.jface.jar
+      /jface/org.eclipse.jface.text_3.5.0.jar
+      /jface/org.eclipse.osgi.jar
+      /jface/org.eclipse.text_3.5.0.v20090513-2000.jar
+    )
+    
+    JRUBY = %w(
+      /jruby/jruby-complete-1.4.0.jar
+      /jruby/jcodings.jar
+      /jruby/jdom.jar
+      /jruby/joni.jar
+    )
+
+    REDCAR_JARS = {
+      "/java-mateview.jar" => "plugins/edit_view_swt/vendor/java-mateview.jar"
+    }
+
+    def grab_jruby
+      puts "* Downloading JRuby"
+      JRUBY.each do |jar_url|
+        download(jar_url, File.expand_path(File.join(File.dirname(__FILE__), "..", File.basename(jar_url))))
+      end
+    end
+    
+    def grab_common_jars
+      puts "* Downloading common jars"
+      JFACE.each do |jar_url|
+        download(jar_url, File.join(plugins_dir, %w(application_swt vendor jface), File.basename(jar_url)))
+      end
+    end
+    
+    def grab_platform_dependencies
+      puts "* Downloading platform-specific SWT jars"
+      case Config::CONFIG["host_os"]
+      when /darwin/i
+        download("/swt/osx.jar", File.join(plugins_dir, %w(application_swt vendor swt osx swt.jar)))
+        download("/swt/osx64.jar", File.join(plugins_dir, %w(application_swt vendor swt osx64 swt.jar)))
+      when /linux/i
+        download("/swt/linux.jar", File.join(plugins_dir, %w(application_swt vendor swt linux swt.jar)))
+        download("/swt/linux64.jar", File.join(plugins_dir, %w(application_swt vendor swt linux64 swt.jar)))
+      when /windows|mswin/i
+        download("/swt/win32.jar", File.join(plugins_dir, %w(application_swt vendor swt win32 swt.jar)))
+        # download("/swt/win64.jar", File.join(plugins_dir, %w(application_swt vendor swt win64 swt.jar)))
+      end
+    end
+    
+    def grab_redcar_jars
+      puts "* Downloading Redcar jars"
+      REDCAR_JARS.each do |jar_url, relative_path|
+        download(jar_url, File.join(File.dirname(__FILE__), "..", "..", relative_path))
+      end
+    end
+    
+    def download(uri, path)
+      uri = ASSET_HOST + uri
+      FileUtils.mkdir_p(File.dirname(path))
+      write_out = open(path, "wb")
+      write_out.write(open(uri).read)
+      write_out.close
+      puts "  downloaded #{uri}\n          to #{path}\n"
+    end
+  end
+end

data/lib/redcar/plist.rb

@@ -0,0 +1,83 @@
+
+require 'rexml/document'
+
+module Redcar
+
+  # An Apple Plist parser. Used by the textmate_* scripts.
+  class Plist
+    class PlistException < StandardError
+    end
+
+    # Convert an xml representation of a plist (in the proper form)
+    # into a Ruby representation formed by Arrays, Hashes and Strings.
+    def self.xml_to_plist(xml)
+      self.plist_from_xml(xml)
+    end
+    
+    def self.plist_from_xml1(element) # :nodoc:
+      case element.name
+      when "dict"
+        dict = {}
+        l = 0
+        element.each_element {|e| l += 1}
+        1.step(l-1, 2) do |i|
+          key_el = element.elements[i]
+          val_el = element.elements[i+1]
+          dict[key_el.text] = plist_from_xml1(val_el)
+        end
+        dict
+      when "string"
+        element.text
+      when "array"
+        arr = []
+        element.each_element {|el| arr << plist_from_xml1(el) }
+        arr
+      end
+    end
+
+    def self.plist_from_xml(xml_string) # :nodoc:
+      plist = []
+      xml = REXML::Document.new(xml_string)
+      xml.root.each_element {|el| plist << plist_from_xml1(el) }
+      plist
+    end
+
+    def self.plist_to_xml1(element, xml_el)
+      case element.class.to_s
+      when "Hash"
+        child = xml_el.add_element "dict"
+        element.keys.sort.each do |key|
+          e1 = child.add_element "key"
+          e1.text = key
+          plist_to_xml1(element[key], child)
+        end
+      when "Array"
+        child = xml_el.add_element "array"
+        element.each do |arr_el|
+          plist_to_xml1(arr_el, child)
+        end
+      when "String"
+        el = xml_el.add_element "string"
+        el.text = element
+      else
+        raise PlistException, "Unknown Plist Type, #{element.class.to_s}"
+      end
+    end
+
+    # Converts from a Ruby plist to an XML plist.
+    def self.plist_to_xml(plist)
+      doc = REXML::Document.new
+      xml_el = doc.add_element "plist", {"version" => "1.0"}
+      plist.each do |el|
+        plist_to_xml1(el, xml_el)
+      end
+      str = ""
+      doc.write(str, 0)
+      dt=<<END
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+END
+      (dt+str).gsub("\'", "\"")
+    end
+  end
+end

data/lib/redcar/ruby_extensions.rb

@@ -0,0 +1,14 @@
+
+module Kernel
+  alias fn lambda
+end
+
+class Object
+  def meta_class
+    class << self; self; end
+  end
+end
+
+def ARGV.option(name)
+  ARGV.map {|arg| arg =~/--#{name}=(.*)$/; $1}.compact.first
+end

data/lib/redcar/runner.rb

@@ -0,0 +1,32 @@
+
+
+module Redcar
+  
+  # Cribbed from ruby-processing. Many thanks!
+  class Runner
+    
+    # Trade in this Ruby instance for a JRuby instance, loading in a 
+    # starter script and passing it some arguments.
+    # If --jruby is passed, use the installed version of jruby, instead of 
+    # our vendored jarred one (useful for gems).
+    def spin_up
+      bin = "#{File.dirname(__FILE__)}/../../bin/redcar"
+      jruby_complete = Dir[File.dirname(__FILE__) + "/../jruby-complete*.jar"].first
+      args = []
+      if false
+        command = "jruby #{java_args} \"#{bin}\" #{ARGV.join(' ')}"
+      else
+        command = "java #{java_args} -cp \"#{jruby_complete}\" org.jruby.Main \"#{bin}\" #{ARGV.join(' ')}"
+      end
+      exec(command)
+    end
+    
+    def java_args
+      if Config::CONFIG["host_os"] =~ /darwin/
+        "-XstartOnFirstThread"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/redcar/usage.rb

@@ -0,0 +1,24 @@
+
+module Redcar
+  
+  class Usage
+    def version_requested
+      if ARGV.include?("-v")
+        puts "Redcar #{Redcar::VERSION}"
+        exit
+      end
+    end
+
+    def help_requested
+      if ARGV.include?("-h")
+        puts "Redcar #{Redcar::VERSION}"
+        puts
+        puts "       --font=FONT  Choose font"
+        puts "  --font-size=SIZE  Choose font point size"
+        puts "     --theme=THEME  Choose Textmate theme"
+        puts
+        exit
+      end
+    end
+  end
+end

data/lib/regex_replace.rb

@@ -0,0 +1,220 @@
+
+begin
+  require 'rubygems'
+  require 'oniguruma'
+rescue LoadError
+  
+end
+
+class RegexReplace
+  COND_RE = /\(
+                \?(\d+):
+                (
+                  (
+                    \\\(|
+                    \\\)|
+                    \\:|
+                    [^():]
+                  )*
+                )
+                (
+                  :
+                  (
+                    (
+                      \\\(|
+                      \\\)|
+                      [^()]
+                    )*
+                  )
+                )?
+              \)
+             /x
+  
+  def initialize(re, replace)
+    if re.class.to_s.include? "Regexp"
+      @re = re
+    else
+      if defined? Oniguruma
+        @re = Oniguruma::ORegexp.new(re)
+      else
+        @re = Regexp.new(re)
+      end
+    end
+    @replace = replace
+  end
+  
+  def regexp_gsub(re, string, &blk)
+    if re.class.to_s == "Oniguruma::ORegexp"
+      re.gsub(string, &blk)
+    else
+      left = string.dup
+      newstr = ""
+      while left.length > 0
+        md = re.match(left)
+        if md
+          newstr += md.pre_match
+          r  = yield md
+          newstr += r
+          left = md.post_match
+        else
+          newstr += left
+          left = ""
+        end
+      end
+      newstr
+    end
+  end
+  
+  def regexp_sub(re, string, &blk)
+    if re.class.to_s == "Oniguruma::ORegexp"
+      re.sub(string, &blk)
+    else
+      md = re.match(string)
+      r  = yield md
+      string[md.begin(0)..(md.end(0)-1)] = r
+      string
+    end
+  end
+  
+  def grep(string)
+    string = string.dup
+    regexp_gsub(@re, string) do |md|
+      parse_replace_string md, @replace.dup
+    end
+  end
+  
+  def rep(string)
+    string = string.dup
+    regexp_sub(@re, string) do |md|
+      parse_replace_string md, @replace.dup
+    end
+  end
+  
+  def inspect
+    "<RegexReplace: #{@re.inspect} -> #{@replace.inspect}>"
+  end
+  
+  private 
+  
+  def parse_replace_string(md, replace)
+    replace.gsub!(COND_RE) do |match|
+      if md[$1.to_i]
+        $2.gsub("\\(", "(").gsub("\\)", ")")
+      else
+        if $4
+          $5.gsub("\\(", "(").gsub("\\)", ")")
+        else
+          ""
+        end
+      end
+    end
+    replace.gsub!(/\$(\d+)/) do |match|
+      md[$1.to_i]
+    end
+    replace.gsub!(/\\U(.*?)(\\E|$)/) do |match|
+      $1.upcase
+    end
+    replace.gsub!(/\\L(.*?)(\\E|$)/) do |match|
+      $1.downcase
+    end
+    replace.gsub!(/\\u(.)/) do |match|
+      $1.upcase
+    end
+    replace.gsub!(/\\l(.)/) do |match|
+      $1.downcase
+    end
+    replace.gsub!(/\\[abefnrstv]/) do |match|
+      eval("\"\\#{match[-1..-1]}\"")
+    end
+    replace.gsub!("\\u", "")
+    replace.gsub!("\\l", "")
+    replace.gsub!("\\U", "")
+    replace.gsub!("\\L", "")
+    replace.gsub!("\\E", "")
+    replace
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+  class TestRegexReplace < Test::Unit::TestCase
+    def test_simple
+      rr = RegexReplace.new("blackbird", 
+                            "laura")
+      assert_equal "foo laura bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_simple_global
+      rr = RegexReplace.new("blackbird", 
+                            "laura")
+      assert_equal "foo laura bar laura bar", rr.grep("foo blackbird bar blackbird bar")
+    end
+    
+    def test_simple_single
+      rr = RegexReplace.new("blackbird", 
+                            "laura")
+      assert_equal "foo laura bar blackbird bar", rr.rep("foo blackbird bar blackbird bar")
+    end
+    
+    def test_escape_characters
+      rr = RegexReplace.new("blackbird", 
+                            "lau\\nr\\ta")
+      assert_equal "foo lau\nr\ta bar blackbird bar", rr.rep("foo blackbird bar blackbird bar")
+      
+    end
+    
+    def test_full_match
+      rr = RegexReplace.new("bl(ackb)ird", 
+                            "laura$0")
+      assert_equal "foo laurablackbird bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_lonely_upcase
+      rr = RegexReplace.new("bl(ackb)ird", 
+                            "\\u")
+      assert_equal "foo  bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_capture1
+      rr = RegexReplace.new("bl(ackb)ird", 
+                            "laura$1")
+      assert_equal "foo lauraackb bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_capture2
+      rr = RegexReplace.new("bl(ackb)i(r)d", 
+                            "$2laura$1")
+      assert_equal "foo rlauraackb bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_upcase_string
+      rr = RegexReplace.new("bl(ackb)i(rd)", 
+                            "\\U$2\\Elaura$1")
+      assert_equal "foo RDlauraackb bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_upcase_letter
+      rr = RegexReplace.new("bl(ackb)i(rd)", 
+                            "\\u$2laura$1")
+      assert_equal "foo Rdlauraackb bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_combination
+      rr = RegexReplace.new("bl(ackb)i(rd)", 
+                            "\\l\\U$2\\Elaura$1")
+      assert_equal "foo rDlauraackb bar", rr.rep("foo blackbird bar")
+    end
+    
+    def test_conditional
+      rr = RegexReplace.new("(\\w+)|(\\W+)", 
+                            "(?1:\\L$1\\E)(?2:\\(_)")
+      assert_equal "textmate(_power(_editing", rr.grep("TextMate: Power Editing")
+    end
+    
+    def test_conditional_with_alternative
+      rr = RegexReplace.new("[[:alpha:]]+|( )", 
+                            "(?1:_:\\L$0)")
+      assert_equal "textmate:_power_editing", rr.grep("TextMate: Power Editing")
+    end
+  end
+end