Class: Mkrf::Availability

### Home Classes Methods

### In Files

- lib/mkrf/availability.rb

### Parent

Object

### Methods

- ::new
- #can_link?
- #find_executable
- #has_function?
- #has_header?
- #has_library?
- #include_header
- #include_library
- #includes_compile_string
- #ldshared_string
- #library_compile_string
- #library_paths_compile_string
- #with_headers
- #with_includes
- #with_loaded_libs

### Files

- CHANGELOG
- MIT-LICENSE
- README

### Class/Module Index

Quicksearch

- Mkrf
- Mkrf::Availability
- Mkrf::Generator
- Object

No matching classes.

# Mkrf::Availability

The `Availability` class is concerned with libraries, headers, and functions. It can be easily wrapped (see `Mkrf::Generator` 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.

### Constants

DEFAULT_INCLUDES
TEMP_EXECUTABLE
TEMP_SOURCE_FILE

  These really shouldn't be static like this..

### Attributes

defines[R]
headers[R]
includes[R]
loaded_libs[R]
logger[R]

### Public Class Methods

new(options = {}) click to toggle source

Create a new Availability instance.

Valid keys for the options hash include:

- `:loaded_libs` -- libraries to load by default

- `:library_paths` -- libraries paths to include by default

- `:headers` -- headers to load by default

- `:compiler` -- which compiler to use when determining availability

- `:includes` -- directories that should be searched for include files

    # File lib/mkrf/availability.rb, line 37
    def initialize(options = {})
      @loaded_libs = [(options[:loaded_libs] || Config::CONFIG["LIBS"].gsub('-l', '').split)].flatten
      @library_paths = [(options[:library_paths] || [])].flatten
      # Not sure what COMMON_HEADERS looks like when populated
      @headers = options[:headers] || [] # Config::CONFIG["COMMON_HEADERS"]
      @compiler = options[:compiler] || Config::CONFIG["CC"]
      @includes = [(options[:includes] || DEFAULT_INCLUDES)].flatten
      @logger = Logger.new('mkrf.log')
      @defines = []
    end

### Public Instance Methods

can_link?(function_body) click to toggle source

Returns the result of an attempt to compile and link the function body passed in

    # File lib/mkrf/availability.rb, line 126
    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

find_executable(bin, *paths) click to toggle source

Takes the name of an executable and an optional set of paths to search. If no paths are given, the environmental path is used by default. Returns the absolute path to an executable, or nil if not found.

    # File lib/mkrf/availability.rb, line 190
    def find_executable(bin, *paths)
      paths = ENV['PATH'].split(File::PATH_SEPARATOR) if paths.empty?
      paths.each do |path|
        file = File.join(path, bin)
        return file if File.executable?(file)
      end
      return nil
    end

has_function?(function) click to toggle source

Returns `true` if the function is able to be called based on libraries and headers currently loaded. Returns `false` otherwise.

Params:

- `function` -- the function to check for

    # File lib/mkrf/availability.rb, line 114
    def has_function?(function)
      if can_link?(simple_call(function)) or can_link?(simple_reference(function))
        logger.info "Function found: #{function}()"
        return true
      else
        logger.warn "Function not found: #{function}()"
        return false
      end
    end

has_header?(header, *paths) click to toggle source

Returns `true` if the header is found in the default search path or in optional paths passed as an argument, `false` otherwise. If the header is found, the preprocessor constant HAVE_BLAH is defined where BLAH is the name of the header in uppercase without the file extension.

Params:

- `header` -- the header to be searched for

- `paths` -- an optional list of search paths if the header is not found in the default paths

    # File lib/mkrf/availability.rb, line 98
    def has_header?(header, *paths)
      if header_already_loaded?(header) || header_can_link?(header) ||
                     header_found_in_paths?(header, paths)
        defines << format("HAVE_%s", header.tr("a-z./\0055", "A-Z___"))
        return true
      end

      logger.warn "Header not found: #{header}"
      return false
    end

has_library?(library, function = "main", *paths) click to toggle source

Returns a boolean whether indicating whether the library can be found by attempting to reference the function passed (`main` by default).

Params:

- `library` -- the library to be included as a string

- `function` -- a method to base the inclusion of the library on. `main` by default.

- `paths` -- an optional list of search paths if the library is not found in the default paths

    # File lib/mkrf/availability.rb, line 81
    def has_library?(library, function = "main", *paths)
      logger.info "Checking for library: #{library}"
      return true if library_already_loaded?(library)
      return true if RUBY_PLATFORM =~ /mswin/ # TODO: find a way on windows
      # Should this be only found_library? or a specialized version with
      # path searching?
      found_library?(library, function)
    end

include_header(header, *paths) click to toggle source

Include a header in the list of availiable headers. Returns `false` if the header is not available. Returns non-false otherwise. If the header is found, the preprocessor constant HAVE_BLAH is defined where BLAH is the name of the header in uppercase without the file extension.

Params:

- `header` -- the name of the header to be included as a string.

- `paths` -- an optional list of search paths if the header is not found in the default paths.

    # File lib/mkrf/availability.rb, line 70
    def include_header(header, *paths)
      @headers << header if has_header?(header, *paths)
    end

include_library(library, function = "main", *paths) click to toggle source

Include a library in the list of available libs. Returns `false` if the library is not available. Returns non-false otherwise.

Params:

- `library` -- the library to be included as a string.

- `function` -- a method to base the inclusion of the library on. `main` by default.

- `paths` -- an optional list of search paths if the library is not found in the default paths.

    # File lib/mkrf/availability.rb, line 55
    def include_library(library, function = "main", *paths)
      paths.each do |library_dir|
        @library_paths << library_dir
      end
      @loaded_libs << library if has_library?(library, function)
    end

includes_compile_string() click to toggle source

Returns a string of include directories formatted for compilation

    # File lib/mkrf/availability.rb, line 183
    def includes_compile_string
      @includes.collect {|i| "-I#{i}"}.join(' ')
    end

ldshared_string() click to toggle source

    # File lib/mkrf/availability.rb, line 166
    def ldshared_string
      if RUBY_PLATFORM =~ /mswin/
        "link -nologo -incremental:no -debug -opt:ref -opt:icf -dll"
      else
        Config::CONFIG['LDSHARED']
      end
    end

library_compile_string() click to toggle source

Returns a string of libraries formatted for compilation

    # File lib/mkrf/availability.rb, line 149
    def library_compile_string
      if RUBY_PLATFORM =~ /mswin/
        @loaded_libs.join(' ')
      else
        @loaded_libs.collect {|l| "-l#{l}"}.join(' ')
      end
    end

library_paths_compile_string() click to toggle source

Returns a string of libraries directories formatted for compilation

    # File lib/mkrf/availability.rb, line 158
    def library_paths_compile_string
      if RUBY_PLATFORM =~ /mswin/
        @library_paths.collect {|l| "/libpath:#{l}"}.join(' ')
      else
        @library_paths.collect {|l| "-L#{l}"}.join(' ')
      end
    end

with_headers(*args, &b) click to toggle source

    # File lib/mkrf/availability.rb, line 136
    def with_headers(*args, &b)
      with_stackable_attribute('headers', *args, &b)
    end

with_includes(*args, &b) click to toggle source

    # File lib/mkrf/availability.rb, line 144
    def with_includes(*args, &b)
      with_stackable_attribute('includes', *args, &b)
    end

with_loaded_libs(*args, &b) click to toggle source

    # File lib/mkrf/availability.rb, line 140
    def with_loaded_libs(*args, &b)
      with_stackable_attribute('loaded_libs', *args, &b)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.