rake-compiler 0.6.0 → 0.7.0

data/features/step_definitions/java_compilation.rb

@@ -0,0 +1,7 @@
+Given %r{^I've installed the Java Development Kit$} do
+  pending('Cannot locate suitable Java compiler (the Java Development Kit) in the PATH.') unless search_path(%w(javac javac.exe))
+end
+
+Given %r{^I've installed JRuby$} do
+  pending('Cannot locate a JRuby installation in the PATH.') unless search_path(%w(jruby jruby.exe jruby.bat))
+end

data/features/support/env.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'cucumber'
 require 'spec'
 require 'fileutils'

data/features/support/file_template_helpers.rb

@@ -75,6 +75,15 @@ end
 EOF
   end
 
+  def template_rake_extension_java_compile(extension_name, gem_spec = nil)
+      <<-EOF
+require 'rake/javaextensiontask'
+Rake::JavaExtensionTask.new("#{extension_name}"#{', SPEC' if gem_spec}) do |ext|
+  # nothing
+end
+EOF
+  end
+
   def template_extconf(extension_name)
     <<-EOF
 require 'mkmf'
@@ -97,6 +106,33 @@ EOF
 #include "ruby.h"
 EOF
   end
+
+  def template_source_java(extension_name)
+    <<-EOF
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class #{camelize(extension_name)}Service implements BasicLibraryService {
+   public boolean basicLoad(final Ruby runtime) throws java.io.IOException {
+     HelloWorldPrinter hwp = new HelloWorldPrinter();
+     hwp.tellTheWorld();
+     return true;
+   }
+
+   private class HelloWorldPrinter {
+     void tellTheWorld() throws java.io.IOException {
+       System.out.println("#{camelize(extension_name)}Service.java of extension #{extension_name}\\n");
+     }
+   }
+}
+
+EOF
+  end
+
+  def camelize(str)
+    str.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+
 end
 
 World(FileTemplateHelpers)

data/features/support/generator_helpers.rb

@@ -4,7 +4,7 @@ module GeneratorHelpers
     FileUtils.mkdir_p "lib"
     FileUtils.mkdir_p "tasks"
     FileUtils.mkdir_p "tmp"
-  
+
     # create Rakefile loader
     File.open("Rakefile", 'w') do |rakefile|
       rakefile.puts template_rakefile.strip
@@ -60,6 +60,25 @@ module GeneratorHelpers
     end
   end
 
+  def generate_java_compile_extension_task_for(extension_name)
+    # create folder structure
+    FileUtils.mkdir_p "ext/#{extension_name}"
+
+    return if File.exist?("tasks/#{extension_name}.rake")
+
+    # create specific extension rakefile
+    # Building a gem?
+    if File.exist?("tasks/gem.rake") then
+      File.open("tasks/gem.rake", 'a+') do |ext_in_gem|
+        ext_in_gem.puts template_rake_extension_java_compile(extension_name, true)
+      end
+    else
+      File.open("tasks/#{extension_name}.rake", 'w') do |ext_rake|
+        ext_rake.puts template_rake_extension_java_compile(extension_name)
+      end
+    end
+  end
+
   def generate_multi_cross_compile_extension_task_for(extension_name)
     # create folder structure
     FileUtils.mkdir_p "ext/#{extension_name}"
@@ -91,6 +110,14 @@ module GeneratorHelpers
       ext.puts template_extconf(extension_name)
     end
   end
+
+  def generate_java_source_code_for(extension_name)
+    # source .java file
+    File.open("ext/#{extension_name}/#{camelize(extension_name)}Service.java", 'w') do |c|
+      c.puts template_source_java(extension_name)
+    end
+  end
+
 end
 
 World(GeneratorHelpers)

data/features/support/platform_extension_helpers.rb

@@ -5,10 +5,23 @@ module PlatformExtensionHelpers
         'bundle'
       when /mingw|mswin|linux/
         'so'
+      when /java/
+        'jar'
       else
         RbConfig::CONFIG['DLEXT']
     end
   end
+
+  def search_path(binaries)
+    paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+    binary = binaries.find do |bin_file|
+      paths.find do |path|
+        bin = File.join(path, bin_file)
+        File.exist?(bin) && File.executable?(bin)
+      end
+    end
+    binary
+  end
 end
 
 World(PlatformExtensionHelpers)

data/lib/rake/baseextensiontask.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/clean'
+require 'rake/tasklib'
+require 'rbconfig'
+require 'yaml'
+require 'pathname'
+
+module Rake
+  autoload :GemPackageTask, 'rake/gempackagetask'
+
+  class BaseExtensionTask < TaskLib
+
+    attr_accessor :name
+    attr_accessor :gem_spec
+    attr_accessor :tmp_dir
+    attr_accessor :ext_dir
+    attr_accessor :lib_dir
+    attr_accessor :platform
+    attr_accessor :config_options
+    attr_accessor :source_pattern
+
+    def platform
+      @platform ||= RUBY_PLATFORM
+    end
+
+    def initialize(name = nil, gem_spec = nil)
+      init(name, gem_spec)
+      yield self if block_given?
+      define
+    end
+
+    def init(name = nil, gem_spec = nil)
+      @name = name
+      @gem_spec = gem_spec
+      @tmp_dir = 'tmp'
+      @ext_dir = "ext/#{@name}"
+      @lib_dir = 'lib'
+      @config_options = []
+    end
+
+    def define
+      fail "Extension name must be provided." if @name.nil?
+
+      define_compile_tasks
+    end
+
+    private
+
+    def define_compile_tasks
+      raise NotImplementedError
+    end
+
+    def binary(platform = nil)
+      ext = case platform
+        when /darwin/
+          'bundle'
+        when /mingw|mswin|linux/
+          'so'
+        when /java/
+          'jar'
+        else
+          RbConfig::CONFIG['DLEXT']
+      end
+      "#{@name}.#{ext}"
+    end
+
+    def source_files
+      @source_files ||= FileList["#{@ext_dir}/#{@source_pattern}"]
+    end
+
+    def warn_once(message)
+      @@already_warned ||= false
+      return if @@already_warned
+      @@already_warned = true
+      warn message
+    end
+
+    def windows?
+      Rake.application.windows?
+    end
+  end
+end

data/lib/rake/extensioncompiler.rb

@@ -50,4 +50,4 @@ module Rake
       @mingw_gcc_executable
     end
   end
-end
+end

data/lib/rake/extensiontask.rb

@@ -1,65 +1,51 @@
 #!/usr/bin/env ruby
 
+require 'rake/baseextensiontask'
+
 # Define a series of tasks to aid in the compilation of C extensions for
 # gem developer/creators.
 
-require 'rake'
-require 'rake/clean'
-require 'rake/tasklib'
-require 'rbconfig'
-require 'yaml'
-
 module Rake
-  autoload :GemPackageTask, 'rake/gempackagetask'
+  class ExtensionTask < BaseExtensionTask
 
-  class ExtensionTask < TaskLib
-    attr_accessor :name
-    attr_accessor :gem_spec
     attr_accessor :config_script
-    attr_accessor :tmp_dir
-    attr_accessor :ext_dir
-    attr_accessor :lib_dir
-    attr_accessor :platform
-    attr_accessor :config_options
-    attr_accessor :source_pattern
     attr_accessor :cross_compile
     attr_accessor :cross_platform
     attr_accessor :cross_config_options
-
-    def initialize(name = nil, gem_spec = nil)
-      init(name, gem_spec)
-      yield self if block_given?
-      define
-    end
+    attr_accessor :no_native
 
     def init(name = nil, gem_spec = nil)
-      @name = name
-      @gem_spec = gem_spec
+      super
       @config_script = 'extconf.rb'
-      @tmp_dir = 'tmp'
-      @ext_dir = "ext/#{@name}"
-      @lib_dir = 'lib'
       @source_pattern = "*.c"
-      @config_options = []
       @cross_compile = false
       @cross_config_options = []
-    end
-
-    def platform
-      @platform ||= RUBY_PLATFORM
+      @cross_compiling = nil
+      @no_native = false
     end
 
     def cross_platform
       @cross_platform ||= 'i386-mingw32'
     end
 
+    def cross_compiling(&block)
+      @cross_compiling = block if block_given?
+    end
+
     def define
-      fail "Extension name must be provided." if @name.nil?
+      if RUBY_PLATFORM == 'java' || (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby')
+        warn_once <<-EOF
+WARNING: You're attempting to (cross-)compile C extensions from a platform
+(#{RUBY_ENGINE}) that does not support native extensions or mkmf.rb.
+Rerun `rake` under MRI Ruby 1.8.x/1.9.x to cross/native compile.
+        EOF
+        return
+      end
 
-      define_compile_tasks
+      super
 
       # only gems with 'ruby' platforms are allowed to define native tasks
-      define_native_tasks if @gem_spec && @gem_spec.platform == 'ruby'
+      define_native_tasks if !@no_native && (@gem_spec && @gem_spec.platform == 'ruby')
 
       # only define cross platform functionality when enabled
       return unless @cross_compile
@@ -118,8 +104,12 @@ module Rake
           cmd << '-rfake'
         end
 
+        # build a relative path to extconf script
+        abs_tmp_path = Pathname.new(Dir.pwd) + tmp_path
+        abs_extconf = Pathname.new(Dir.pwd) + extconf
+
         # now add the extconf script
-        cmd << File.join(Dir.pwd, extconf)
+        cmd << abs_extconf.relative_path_from(abs_tmp_path)
 
         # rbconfig.rb will be present if we are cross compiling
         if t.prerequisites.include?("#{tmp_path}/rbconfig.rb") then
@@ -164,7 +154,7 @@ module Rake
       end
     end
 
-    def define_native_tasks(for_platform = nil, ruby_ver = RUBY_VERSION)
+    def define_native_tasks(for_platform = nil, ruby_ver = RUBY_VERSION, callback = nil)
       platf = for_platform || platform
 
       # tmp_path
@@ -178,7 +168,7 @@ module Rake
         task "native:#{@gem_spec.name}:#{platf}" do |t|
           # FIXME: truly duplicate the Gem::Specification
           # workaround the lack of #dup for Gem::Specification
-          spec = Gem::Specification.from_yaml(gem_spec.to_yaml)
+          spec = gem_spec.dup
 
           # adjust to specified platform
           spec.platform = Gem::Platform.new(platf)
@@ -197,6 +187,11 @@ module Rake
           # include the files in the gem specification
           spec.files += ext_files
 
+          # expose gem specification for customization
+          if callback
+            callback.call(spec)
+          end
+
           # Generate a package for this gem
           gem_package = Rake::GemPackageTask.new(spec) do |pkg|
             pkg.need_zip = false
@@ -213,7 +208,7 @@ module Rake
         file "#{lib_path}/#{binary(platf)}" => ["copy:#{@name}:#{platf}:#{ruby_ver}"]
       end
 
-      # Allow segmented packaging by platfrom (open door for 'cross compile')
+      # Allow segmented packaging by platform (open door for 'cross compile')
       task "native:#{platf}" => ["native:#{@gem_spec.name}:#{platf}"]
 
       # Only add this extension to the compile chain if current
@@ -226,7 +221,7 @@ module Rake
 
     def define_cross_platform_tasks(for_platform)
       if ruby_vers = ENV['RUBY_CC_VERSION']
-        ruby_vers = ENV['RUBY_CC_VERSION'].split(File::PATH_SEPARATOR)
+        ruby_vers = ENV['RUBY_CC_VERSION'].split(':')
       else
         ruby_vers = [RUBY_VERSION]
       end
@@ -275,7 +270,7 @@ module Rake
       # mkmf
       mkmf_file = File.expand_path(File.join(File.dirname(rbconfig_file), '..', 'mkmf.rb'))
 
-      # define compilation tasks for cross platfrom!
+      # define compilation tasks for cross platform!
       define_compile_tasks(for_platform, ruby_ver)
 
       # chain fake.rb, rbconfig.rb and mkmf.rb to Makefile generation
@@ -301,7 +296,9 @@ module Rake
       end
 
       # now define native tasks for cross compiled files
-      define_native_tasks(for_platform, ruby_ver) if @gem_spec && @gem_spec.platform == 'ruby'
+      if @gem_spec && @gem_spec.platform == 'ruby' then
+        define_native_tasks(for_platform, ruby_ver, @cross_compiling)
+      end
 
       # create cross task
       task 'cross' do
@@ -335,19 +332,15 @@ module Rake
     end
 
     def make
-      RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make'
-    end
-
-    def binary(platform = nil)
-      ext = case platform
-        when /darwin/
-          'bundle'
-        when /mingw|mswin|linux/
-          'so'
-        else
-          RbConfig::CONFIG['DLEXT']
+      unless @make
+        @make =
+          if RUBY_PLATFORM =~ /mswin/ then
+            'nmake'
+          else
+            ENV['MAKE'] || %w[gmake make].find { |c| system(c, '-v') }
+          end
       end
-      "#{@name}.#{ext}"
+      @make
     end
 
     def source_files
@@ -372,5 +365,6 @@ module Rake
         end
 FAKE_RB
     end
+
   end
 end

data/lib/rake/javaextensiontask.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+
+require 'rake/baseextensiontask'
+
+# Define a series of tasks to aid in the compilation of Java extensions for
+# gem developer/creators.
+
+module Rake
+  class JavaExtensionTask < BaseExtensionTask
+
+    attr_accessor :classpath
+    attr_accessor :debug
+
+    # Provide source compatibility with specified release
+    attr_accessor :source_version
+
+    # Generate class files for specific VM version
+    attr_accessor :target_version
+
+    def platform
+      @platform ||= 'java'
+    end
+
+    def java_compiling(&block)
+      @java_compiling = block if block_given?
+    end
+
+    def init(name = nil, gem_spec = nil)
+      super
+      @source_pattern = '**/*.java'
+      @classpath      = nil
+      @java_compiling = nil
+      @debug          = false
+      @source_version = '1.5'
+      @target_version = '1.5'
+    end
+
+    def define
+      super
+
+      define_java_platform_tasks
+    end
+
+    private
+    def define_compile_tasks(for_platform = nil, ruby_ver = RUBY_VERSION)
+      # platform usage
+      platf = for_platform || platform
+
+      # lib_path
+      lib_path = lib_dir
+
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{platf}/#{@name}"
+
+      # cleanup and clobbering
+      CLEAN.include(tmp_path)
+      CLOBBER.include("#{lib_path}/#{binary(platf)}")
+      CLOBBER.include("#{@tmp_dir}")
+
+      # directories we need
+      directory tmp_path
+      directory lib_dir
+
+      # copy binary from temporary location to final lib
+      # tmp/extension_name/extension_name.{so,bundle} => lib/
+      task "copy:#{@name}:#{platf}" => [lib_path, "#{tmp_path}/#{binary(platf)}"] do
+        cp "#{tmp_path}/#{binary(platf)}", "#{lib_path}/#{binary(platf)}"
+      end
+
+      not_jruby_compile_msg = <<-EOF
+WARNING: You're cross-compiling a binary extension for JRuby, but are using
+another interpreter. If your Java classpath or extension dir settings are not
+correctly detected, then either check the appropriate environment variables or
+execute the Rake compilation task using the JRuby interpreter.
+(e.g. `jruby -S rake compile:java`)
+      EOF
+      warn_once(not_jruby_compile_msg) unless defined?(JRUBY_VERSION)
+
+      file "#{tmp_path}/#{binary(platf)}" => "#{tmp_path}/.build" do
+
+        class_files = FileList["#{tmp_path}/**/*.class"].
+          gsub("#{tmp_path}/", '')
+
+        # avoid environment variable expansion using backslash
+        class_files.gsub!('$', '\$') unless windows?
+
+        args = class_files.map { |path|
+          ["-C #{tmp_path}", path]
+        }.flatten
+
+        sh "jar cf #{tmp_path}/#{binary(platf)} #{args.join(' ')}"
+      end
+
+      file "#{tmp_path}/.build" => [tmp_path] + source_files do
+        classpath_arg = java_classpath_arg(@classpath)
+        debug_arg     = @debug ? '-g' : ''
+
+        sh "javac #{java_extdirs_arg} -target #{@target_version} -source #{@source_version} -Xlint:unchecked #{debug_arg} #{classpath_arg} -d #{tmp_path} #{source_files.join(' ')}"
+
+        # Checkpoint file
+        touch "#{tmp_path}/.build"
+      end
+
+      # compile tasks
+      unless Rake::Task.task_defined?('compile') then
+        desc "Compile all the extensions"
+        task "compile"
+      end
+
+      # compile:name
+      unless Rake::Task.task_defined?("compile:#{@name}") then
+        desc "Compile #{@name}"
+        task "compile:#{@name}"
+      end
+
+      # Allow segmented compilation by platform (open door for 'cross compile')
+      task "compile:#{@name}:#{platf}" => ["copy:#{@name}:#{platf}"]
+      task "compile:#{platf}" => ["compile:#{@name}:#{platf}"]
+
+      # Only add this extension to the compile chain if current
+      # platform matches the indicated one.
+      if platf == RUBY_PLATFORM then
+        # ensure file is always copied
+        file "#{lib_path}/#{binary(platf)}" => ["copy:#{name}:#{platf}"]
+
+        task "compile:#{@name}" => ["compile:#{@name}:#{platf}"]
+        task "compile" => ["compile:#{platf}"]
+      end
+    end
+
+    def define_java_platform_tasks
+      # lib_path
+      lib_path = lib_dir
+
+      if @gem_spec && !Rake::Task.task_defined?("java:#{@gem_spec.name}")
+        task "java:#{@gem_spec.name}" do |t|
+
+          # FIXME: truly duplicate the Gem::Specification
+          spec = gem_spec.dup
+
+          # adjust to specified platform
+          spec.platform = Gem::Platform.new('java')
+
+          # clear the extensions defined in the specs
+          spec.extensions.clear
+
+          # add the binaries that this task depends on
+          ext_files = []
+
+          # go through native prerequisites and grab the real extension files from there
+          t.prerequisites.each do |ext|
+            ext_files << ext
+          end
+
+          # include the files in the gem specification
+          spec.files += ext_files
+
+          # expose gem specification for customization
+          if @java_compiling
+            @java_compiling.call(spec)
+          end
+
+          # Generate a package for this gem
+          gem_package = Rake::GemPackageTask.new(spec) do |pkg|
+            pkg.need_zip = false
+            pkg.need_tar = false
+          end
+        end
+
+        # add binaries to the dependency chain
+        task "java:#{@gem_spec.name}" => ["#{lib_path}/#{binary(platform)}"]
+
+        # ensure the extension get copied
+        unless Rake::Task.task_defined?("#{lib_path}/#{binary(platform)}") then
+          file "#{lib_path}/#{binary(platform)}" => ["copy:#{name}:#{platform}"]
+        end
+
+        task 'java' => ["java:#{@gem_spec.name}"]
+      end
+
+      task 'java' do
+        task 'compile' => 'compile:java'
+      end
+    end
+
+    #
+    # Discover Java Extension Directories and build an extdirs argument
+    #
+    def java_extdirs_arg
+      extdirs = Java::java.lang.System.getProperty('java.ext.dirs') rescue nil
+      extdirs = ENV['JAVA_EXT_DIR'] unless extdirs
+      java_extdir = extdirs.nil? ? "" : "-extdirs \"#{extdirs}\""
+    end
+
+    #
+    # Discover the Java/JRuby classpath and build a classpath argument
+    #
+    # @params
+    #   *args:: Additional classpath arguments to append
+    #
+    # Copied verbatim from the ActiveRecord-JDBC project. There are a small myriad
+    # of ways to discover the Java classpath correctly.
+    #
+    def java_classpath_arg(*args)
+      jruby_cpath = nil
+      if RUBY_PLATFORM =~ /java/
+        begin
+          cpath  = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
+          cpath += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
+          jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
+        rescue => e
+        end
+      end
+      unless jruby_cpath
+        jruby_cpath = ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] &&
+          Dir.glob("#{File.expand_path(ENV['JRUBY_HOME'])}/lib/*.jar").
+            join(File::PATH_SEPARATOR)
+      end
+      raise "JRUBY_HOME or JRUBY_PARENT_CLASSPATH are not set" unless jruby_cpath
+      jruby_cpath += File::PATH_SEPARATOR + args.join(File::PATH_SEPARATOR) unless args.empty?
+      jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
+    end
+
+  end
+end