luislavena-rake-compiler 0.1.1 → 0.2.0

data/README.rdoc

@@ -157,12 +157,78 @@ personalize several settings for <tt>Rake::ExtensionTask</tt>:
       ext.config_script = 'custom_extconf.rb' # use instead of 'extconf.rb' default
       ext.tmp_dir = 'tmp'                     # temporary folder used during compilation.
       ext.source_pattern = "*.{c,cpp}"        # monitor file changes to allow simple rebuild.
-      ext.additional_options << '--with-foo'  # supply addition configure options to config script-
+      ext.config_options << '--with-foo'      # supply additional configure options to config script.
       ext.gem_spec = spec                     # optional indicate which gem specification
                                               # will be used to based on.
     end
 
 
+== Future is now: Cross compilation
+
+rake-compiler provides now an standarized way to generate, from Linux or OSX
+both extensions and gem binaries for Windows!
+
+It takes advantages from GCC host/target to build binaries (for target) on 
+different OS (hosts).
+
+
+=== How I enjoy this?
+
+Besides having the development tool chain installed (GCC), you should install
+also <tt>mingw32</tt> cross compilation package.
+
+Dependending on your operating system distribution, a simple <tt>apt-get install mingw32</tt>
+will be enough.
+
+Please check OSX documentation about installing mingw32 from macports.
+
+
+=== I have my toolchain, now what?
+
+You need to build Ruby for Windows.
+
+Relax, no need to freak out. rake-compiler do it for you:
+
+  rake-compiler cross-ruby
+
+And you're done. It will automatically download, configure and compile latest
+stable version of Ruby for Windows, and place it into <tt>~/.rake-compiler</tt>
+
+If, instead, you want to build another version than the default one, please
+supply a <tt>VERSION</tt>:
+
+  rake-compiler cross-ruby VERSION=1.8.6-p114
+
+=== Let's build some gems!
+
+Now, you only need to use additional options in your extension defintion:
+
+    Rake::ExtensionTask.new('my_extension', gem_spec) do |ext|
+      ext.cross_compile = true                # enable cross compilation (requires cross compile toolchain)
+      ext.cross_platform = 'i386-mswin32'     # forces the Windows platform instead of the default one
+                                              # configure options only for cross compile
+      ext.cross_config_options << '--with-something'
+    end
+
+By default, cross compilation targets 'i386-mingw32' which is default GCC platform
+for Ruby.
+
+To target gems for current Ruby official distribution, please force the platform
+to the one shown before.
+
+=== Magician doing some tricks, don't blink!
+
+Compiles keeps being simple:
+
+  rake cross compile
+
+And now, build your gems for Windows is just 4 more letters:
+
+  rake cross native gem
+
+And you're done, yeah.
+
+
 == Future
 
 rake-compiler is a work in progress and we will appreciate feedback during the

data/features/compile.feature

@@ -20,7 +20,7 @@ Feature: Compile C code into Ruby extensions.
     And not changed any file since
     When rake task 'compile' is invoked
     Then rake task 'compile' succeeded
-    And output of rake task 'compile' do not contain /extension_one/
+    And output of rake task 'compile' do not contain /gcc|cl/
 
   Scenario: recompile extension when source is modified
     Given a safe project directory

data/features/cross-compile.feature

@@ -0,0 +1,13 @@
+Feature: Cross-compile C extensions
+
+  In order to avoid bitching from Windows users
+  As a Ruby developer on Linux
+  I want some rake tasks that take away the pain of compilation
+
+  Scenario: compile single extension
+    Given that all my source files are in place
+    And I'm running a POSIX operating system
+    And I've installed cross compile toolchain
+    When rake task 'cross compile' is invoked
+    Then rake task 'cross compile' succeeded
+    And binaries for platform 'i386-mingw32' get generated

data/features/cross-package.feature

@@ -0,0 +1,14 @@
+Feature: Generate Windows gems from Linux
+
+  In order to keep sanity in the Ruby world
+  As a Gem developer on Linux
+  I want more rake magic that turns monotony into joy.
+
+  Scenario: package a gem for Windows
+    Given that my gem source is all in place
+    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-mingw32' get generated

data/features/package.feature

@@ -33,8 +33,8 @@ Feature: Distribute native extension with gems
     And a extension 'extension_one' with forced platform 'universal-unknown'
     And I've already successfully executed rake task 'compile'
     And 'pkg' folder is deleted
-    When rake task 'native gem' is invoked
-    Then rake task 'native gem' succeeded
+    When rake task 'native:universal-unknown gem' is invoked
+    Then rake task 'native:universal-unknown gem' succeeded
     And 'pkg' folder is created
     And ruby gem for 'my_project' version '0.1.0' do exist in 'pkg'
     And a gem for 'my_project' version '0.1.0' platform 'universal-unknown' do exist in 'pkg'

data/features/step_definitions/compilation.rb

@@ -3,11 +3,27 @@ Given /^a extension named '(.*)'$/ do |extension_name|
   generate_source_code_for extension_name
 end
 
+Given /^a extension cross-compilable '(.*)'$/ do |extension_name|
+  generate_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
 end
 
+Given /^that all my source files are in place$/ do
+  Given "a safe project directory"
+  Given "a extension cross-compilable 'extension_one'"
+end
+
+Given /^that my gem source is all in place$/ do
+  Given "a safe project directory"
+  Given "a gem named 'gem_abc'"
+  Given "a extension cross-compilable 'extension_one'"
+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

@@ -0,0 +1,20 @@
+# Naive way of looking into platforms, please include others like FreeBSD?
+if RUBY_PLATFORM =~ /linux|darwin/
+  Given %r{^I'm running a POSIX operating system$} do
+  end
+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
+  end
+  raise "Cannot locate '#{compiler}' in the PATH." unless found
+end
+
+Then /^binaries for platform '(.*)' get generated$/ do |platform|
+  ext_for_platform = Dir.glob("tmp/#{platform}/**/*.#{RbConfig::CONFIG['DLEXT']}")
+  ext_for_platform.should_not be_empty
+end

data/features/step_definitions/gem.rb

@@ -14,6 +14,10 @@ Then /^a gem for '(.*)' version '(.*)' platform '(.*)' do exist in '(.*)'$/ do |
   File.exist?(gem_file_platform(folder, name, version, platform)).should be_true
 end
 
+Then /^gem for platform '(.*)' get generated$/ do |platform|
+  Then "a gem for 'gem_abc' version '0.1.0' platform '#{platform}' do exist in 'pkg'"
+end
+
 def gem_file(folder, name, version)
   "#{folder}/#{name}-#{version}.gem"
 end

data/features/support/file_templates.rb

@@ -19,6 +19,10 @@ SPEC = Gem::Specification.new do |s|
   s.version = "0.1.0"
   s.summary = "#{gem_name} test gem for rake-compiler"
 
+  s.files = FileList["ext/**/*.{rb,c,h}", "Rakefile", "tasks/*.rake", "lib/**/*.rb"]
+
+  s.extensions = FileList["ext/**/extconf.rb"]
+
   s.has_rdoc = true
 
   s.homepage = 'http://github.com/luislavena/rake-compiler'
@@ -51,6 +55,15 @@ end
 EOF
 end
 
+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_extconf(extension_name)
 <<-EOF
 require 'mkmf'

data/features/support/generators.rb

@@ -40,6 +40,25 @@ def generate_extension_task_for(extension_name, platform = nil)
   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_source_code_for(extension_name)
   # source C file
   File.open("ext/#{extension_name}/source.c", 'w') do |c|

data/lib/rake/extensiontask.rb

@@ -9,6 +9,9 @@ require 'rake/tasklib'
 require 'rbconfig'
 
 module Rake
+  autoload :GemPackageTask, 'rake/gempackagetask'
+  autoload :YAML, 'yaml'
+
   class ExtensionTask < TaskLib
     attr_accessor :name
     attr_accessor :gem_spec
@@ -17,8 +20,11 @@ module Rake
     attr_accessor :ext_dir
     attr_accessor :lib_dir
     attr_accessor :platform
-    attr_accessor :additional_options
+    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)
@@ -34,149 +40,231 @@ module Rake
       @ext_dir = 'ext'
       @lib_dir = 'lib'
       @source_pattern = "*.c"
-      @additional_options = []
+      @config_options = []
+      @cross_compile = false
+      @cross_config_options = []
     end
 
     def platform
       @platform ||= RUBY_PLATFORM
     end
 
+    def cross_platform
+      @cross_platform ||= 'i386-mingw32'
+    end
+
     def define
       fail "Extension name must be provided." if @name.nil?
 
       define_compile_tasks
-      define_native_tasks if @gem_spec
+
+      # only gems with 'ruby' platforms are allowed to define native tasks
+      define_native_tasks if @gem_spec && @gem_spec.platform == 'ruby'
+
+      # only define cross platform functionality when enabled
+      # FIXME: there is no value for having this on Windows or JRuby
+      define_cross_platform_tasks if @cross_compile
     end
 
     private
-    def define_compile_tasks
+    def define_compile_tasks(for_platform = nil)
+      # platform usage
+      platf = for_platform || platform
+
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{platf}/#{@name}"
+
+      # cleanup and clobbering
+      CLEAN.include(tmp_path)
+      CLOBBER.include("#{@lib_dir}/#{binary}")
+      CLOBBER.include("#{@tmp_dir}")
+
       # directories we need
       directory tmp_path
-      directory @lib_dir
+      directory lib_dir
 
-      # platform specific temp folder should be on the cleaning
-      CLEAN.include(tmp_path)
+      # copy binary from temporary location to final lib
+      # tmp/extension_name/extension_name.{so,bundle} => lib/
+      task "copy:#{@name}:#{platf}" => [lib_dir, "#{tmp_path}/#{binary}"] do
+        cp "#{tmp_path}/#{binary}", "#{@lib_dir}/#{binary}"
+      end
+
+      # binary in temporary folder depends on makefile and source files
+      # tmp/extension_name/extension_name.{so,bundle}
+      file "#{tmp_path}/#{binary}" => ["#{tmp_path}/Makefile"] + source_files do
+        chdir tmp_path do
+          sh make
+        end
+      end
 
       # makefile depends of tmp_dir and config_script
       # tmp/extension_name/Makefile
-      file makefile => [tmp_path, extconf] do
+      file "#{tmp_path}/Makefile" => [tmp_path, extconf] do |t|
+        options = @config_options.dup
+
+        # rbconfig.rb will be present if we are cross compiling
+        if t.prerequisites.include?("#{tmp_path}/rbconfig.rb") then
+          options.push(*@cross_config_options)
+        end
+
         parent = Dir.pwd
-        Dir.chdir tmp_path do
+        chdir tmp_path do
           # FIXME: Rake is broken for multiple arguments system() calls.
           # Add current directory to the search path of Ruby
           # Also, include additional parameters supplied.
-          ruby ['-I.', File.join(parent, extconf), *@additional_options].join(' ')
+          ruby ['-I.', File.join(parent, extconf), *options].join(' ')
         end
       end
 
-      # binary in temporary folder depends on makefile and source files
-      # tmp/extension_name/extension_name.{so,bundle}
-      file tmp_binary => [makefile] + source_files do
-        Dir.chdir tmp_path do
-          sh make
-        end
+      # compile tasks
+      unless Rake::Task.task_defined?('compile') then
+        desc "Compile all the extensions"
+        task "compile"
       end
 
-      # copy binary from temporary location to final lib
-      # tmp/extension_name/extension_name.{so,bundle} => lib/
-      file lib_binary => [lib_path, tmp_binary] do
-        cp tmp_binary, lib_binary
+      # compile:name
+      unless Rake::Task.task_defined?("compile:#{@name}") then
+        desc "Compile #{@name}"
+        task "compile:#{@name}"
       end
 
-      # clobbering should remove the binaries from lib_path
-      CLOBBER.include(lib_binary)
+      # Allow segmented compilation by platfrom (open door for 'cross compile')
+      task "compile:#{@name}:#{platf}" => ["copy:#{@name}:#{platf}"]
+      task "compile:#{platf}" => ["compile:#{@name}:#{platf}"]
 
-      # we should also clobber the tmp folder
-      CLOBBER.include(@tmp_dir)
+      # 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_dir}/#{binary}" => ["copy:#{name}:#{platf}"]
 
-      desc "Compile just the #{@name} extension"
-      task "compile:#{@name}" => [lib_binary]
-
-      desc "Compile the extension(s)" unless Rake::Task.task_defined?('compile')
-      task "compile" => ["compile:#{@name}"]
+        task "compile:#{@name}" => ["compile:#{@name}:#{platf}"]
+        task "compile" => ["compile:#{platf}"]
+      end
     end
 
-    def define_native_tasks
-      # only gems with 'ruby' platforms are allowed to define native tasks
-      return unless @gem_spec.platform == 'ruby'
+    def define_native_tasks(for_platform = nil)
+      platf = for_platform || platform
 
-      require 'rake/gempackagetask' unless defined?(Rake::GemPackageTask)
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{platf}/#{@name}"
 
       # create 'native:gem_name' and chain it to 'native' task
-      native_task_for(@gem_spec)
-
-      # hook the binary to the prerequisites for this task
-      task native_task_gem => [lib_binary]
-    end
-
-    def makefile
-      "#{tmp_path}/Makefile"
-    end
+      spec = @gem_spec.dup
+
+      unless Rake::Task.task_defined?("native:#{@gem_spec.name}:#{platf}")
+        task "native:#{@gem_spec.name}:#{platf}" do |t|
+          # adjust to specified platform
+          spec.platform = platf
+
+          # clear the extensions defined in the specs
+          spec.extensions.clear
+
+          # add the binaries that this task depends on
+          # ensure the files get properly copied to lib_dir
+          ext_files = t.prerequisites.map { |ext| "#{@lib_dir}/#{File.basename(ext)}" }
+          ext_files.each do |ext|
+            unless Rake::Task.task_defined?("#{@lib_dir}/#{File.basename(ext)}") then
+              # strip out path and .so/.bundle
+              file "#{@lib_dir}/#{File.basename(ext)}" => ["copy:#{File.basename(ext).ext('')}:#{platf}"]
+            end
+          end
+
+          # include the files in the gem specification
+          spec.files += ext_files
+
+          # Generate a package for this gem
+          gem_package = Rake::GemPackageTask.new(spec) do |pkg|
+            pkg.need_zip = false
+            pkg.need_tar = false
+          end
+
+          # ensure the binaries are copied
+          task "#{gem_package.package_dir}/#{gem_package.gem_file}" => ["copy:#{@name}:#{platf}"]
+        end
+      end
 
-    def extconf
-      "#{ext_path}/#{@config_script}"
-    end
+      # add binaries to the dependency chain
+      task "native:#{@gem_spec.name}:#{platf}" => ["#{tmp_path}/#{binary}"]
 
-    def tmp_path
-      File.join(@tmp_dir, platform, @name)
-    end
+      # Allow segmented packaging by platfrom (open door for 'cross compile')
+      task "native:#{platf}" => ["native:#{@gem_spec.name}:#{platf}"]
 
-    def ext_path
-      File.join(@ext_dir, @name)
+      # Only add this extension to the compile chain if current
+      # platform matches the indicated one.
+      if platf == RUBY_PLATFORM then
+        task "native:#{@gem_spec.name}" => ["native:#{@gem_spec.name}:#{platf}"]
+        task "native" => ["native:#{platf}"]
+      end
     end
 
-    def lib_path
-      @lib_dir
-    end
+    def define_cross_platform_tasks
+      config_path = File.expand_path("~/.rake-compiler/config.yml")
+      major_ver = RUBY_VERSION.match(/(\d+.\d+)/)[1]
 
-    def make
-      RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make'
-    end
+      # warn the user about the need of configuration to use cross compilation.
+      unless File.exist?(config_path)
+        warn "rake-compiler must be configured first to enable cross-compilation"
+        return
+      end
 
-    def binary
-      "#{@name}.#{RbConfig::CONFIG['DLEXT']}"
-    end
+      config_file = YAML.load_file(config_path)
 
-    def source_files
-     @source_files ||= FileList["#{ext_path}/#{@source_pattern}"]
-    end
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{cross_platform}/#{@name}"
 
-    def tmp_binary
-      "#{tmp_path}/#{binary}"
-    end
+      unless rbconfig_file = config_file["rbconfig-#{major_ver}"] then
+        fail "no configuration section for this version of Ruby (rbconfig-#{major_ver})"
+      end
 
-    def lib_binary
-      "#{lib_path}/#{binary}"
-    end
+      # define compilation tasks for cross platfrom!
+      define_compile_tasks(cross_platform)
 
-    def native_task_gem
-      "native:#{@gem_spec.name}"
-    end
+      # chain rbconfig.rb to Makefile generation
+      file "#{tmp_path}/Makefile" => ["#{tmp_path}/rbconfig.rb"]
 
-    def native_task_for(gem_spec)
-      return if Rake::Task.task_defined?(native_task_gem)
+      # copy the file from the cross-ruby location
+      file "#{tmp_path}/rbconfig.rb" => [rbconfig_file] do |t|
+        cp t.prerequisites.first, t.name
+      end
 
-      spec = gem_spec.dup
+      # now define native tasks for cross compiled files
+      define_native_tasks(cross_platform) if @gem_spec && @gem_spec.platform == 'ruby'
 
-      task native_task_gem do |t|
-        # adjust to current platform
-        spec.platform = (@platform || Gem::Platform::CURRENT)
+      # create cross task
+      task 'cross' do
+        # clear compile dependencies
+        Rake::Task['compile'].prerequisites.clear
 
-        # clear the extensions defined in the specs
-        spec.extensions.clear
+        # chain the cross platform ones
+        task 'compile' => ["compile:#{cross_platform}"]
 
-        # add the binary dependencies of this task
-        spec.files += t.prerequisites
+        # clear lib/binary dependencies and trigger cross platform ones
+        Rake::Task["#{@lib_dir}/#{binary}"].prerequisites.clear
+        file "#{@lib_dir}/#{binary}" => ["copy:#{@name}:#{cross_platform}"]
 
-        # Generate a package for this gem
-        gem_package = Rake::GemPackageTask.new(spec) do |pkg|
-          pkg.need_zip = false
-          pkg.need_tar = false
+        # if everything for native task is in place
+        if @gem_spec && @gem_spec.platform == 'ruby' then
+          Rake::Task['native'].prerequisites.clear
+          task 'native' => ["native:#{cross_platform}"]
         end
       end
+    end
 
-      # add this native task to the list
-      task "native" => [native_task_gem]
+    def extconf
+      "#{@ext_dir}/#{@name}/#{@config_script}"
+    end
+
+    def make
+      RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make'
+    end
+
+    def binary
+      "#{@name}.#{RbConfig::CONFIG['DLEXT']}"
+    end
+
+    def source_files
+     @source_files ||= FileList["#{@ext_dir}/#{@name}/#{@source_pattern}"]
     end
   end
 end

data/spec/lib/rake/extensiontask_spec.rb

@@ -80,13 +80,25 @@ describe Rake::ExtensionTask do
       @ext.source_pattern.should == "*.c"
     end
 
-    it 'should have no additional options preset to delegate' do
-      @ext.additional_options.should be_empty
+    it 'should have no configuration options preset to delegate' do
+      @ext.config_options.should be_empty
     end
 
     it 'should default to current platform' do
       @ext.platform.should == RUBY_PLATFORM
     end
+
+    it 'should default to no cross compilation' do
+      @ext.cross_compile.should be_false
+    end
+
+    it 'should have no configuration options for cross compilation' do
+      @ext.cross_config_options.should be_empty
+    end
+
+    it "should have cross platform defined to 'i386-mingw32'" do
+      @ext.cross_platform.should == 'i386-mingw32'
+    end
   end
 
   describe '(tasks)' do
@@ -109,8 +121,8 @@ describe Rake::ExtensionTask do
           Rake::Task.task_defined?('compile').should be_true
         end
 
-        it "should depend on 'compile:extension_one'" do
-          Rake::Task['compile'].prerequisites.should include('compile:extension_one')
+        it "should depend on 'compile:{platform}'" do
+          Rake::Task['compile'].prerequisites.should include("compile:#{@platform}")
         end
       end
 
@@ -119,8 +131,8 @@ describe Rake::ExtensionTask do
           Rake::Task.task_defined?('compile:extension_one').should be_true
         end
 
-        it "should depend on 'lib/extension_one.{so,bundle}'" do
-          Rake::Task['compile:extension_one'].prerequisites.should include("lib/#{@ext_bin}")
+        it "should depend on 'compile:extension_one:{platform}'" do
+          Rake::Task['compile:extension_one'].prerequisites.should include("compile:extension_one:#{@platform}")
         end
       end
 
@@ -129,12 +141,8 @@ describe Rake::ExtensionTask do
           Rake::Task.task_defined?("lib/#{@ext_bin}").should be_true
         end
 
-        it "should depend on 'lib'" do
-          Rake::Task["lib/#{@ext_bin}"].prerequisites.should include("lib")
-        end
-
-        it "should depend on 'tmp/extension_one.{so,bundle}'" do
-          Rake::Task["lib/#{@ext_bin}"].prerequisites.should include("tmp/#{@platform}/extension_one/#{@ext_bin}")
+        it "should depend on 'copy:extension_one:{platform}'" do
+          Rake::Task["lib/#{@ext_bin}"].prerequisites.should include("copy:extension_one:#{@platform}")
         end
       end
 
@@ -192,6 +200,7 @@ describe Rake::ExtensionTask do
         Rake::FileList.stub!(:[]).and_return(["ext/extension_one/source.c"])
         @spec = mock_gem_spec
         @ext_bin = ext_bin('extension_one')
+        @platform = RUBY_PLATFORM
       end
 
       describe 'native' do
@@ -216,15 +225,93 @@ describe Rake::ExtensionTask do
           Rake::Task.task_defined?('native').should be_false
         end
 
-        it 'should depend on gem specific native tasks' do
+        it 'should depend on platform specific native tasks' do
           Rake::ExtensionTask.new('extension_one', @spec)
-          Rake::Task["native"].prerequisites.should include("native:my_gem")
+          Rake::Task["native"].prerequisites.should include("native:#{@platform}")
         end
 
-        describe 'native:my_gem' do
+        describe 'native:my_gem:{platform}' do
           it 'should depend on binary extension' do
             Rake::ExtensionTask.new('extension_one', @spec)
-            Rake::Task["native:my_gem"].prerequisites.should include("lib/#{@ext_bin}")
+            Rake::Task["native:my_gem:#{@platform}"].prerequisites.should include("tmp/#{@platform}/extension_one/#{@ext_bin}")
+          end
+        end
+      end
+    end
+
+    describe '(cross platform tasks)' do
+      before :each do
+        File.stub!(:exist?).and_return(true)
+        YAML.stub!(:load_file).and_return(mock_config_yml)
+        Rake::FileList.stub!(:[]).and_return(["ext/extension_one/source.c"])
+        @spec = mock_gem_spec
+        @config_file = File.expand_path("~/.rake-compiler/config.yml")
+        @major_ver = RUBY_VERSION.match(/(\d+.\d+)/)[1]
+        @config_path = mock_config_yml["rbconfig-#{@major_ver}"]
+      end
+
+      it 'should not generate an error if no rake-compiler configuration exist' do
+        File.should_receive(:exist?).with(@config_file).and_return(false)
+        lambda {
+          Rake::ExtensionTask.new('extension_one') do |ext|
+            ext.cross_compile = true
+          end
+        }.should_not raise_error(RuntimeError)
+      end
+
+      it 'should parse the config file using YAML' do
+        YAML.should_receive(:load_file).with(@config_file).and_return(mock_config_yml)
+        Rake::ExtensionTask.new('extension_one') do |ext|
+          ext.cross_compile = true
+        end
+      end
+
+      it 'should fail if no section of config file defines running version of ruby' do
+        config = mock(Hash)
+        config.should_receive(:[]).with("rbconfig-#{@major_ver}").and_return(nil)
+        YAML.stub!(:load_file).and_return(config)
+        lambda {
+          Rake::ExtensionTask.new('extension_one') do |ext|
+            ext.cross_compile = true
+          end
+        }.should raise_error(RuntimeError, /no configuration section for this version of Ruby/)
+      end
+
+      describe "(cross for 'universal-unknown' platform)" do
+        before :each do
+          @ext = Rake::ExtensionTask.new('extension_one', @spec) do |ext|
+            ext.cross_compile = true
+            ext.cross_platform = 'universal-unknown'
+          end
+        end
+
+        describe 'rbconfig' do
+          it 'should chain rbconfig tasks to Makefile generation' do
+            Rake::Task['tmp/universal-unknown/extension_one/Makefile'].prerequisites.should include('tmp/universal-unknown/extension_one/rbconfig.rb')
+          end
+
+          it 'should take rbconfig from rake-compiler configuration' do
+            Rake::Task['tmp/universal-unknown/extension_one/rbconfig.rb'].prerequisites.should include(@config_path)
+          end
+        end
+
+        describe 'compile:universal-unknown' do
+          it "should be defined" do
+            Rake::Task.task_defined?('compile:universal-unknown').should be_true
+          end
+
+          it "should depend on 'compile:extension_one:universal-unknown'" do
+            Rake::Task['compile:universal-unknown'].prerequisites.should include('compile:extension_one:universal-unknown')
+          end
+        end
+
+        describe 'native:universal-unknown' do
+          it "should be defined" do
+            Rake::Task.task_defined?('native:universal-unknown').should be_true
+          end
+
+          it "should depend on 'native:my_gem:universal-unknown'" do
+            Rake::Task['native:universal-unknown'].prerequisites.should include('native:my_gem:universal-unknown')
           end
         end
       end
@@ -242,4 +329,10 @@ describe Rake::ExtensionTask do
     )
   end
 
+  def mock_config_yml
+    {
+      'rbconfig-1.8' => '/some/path/version/1.8/to/rbconfig.rb',
+      'rbconfig-1.9' => '/some/path/version/1.9/to/rbconfig.rb'
+    }
+  end
 end

data/tasks/rubygems.rake

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   # basic information
   s.name        = "rake-compiler"
-  s.version     = "0.1.1"
+  s.version     = "0.2.0"
   s.platform    = Gem::Platform::RUBY
 
   # description and details

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: luislavena-rake-compiler
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Luis Lavena
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-27 18:00:00 -08:00
+date: 2008-11-28 18:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -36,8 +36,11 @@ extra_rdoc_files:
 - LICENSE.txt
 files: 
 - features/compile.feature
+- features/cross-compile.feature
+- features/cross-package.feature
 - features/package.feature
 - features/step_definitions/compilation.rb
+- features/step_definitions/cross_compilation.rb
 - features/step_definitions/execution.rb
 - features/step_definitions/folders.rb
 - features/step_definitions/gem.rb