rake-compiler 0.3.0

data/features/support/file_templates.rb

@@ -0,0 +1,88 @@
+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'))
+
+require 'rubygems'
+require 'rake'
+
+# load rakefile extensions (tasks)
+Dir['tasks/*.rake'].each { |f| import f }
+EOF
+end
+
+def template_rake_gemspec(gem_name)
+<<-EOF
+require 'rake/gempackagetask'
+SPEC = Gem::Specification.new do |s|
+  s.name = "#{gem_name}"
+  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'
+  s.rubyforge_project = 'TODO'
+
+  s.authors = ["Luis Lavena"]
+  s.email = ["luislavena@gmail.com"]
+end
+
+gem_package = Rake::GemPackageTask.new(SPEC) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+EOF
+end
+
+def template_rake_extension(extension_name, gem_spec = nil)
+<<-EOF
+require 'rake/extensiontask'
+Rake::ExtensionTask.new("#{extension_name}"#{', SPEC' if gem_spec})
+EOF
+end
+
+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
+
+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'
+create_makefile("#{extension_name}")
+EOF
+end
+
+def template_source_c(extension_name)
+<<-EOF
+#include "source.h"
+void Init_#{extension_name}()
+{
+  printf("source.c of extension #{extension_name}\\n");
+}
+EOF
+end
+
+def template_source_h
+<<-EOF
+#include "ruby.h"
+EOF
+end

data/features/support/generators.rb

@@ -0,0 +1,77 @@
+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_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

data/lib/rake/extensiontask.rb

@@ -0,0 +1,270 @@
+#!/usr/bin/env ruby
+
+# 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'
+
+module Rake
+  autoload :GemPackageTask, 'rake/gempackagetask'
+  autoload :YAML, 'yaml'
+
+  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
+
+    def init(name = nil, gem_spec = nil)
+      @name = name
+      @gem_spec = gem_spec
+      @config_script = 'extconf.rb'
+      @tmp_dir = 'tmp'
+      @ext_dir = 'ext'
+      @lib_dir = 'lib'
+      @source_pattern = "*.c"
+      @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
+
+      # 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(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
+
+      # 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 "#{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
+        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), *options].join(' ')
+        end
+      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 platfrom (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_dir}/#{binary}" => ["copy:#{name}:#{platf}"]
+
+        task "compile:#{@name}" => ["compile:#{@name}:#{platf}"]
+        task "compile" => ["compile:#{platf}"]
+      end
+    end
+
+    def define_native_tasks(for_platform = nil)
+      platf = for_platform || platform
+
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{platf}/#{@name}"
+
+      # create 'native:gem_name' and chain it to 'native' task
+      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
+
+      # add binaries to the dependency chain
+      task "native:#{@gem_spec.name}:#{platf}" => ["#{tmp_path}/#{binary}"]
+
+      # Allow segmented packaging by platfrom (open door for 'cross compile')
+      task "native:#{platf}" => ["native:#{@gem_spec.name}:#{platf}"]
+
+      # 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 define_cross_platform_tasks
+      config_path = File.expand_path("~/.rake-compiler/config.yml")
+      major_ver = (ENV['RUBY_CC_VERSION'] || RUBY_VERSION).match(/(\d+.\d+)/)[1]
+
+      # 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
+
+      config_file = YAML.load_file(config_path)
+
+      # tmp_path
+      tmp_path = "#{@tmp_dir}/#{cross_platform}/#{@name}"
+
+      unless rbconfig_file = config_file["rbconfig-#{major_ver}"] then
+        fail "no configuration section for this version of Ruby (rbconfig-#{major_ver})"
+      end
+
+      # define compilation tasks for cross platfrom!
+      define_compile_tasks(cross_platform)
+
+      # chain rbconfig.rb to Makefile generation
+      file "#{tmp_path}/Makefile" => ["#{tmp_path}/rbconfig.rb"]
+
+      # copy the file from the cross-ruby location
+      file "#{tmp_path}/rbconfig.rb" => [rbconfig_file] do |t|
+        cp t.prerequisites.first, t.name
+      end
+
+      # now define native tasks for cross compiled files
+      define_native_tasks(cross_platform) if @gem_spec && @gem_spec.platform == 'ruby'
+
+      # create cross task
+      task 'cross' do
+        # clear compile dependencies
+        Rake::Task['compile'].prerequisites.clear
+
+        # chain the cross platform ones
+        task 'compile' => ["compile:#{cross_platform}"]
+
+        # clear lib/binary dependencies and trigger cross platform ones
+        Rake::Task["#{@lib_dir}/#{binary}"].prerequisites.clear
+        file "#{@lib_dir}/#{binary}" => ["copy:#{@name}:#{cross_platform}"]
+
+        # 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
+
+    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