rake-compiler 0.3.0 → 0.5.0

data/History.txt

@@ -1,32 +1,85 @@
-=== 0.3.0 / 2008-12-07
+=== 0.5.0 / 2009-04-25
+
+* Enhancements
+  * Allow generation of multiple gems for Windows (EXPERIMENTAL)
+    This allows build gems for both VC6 and MinGW builts of Ruby
+    (Thanks to Jonathan Stott for the suggestion)
+
+      Rake::ExtensionTask.new('my_extension', GEM_SPEC) do |ext|
+        ext.cross_compile = true
+        ext.cross_platform = ['i386-mswin32', 'i386-mingw32']
+      end
+
+=== 0.4.1 / 2009-04-09
+
+* Enhancements
+  * Target specific versions of Ruby when generating binaries.
+    This avoids installing a 1.8.x binary gem in 1.9.x and viceversa.
+    (Thanks to Aaron Patterson for the patches)
+
+* Bugfixes
+  * No longer raises error if rake-compiler configuration is missing.
+    Not all users of a project would have it installed.
+    (Thanks to Aaron Patterson for the patch)
+
+=== 0.4.0 / 2009-04-03
+
+* Enhancements
+  * Bended the convention for extension folder.
+    Defining <tt>ext_dir</tt> for custom extension location.
+
+      Rake::ExtensionTask.new('my_extension') do |ext|
+        ext.ext_dir = 'custom/location'         # look into custom/location
+      end                                       # instead of ext/my_extension
 
-* 1 Major Enhancement:
+  * Better detection of mingw target across Linux/OSX.
+    Exposed it as Rake::ExtensionCompiler
+  * Display list of available tasks when calling rake-compiler script
+  * Track Ruby full versioning (x.y.z).
+    This will help the compilation of extensions targetting 1.8.6/7 and 1.9.1
 
+* Bugfixes
+  * Better output of Rake development tasks (Thanks to Luis Parravicini).
+  * Proper usage of Gem::Platform for native gems (Thanks to Dirkjan Bussink).
+  * Don't use autoload for YAML (present problems with Ruby 1.9.1).
+
+=== 0.3.1 / 2009-01-09
+
+* Enhancements
+  * Download cross-ruby source code using HTTP instead of FTP.
+  * Disabled Tcl/Tk extension building on cross-ruby (helps with 1.9).
+
+* Bugfixes
+  * Workaround bug introduced by lack of Gem::Specification cloning. Fixes DM LH #757.
+  * Use proper binary extension on OSX (reported by Dirkjan Bussink).
+  * Ensure lib/binary task is defined prior clear of requisites.
+
+=== 0.3.0 / 2008-12-07
+
+* New features
   * Let you specify the Ruby version used for cross compilation instead 
     of default one.
 
       rake cross compile RUBY_CC_VERSION=1.8
 
-* 2 Minor Enhancements:
-
+* Enhancements
   * Properly update rake-compiler configuration when new version is installed.
   * Automated release process to RubyForge, yay!
 
-* 1 Bug fix:
-
+* Bugfixes
   * Corrected documentation to reflect the available options
 
 === 0.2.1 / 2008-11-30
 
-* 2 Major Enhancements:
+* New features
 
   * Allow cross compilation (cross compile) using mingw32 on Linux or OSX.
   * Allow packaging of gems for Windows on Linux or OSX.
 
-* 1 Minor Enhancement:
+* Enhancements
 
   * Made generation of extensions safe and target folders per-platform
 
-* 1 Bug Fix:
+* Bugfixes
 
   * Ensure binaries for the specific platform are copied before packaging.

data/Rakefile

@@ -20,4 +20,4 @@ rescue LoadError
 end
 
 # load rakefile extensions (tasks)
-Dir['tasks/*.rake'].each { |f| import f }
+Dir['tasks/*.rake'].sort.each { |f| load f }

data/features/cross-package-multi.feature

@@ -0,0 +1,15 @@
+Feature: Generate multiple Windows gems from Linux
+
+  In order to keep compatibility with versions of Ruby on Windows
+  As a Gem developer on Linux
+  I want to build binary gems for One-Click Installer (old and new versions)
+
+  Scenario: package multiple gems for Windows
+    Given that my gem source is all in place to target two platforms
+    And I'm running a POSIX operating system
+    And I've installed cross compile toolchain
+    And I've already successfully executed rake task 'cross compile'
+    When rake task 'cross native gem' is invoked
+    Then rake task 'cross native gem' succeeded
+    And gem for platform 'x86-mswin32' get generated
+    And gem for platform 'x86-mingw32' get generated

data/features/step_definitions/compilation.rb

@@ -8,6 +8,11 @@ Given /^a extension cross-compilable '(.*)'$/ do |extension_name|
   generate_source_code_for extension_name
 end
 
+Given /^a extension '(.*)' multi cross\-compilable$/ do |extension_name|
+  generate_multi_cross_compile_extension_task_for extension_name
+  generate_source_code_for extension_name
+end
+
 Given /^a extension '(.*)' with forced platform '(.*)'$/ do |extension_name, forced_platform|
   generate_extension_task_for extension_name, forced_platform
   generate_source_code_for extension_name
@@ -24,6 +29,12 @@ Given /^that my gem source is all in place$/ do
   Given "a extension cross-compilable 'extension_one'"
 end
 
+Given /^that my gem source is all in place to target two platforms$/ do
+  Given "a safe project directory"
+  Given "a gem named 'gem_abc'"
+  Given "a extension 'extension_one' multi cross-compilable"
+end
+
 Given /^not changed any file since$/ do
   # don't do anything, that's the purpose of this step!
 end

data/features/step_definitions/cross_compilation.rb

@@ -6,16 +6,26 @@ Given %r{^I'm running a POSIX operating system$} do
 end
 
 Given %r{^I've installed cross compile toolchain$} do
-  compiler = 'i586-mingw32msvc-gcc'
-  found = false
-  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-    next unless File.exist?(File.join(path, compiler))
-    found = true
+  compilers = %w(i586-mingw32msvc-gcc i386-mingw32-gcc)
+  paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+  compiler = compilers.find do |comp|
+    paths.find do |path|
+      File.exist? File.join(path, comp)
+    end
   end
-  raise "Cannot locate '#{compiler}' in the PATH." unless found
+  raise "Cannot locate '#{compiler}' in the PATH." unless compiler
 end
 
 Then /^binaries for platform '(.*)' get generated$/ do |platform|
-  ext_for_platform = Dir.glob("tmp/#{platform}/**/*.#{RbConfig::CONFIG['DLEXT']}")
+  ext = case platform
+    when /darwin/
+      'bundle'
+    when /mingw|mswin|linux/
+      'so'
+    else
+      RbConfig::CONFIG['DLEXT']
+  end
+
+  ext_for_platform = Dir.glob("tmp/#{platform}/**/*.#{ext}")
   ext_for_platform.should_not be_empty
 end

data/features/step_definitions/gem.rb

@@ -24,6 +24,7 @@ end
 
 def gem_file_platform(folder, name, version, platform = nil)
   file = "#{folder}/#{name}-#{version}"
-  file << "-" << (platform || Gem::Platform.local.to_s)
+  file << "-" << (platform || Gem::Platform.new(RUBY_PLATFORM).to_s)
   file << ".gem"
+  file
 end

data/features/support/{file_templates.rb → file_template_helpers.rb}

@@ -1,5 +1,6 @@
-def template_rakefile
-<<-EOF
+module FileTemplateHelpers
+  def template_rakefile
+    <<-EOF
 # add rake-compiler lib dir to the LOAD_PATH
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '../..', 'lib'))
 
@@ -9,10 +10,10 @@ require 'rake'
 # load rakefile extensions (tasks)
 Dir['tasks/*.rake'].each { |f| import f }
 EOF
-end
+  end
 
-def template_rake_gemspec(gem_name)
-<<-EOF
+  def template_rake_gemspec(gem_name)
+    <<-EOF
 require 'rake/gempackagetask'
 SPEC = Gem::Specification.new do |s|
   s.name = "#{gem_name}"
@@ -37,52 +38,65 @@ gem_package = Rake::GemPackageTask.new(SPEC) do |pkg|
   pkg.need_tar = false
 end
 EOF
-end
+  end
 
-def template_rake_extension(extension_name, gem_spec = nil)
-<<-EOF
+  def template_rake_extension(extension_name, gem_spec = nil)
+    <<-EOF
 require 'rake/extensiontask'
 Rake::ExtensionTask.new("#{extension_name}"#{', SPEC' if gem_spec})
 EOF
-end
+  end
 
-def template_rake_extension_with_platform(extension_name, platform)
-<<-EOF
+  def template_rake_extension_with_platform(extension_name, platform)
+    <<-EOF
 require 'rake/extensiontask'
 Rake::ExtensionTask.new("#{extension_name}", SPEC) do |ext|
   ext.platform = "#{platform}"
 end
 EOF
-end
+  end
 
-def template_rake_extension_cross_compile(extension_name, gem_spec = nil)
-<<-EOF
+  def template_rake_extension_cross_compile(extension_name, gem_spec = nil)
+    <<-EOF
 require 'rake/extensiontask'
 Rake::ExtensionTask.new("#{extension_name}"#{', SPEC' if gem_spec}) do |ext|
   ext.cross_compile = true
 end
 EOF
+  end
+
+  def template_rake_extension_multi_cross_compile(extension_name)
+    <<-EOF
+require 'rake/extensiontask'
+Rake::ExtensionTask.new("#{extension_name}", SPEC) do |ext|
+  ext.cross_compile = true
+  ext.cross_platform = ['i386-mswin32', 'i386-mingw32']
 end
+EOF
+  end
 
-def template_extconf(extension_name)
-<<-EOF
+  def template_extconf(extension_name)
+    <<-EOF
 require 'mkmf'
 create_makefile("#{extension_name}")
 EOF
-end
+  end
 
-def template_source_c(extension_name)
-<<-EOF
+  def template_source_c(extension_name)
+    <<-EOF
 #include "source.h"
 void Init_#{extension_name}()
 {
   printf("source.c of extension #{extension_name}\\n");
 }
 EOF
-end
+  end
 
-def template_source_h
-<<-EOF
+  def template_source_h
+    <<-EOF
 #include "ruby.h"
 EOF
+  end
 end
+
+World(FileTemplateHelpers)

data/features/support/generator_helpers.rb

@@ -0,0 +1,96 @@
+module GeneratorHelpers
+  def generate_scaffold_structure
+    # create folder structure
+    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
+    end
+  end
+
+  def generate_gem_task(gem_name)
+    # create generic gem task
+    File.open("tasks/gem.rake", 'w') do |gem_rake|
+      gem_rake.puts template_rake_gemspec(gem_name)
+    end
+  end
+
+  def generate_extension_task_for(extension_name, platform = nil)
+    # create folder structure
+    FileUtils.mkdir_p "ext/#{extension_name}"
+
+    return if File.exist?("tasks/#{extension_name}.rake")
+
+    # Building a gem?
+    if File.exist?("tasks/gem.rake") then
+      File.open("tasks/gem.rake", 'a+') do |ext_in_gem|
+        if platform
+          ext_in_gem.puts template_rake_extension_with_platform(extension_name, platform)
+        else
+          ext_in_gem.puts template_rake_extension(extension_name, true)
+        end
+      end
+    else
+      # create specific extension rakefile
+      File.open("tasks/#{extension_name}.rake", 'w') do |ext_rake|
+        ext_rake.puts template_rake_extension(extension_name)
+      end
+    end
+  end
+
+  def generate_cross_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_cross_compile(extension_name, true)
+      end
+    else
+      File.open("tasks/#{extension_name}.rake", 'w') do |ext_rake|
+        ext_rake.puts template_rake_extension_cross_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}"
+
+    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_multi_cross_compile(extension_name)
+      end
+    end
+  end
+
+  def generate_source_code_for(extension_name)
+    # source C file
+    File.open("ext/#{extension_name}/source.c", 'w') do |c|
+      c.puts template_source_c(extension_name)
+    end
+
+    # header H file
+    File.open("ext/#{extension_name}/source.h", 'w') do |h|
+      h.puts template_source_h
+    end
+
+    # extconf.rb file
+    File.open("ext/#{extension_name}/extconf.rb", 'w') do |ext|
+      ext.puts template_extconf(extension_name)
+    end
+  end
+end
+
+World(GeneratorHelpers)

data/lib/rake/extensioncompiler.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+module Rake
+
+  #
+  # HACK: Lousy API design, sue me. At least works ;-)
+  #
+  # Define a series of helpers to aid in search and usage of MinGW (GCC) Compiler
+  # by gem developer/creators.
+  #
+  module ExtensionCompiler
+    # return the host portion from the installed MinGW
+    def self.mingw_host
+      return @mingw_host if @mingw_host
+
+      # the mingw_gcc_executable is helpful here
+      if target = mingw_gcc_executable then
+        # we only care for the filename
+        target = File.basename(target)
+
+        # now strip the extension (if present)
+        target.sub!(File.extname(target), '')
+
+        # get rid of '-gcc' portion too ;-)
+        target.sub!('-gcc', '')
+      end
+
+      raise "No MinGW tools or unknown setup platform?" unless target
+
+      @mingw_host = target
+    end
+
+    # return the first compiler found that includes both mingw and gcc conditions
+    # (this assumes you have one installed)
+    def self.mingw_gcc_executable
+      return @mingw_gcc_executable if @mingw_gcc_executable
+
+      # grab the paths defined in the environment
+      paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+
+      # the pattern to look into (captures *nix and windows executables)
+      pattern = "*mingw*gcc{,.*}"
+
+      @mingw_gcc_executable = paths.find do |path|
+        # cleanup paths before globbing
+        gcc = Dir.glob("#{File.expand_path(path)}/#{pattern}").first
+        break gcc if gcc
+      end
+
+      @mingw_gcc_executable
+    end
+  end
+end