mkrf 0.1.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+= 0.1.0  6/28/06
+* First release.

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006 Kevin Clark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,54 @@
+= mkrf -- making C extensions for Ruby a bit easier
+
+<tt>mkrf</tt> is intended to replace <tt>mkmf</tt>, a library for buildling
+Makefiles to build C extensions to Ruby. Its major goals are easy code reuse of
+its <tt>Availability</tt> class and simple, well documented, use of the
+<tt>Generator</tt> class for Rakefile generation for extensions.
+
+== Basic Usage
+
+<tt>mkrf</tt> works similarly to <tt>mkmf</tt> in that a user writes an
+extension configuration (usually <tt>extconf.rb</tt>) and then runs it, which
+generates a <tt>Rakefile</tt>. 
+
+In general, <tt>extconf.rb</tt> should be placed in the root directory of the 
+extension and it expects by default that files to be compiled have a <tt>.c</tt> 
+extension and are in the <tt>lib/</tt> directory.
+
+The most basic usage looks like this, with the name of the library to be linked
+as the first argument to <tt>Mkrf::Generator.new</tt>:
+
+  require 'mkrf'
+  Mkrf::Generator.new('libtrivial_so.bundle')
+
+Extra arguments may be passed to the generator in a block:
+
+  Mkrf::Generator.new('libxml_so.bundle', '*.c') do |g|
+    g.include_library('socket','socket')
+    g.include_header('libxml/xmlversion.h', 
+                     '/opt/include/libxml2', 
+                     '/usr/local/include/libxml2', 
+                     '/usr/include/libxml2')
+  end
+
+If the extension does not follow the source in <tt>lib/</tt> / <tt>.c</tt> 
+extension convention, it may be overridden in the constructor:
+
+  Mkrf::Generator.new('syck.bundle', '*.c') do |g|
+    g.include_header("st.h")
+  end
+
+
+== Credits
+* Jim Weirich for writing Rake
+
+== Licence
+mkrf is available under an MIT-style license.
+
+Copyright (c) 2006 Kevin Clark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,107 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rubygems'
+
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'mkrf'
+
+PKG_NAME      = 'mkrf'
+PKG_VERSION   = Mkrf::VERSION
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "mkrf"
+RUBY_FORGE_USER    = "kevinclark"
+
+
+task :default => ["test:units"]
+
+namespace :test do
+  
+  desc "Run basic tests"
+  Rake::TestTask.new("units") { |t|
+    t.pattern = 'test/test_*.rb'
+    t.verbose = true
+    t.warning = true
+  }
+  
+  namespace :samples do
+    
+    BASE_DIR = File.dirname(__FILE__) + '/test/sample_files'
+    
+    SAMPLE_DIRS = {
+      :libtrivial => BASE_DIR + '/libtrivial/',
+      :syck => BASE_DIR + '/syck-0.55/ext/ruby/ext/syck/',
+      :libxml => BASE_DIR + '/libxml-ruby-0.3.8/ext/xml/'
+    }
+    
+    task :default => [:all]
+    
+    desc "Try to compile all of the sample extensions"
+    task :all => [:clean, :trivial, :libxml, :syck]
+    
+    desc "Try to compile a trivial extension"
+    task :trivial do
+      sh "cd #{SAMPLE_DIRS[:libtrivial]}; ruby extconf.rb; rake"
+    end
+    
+    desc "Try to compile libxml"
+    task :libxml do
+      sh "cd #{SAMPLE_DIRS[:libxml]}; ruby extconf.rb; rake"
+    end
+    
+    desc "Try to compile syck"
+    task :syck do
+      sh "cd #{SAMPLE_DIRS[:syck]}; ruby extconf.rb; rake"
+    end
+    
+    desc "Clean up after sample tests"
+    task :clean do
+      SAMPLE_DIRS.each_value do |test_dir|
+        puts "test_dir is #{test_dir}"
+        next unless File.exist?(test_dir + "/Rakefile")
+        sh "cd #{test_dir}; rake clean; rake clobber; rm Rakefile"
+      end
+    end
+    
+  end  
+
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+end
+  
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "Generate Rakefiles to Build C Extensions to Ruby"
+  s.description = %q{This proposed replacement to mkmf generates Rakefiles to build C Extensions.}
+  s.version = PKG_VERSION
+
+  s.author = "Kevin Clark"
+  s.email = "kevin.clark@gmail.com"
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.homepage = "http://glu.ttono.us"
+
+  s.has_rdoc = true
+  s.requirements << 'rake'
+  s.require_path = 'lib'
+  s.autorequire = 'mkrf'
+
+  s.files = [ "Rakefile", "README", "CHANGELOG", "MIT-LICENSE" ]
+  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end

data/lib/mkrf.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/mkrf/availability'
+require File.dirname(__FILE__) + '/mkrf/generator'
+
+Mkrf::VERSION = "0.1.0"

data/lib/mkrf/availability.rb

@@ -0,0 +1,219 @@
+require 'rbconfig'
+require 'logger'
+
+module Mkrf
+  
+  # The +Availability+ class is concerned with libraries, headers, and
+  # functions. It can be easily wrapped (see <tt>Mkrf::Generator</tt> for an
+  # example) and should be able to be used as a basis for a variety of programs
+  # which need to determine functionality based on what libraries are available
+  # on the current system.
+  class Availability
+    DEFAULT_LIBS = ["ruby", "dl"]
+    
+    # These really shouldn't be static like this..
+    TEMP_SOURCE_FILE = "temp_source.c"
+    TEMP_EXECUTABLE = "temp_executable"
+    
+    attr_reader :headers, :loaded_libs, :includes
+    
+    # Create a new Availability instance.
+    #
+    # Valid keys for the options hash include:
+    # * <tt>:loaded_libs</tt> -- libraries to load by default
+    # * <tt>:headers</tt> -- headers to load by default
+    # * <tt>:compiler</tt> -- which compiler to use when determining availability
+    # * <tt>:includes</tt> -- directories that should be searched for include files
+    def initialize(options = {})
+      @loaded_libs = options[:loaded_libs] || DEFAULT_LIBS
+      @headers = options[:headers] || []
+      @compiler = options[:compiler] || "gcc"
+      @includes = (options[:includes].to_a) || []
+      @logger = Logger.new('mkrf.log')
+    end
+    
+    # Include a library in the list of available libs. Returns +false+ if the
+    # library is not available. Returns non-false otherwise.
+    #
+    # Params:
+    # * <tt>library</tt> -- the library to be included as a string.
+    # * <tt>function</tt> -- a method to base the inclusion of the library on. +main+ by default.
+    def include_library(library, function = "main")
+      @loaded_libs << library if has_library?(library, function)
+    end
+    
+    # Include a header in the list of availiable headers. Returns +false+ if the
+    # header is not available. Returns non-false otherwise.
+    #
+    # Params:
+    # * <tt>header</tt> -- the name of the header to be included as a string.
+    # * <tt>paths</tt> -- an optional list of search paths if the header is not found in the default paths.
+    def include_header(header, *paths)
+      @headers << header if has_header?(header, *paths)
+    end
+    
+    # Returns a boolean whether indicating whether the library can be found 
+    # by attempting to reference the function passed (+main+ by default).
+    #
+    # Params:
+    # * <tt>library</tt> -- the library to be included as a string
+    # * <tt>function</tt> -- a method to base the inclusion of the library on. +main+ by default.
+    def has_library?(library, function = "main")
+      return true if @loaded_libs.include? library
+      with_loaded_libs(library) {
+        has_function? function
+      }
+    end
+    
+    # Returns +true+ if the header is found in the default search path or in
+    # optional paths passed as an argument, +false+ otherwise.
+    #
+    # Params:
+    # * <tt>header</tt> -- the header to be searched for
+    # * <tt>paths</tt> -- an optional list of search paths if the header is not found in the default paths
+    def has_header?(header, *paths)
+      return true if @headers.include? header
+      
+      has_header = with_headers(header) {
+        can_link?(simple_include(header))
+      }
+      
+      return true if has_header
+      
+      paths.each do |include_path|
+        has_header = with_includes(include_path) {
+          with_headers(header) {
+            can_link?(simple_include(header))
+          }
+        }
+        @includes << include_path and return true if has_header
+      end
+
+      return false
+    end
+    
+    # Returns +true+ if the function is able to be called based on libraries and
+    # headers currently loaded. Returns +false+ otherwise.
+    #
+    # Params:
+    # * <tt>function</tt> -- the function to check for
+    def has_function?(function)
+      can_link?(simple_call(function)) or can_link?(simple_reference(function))
+    end
+    
+    # Returns the result of an attempt to compile and link the function body
+    # passed in
+    def can_link?(function_body)
+      silence_command_line do
+        create_source(function_body)
+        system(link_command)
+      end
+    ensure
+      FileUtils.rm_f TEMP_SOURCE_FILE
+      FileUtils.rm_f TEMP_EXECUTABLE
+    end
+    
+    def method_missing(method, *args, &b)
+      if match = /^with_([_a-zA-Z]\w*)$/.match(method.to_s)
+        super unless STACKABLE_ATTRIBUTES.include? match[1]
+        with_stackable_attribute(match[1], *args, &b)
+      else
+        super
+      end
+    end
+    
+    # Returns a string of libraries formatted for compilation
+    def library_compile_string
+      @loaded_libs.collect {|l| "-l#{l}"}.join(' ')
+    end
+    
+    # Returns a string of include directories formatted for compilation
+    def includes_compile_string
+      @includes.collect {|i| "-I#{i}"}.join(' ')
+    end
+    
+    private
+        
+    STACKABLE_ATTRIBUTES = ['loaded_libs', 'headers', 'includes']
+    
+    def with_stackable_attribute(attribute, *args)
+      args = args.to_a
+      instance_variable_set(:"@#{attribute}", 
+                            instance_variable_get(:"@#{attribute}") + args)
+      value = yield
+      instance_variable_set(:"@#{attribute}", 
+                            instance_variable_get(:"@#{attribute}") - args)
+      return value
+    end
+    
+    def header_include_string
+      @headers.collect {|header| "#include <#{header}>"}.join('\n')
+    end
+    
+    def link_command
+      "#{@compiler} -o #{TEMP_EXECUTABLE} #{library_compile_string} " +
+      "#{includes_compile_string} #{TEMP_SOURCE_FILE}"
+    end
+
+    # Creates a temporary source file with the string passed
+    def create_source(src)
+      File.open(TEMP_SOURCE_FILE, "w+") do |f|
+        f.write(src)
+      end
+    end
+        
+    # Basic skeleton for calling a function
+    def simple_call(func)
+      src = <<-SRC
+        #{header_include_string}
+        int main() { return 0; }
+        int t() { #{func}(); return 0; }
+      SRC
+    end
+    
+    # Basic skeleton for referencing a function
+    def simple_reference(func)
+      src = <<-SRC
+        #{header_include_string}
+        int main() { return 0; }
+        int t() { void ((*volatile p)()); p = (void ((*)()))#{func}; return 0; }
+      SRC
+    end
+    
+    # skeleton for testing includes
+    def simple_include(header)
+      src = <<-SRC
+        #{header_include_string}
+        #include <#{header}>
+        int main() { return 0; }
+      SRC
+    end
+        
+    def silence_command_line
+      silence_stream(STDERR) do
+        silence_stream(STDOUT) do
+          yield
+        end
+      end
+    end
+    
+    # silence_stream taken from Rails ActiveSupport reporting.rb
+    
+    # Silences any stream for the duration of the block.
+    #
+    #   silence_stream(STDOUT) do
+    #     puts 'This will never be seen'
+    #   end
+    #
+    #   puts 'But this will'
+    def silence_stream(stream)
+      old_stream = stream.dup
+      stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+      stream.sync = true
+      yield
+    ensure
+      stream.reopen(old_stream)
+    end
+    
+  end
+end

data/lib/mkrf/generator.rb

@@ -0,0 +1,146 @@
+require 'rubygems'
+require 'rbconfig'
+require 'rake/tasklib'
+
+module Mkrf
+  
+  # +Generator+ is concerned with taking configuration for an extension
+  # and writing a +Rakefile+ to the local filesystem to build the extension.
+  #
+  # = Usage
+  # In the most basic usage, +Generator+ simply takes the name of the library
+  # to compile:
+  #
+  #   require 'mkrf'
+  #   Mkrf::Generator.new('libtrivial_so.bundle')
+  #
+  # Configuration of the build can be passed to the +Generator+ constructor
+  # as a block:
+  #
+  #   Mkrf::Generator.new('libxml_so.bundle', '*.c') do |g|
+  #     g.include_library('socket','socket')
+  #     g.include_header('libxml/xmlversion.h',
+  #                      '/opt/include/libxml2',
+  #                      '/usr/local/include/libxml2',
+  #                      '/usr/include/libxml2')
+  #   end
+  #  
+  class Generator
+    include Rake
+    
+    CONFIG = Config::CONFIG
+    
+    # Create a new generator which will write a new +Rakefile+ to the local
+    # filesystem.
+    #
+    # Params:
+    # * +library_location+ -- the location of the library to be compiled on the local filesystem
+    # * +source_patterns+ -- a pattern describing source files to be compiled, "lib/*.c" by default
+    def initialize(library_location, *source_patterns)
+      @sources = source_patterns || ["lib/*.c"]
+      @library_location = library_location
+      @available = Mkrf::Availability.new(:includes => [CONFIG['includedir'], CONFIG["archdir"],
+                                                        CONFIG['sitelibdir'], "."] )
+      @defines = []
+      
+      yield self if block_given?
+      write_rakefile
+    end
+    
+    # Add a new pattern to the list of source patterns
+    def add_source(pattern)
+      @sources << pattern
+    end
+    
+    # An array of the source patterns as single quoted strings
+    def sources
+      @sources.collect {|s| "'#{s}'"}
+    end
+    
+    # Add a define to the compile string. Example: 
+    #
+    #   Mkrf::Generator.new('my_library.bundle') do |g|    
+    #     g.add_define(HAVE_PTHREADS)
+    #   end
+    #
+    # Params:
+    # * +defn+ -- string to add to compile time defines
+    def add_define(defn)
+      @defines.push(defn)
+    end
+    
+    # Include a library in the compile. Returns +false+ if the
+    # library is not available. Returns non-false otherwise.
+    # Parameters are the same as Mkrf::Availability#include_library
+    def include_library(*args)
+      @available.include_library(*args)
+    end
+    
+    # Include a header in the compile. Returns +false+ if the header is not
+    # available, returns non-false otherwise. As a side effect, a compile
+    # time define occurs as +HAVE_+ appended with the name of the header in
+    # upper and scored case.
+    # Parameters are the same as Mkrf::Availability#include_header
+    def include_header(*args)
+      @available.include_header(*args)
+    end
+    
+    # Returns +true+ if the function is able to be called based on libraries and
+    # headers currently loaded. Returns +false+ otherwise.
+    #
+    # Params:
+    # * <tt>function</tt> -- the function to check for
+    def has_function?(function)
+      @available.has_function? function
+    end
+    
+    def write_rakefile(filename = "Rakefile") # :nodoc:
+      File.open(filename, "w+") do |f|
+        f.puts rakefile_contents
+      end
+    end
+    
+    def defines_compile_string # :nodoc:
+      (@defines.collect {|define| "-D#{define}" } +
+      @available.headers.collect { |header|
+        format("-DHAVE_%s", header.tr("a-z./\055", "A-Z___"))
+      }).join(' ')
+    end
+    
+    def rakefile_contents # :nodoc:
+      <<-END_RAKEFILE
+        require 'rake/clean'
+        
+        CLEAN.include('*.o')
+        CLOBBER.include('#{@library_location}')
+        
+        SRC = FileList[#{sources.join(',')}]
+        OBJ = SRC.ext('o')
+        CC = "gcc"
+
+        LDSHARED = "#{CONFIG['LDSHARED']}"
+        LIBPATH =  '-L"/usr/local/lib"'
+        
+        INCLUDES = "#{@available.includes_compile_string}"
+
+        LIBS = "#{@available.library_compile_string}"
+
+        CFLAGS   = "#{CONFIG['CCDLFLAGS']} #{CONFIG['CFLAGS']} #{CONFIG['ARCH_FLAG']} #{defines_compile_string}"
+        
+        task :default => ['#{@library_location}']
+
+        rule '.o' => '.c' do |t|
+          sh "\#{CC} \#{CFLAGS} \#{INCLUDES} -c -o \#{t.name} \#{t.source}"
+        end
+
+        rule '.so' => '.o' do |t|
+          sh "\#{LDSHARED} \#{LIBPATH} -o \#{OBJ} \#{LOCAL_LIBS} \#{LIBS}"
+        end
+
+        file '#{@library_location}' => OBJ do
+          sh "\#{LDSHARED} \#{LIBPATH} -o #{@library_location} \#{OBJ} \#{LIBS}"
+        end
+      END_RAKEFILE
+    end
+  end
+end