utilrb 3.1.0 → 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
     #
@@ -62,7 +62,9 @@ module Utilrb
 
         # 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, minimal: false, pkg_config_path: self.pkg_config_path)
+        def self.get(name, version_spec = nil, preset_variables = Hash.new,
+            minimal: false, pkg_config_path: self.pkg_config_path, memo: Hash.new)
+
             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}"
@@ -74,14 +76,15 @@ module Utilrb
 
             # Now try to find a matching spec
             if match = find_matching_version(candidates, version_spec)
-                match
+                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
 
-            if !minimal
-                match.load_fields
-            end
+            match.load_fields(memo: memo) unless minimal
+
+            memo[[name, version_spec]] = [true, match]
             match
         end
 
@@ -93,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
@@ -128,29 +131,30 @@ 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 :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
 
@@ -165,13 +169,13 @@ module Utilrb
         # @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
+        # 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+
@@ -192,31 +196,38 @@ 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}
@@ -256,7 +267,6 @@ module Utilrb
                 end
             end.compact
 
-
             raw_variables, raw_fields = Hash.new, Hash.new
             file.each do |line|
                 case line
@@ -271,7 +281,7 @@ module Utilrb
             end
             return raw_variables, raw_fields
         end
-        
+
         def expand_variables(raw_variables)
             raw_variables = raw_variables.dup
 
@@ -288,9 +298,9 @@ module Utilrb
             end
             variables
         end
-        
+
         def expand_field(name, field)
-            if SHELL_VARS.include?(name) 
+            if SHELL_VARS.include?(name)
                 value = Shellwords.shellsplit(field)
                 resolved = Array.new
                 while !value.empty?
@@ -310,17 +320,28 @@ module Utilrb
             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)
+            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)
+            @variables = expand_variables(
+                raw_variables.merge(builtin_variables(path))
+            )
             if raw_fields['Version']
                 @raw_version = expand_field('Version', raw_fields['Version'])
             else
@@ -333,7 +354,7 @@ module Utilrb
             @path = path
         end
 
-        def load_fields
+        def load_fields(memo: Hash.new)
             fields = Hash.new
             @raw_fields.each do |name, value|
                 fields[name] = expand_field(name, value)
@@ -344,27 +365,39 @@ module Utilrb
             @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,
@@ -387,7 +420,7 @@ module Utilrb
             load_fields
         end
 
-	def self.define_pkgconfig_action(action) # :nodoc:
+        def self.define_pkgconfig_action(action) # :nodoc:
             class_eval <<-EOD, __FILE__, __LINE__+1
             def pkgconfig_#{action.gsub(/-/, '_')}(static = false)
                 if static
@@ -397,8 +430,8 @@ module Utilrb
                 end
             end
             EOD
-	    nil
-	end
+            nil
+        end
 
         def pkgconfig_variable(varname)
             `pkg-config --variable=#{varname}`.strip
@@ -411,6 +444,7 @@ module Utilrb
             if result.any?(&:empty?)
                 raise Invalid.new(name), "empty include directory (-I without argument) found in pkg-config package #{name}"
             end
+
             result
         end
 
@@ -421,12 +455,38 @@ module Utilrb
             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
@@ -495,13 +555,13 @@ module Utilrb
             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
+            else
+                super(varname, *args, &proc)
+            end
+        end
 
         def self.pkg_config_path
             ENV['PKG_CONFIG_PATH']
@@ -509,9 +569,8 @@ module Utilrb
 
         def self.each_pkgconfig_directory(pkg_config_path: self.pkg_config_path, &block)
             return enum_for(__method__) if !block_given?
-            if pkg_config_path
-                pkg_config_path.split(':').each(&block)
-            end
+
+            pkg_config_path.split(':').each(&block) if pkg_config_path
             default_search_path.each(&block)
         end
 
@@ -561,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

data/lib/utilrb/thread_pool.rb

@@ -9,8 +9,8 @@ module Utilrb
     #
     # @example Using a thread pool of 10 threads
     #   pool = ThreadPool.new(10)
-    #   0.upto(9) do 
-    #      pool.process do 
+    #   0.upto(9) do
+    #      pool.process do
     #        sleep 1
     #        puts "done"
     #      end
@@ -40,7 +40,7 @@ module Utilrb
             attr_reader :pool
 
             # State of the task
-            # 
+            #
             # @return [:waiting,:running,:stopping,:finished,:terminated,:exception] the state
             attr_reader :state
 
@@ -54,7 +54,7 @@ module Utilrb
             # return [Thread] the thread
             attr_reader :thread
 
-            # The time the task was queued 
+            # The time the task was queued
             #
             # return [Time] the time
             attr_accessor :queued_at
@@ -115,15 +115,15 @@ module Utilrb
             def exception?; @state == :exception; end
 
             # A new task which can be added to the work queue of a {ThreadPool}.
-            # If a sync key is given no task having the same key will be 
+            # If a sync key is given no task having the same key will be
             # executed in parallel which is useful for instance member calls
             # which are not thread safe.
             #
             # @param [Hash] options The options of the task.
             # @option options [Object] :sync_key The sync key
             # @option options [Proc] :callback The callback
-            # @option options [Object] :default Default value returned when an error ocurred which was handled. 
-            # @param [Array] args The arguments for the code block 
+            # @option options [Object] :default Default value returned when an error ocurred which was handled.
+            # @param [Array] args The arguments for the code block
             # @param [#call] block The code block
             def initialize (options = Hash.new,*args, &block)
                 unless block
@@ -162,7 +162,7 @@ module Utilrb
             # returns true if the task has a default return vale
             # @return [Boolean]
             def default?
-                 @mutex.synchronize do 
+                 @mutex.synchronize do
                      @default != nil
                  end
             end
@@ -170,7 +170,7 @@ module Utilrb
             #sets all internal state to running
             #call execute after that.
             def pre_execute(pool=nil)
-                @mutex.synchronize do 
+                @mutex.synchronize do
                     #store current thread to be able to terminate
                     #the thread
                     @pool = pool
@@ -182,7 +182,7 @@ module Utilrb
 
             # Executes the task.
             # Should be called from a worker thread after pre_execute was called.
-            # After execute returned and the task was deleted 
+            # After execute returned and the task was deleted
             # from any internal list finalize must be called
             # to propagate the task state.
             def execute()
@@ -200,7 +200,7 @@ module Utilrb
                         end
                 @stopped_at = Time.now
             end
-            
+
             # propagates the tasks state
             # should be called after execute
             def finalize
@@ -225,7 +225,7 @@ module Utilrb
                 end
             end
 
-            # Called from the worker thread when the work is done 
+            # Called from the worker thread when the work is done
             #
             # @yield [Object,Exception] The callback
             def callback(&block)
@@ -249,6 +249,10 @@ module Utilrb
                     0
                 end
             end
+
+            def to_s
+                "#<Utilrb::ThreadPool::Task #{@state} #{@block}>"
+            end
         end
 
         # The minimum number of worker threads.
@@ -270,12 +274,12 @@ module Utilrb
         #
         # @return [Fixnum]
         attr_reader :waiting
-        
+
         # The average execution time of a (running) task.
         #
         # @return [Float]
         attr_reader :avg_run_time
-        
+
         # The average waiting time of a task before being executed.
         #
         # @return [Float]
@@ -300,7 +304,7 @@ module Utilrb
 
             @tasks_waiting = []         # tasks waiting for execution
             @tasks_running = []         # tasks which are currently running
-            
+
             # Statistics
             @avg_run_time = 0           # average run time of a task in s [Float]
             @avg_wait_time = 0          # average time a task has to wait for execution in s [Float]
@@ -370,10 +374,10 @@ module Utilrb
         end
 
         # Number of tasks waiting for execution
-        # 
+        #
         # @return [Fixnum] the number of tasks
         def backlog
-            @mutex.synchronize do 
+            @mutex.synchronize do
                 @tasks_waiting.length
             end
         end
@@ -396,7 +400,7 @@ module Utilrb
             process_with_options(nil,*args,&block)
         end
 
-        # Returns true if a worker thread is currently processing a task 
+        # Returns true if a worker thread is currently processing a task
         # and no work is queued
         #
         # @return [Boolean]
@@ -426,7 +430,7 @@ module Utilrb
         # safe.
         #
         # @param [Object] sync_key The sync key
-        # @yield [*args] the code block block 
+        # @yield [*args] the code block block
         # @return [Object] The result of the code block
         def sync(sync_key,*args,&block)
             raise ArgumentError,"no sync key" unless sync_key
@@ -454,7 +458,7 @@ module Utilrb
         #
         # @param [Object] sync_key The sync key
         # @param [Float] timeout The timeout
-        # @yield [*args] the code block block 
+        # @yield [*args] the code block block
         # @return [Object] The result of the code block
         def sync_timeout(sync_key,timeout,*args,&block)
             raise ArgumentError,"no sync key" unless sync_key
@@ -480,14 +484,14 @@ module Utilrb
         end
 
         # Processes the given {Task} as soon as the next thread is available
-        # 
+        #
         # @param [Task] task The task.
         # @return [Task]
         def <<(task)
             raise "cannot add task #{task} it is still running" if task.thread
             task.reset if task.finished?
             @mutex.synchronize do
-                if shutdown? 
+                if shutdown?
                     raise "unable to add work while shutting down"
                 end
                 task.queued_at = Time.now
@@ -500,7 +504,7 @@ module Utilrb
             task
         end
 
-        # Trims the number of threads if threads are waiting for work and 
+        # Trims the number of threads if threads are waiting for work and
         # the number of spawned threads is higher than the minimum number.
         #
         # @param [boolean] force Trim even if no thread is waiting.
@@ -551,12 +555,12 @@ module Utilrb
 
         private
 
-        #calculates the moving average 
+        #calculates the moving average
         def moving_average(current_val,new_val)
             return new_val if current_val == 0
             current_val * 0.95 + new_val * 0.05
         end
-        
+
         # spawns a worker thread
         # must be called from a synchronized block
         def spawn_thread

data/lib/utilrb/version.rb

@@ -1,4 +1,4 @@
 module Utilrb
-    VERSION = "3.1.0"
+    VERSION = "3.2.0"
 end