rbind 0.0.9 → 0.0.10

data/lib/rbind/generator_c.rb

@@ -258,9 +258,11 @@ module Rbind
        end
 
        class CMakeListsHelper < HelperBase
-           def initialize(name,pkg_config=Array.new,libs=Array.new)
+           def initialize(name,pkg_config=Array.new,libs=Array.new,gems=Array.new)
                super(name,pkg_config)
                @libs = libs
+               @gems = gems
+               @find_gem = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_gem.txt")).read)
                @find_package = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_package.txt")).read)
            end
 
@@ -270,6 +272,10 @@ module Rbind
                end.join("")
            end
 
+           def find_gems
+               @find_gem.result(@gems.instance_eval("binding")) unless @gems.empty?
+           end
+
            def libs
                str = @root.map do |pkg|
                    "${#{pkg.upcase}_LIBS} ${#{pkg.upcase}_LDFLAGS}"
@@ -368,15 +374,18 @@ module Rbind
 
            if generate_cmake && !File.exist?(File.join(path,"CMakeLists.txt"))
                file_cmakelists = File.new(File.join(path,"CMakeLists.txt"),"w")
-               libs = gem_paths.map do |path|
-                   Dir.glob(File.join(path,"lib*"))
-               end
-               cmakelists = CMakeListsHelper.new(@library_name,@pkg_config,@libs+libs)
+               cmakelists = CMakeListsHelper.new(@library_name,@pkg_config,@libs,@gems)
                file_cmakelists.write @erb_cmakelists.result(cmakelists.binding)
                if !File.exist?(File.join(path,"rbind.pc.in"))
                    file_pkg_config = File.new(File.join(path,"rbind.pc.in"),"w")
                    file_pkg_config.write @erb_pkg_config.result(Kernel.binding)
                end
+
+               src_path = File.join(File.dirname(__FILE__),"templates","c","cmake")
+               cmake_path = File.join(path,"cmake")
+               FileUtils.mkdir_p(cmake_path) if !File.directory?(cmake_path)
+               FileUtils.copy(File.join(src_path,"FindGem.cmake"),File.join(cmake_path,"FindGem.cmake"))
+               FileUtils.copy(File.join(src_path,"FindRuby.cmake"),File.join(cmake_path,"FindRuby.cmake"))
            end
        end
    end

data/lib/rbind/generator_ruby.rb

@@ -4,13 +4,23 @@ require 'erb'
 
 module Rbind
     class GeneratorRuby
-        @@ruby_default_value_map ||= {"true" => "true","TRUE" => "true", "false" => "false","FALSE" => "false"}
-        @@ffi_type_map ||= {"char *" => "string","unsigned char" => "uchar" ,"const char *" => "string" }
+        class << self
+            attr_accessor :ruby_default_value_map
+            attr_accessor :on_normalize_type_name
+            attr_accessor :ffi_type_map
+        end
+        self.ruby_default_value_map ||= {"true" => "true","TRUE" => "true", "false" => "false","FALSE" => "false"}
+        self.ffi_type_map ||= {"char *" => "string","unsigned char" => "uchar" ,"const char *" => "string" }
+
 
         def self.keyword?(name)
             %w{__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield}.include? name
         end
 
+        def self.on_normalize_type_name(&block)
+            self.on_normalize_type_name = block
+        end
+
         def self.normalize_arg_name(name)
             name = name.to_s.sub(/\A#{RBase.cprefix}?/, "").gsub(/(?<!\A)\p{Lu}/u, '_\0').downcase
             name = if keyword?(name)
@@ -29,8 +39,8 @@ module Rbind
         def self.normalize_default_value(parameter)
             return nil unless parameter.default_value
             val = if parameter.type.basic_type? || parameter.type.ptr?
-                      if @@ruby_default_value_map.has_key?(parameter.default_value)
-                          @@ruby_default_value_map[parameter.default_value]
+                      if ruby_default_value_map.has_key?(parameter.default_value)
+                          ruby_default_value_map[parameter.default_value]
                       elsif parameter.type.name == "float"
                           parameter.default_value.gsub("f","")
                       elsif parameter.type.name == "double"
@@ -77,6 +87,12 @@ module Rbind
 
 
         def self.normalize_type_name(name)
+            # custom normalization
+            if @on_normalize_type_name
+                n = @on_normalize_type_name.call(name)
+                return n if n
+            end
+
             if name =~ /^u?int\d*$/ || name =~ /^u?int\d+_t$/
                 return "Fixnum"
             end
@@ -98,7 +114,7 @@ module Rbind
         end
 
         def self.normalize_basic_type_name_ffi(name)
-            n = @@ffi_type_map[name]
+            n = ffi_type_map[name]
             n ||= name
             if n =~ /\*/
                 "pointer"
@@ -172,7 +188,7 @@ module Rbind
         class RBindHelper < HelperBase
             attr_reader :compact_namespace
 
-            def initialize(name, root,compact_namespace=false)
+            def initialize(name, root,compact_namespace=true)
                 @compact_namespace = compact_namespace
                 super(name,root)
             end

data/lib/rbind/templates/c/CMakeLists.txt

@@ -1,27 +1,45 @@
 cmake_minimum_required(VERSION 2.6)
 PROJECT(<%= library_name %> CXX)
 
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(FindPkgConfig)
 <%= find_packages %>
-
+<%= find_gems%>
 SET(RBIND_SRC
     "${CMAKE_CURRENT_SOURCE_DIR}/types.cc"
     "${CMAKE_CURRENT_SOURCE_DIR}/operations.cc"
     "${CMAKE_CURRENT_SOURCE_DIR}/conversions.cc")
-ADD_LIBRARY(<%= library_name %> SHARED ${RBIND_SRC})
 
-TARGET_LINK_LIBRARIES(<%= library_name %> <%= libs %>)
+add_custom_command(OUTPUT ${RBIND_SRC}
+       COMMAND ruby "${CMAKE_CURRENT_SOURCE_DIR}/../rbind.rb")
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/rbind.pc.in ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc DESTINATION lib/pkgconfig)
+ADD_LIBRARY(<%= library_name %> SHARED ${RBIND_SRC})
+TARGET_LINK_LIBRARIES(<%= library_name %> <%= libs %> ${GEM_LIBRARIES})
 
-install(TARGETS <%= library_name %> LIBRARY DESTINATION lib)
-install(FILES types.h operations.h conversions.hpp DESTINATION include/${PROJECT_NAME}/${DIR})
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/rbind.pc.in ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc @ONLY)
+set(ROOT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/..)
 
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind)
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION include/${PROJECT_NAME}/${DIR})
-endif()
+# global install
+if(GEM_INSTALL)
+    # local install
+    install(TARGETS <%= library_name %> LIBRARY DESTINATION ${ROOT_FOLDER}/lib/lib)
+    install(FILES types.h operations.h conversions.hpp DESTINATION ${ROOT_FOLDER}/lib/include)
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION ${ROOT_FOLDER}/lib/include)
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION ${ROOT_FOLDER}/lib/include)
+else()
+    # global install
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc DESTINATION lib/pkgconfig)
+    install(TARGETS <%= library_name %> LIBRARY DESTINATION lib)
+    install(FILES types.h operations.h conversions.hpp DESTINATION include/${PROJECT_NAME})
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION include/${PROJECT_NAME})
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION include/${PROJECT_NAME})
 
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind)
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION include/${PROJECT_NAME}/${DIR})
+    FIND_PACKAGE(Ruby)
+    IF(NOT RUBY_INCLUDE_PATH)
+        MESSAGE(STATUS "Ruby library not found. Cannot install ruby extensions")
+    ELSEIF(NOT RUBY_EXTENSIONS_AVAILABLE)
+        STRING(REGEX REPLACE ".*lib(32|64)?/?" "lib/" RUBY_LIBRARY_INSTALL_DIR ${RUBY_RUBY_LIB_PATH})
+        INSTALL(DIRECTORY ${ROOT_FOLDER}/lib/ruby DESTINATION ${RUBY_LIBRARY_INSTALL_DIR}
+            FILES_MATCHING PATTERN "*.rb")
+    ENDIF(NOT RUBY_INCLUDE_PATH)
 endif()

data/lib/rbind/templates/c/cmake/FindGem.cmake

@@ -0,0 +1,155 @@
+# Author thomas.roehr@dfki.de
+#
+# Version 0.3 2013-07-02
+#       - rely on `gem content` to find library and header
+#       - introduce GEM_OS_PKG to allow search via pkgconfig
+# Version 0.2 2010-01-14
+#       - add support for searching for multiple gems
+# Version 0.1 2010-12-15
+# 	- support basic search functionality 
+#       - tested to find rice
+#
+# OUTPUT:
+#
+# GEM_INCLUDE_DIRS	After successful search contains the include directores
+#
+# GEM_LIBRARIES		After successful search contains the full path of each found library
+#
+#
+# Usage: 
+# set(GEM_DEBUG TRUE)
+# find_package(Gem COMPONENTS rice hoe)
+# include_directories(${GEM_INCLUDE_DIRS})
+# target_link_libraries(${GEM_LIBRARIES}
+#
+# in case pkg-config should be used to search for the os pkg, set GEM_OS_PKG, i.e.
+# set(GEM_OS_PKG TRUE)
+#
+# Check for how 'gem' should be called
+find_program(GEM_EXECUTABLE
+    NAMES "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
+        "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}"
+        "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
+        "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}"
+        "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}"
+        "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}"
+        "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}"
+        "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}"
+        "gem")
+
+# Making backward compatible
+if(Gem_DEBUG)
+    set(GEM_DEBUG TRUE)
+endif()
+
+if(NOT GEM_EXECUTABLE)
+	MESSAGE(FATAL_ERROR "Could not find the gem executable - install 'gem' first")
+endif()
+
+if(NOT Gem_FIND_COMPONENTS)
+	MESSAGE(FATAL_ERROR "If searching for a Gem you have to provide COMPONENTS with the name of the gem")
+endif()
+
+set(GEM_FOUND TRUE)
+foreach(Gem_NAME ${Gem_FIND_COMPONENTS})
+    # If the gem is installed as a gem
+    if(NOT GEM_OS_PKG)
+	    set(GEM_HOME ENV{GEM_HOME})
+
+        # Use `gem content <gem-name>` to extract current information about installed gems
+        # Store the information into ${GEM_LOCAL_INFO}
+        EXECUTE_PROCESS(COMMAND ${GEM_EXECUTABLE} content ${Gem_NAME} OUTPUT_VARIABLE GEM_LOCAL_INFO)
+
+	    if("${GEM_LOCAL_INFO}" STREQUAL "")
+	    	MESSAGE(FATAL_ERROR "No local gem found. Check your GEM_HOME setting!")
+	    else()
+            set(_library_NAME_PATTERN lib${Gem_NAME}.a
+	        		   lib${Gem_NAME}.so
+	        		   lib${Gem_NAME}.dylib
+	        		   ${Gem_NAME}.a
+	        		   ${Gem_NAME}.so
+	        		   ${Gem_NAME}.dylib
+                       .*.a
+                       .*.so
+                       .*.dylib
+	        )
+
+            set(_header_SUFFIX_PATTERN
+                        .h
+                        .hh
+                        .hpp
+            )
+
+            # Create a list from the output results of the gem command
+            string(REPLACE "\n" ";" GEM_CONTENT_LIST ${GEM_LOCAL_INFO})
+            foreach(_gem_CONTENT_PATH ${GEM_CONTENT_LIST})
+                
+                # Convert so that only '/' Unix path separator are being using
+                # needed to do proper regex matching
+                FILE(TO_CMAKE_PATH ${_gem_CONTENT_PATH} gem_CONTENT_PATH)
+
+                # Identify library -- checking for a library in the gems 'lib' (sub)directory
+                # Search for an existing library, but only within the gems folder
+                foreach(_library_NAME ${_library_NAME_PATTERN})
+                    STRING(REGEX MATCH ".*${Gem_NAME}.*/lib/.*${_library_NAME}$" GEM_PATH_INFO "${gem_CONTENT_PATH}")
+                    if(NOT "${GEM_PATH_INFO}" STREQUAL "")
+                        list(APPEND GEM_LIBRARIES ${GEM_PATH_INFO})
+                        break()
+                    endif()
+                endforeach()
+
+                # Identify headers
+                # Checking for available headers in an include directory
+                foreach(_header_PATTERN ${_header_SUFFIX_PATTERN})
+                    STRING(REGEX MATCH ".*${Gem_NAME}.*/include/.*${_header_PATTERN}$" GEM_PATH_INFO "${gem_CONTENT_PATH}")
+                    if(NOT "${GEM_PATH_INFO}" STREQUAL "")
+                        STRING(REGEX REPLACE "(.*${Gem_NAME}.*/include/).*${_header_PATTERN}$" "\\1" GEM_PATH_INFO "${gem_CONTENT_PATH}")
+                        list(APPEND GEM_INCLUDE_DIRS ${GEM_PATH_INFO})
+                        break()
+                    endif()
+                endforeach()
+            endforeach()
+
+            # Compact the lists
+            if(${GEM_LIBRARIES})
+                LIST(REMOVE_DUPLICATES GEM_LIBRARIES)
+            endif()
+            if(${GEM_INCLUDE_DIRS})
+                LIST(REMOVE_DUPLICATES GEM_INCLUDE_DIRS)
+            endif()
+        endif()
+    else(NOT GEM_OS_PKG)
+        pkg_check_modules(GEM_PKG ${Gem_NAME})
+        set(GEM_INCLUDE_DIRS ${GEM_PKG_INCLUDE_DIRS})
+        set(GEM_LIBRARIES ${GEM_PKG_LIBRARIES} ${GEM_PKG_STATIC_LIBRARIES})
+        list(APPEND GEM_LIBRARIES ${GEM_PKG_LDFLAGS} ${GEM_PKG_STATIC_LDFLAGS})
+        list(APPEND GEM_LIBRARIES ${GEM_PKG_LDFLAGS_OTHER} ${GEM_PKG_STATIC_LDFLAGS_OTHER})
+
+        if(GEM_DEBUG)
+            message(STATUS "GEM_OS_PKG is defined")
+            message(STATUS "GEM_INCLUDE_DIRS ${GEM_INCLUDE_DIRS}")
+            message(STATUS "GEM_STATIC_LIBRARY_DIRS ${GEM_PKG_STATIC_LIBRARY_DIRS}")
+            message(STATUS "GEM_LIBRARY_DIRS ${GEM_PKG_STATIC_LIBRARY_DIRS}")
+            message(STATUS "GEM_STATIC_LIBRARIES ${GEM_PKG_STATIC_LIBRARIES}")
+            message(STATUS "GEM_LIBRARIES ${GEM_LIBRARIES}")
+        endif()
+    endif()
+
+	if("${GEM_LIBRARIES}" STREQUAL "")
+		set(GEM_FOUND FALSE)
+    else()
+        MESSAGE(STATUS "Gem: ${Gem_NAME} found")
+	endif()
+
+    if(GEM_DEBUG)
+		message(STATUS "${Gem_NAME} library dir: ${GEM_LIBRARIES}")
+		message(STATUS "${Gem_NAME} include dir: ${GEM_INCLUDE_DIRS}")
+    endif()
+		
+    if(Gem_FIND_REQUIRED)
+        if(NOT GEM_FOUND)
+		    MESSAGE(FATAL_ERROR "Gem: ${Gem_NAME} could not be found")
+        endif()
+	endif()
+endforeach()
+

data/lib/rbind/templates/c/cmake/FindRuby.cmake

@@ -0,0 +1,260 @@
+# - Find Ruby
+# This module finds if Ruby is installed and determines where the include files
+# and libraries are. Ruby 1.8 and 1.9 are supported. The minimum required version 
+# specified in the find_package() command is honored.
+# It also determines what the name of the library is. This
+# code sets the following variables:
+#
+#  RUBY_EXECUTABLE   = full path to the ruby binary
+#  RUBY_INCLUDE_DIRS = include dirs to be used when using the ruby library
+#  RUBY_LIBRARY      = full path to the ruby library
+#  RUBY_VERSION      = the version of ruby which was found, e.g. "1.8.7"
+#  RUBY_FOUND        = set to true if ruby ws found successfully
+#
+#  RUBY_INCLUDE_PATH = same as RUBY_INCLUDE_DIRS, only provided for compatibility reasons, don't use it
+
+#=============================================================================
+# Copyright 2004-2009 Kitware, Inc.
+# Copyright 2008-2009 Alexander Neundorf <neundorf@kde.org>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+#   RUBY_ARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"archdir"@:>@)'`
+#   RUBY_SITEARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"sitearchdir"@:>@)'`
+#   RUBY_SITEDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"sitelibdir"@:>@)'`
+#   RUBY_LIBDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"libdir"@:>@)'`
+#   RUBY_LIBRUBYARG=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"LIBRUBYARG_SHARED"@:>@)'`
+
+# uncomment the following line to get debug output for this file
+# SET(_RUBY_DEBUG_OUTPUT TRUE)
+
+# Determine the list of possible names of the ruby executable depending
+# on which version of ruby is required
+SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${RUBY_PROGRAM_NAME} ruby)
+
+# if 1.9 is required, don't look for ruby18 and ruby1.8, default to version 1.8
+IF(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+   SET(Ruby_FIND_VERSION_SHORT_NODOT "${Ruby_FIND_VERSION_MAJOR}${RUBY_FIND_VERSION_MINOR}")
+ELSE(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+   SET(Ruby_FIND_VERSION_SHORT_NODOT "18")
+ENDIF(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+
+SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES} ruby1.9 ruby19)
+
+# if we want a version below 1.9, also look for ruby 1.8
+IF("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
+   SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES} ruby1.8 ruby18)
+ENDIF("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
+
+FIND_PROGRAM(RUBY_EXECUTABLE NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES})
+
+
+IF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
+  # query the ruby version
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MAJOR']"
+      OUTPUT_VARIABLE RUBY_VERSION_MAJOR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MINOR']"
+      OUTPUT_VARIABLE RUBY_VERSION_MINOR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['TEENY']"
+      OUTPUT_VARIABLE RUBY_VERSION_PATCH)
+
+   # query the different directories
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['archdir']"
+      OUTPUT_VARIABLE RUBY_ARCH_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['arch']"
+      OUTPUT_VARIABLE RUBY_ARCH)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubyhdrdir']"
+      OUTPUT_VARIABLE RUBY_HDR_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['libdir']"
+      OUTPUT_VARIABLE RUBY_POSSIBLE_LIB_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubylibdir']"
+      OUTPUT_VARIABLE RUBY_RUBY_LIB_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['LIBRUBY_SO']"
+      OUTPUT_VARIABLE RUBY_RUBY_LIBRARY)
+   STRING(REGEX REPLACE "^lib" "" RUBY_RUBY_LIBRARY "${RUBY_RUBY_LIBRARY}")
+   STRING(REGEX REPLACE "\\.so.*" "" RUBY_RUBY_LIBRARY "${RUBY_RUBY_LIBRARY}")
+
+   # site_ruby
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['sitearchdir']"
+      OUTPUT_VARIABLE RUBY_SITEARCH_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['sitelibdir']"
+      OUTPUT_VARIABLE RUBY_SITELIB_DIR)
+
+   # vendor_ruby available ?
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r vendor-specific -e "print 'true'"
+      OUTPUT_VARIABLE RUBY_HAS_VENDOR_RUBY  ERROR_QUIET)
+
+   IF(RUBY_HAS_VENDOR_RUBY)
+       EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorlibdir']"
+         OUTPUT_VARIABLE RUBY_VENDORLIB_DIR)
+
+     EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorarchdir']"
+         OUTPUT_VARIABLE RUBY_VENDORARCH_DIR)
+   ENDIF(RUBY_HAS_VENDOR_RUBY)
+
+   # save the results in the cache so we don't have to run ruby the next time again
+   SET(RUBY_VERSION_MAJOR    ${RUBY_VERSION_MAJOR}    CACHE PATH "The Ruby major version" FORCE)
+   SET(RUBY_VERSION_MINOR    ${RUBY_VERSION_MINOR}    CACHE PATH "The Ruby minor version" FORCE)
+   SET(RUBY_VERSION_PATCH    ${RUBY_VERSION_PATCH}    CACHE PATH "The Ruby patch version" FORCE)
+   SET(RUBY_ARCH_DIR         ${RUBY_ARCH_DIR}         CACHE PATH "The Ruby arch dir" FORCE)
+   SET(RUBY_HDR_DIR          ${RUBY_HDR_DIR}          CACHE PATH "The Ruby header dir (1.9)" FORCE)
+   SET(RUBY_POSSIBLE_LIB_DIR ${RUBY_POSSIBLE_LIB_DIR} CACHE PATH "The Ruby lib dir" FORCE)
+   SET(RUBY_RUBY_LIB_DIR     ${RUBY_RUBY_LIB_DIR}     CACHE PATH "The Ruby ruby-lib dir" FORCE)
+   SET(RUBY_SITEARCH_DIR     ${RUBY_SITEARCH_DIR}     CACHE PATH "The Ruby site arch dir" FORCE)
+   SET(RUBY_SITELIB_DIR      ${RUBY_SITELIB_DIR}      CACHE PATH "The Ruby site lib dir" FORCE)
+   SET(RUBY_HAS_VENDOR_RUBY  ${RUBY_HAS_VENDOR_RUBY}  CACHE BOOL "Vendor Ruby is available" FORCE)
+   SET(RUBY_VENDORARCH_DIR   ${RUBY_VENDORARCH_DIR}   CACHE PATH "The Ruby vendor arch dir" FORCE)
+   SET(RUBY_VENDORLIB_DIR    ${RUBY_VENDORLIB_DIR}    CACHE PATH "The Ruby vendor lib dir" FORCE)
+
+   MARK_AS_ADVANCED(
+     RUBY_ARCH_DIR
+     RUBY_ARCH
+     RUBY_HDR_DIR
+     RUBY_POSSIBLE_LIB_DIR
+     RUBY_RUBY_LIB_DIR
+     RUBY_SITEARCH_DIR
+     RUBY_SITELIB_DIR
+     RUBY_HAS_VENDOR_RUBY
+     RUBY_VENDORARCH_DIR
+     RUBY_VENDORLIB_DIR
+     RUBY_VERSION_MAJOR
+     RUBY_VERSION_MINOR
+     RUBY_VERSION_PATCH
+     )
+ENDIF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
+
+# In case RUBY_EXECUTABLE could not be executed (e.g. cross compiling) 
+# try to detect which version we found. This is not too good.
+IF(NOT RUBY_VERSION_MAJOR)
+   # by default assume 1.8.0
+   SET(RUBY_VERSION_MAJOR 1)
+   SET(RUBY_VERSION_MINOR 8)
+   SET(RUBY_VERSION_PATCH 0)
+   # check whether we found 1.9.x
+   IF(${RUBY_EXECUTABLE} MATCHES "ruby1.?9"  OR  RUBY_HDR_DIR)
+      SET(RUBY_VERSION_MAJOR 1)
+      SET(RUBY_VERSION_MINOR 9)
+   ENDIF(${RUBY_EXECUTABLE} MATCHES "ruby1.?9"  OR  RUBY_HDR_DIR)
+ENDIF(NOT RUBY_VERSION_MAJOR)
+
+
+SET(RUBY_VERSION "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}")
+SET(_RUBY_VERSION_SHORT "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}")
+SET(_RUBY_VERSION_SHORT_NODOT "${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}")
+
+# Now we know which version we found
+IF(Ruby_FIND_VERSION)
+   IF(${RUBY_VERSION}  VERSION_LESS  ${Ruby_FIND_VERSION})
+      # force running ruby the next time again
+      SET(RUBY_VERSION_MAJOR    ""    CACHE PATH "The Ruby major version" FORCE)
+      IF(Ruby_FIND_REQUIRED)
+         MESSAGE(FATAL_ERROR "Ruby version ${Ruby_FIND_VERSION} required, but only version ${RUBY_VERSION} found.")
+      ELSE(Ruby_FIND_REQUIRED)
+         IF(NOT Ruby_FIND_QUIETLY)
+            MESSAGE(STATUS "Ruby version ${Ruby_FIND_VERSION} required, but only version ${RUBY_VERSION} found.")
+         ENDIF(NOT Ruby_FIND_QUIETLY)
+         RETURN()
+      ENDIF(Ruby_FIND_REQUIRED)
+   ENDIF(${RUBY_VERSION}  VERSION_LESS  ${Ruby_FIND_VERSION})
+ENDIF(Ruby_FIND_VERSION)
+
+FIND_PATH(RUBY_INCLUDE_DIR
+   NAMES ruby.h
+   HINTS
+   ${RUBY_HDR_DIR}
+   ${RUBY_ARCH_DIR}
+   /usr/lib/ruby/${_RUBY_VERSION_SHORT}/i586-linux-gnu/ )
+
+SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIR} )
+
+# if ruby > 1.8 is required or if ruby > 1.8 was found, search for the config.h dir
+IF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
+   message(STATUS "lookign for config.h")
+   FIND_PATH(RUBY_CONFIG_INCLUDE_DIR
+     NAMES ruby/config.h  config.h
+     HINTS 
+     ${RUBY_HDR_DIR}/${RUBY_ARCH}
+     ${RUBY_ARCH_DIR} 
+     )
+
+   SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIRS} ${RUBY_CONFIG_INCLUDE_DIR} )
+ENDIF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
+
+
+# Determine the list of possible names for the ruby library
+SET(_RUBY_POSSIBLE_LIB_NAMES ruby ruby-static ruby${_RUBY_VERSION_SHORT} ${RUBY_RUBY_LIBRARY})
+
+IF(WIN32)
+   SET( _RUBY_MSVC_RUNTIME "" )
+   IF( MSVC60 )
+     SET( _RUBY_MSVC_RUNTIME "60" )
+   ENDIF( MSVC60 )
+   IF( MSVC70 )
+     SET( _RUBY_MSVC_RUNTIME "70" )
+   ENDIF( MSVC70 )
+   IF( MSVC71 )
+     SET( _RUBY_MSVC_RUNTIME "71" )
+   ENDIF( MSVC71 )
+   IF( MSVC80 )
+     SET( _RUBY_MSVC_RUNTIME "80" )
+   ENDIF( MSVC80 )
+   IF( MSVC90 )
+     SET( _RUBY_MSVC_RUNTIME "90" )
+   ENDIF( MSVC90 )
+
+   LIST(APPEND _RUBY_POSSIBLE_LIB_NAMES
+               "msvcr${_RUBY_MSVC_RUNTIME}-ruby${RUBY_NODOT_VERSION}"
+               "msvcr${_RUBY_MSVC_RUNTIME}-ruby${RUBY_NODOT_VERSION}-static" 
+               "msvcrt-ruby${RUBY_NODOT_VERSION}"
+               "msvcrt-ruby${RUBY_NODOT_VERSION}-static" )
+ENDIF(WIN32)
+
+FIND_LIBRARY(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_POSSIBLE_LIB_DIR} )
+
+INCLUDE(FindPackageHandleStandardArgs)
+SET(_RUBY_REQUIRED_VARS RUBY_EXECUTABLE RUBY_INCLUDE_DIR RUBY_LIBRARY)
+IF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
+   LIST(APPEND _RUBY_REQUIRED_VARS RUBY_CONFIG_INCLUDE_DIR)
+ENDIF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
+
+IF(_RUBY_DEBUG_OUTPUT)
+   MESSAGE(STATUS "--------FindRuby.cmake debug------------")
+   MESSAGE(STATUS "_RUBY_POSSIBLE_EXECUTABLE_NAMES: ${_RUBY_POSSIBLE_EXECUTABLE_NAMES}")
+   MESSAGE(STATUS "_RUBY_POSSIBLE_LIB_NAMES: ${_RUBY_POSSIBLE_LIB_NAMES}")
+   MESSAGE(STATUS "RUBY_ARCH_DIR: ${RUBY_ARCH_DIR}")
+   MESSAGE(STATUS "RUBY_HDR_DIR: ${RUBY_HDR_DIR}")
+   MESSAGE(STATUS "RUBY_POSSIBLE_LIB_DIR: ${RUBY_POSSIBLE_LIB_DIR}")
+   MESSAGE(STATUS "Found RUBY_VERSION: \"${RUBY_VERSION}\" , short: \"${_RUBY_VERSION_SHORT}\", nodot: \"${_RUBY_VERSION_SHORT_NODOT}\"")
+   MESSAGE(STATUS "_RUBY_REQUIRED_VARS: ${_RUBY_REQUIRED_VARS}")
+   MESSAGE(STATUS "--------------------")
+ENDIF(_RUBY_DEBUG_OUTPUT)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Ruby  DEFAULT_MSG  ${_RUBY_REQUIRED_VARS})
+
+MARK_AS_ADVANCED(
+  RUBY_EXECUTABLE
+  RUBY_LIBRARY
+  RUBY_INCLUDE_DIR
+  RUBY_CONFIG_INCLUDE_DIR
+  )
+
+# Set some variables for compatibility with previous version of this file
+SET(RUBY_POSSIBLE_LIB_PATH ${RUBY_POSSIBLE_LIB_DIR})
+SET(RUBY_RUBY_LIB_PATH ${RUBY_RUBY_LIB_DIR})
+SET(RUBY_INCLUDE_PATH ${RUBY_INCLUDE_DIRS})

data/lib/rbind/templates/c/find_gem.txt

@@ -0,0 +1,3 @@
+find_package(Gem COMPONENTS REQUIRED <%= self.join(" ") %>)
+include_directories(${GEM_INCLUDE_DIRS})
+

data/lib/rbind/templates/ruby/rbind.rb

@@ -8,7 +8,7 @@ module <%= name %>
         extend FFI::Library
 
         #load library <%= library_name %>
-        path = Dir.chdir(File.dirname(__FILE__)) do
+        path = Dir.chdir(File.join(File.dirname(__FILE__),"..","..","lib")) do
             path = Dir.glob("lib<%= library_name %>.*").first
             File.absolute_path(path) if path
         end

data/rbind.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
     s.name              = 'rbind'
-    s.version           = '0.0.9'
-    s.date              = '2013-06-30'
+    s.version           = '0.0.10'
+    s.date              = '2013-07-02'
     s.platform          = Gem::Platform::RUBY
     s.authors           = ['Alexander Duda']
     s.email             = ['Alexander.Duda@dfki.de']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbind
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-30 00:00:00.000000000 Z
+date: 2013-07-02 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email:
@@ -41,9 +41,12 @@ files:
 - lib/rbind/logger.rb
 - lib/rbind/rbind.rb
 - lib/rbind/templates/c/CMakeLists.txt
+- lib/rbind/templates/c/cmake/FindGem.cmake
+- lib/rbind/templates/c/cmake/FindRuby.cmake
 - lib/rbind/templates/c/consts.h
 - lib/rbind/templates/c/conversions.cc
 - lib/rbind/templates/c/conversions.hpp
+- lib/rbind/templates/c/find_gem.txt
 - lib/rbind/templates/c/find_package.txt
 - lib/rbind/templates/c/operation_wrapper.cc
 - lib/rbind/templates/c/operations.cc
@@ -93,4 +96,3 @@ signing_key:
 specification_version: 3
 summary: Library for genereating automated ffi-bindings for c/c++ libraries
 test_files: []
-has_rdoc: