mkmf-lite 0.1.0

data/CHANGES

@@ -0,0 +1,2 @@
+= 0.1.0 - 24-May-2010
+* Initial release.

data/MANIFEST

@@ -0,0 +1,7 @@
+* CHANGES
+* MANIFEST
+* Rakefile
+* mkmf-lite.gemspec
+* lib/mkmf/lite.rb
+* lib/mkmf/templates/have_header.erb
+* test/test_mkmf_lite.rb

data/README

@@ -0,0 +1,45 @@
+= Summary
+  A light version of mkmf designed for use within programs.
+
+= Synopsis
+  require 'mkmf/lite'
+
+  class System
+    include Mkmf::Lite
+
+    HAVE_PW_NAME = have_struct_member('struct passwd', 'pw_name', 'pwd.h')
+
+    def some_method
+      if HAVE_PW_NAME
+        # Do something
+      end
+    end
+  end
+
+= Description
+  The mkmf library that ships as part of the Ruby standard library is not
+  meant for use as an internal library. It's strictly designed for building
+  C extensions. It's huge, its methods sit in a global namespace, it contains
+  many methods you don't care about, and emits output to $stdout that cannot
+  easily be disabled. Also, the source code is monstrous.
+
+  The mkmf-lite is a module, it's small, and it's designed to be mixed into
+  classes. It contains a handful of methods that, most likely, will be used
+  in conjunction with FFI. Also, the source code is quite readable.
+
+  It does not package C extensions, nor generate a log file or a Makefile.
+
+== License
+  Artistic 2.0
+
+== Copyright
+  (C) 2010 Daniel J. Berger
+  All Rights Reserved
+
+== Warranty
+  This library is provided "as is" and without any express or
+  implied warranties, including, without limitation, the implied
+  warranties of merchantability and fitness for a particular purpose.
+
+= Author
+  Daniel Berger

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/testtask'
+require 'rbconfig'
+
+
+namespace 'gem' do
+  desc 'Remove any existing .gem files'
+  task :clean do
+    Dir['**/*.gem'].each{ |f| File.delete(f) }
+  end
+  
+  desc 'Create the mkmf-lite gem.'
+  task :create => [:clean] do
+    spec = eval(IO.read('mkmf-lite.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc 'Install the mkmf-lite gem.'
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.verbose = true
+  t.warning = true
+end

data/lib/mkmf/lite.rb

@@ -0,0 +1,127 @@
+require 'erb'
+require 'rbconfig'
+require 'tmpdir'
+require 'ptools'
+
+module Mkmf
+  module Lite
+    # The version of the mkmf-lite library
+    MKMF_LITE_VERSION = '0.1.0'
+
+    @@cpp_command   = Config::CONFIG['CC'] || Config::CONFIG['CPP']
+    @@cpp_outfile   = Config::CONFIG['CPPOUTFILE'] # -o conftest.i
+    @@cpp_libraries = Config::CONFIG['LIBS'] + Config::CONFIG['LIBRUBYARG']
+    @@cpp_srcfile   = 'conftest.c'
+
+    # Check for the presence of the given +header+ file.
+    #
+    # Returns true if found, or false if not found.
+    #
+    def have_header(header)
+      erb = ERB.new(read_template('have_header.erb'))
+      code = erb.result(binding)
+      try_to_compile(code)
+    end
+
+    # Check for the presence of the given +function+ in the common header
+    # files, or within any +headers+ that you provide.
+    #
+    # Returns true if found, or false if not found.
+    #
+    def have_func(function, headers = [])
+      headers = get_header_string(headers)
+
+      erb_ptr = ERB.new(read_template('have_func_pointer.erb'))
+      erb_std = ERB.new(read_template('have_func.erb'))
+
+      ptr_code = erb_ptr.result(binding)
+      std_code = erb_std.result(binding)
+
+      # Check for just the function pointer first. If that fails, then try
+      # to compile with the function declaration.
+      try_to_compile(ptr_code) || try_to_compile(std_code)
+    end
+
+    # Checks whether or not the struct of type +struct_type+ contains the
+    # +struct_member+.  If it does not, or the struct type cannot be found,
+    # then false is returned.
+    #
+    # An optional list of +headers+ may be specified, in addition to the
+    # common header files that are already searched.
+    #
+    def have_struct_member(struct_type, struct_member, headers = [])
+      headers = get_header_string(headers)
+      erb = ERB.new(read_template('have_struct_member.erb'))
+      code = erb.result(binding)
+
+      try_to_compile(code)
+    end
+
+    private
+
+    # Take an array of header file names (or convert it to an array if it's a
+    # single argument), add the COMMON_HEADERS, flatten it out and remove any
+    # duplicates.
+    #
+    # Finally, convert the result into a single string of '#include'
+    # directives, each separated by a newline.
+    #
+    # This string is then to be used at the top of the ERB templates.
+    #
+    def get_header_string(headers)
+      headers = [headers] unless headers.is_a?(Array)
+
+      unless Config::CONFIG['COMMON_HEADERS'].empty?
+        headers += Config::CONFIG['COMMON_HEADERS'].split
+      end
+
+      headers = headers.flatten.uniq
+      headers = headers.map{ |h| "#include <#{h}>" }.join("\n")
+
+      headers
+    end
+
+    # Create a temporary bit of C source code in the temp directory, and
+    # try to compile it. If it succeeds, return true. Otherwise, return
+    # false.
+    #
+    # Note that $stderr is temporarily redirected to the null device because
+    # we don't actually care about the reason for failure.
+    #
+    def try_to_compile(code)
+      begin
+        bool = false
+        stderr_orig = $stderr.dup
+
+        Dir.chdir(Dir.tmpdir){
+          File.open(@@cpp_srcfile, 'w'){ |fh| fh.write(code) }
+
+          command  = @@cpp_command + ' '
+          command += @@cpp_outfile + ' '
+          command += @@cpp_srcfile
+
+          $stderr.reopen(File.null)
+          bool = system(command)
+        }
+      ensure
+        File.delete(@@cpp_srcfile) if File.exists?(@@cpp_srcfile)
+        File.delete(@@cpp_outfile) if File.exists?(@@cpp_outfile)
+        $stderr.reopen(stderr_orig)
+      end
+
+      bool
+    end
+
+    # Slurp the contents of the template file for evaluation later.
+    #
+    def read_template(file)
+      IO.read(get_template_file(file))
+    end
+
+    # Retrieve the path to the template +file+ name.
+    #
+    def get_template_file(file)
+      File.join(File.dirname(__FILE__), 'templates', file)
+    end
+  end
+end

data/lib/mkmf/templates/have_func.erb

@@ -0,0 +1,10 @@
+<%= headers %>
+
+int try_func(){
+  <%= function %>();
+  return 0;
+}
+
+int main(){
+  return 0;
+}

data/lib/mkmf/templates/have_func_pointer.erb

@@ -0,0 +1,11 @@
+<%= headers %>
+
+int check_for_function(){
+  void ((*volatile p)());
+  p = (void ((*)()))<%= function %>;
+  return 0;
+}
+
+int main(){
+  return 0;
+}

data/lib/mkmf/templates/have_header.erb

@@ -0,0 +1,5 @@
+#include <<%= header %>>
+
+int main(){
+  return 0;
+}

data/lib/mkmf/templates/have_struct_member.erb

@@ -0,0 +1,6 @@
+<%= headers %>
+
+int main(){
+  int s = (char *)&((<%= struct_type %>*)0)-><%= struct_member %> - (char *)0;
+  return 0;
+}

data/mkmf-lite.gemspec

@@ -0,0 +1,27 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name      = 'mkmf-lite'
+  spec.summary   = 'A lighter version of mkmf designed for use as a library'
+  spec.version   = '0.1.0'
+  spec.author    = 'Daniel J. Berger'
+  spec.license   = 'Artistic 2.0'
+  spec.email     = 'djberg96@gmail.com'
+  spec.homepage  = 'http://www.rubyforge.org/projects/shards'
+  spec.test_file = 'test/test_mkmf_lite.rb'
+  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+  spec.rubyforge_project = 'shards'
+   
+  spec.add_dependency('ptools')
+  spec.add_development_dependency('test-unit', '>= 2.0.7')
+
+  spec.description = <<-EOF
+    The mkmf-lite library is a light version of the the mkmf library
+    designed for use as a library. It does not create packages, builds,
+    or log files of any kind. Instead, it provides mixin methods that you
+    can use in FFI or tests to check for the presence of header files,
+    constants, and so on.
+  EOF
+end

data/test/test_mkmf_lite.rb

@@ -0,0 +1,94 @@
+########################################################################
+# test_mkmf_lite.rb
+#
+# Tests for the mkmf-lite library.
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
+require 'mkmf/lite'
+
+class TC_Mkmf_Lite < Test::Unit::TestCase
+  include Mkmf::Lite
+
+  def self.startup
+    @@windows = Config::CONFIG['host_os'] =~ /mswin|msdos|win32|mingw|cygwin/i
+  end
+
+  def setup
+    @st_type   = 'struct stat'
+    @st_member = 'st_uid'
+    @st_header = 'sys/stat.h' 
+  end
+
+  test "version information" do
+    assert_equal('0.1.0', MKMF_LITE_VERSION)
+  end
+
+  test "have_header basic functionality" do
+    assert_respond_to(self, :have_header)
+  end
+
+  test "have_header returns expected boolean value" do
+    assert_true(have_header('stdio.h'))
+    assert_false(have_header('foobar.h'))
+  end
+
+  test "have_header requires one argument only" do
+    assert_raise(ArgumentError){ have_header }
+    assert_raise(ArgumentError){ have_header('stdio.h', 'stdlib.h') }
+  end
+
+  test "have_func basic functionality" do
+    assert_respond_to(self, :have_func)
+  end
+
+  test "have_func with no arguments returns expected boolean value" do
+    assert_true(have_func('abort'))
+    assert_false(have_header('abortxyz'))
+  end
+
+  test "have_func with arguments returns expected boolean value" do
+    assert_true(have_func('printf', 'stdio.h'))
+    assert_false(have_func('printfx', 'stdio.h'))
+  end
+
+  test "have_func requires at least one argument" do
+    assert_raise(ArgumentError){ have_func }
+  end
+
+  test "have_func accepts a maximum of two arguments" do
+    assert_raise(ArgumentError){ have_func('printf', 'stdio.h', 'bogus') }
+  end
+
+  test "have_struct_member basic functionality" do
+    assert_respond_to(self, :have_struct_member)
+  end
+
+  test "have_struct_member returns expected boolean value" do
+    assert_true(have_struct_member(@st_type, @st_member, @st_header))
+    assert_false(have_struct_member(@st_type, 'pw_bogus', @st_header))
+    assert_false(have_struct_member(@st_type, @st_member))
+  end
+
+  test "have_struct_member requires at least two arguments" do
+    assert_raise(ArgumentError){ have_struct_member() }
+    assert_raise(ArgumentError){ have_struct_member('struct passwd') }
+  end
+
+  test "have_struct_member accepts a maximum of three arguments" do
+    assert_raise(ArgumentError){
+      have_struct_member('struct passwd', 'pw_name', 'pwd.h', true)
+    }
+  end
+
+  def teardown
+    @st_type   = nil
+    @st_member = nil
+    @st_header = nil
+  end
+
+  def self.shutdown
+    @@windows = nil
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: mkmf-lite
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-24 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ptools
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 7
+        version: 2.0.7
+  type: :development
+  version_requirements: *id002
+description: "    The mkmf-lite library is a light version of the the mkmf library\n    designed for use as a library. It does not create packages, builds,\n    or log files of any kind. Instead, it provides mixin methods that you\n    can use in FFI or tests to check for the presence of header files,\n    constants, and so on.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+files: 
+- CHANGES
+- lib/mkmf/lite.rb
+- lib/mkmf/templates/have_func.erb
+- lib/mkmf/templates/have_func_pointer.erb
+- lib/mkmf/templates/have_header.erb
+- lib/mkmf/templates/have_struct_member.erb
+- MANIFEST
+- mkmf-lite.gemspec
+- Rakefile
+- README
+- test/test_mkmf_lite.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/shards
+licenses: 
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: shards
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A lighter version of mkmf designed for use as a library
+test_files: 
+- test/test_mkmf_lite.rb