utilrb 3.0.1 → 3.2.0

data/lib/utilrb/pkgconfig.rb

@@ -1,5 +1,5 @@
-require 'set'
-require 'shellwords'
+require "set"
+require "shellwords"
 
 module Utilrb
     # Access to information from pkg-config(1)
@@ -32,7 +32,7 @@ module Utilrb
     #   pkg.static
     #
     # Arbitrary variables defined in the .pc file can be accessed with
-    # 
+    #
     #   pkg.prefix
     #   pkg.libdir
     #
@@ -41,15 +41,6 @@ module Utilrb
         VAR_NAME_RX     = /\w+/
         FIELD_NAME_RX   = /[\w\.\-]+/
 
-        class << self
-            attr_reader :loaded_packages
-
-            def clear_cache
-                loaded_packages.clear
-            end
-        end
-        @loaded_packages = Hash.new
-
         def self.load(path, preset_variables)
             pkg_name = File.basename(path, ".pc")
             pkg = Class.instance_method(:new).bind(PkgConfig).call(pkg_name)
@@ -57,28 +48,44 @@ module Utilrb
             pkg
         end
 
+        def self.load_minimal(path, preset_variables)
+            pkg_name = File.basename(path, ".pc")
+            pkg = Class.instance_method(:new).bind(PkgConfig).call(pkg_name)
+            pkg.load_minimal(path, preset_variables)
+            pkg
+        end
+
+        # @deprecated {PkgConfig} does not cache the packages anymore, so no
+        #   need to call this method
+        def self.clear_cache
+        end
+
         # Returns the pkg-config object that matches the given name, and
         # optionally a version string
-        def self.get(name, version_spec = nil, preset_variables = Hash.new)
-            if !(candidates = loaded_packages[name])
-                paths = find_all_package_files(name)
-                if paths.empty?
-                    raise NotFound.new(name), "cannot find the pkg-config specification for #{name}"
-                end
+        def self.get(name, version_spec = nil, preset_variables = Hash.new,
+            minimal: false, pkg_config_path: self.pkg_config_path, memo: Hash.new)
 
-                candidates = Array.new
-                paths.each do |p|
-                    candidates << PkgConfig.load(p, preset_variables)
-                end
-                loaded_packages[name] = candidates
+            paths = find_all_package_files(name, pkg_config_path: pkg_config_path)
+            if paths.empty?
+                raise NotFound.new(name), "cannot find the pkg-config specification for #{name}"
+            end
+
+            candidates = paths.map do |p|
+                PkgConfig.load_minimal(p, preset_variables)
             end
 
             # Now try to find a matching spec
-            if version_match = find_matching_version(candidates, version_spec)
-                version_match
+            if match = find_matching_version(candidates, version_spec)
+                memo[[name, version_spec]] = [false, match]
             else
-                raise NotFound, "found #{candidates.size} packages for #{name}, but none match the version specification #{version_spec}"
+                raise NotFound, "found #{candidates.size} packages for #{name},"\
+                    " but none match the version specification #{version_spec}"
             end
+
+            match.load_fields(memo: memo) unless minimal
+
+            memo[[name, version_spec]] = [true, match]
+            match
         end
 
         # Finds the provided package and optional version and returns its
@@ -89,8 +96,8 @@ module Utilrb
         # ...
         # @return [PkgConfig] the pkg-config description
         # @raise [NotFound] if the package is not found
-        def self.new(name, version_spec = nil, options = Hash.new)
-            get(name, version_spec, options)
+        def self.new(name, version_spec = nil, **options)
+            get(name, version_spec, **options)
         end
 
         # Returns the first package in +candidates+ that match the given version
@@ -124,44 +131,51 @@ module Utilrb
         end
 
         # Exception raised when a request pkg-config file is not found
-	class NotFound < RuntimeError
+        class NotFound < RuntimeError
             # The name of the pkg-config package
-	    attr_reader :name
+            attr_reader :name
 
-	    def initialize(name); @name = name end
-	end
+            def initialize(name); @name = name end
+        end
 
         # Exception raised when invalid data is found in a pkg-config file
         class Invalid < RuntimeError
             # The name of the pkg-config package
-	    attr_reader :name
+            attr_reader :name
 
-	    def initialize(name); @name = name end
+            def initialize(name); @name = name end
         end
 
-
-        attr_reader :file
         attr_reader :path
-	
-	# The module name
-	attr_reader :name
+
+        # The module name
+        attr_reader :name
         attr_reader :description
+
         # The module version as a string
         attr_reader :raw_version
+
         # The module version, as an array of integers
         attr_reader :version
 
+        attr_reader :raw_fields
+
         # Information extracted from the file
         attr_reader :variables
         attr_reader :fields
 
-	# Create a PkgConfig object for the package +name+
-	# Raises PkgConfig::NotFound if the module does not exist
-	def initialize(name)
-	    @name    = name
-	    @fields    = Hash.new
-	    @variables = Hash.new
-	end
+        # The list of packages that are Require:'d by this package
+        #
+        # @return [Array<PkgConfig>]
+        attr_reader :requires
+
+        # Create a PkgConfig object for the package +name+
+        # Raises PkgConfig::NotFound if the module does not exist
+        def initialize(name)
+            @name    = name
+            @fields    = Hash.new
+            @variables = Hash.new
+        end
 
         # Helper method that expands ${word} in +value+ using the name to value
         # map +variables+
@@ -169,7 +183,7 @@ module Utilrb
         # +current+ is a string that describes what we are expanding. It is used
         # to detect recursion in expansion of variables, and to give meaningful
         # errors to the user
-        def expand_variables(value, variables, current)
+        def perform_substitution(value, variables, current)
             value = value.gsub(/\$\{(\w+)\}/) do |rx|
                 expand_name = $1
                 if expand_name == current
@@ -182,45 +196,59 @@ module Utilrb
             value
         end
 
-        def self.parse_dependencies(string)
-            if string =~ /,/
-                packages = string.split(',')
-            else
-                packages = []
-                words = string.split(' ')
-                while !words.empty?
-                    w = words.shift
-                    if w =~ /[<>=]/
-                        packages[-1] += " #{w} #{words.shift}"
+        class DependencyLoop < RuntimeError; end
+
+        def self.parse_dependencies(string, allow_loops: false, memo: Hash.new)
+            string = string.gsub(',', ' ')
+            packages = []
+            words = string.split(' ')
+            while !words.empty?
+                w = words.shift
+                if w =~ /[<>=]/
+                    version = words.shift
+                    if  version =~ /[\d\.]+/
+                        packages[-1][1] = "#{w} #{version}"
                     else
-                        packages << w
+                        packages << [version, nil]
                     end
+                else
+                    packages << [w, nil]
                 end
             end
-
             result = packages.map do |dep|
-                dep = dep.strip
-                if dep =~ /^(#{PACKAGE_NAME_RX})\s*([=<>]+.*)/
-                    PkgConfig.get($1, $2.strip)
+                finished, pkg = memo[dep]
+                if pkg
+                    if allow_loops || finished
+                        pkg
+                    else
+                        raise DependencyLoop, "found a dependency loop"
+                    end
                 else
-                    PkgConfig.get(dep)
+                    PkgConfig.get(*dep, memo: memo)
                 end
             end
-            result
+            result.compact
         end
 
         SHELL_VARS = %w{Cflags Libs Libs.private}
 
-        # Loads the information contained in +path+
-        def load(path, preset_variables = Hash.new)
-            @path = path
-            @file = File.readlines(path).map(&:strip)
-
-            raw_variables = preset_variables.dup
-            raw_fields    = Hash.new
+        # @api private
+        #
+        # Normalize a field name to be lowercase with only the first letter
+        # capitalized
+        def normalize_field_name(name)
+            name = name.downcase
+            name[0, 1] = name[0, 1].upcase
+            name
+        end
 
+        # Parse a pkg-config field and extracts the raw definition of variables
+        # and fields
+        #
+        # @return [(Hash,Hash)] the set of variables and the set of fields
+        def parse(path)
             running_line = nil
-            @file = file.map do |line|
+            file = File.readlines(path).map do |line|
                 line = line.gsub(/\s*#.*$/, '')
                 line = line.strip
                 next if line.empty?
@@ -239,79 +267,137 @@ module Utilrb
                 end
             end.compact
 
-
+            raw_variables, raw_fields = Hash.new, Hash.new
             file.each do |line|
                 case line
                 when /^(#{VAR_NAME_RX})\s*=(.*)/
                     raw_variables[$1] = $2.strip
                 when /^(#{FIELD_NAME_RX}):\s*(.*)/
-                    raw_fields[$1] = $2.strip
+                    field_name = normalize_field_name($1)
+                    raw_fields[field_name] = $2.strip
                 else
                     raise NotImplementedError, "#{path}: cannot parse pkg-config line #{line.inspect}"
                 end
             end
+            return raw_variables, raw_fields
+        end
+
+        def expand_variables(raw_variables)
+            raw_variables = raw_variables.dup
 
+            variables = Hash.new
             # Resolve the variables
             while variables.size != raw_variables.size
                 raw_variables.each do |name, value|
-                    value = expand_variables(value, raw_variables, name)
+                    value = perform_substitution(value, raw_variables, name)
                     raw_variables[name] = value
                     if value !~ /\$\{#{VAR_NAME_RX}\}/
                         variables[name] = value
                     end
                 end
             end
+            variables
+        end
 
-            # Shell-split the fields, and expand the variables in them
-            raw_fields.each do |name, value|
-                if SHELL_VARS.include?(name) 
-                    value = Shellwords.shellsplit(value)
-                    resolved = Array.new
-                    while !value.empty?
-                        value = value.flat_map do |v|
-                            expanded = expand_variables(v, variables, name)
-                            if expanded == v
-                                resolved << v
-                                nil
-                            else
-                                Shellwords.shellsplit(expanded)
-                            end
-                        end.compact
-                    end
-                    fields[name] = resolved
-                else
-                    fields[name] = expand_variables(value, variables, name)
+        def expand_field(name, field)
+            if SHELL_VARS.include?(name)
+                value = Shellwords.shellsplit(field)
+                resolved = Array.new
+                while !value.empty?
+                    value = value.flat_map do |v|
+                        expanded = perform_substitution(v, variables, name)
+                        if expanded == v
+                            resolved << v
+                            nil
+                        else
+                            Shellwords.shellsplit(expanded)
+                        end
+                    end.compact
                 end
+                resolved
+            else
+                perform_substitution(field, variables, name)
+            end
+        end
+
+        def builtin_variables(path)
+            {
+                "pcfiledir" => File.dirname(path),
+                "pc_sysrootdir" => sysrootdir
+            }
+        end
+
+        def load_variables(path, preset_variables = Hash.new)
+            raw_variables, raw_fields = parse(path)
+            raw_variables = preset_variables.merge(raw_variables)
+            expand_variables(
+                raw_variables.merge(builtin_variables(path))
+            )
+        end
+
+        def load_minimal(path, preset_variables = Hash.new)
+            raw_variables, raw_fields = parse(path)
+            raw_variables = preset_variables.merge(raw_variables)
+
+            @variables = expand_variables(
+                raw_variables.merge(builtin_variables(path))
+            )
+            if raw_fields['Version']
+                @raw_version = expand_field('Version', raw_fields['Version'])
+            else
+                @raw_version = ''
+            end
+            @version = raw_version.split('.').map { |v| Integer(v) if v =~ /^\d+$/ }.compact
+
+            # To be used in the call to #load
+            @raw_fields = raw_fields
+            @path = path
+        end
 
+        def load_fields(memo: Hash.new)
+            fields = Hash.new
+            @raw_fields.each do |name, value|
+                fields[name] = expand_field(name, value)
             end
+            @fields = fields
 
             # Initialize the main flags
-            @raw_version = (fields['Version'] || '')
-            @version = raw_version.split('.').map { |v| Integer(v) if v =~ /^\d+$/ }.compact
             @description = (fields['Description'] || '')
 
             # Get the requires/conflicts
-            @requires  = PkgConfig.parse_dependencies(fields['Requires'] || '')
-            @requires_private  = PkgConfig.parse_dependencies(fields['Requires.private'] || '')
-            @conflicts = PkgConfig.parse_dependencies(fields['Conflicts'] || '')
+            @requires  = PkgConfig.parse_dependencies(
+                fields['Requires'] || '', allow_loops: false, memo: memo)
+            @requires_private  = PkgConfig.parse_dependencies(
+                fields['Requires.private'] || '', allow_loops: false, memo: memo)
+            @conflicts = PkgConfig.parse_dependencies(
+                fields['Conflicts'] || '', allow_loops: true, memo: memo)
 
             # And finally resolve the compilation flags
-            @cflags = fields['Cflags'] || []
+            cflags = fields['Cflags'] || []
+            cflags.uniq!
+            cflags -= self.class.default_search_path_I
+            cflags = apply_sysrootdir(cflags, "-I")
             @requires.each do |pkg|
-                @cflags.concat(pkg.raw_cflags)
+                cflags.concat(pkg.raw_cflags)
             end
             @requires_private.each do |pkg|
-                @cflags.concat(pkg.raw_cflags)
+                cflags.concat(pkg.raw_cflags)
             end
-            @cflags.uniq!
-            @cflags.delete('-I/usr/include')
-            @ldflags = Hash.new
-            @ldflags[false] = fields['Libs'] || []
-            @ldflags[false].delete('-L/usr/lib')
-            @ldflags[false].uniq!
-            @ldflags[true] = @ldflags[false] + (fields['Libs.private'] || [])
-            @ldflags[true].delete('-L/usr/lib')
-            @ldflags[true].uniq!
+            @cflags = cflags
+
+            ldflags_public = fields['Libs'] || []
+            ldflags_public.uniq!
+            ldflags_private = ldflags_public + (fields['Libs.private'] || [])
+            ldflags_private.uniq!
+
+            ldflags_public -= self.class.default_search_path_L
+            ldflags_public = apply_sysrootdir(ldflags_public, "-L")
+            ldflags_private -= self.class.default_search_path_L
+            ldflags_private = apply_sysrootdir(ldflags_private, "-L")
+            @ldflags = {
+                false => ldflags_public,
+                true => ldflags_private
+            }
 
             @ldflags_with_requires = {
                 true => @ldflags[true].dup,
@@ -326,7 +412,15 @@ module Utilrb
             end
         end
 
-	def self.define_pkgconfig_action(action) # :nodoc:
+        # Loads the information contained in +path+
+        def load(path, preset_variables = Hash.new)
+            if !@raw_fields
+                load_minimal(path, preset_variables)
+            end
+            load_fields
+        end
+
+        def self.define_pkgconfig_action(action) # :nodoc:
             class_eval <<-EOD, __FILE__, __LINE__+1
             def pkgconfig_#{action.gsub(/-/, '_')}(static = false)
                 if static
@@ -336,8 +430,8 @@ module Utilrb
                 end
             end
             EOD
-	    nil
-	end
+            nil
+        end
 
         def pkgconfig_variable(varname)
             `pkg-config --variable=#{varname}`.strip
@@ -346,43 +440,79 @@ module Utilrb
         # Returns the list of include directories listed in the Cflags: section
         # of the pkgconfig file
         def include_dirs
-            result = Shellwords.shellsplit(cflags_only_I).map { |v| v[2..-1] }
+            result = raw_cflags_only_I.map { |v| v[2..-1] }
             if result.any?(&:empty?)
                 raise Invalid.new(name), "empty include directory (-I without argument) found in pkg-config package #{name}"
             end
+
             result
         end
 
         # Returns the list of library directories listed in the Libs: section
         # of the pkgconfig file
         def library_dirs
-            result = Shellwords.shellsplit(libs_only_L).map { |v| v[2..-1] }
+            result = raw_libs_only_L.map { |v| v[2..-1] }
             if result.any?(&:empty?)
                 raise Invalid.new(name), "empty link directory (-L without argument) found in pkg-config package #{name}"
             end
+
             result
         end
 
-	ACTIONS = %w{cflags cflags-only-I cflags-only-other 
+        # A "new root" that should be prepended to -L and -I flags
+        def sysrootdir
+            ENV["PKG_CONFIG_SYSROOT_DIR"] || "/"
+        end
+
+        # @api private
+        #
+        # Apply {#sysrootdir} to all the given paths flags (-I or -L)
+        def apply_sysrootdir(entries, flag_name)
+            sysrootdir = self.sysrootdir
+            return entries if sysrootdir == "/"
+
+            entries.map do |v|
+                if v.start_with?(flag_name)
+                    "#{flag_name}#{sysrootdir}#{v[2..-1]}"
+                else
+                    v
+                end
+            end
+        end
+
+	ACTIONS = %w{cflags cflags-only-I cflags-only-other
 		    libs libs-only-L libs-only-l libs-only-other}
-	ACTIONS.each { |action| define_pkgconfig_action(action) }
+        ACTIONS.each { |action| define_pkgconfig_action(action) }
+
+        def conflicts
+            @conflicts
+        end
 
         def raw_cflags
             @cflags
         end
 
+        def raw_cflags_only_I
+            @cflags.grep(/^-I/)
+        end
+
+        def raw_cflags_only_other
+            @cflags.find_all { |s| s !~ /^-I/ }
+        end
+
         def cflags
-            @cflags.join(" ")
+            raw_cflags.join(" ")
         end
 
         def cflags_only_I
-            @cflags.grep(/^-I/).join(" ")
+            raw_cflags_only_I.join(" ")
         end
 
         def cflags_only_other
-            @cflags.find_all { |s| s !~ /^-I/ }.join(" ")
+            raw_cflags_only_other.join(" ")
         end
 
+
         def raw_ldflags
             @ldflags
         end
@@ -391,41 +521,63 @@ module Utilrb
             @ldflags_with_requires
         end
 
+
+        def raw_libs(static = false)
+            @ldflags_with_requires[static]
+        end
+
+        def raw_libs_only_L(static = false)
+            @ldflags_with_requires[static].grep(/^-L/)
+        end
+
+        def raw_libs_only_l(static = false)
+            @ldflags_with_requires[static].grep(/^-l/)
+        end
+
+        def raw_libs_only_other(static = false)
+            @ldflags_with_requires[static].find_all { |s| s !~ /^-[lL]/ }
+        end
+
+
         def libs(static = false)
-            @ldflags_with_requires[static].join(" ")
+            raw_libs(static).join(" ")
         end
 
         def libs_only_L(static = false)
-            @ldflags_with_requires[static].grep(/^-L/).join(" ")
+            raw_libs_only_L(static).join(" ")
         end
 
         def libs_only_l(static = false)
-            @ldflags_with_requires[static].grep(/^-l/).join(" ")
+            raw_libs_only_l(static).join(" ")
         end
 
         def libs_only_other(static = false)
-            @ldflags_with_requires[static].find_all { |s| s !~ /^-[lL]/ }.join(" ")
+            raw_libs_only_other(static).join(" ")
         end
 
-	def method_missing(varname, *args, &proc) # :nodoc:
-	    if args.empty?
+        def method_missing(varname, *args, &proc) # :nodoc:
+            if args.empty?
                 variables[varname.to_s]
-	    else
-		super(varname, *args, &proc)
-	    end
-	end
-
-        def self.each_pkgconfig_directory(&block)
-            if path = ENV['PKG_CONFIG_PATH']
-                path.split(':').each(&block)
+            else
+                super(varname, *args, &proc)
             end
+        end
+
+        def self.pkg_config_path
+            ENV['PKG_CONFIG_PATH']
+        end
+
+        def self.each_pkgconfig_directory(pkg_config_path: self.pkg_config_path, &block)
+            return enum_for(__method__) if !block_given?
+
+            pkg_config_path.split(':').each(&block) if pkg_config_path
             default_search_path.each(&block)
         end
 
         # Returns true if there is a package with this name
-        def self.find_all_package_files(name)
+        def self.find_all_package_files(name, pkg_config_path: self.pkg_config_path)
             result = []
-            each_pkgconfig_directory do |dir|
+            each_pkgconfig_directory(pkg_config_path: pkg_config_path) do |dir|
                 path = File.join(dir, "#{name}.pc")
                 if File.exist?(path)
                     result << path
@@ -434,9 +586,9 @@ module Utilrb
             result
         end
 
-        def self.available_package_names
+        def self.available_package_names(pkg_config_path: self.pkg_config_path)
             result = []
-            each_pkgconfig_directory do |dir|
+            each_pkgconfig_directory(pkg_config_path: pkg_config_path) do |dir|
                 Dir.glob(File.join(dir, "*.pc")) do |path|
                     result << File.basename(path, ".pc")
                 end
@@ -445,15 +597,17 @@ module Utilrb
         end
 
         # Returns true if there is a package with this name
-        def self.has_package?(name)
-            !find_all_package_files(name).empty?
+        def self.has_package?(name, pkg_config_path: self.pkg_config_path)
+            !find_all_package_files(name, pkg_config_path: pkg_config_path).empty?
         end
 
         # Yields the package names of available packages. If +regex+ is given,
         # lists only the names that match the regular expression.
-        def self.each_package(regex = nil)
+        def self.each_package(regex = nil, pkg_config_path: self.pkg_config_path)
+            return enum_for(__method__) if !block_given?
+
             seen = Set.new
-            each_pkgconfig_directory do |dir|
+            each_pkgconfig_directory(pkg_config_path: pkg_config_path) do |dir|
                 Dir.glob(File.join(dir, '*.pc')) do |file|
                     pkg_name = File.basename(file, ".pc")
                     next if seen.include?(pkg_name)
@@ -466,34 +620,64 @@ module Utilrb
         end
 
 
-        FOUND_PATH_RX = /Scanning directory (?:#\d+ )?'(.*\/)((?:lib|lib64|share)\/.*)'$/
-        NONEXISTENT_PATH_RX = /Cannot open directory (?:#\d+ )?'.*\/((?:lib|lib64|share)\/.*)' in package search path:.*/
+        PKGCONFIG_PATH_RX = %r{.*/((?:lib|lib64|share)/.*)}.freeze
 
         # Returns the system-wide search path that is embedded in pkg-config
         def self.default_search_path
-            if !@default_search_path
-                output = `LANG=C PKG_CONFIG_PATH= pkg-config --debug 2>&1`.split("\n")
-                @default_search_path = output.grep(FOUND_PATH_RX).
-                    map { |l| l.gsub(FOUND_PATH_RX, '\1\2') }
-            end
-            return @default_search_path
+            @default_search_path ||=
+                `LANG=C pkg-config --variable pc_path pkg-config`
+                .strip
+                .split(":")
+                .grep(PKGCONFIG_PATH_RX)
+                .to_set
         end
+
         @default_search_path = nil
 
+        def self.arch_dir
+            return if @arch_dir == false
+
+            unless @arch_dir
+                suffix_with_arch =
+                    default_search_suffixes
+                    .find { |p| %r{^lib/[^/]+/pkgconfig} =~ p }
+
+                @arch_dir =
+                    if suffix_with_arch
+                        suffix_with_arch.split("/")[1]
+                    else
+                        false
+                    end
+            end
+
+            @arch_dir
+        end
+
+        def self.default_search_path_L # rubocop:disable Naming/MethodName
+            unless @default_search_path_L
+                arch_dir = self.arch_dir
+                @default_search_path_L = # rubocop:disable Naming/VariableName
+                    ["-L/usr/lib", "-L/lib"]
+                    .flat_map { |p| [p, "#{p}/#{arch_dir}"] }
+            end
+
+            @default_search_path_L
+        end
+
+        def self.default_search_path_I # rubocop:disable Naming/MethodName
+            @default_search_path_I ||= ["-I/usr/include"] # rubocop:disable Naming/VariableName
+        end
+
         # Returns the system-wide standard suffixes that should be appended to
         # new prefixes to find pkg-config files
         def self.default_search_suffixes
-            if !@default_search_suffixes
-                output = `LANG=C PKG_CONFIG_PATH= pkg-config --debug 2>&1`.split("\n")
-                found_paths = output.grep(FOUND_PATH_RX).
-                    map { |l| l.gsub(FOUND_PATH_RX, '\2') }.
-                    to_set
-                not_found = output.grep(NONEXISTENT_PATH_RX).
-                    map { |l| l.gsub(NONEXISTENT_PATH_RX, '\1') }.
-                    to_set
-                @default_search_suffixes = found_paths | not_found
-            end
-            return @default_search_suffixes
+            @default_search_suffixes ||=
+                `LANG=C pkg-config --variable pc_path pkg-config`
+                .strip
+                .split(":")
+                .grep(PKGCONFIG_PATH_RX)
+                .map { |l| l.gsub(PKGCONFIG_PATH_RX, '\1') }
+                .to_set
         end
     end
 end