utilrb 1.3.3 → 1.4.0

data/lib/utilrb/pkgconfig.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'shellwords'
 
 module Utilrb
@@ -36,36 +37,258 @@ module Utilrb
     #   pkg.libdir
     #
     class PkgConfig
+        PACKAGE_NAME_RX = /[\w\-\.]+/
+        VAR_NAME_RX     = /\w+/
+        FIELD_NAME_RX   = /[\w\.\-]+/
+
+        class << self
+            attr_reader :loaded_packages
+
+            def clear_cache
+                cache.clear
+            end
+        end
+        @loaded_packages = Hash.new
+
+        def self.load(path)
+            pkg_name = File.basename(path, ".pc")
+            pkg = Class.instance_method(:new).bind(PkgConfig).call(pkg_name)
+            pkg.load(path)
+            pkg
+        end
+
+        # Returns the pkg-config object that matches the given name, and
+        # optionally a version string
+        def self.get(name, version_spec = nil)
+            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
+
+                candidates = loaded_packages[name] = Array.new
+                paths.each do |p|
+                    candidates << PkgConfig.load(p)
+                end
+            end
+
+            # Now try to find a matching spec
+            find_matching_version(candidates, version_spec)
+        end
+
+        def self.new(name, version_spec = nil)
+            get(name, version_spec)
+        end
+
+        # Returns the first package in +candidates+ that match the given version
+        # spec
+        def self.find_matching_version(candidates, version_spec)
+            if version_spec
+                version_spec =~ /([<>=]+)\s*([\d\.]+)/
+                op, requested_version = $1, $2
+
+                requested_op =
+                    if op == "=" then [0]
+                    elsif op == ">" then [1]
+                    elsif op == "<" then [-1]
+                    elsif op == "<=" then [-1, 0]
+                    elsif op == ">=" then [1, 0]
+                    end
+
+                requested_version = requested_version.split('.').map { |v| Integer(v) }
+
+                result = candidates.find do |pkg|
+                    requested_op.include?(pkg.version <=> requested_version)
+                end
+                if !result
+                    raise NotFound.new(name), "no version of #{name} match #{version_spect}. Available versions are: #{candidates.map(&:raw_version).join(", ")}"
+                end
+                result
+            else
+                candidates.first
+            end
+        end
+
 	class NotFound < RuntimeError
 	    attr_reader :name
 	    def initialize(name); @name = name end
 	end
+
+        attr_reader :file
+        attr_reader :path
 	
 	# The module name
 	attr_reader :name
-	# The module version
-	attr_reader :version
+        attr_reader :description
+        # The module version as a string
+        attr_reader :raw_version
+        # The module version, as an array of integers
+        attr_reader :version
+
+        # 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)
-	    if !system("pkg-config --exists #{name}")
-		raise NotFound.new(name), "#{name} is not available to pkg-config"
-	    end
-	    
 	    @name    = name
-	    @version = `pkg-config --modversion #{name}`.chomp.strip
-	    @actions = Hash.new
+	    @fields    = Hash.new
 	    @variables = Hash.new
 	end
 
-	def self.define_action(action) # :nodoc:
-	    define_method(action.gsub(/-/, '_')) do 
-		@actions[action] ||= `pkg-config --#{action} #{name}`.chomp.strip
-	    end
+        # Helper method that expands ${word} in +value+ using the name to value
+        # map +variables+
+        #
+        # +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)
+            value = value.gsub(/\$\{(\w+)\}/) do |rx|
+                expand_name = $1
+                if expand_name == current
+                    raise "error in pkg-config file #{path}: #{current} contains a reference to itself"
+                elsif !(expanded = variables[expand_name])
+                    raise "error in pkg-config file #{path}: #{current} contains a reference to #{expand_name} but there is no such variable"
+                end
+                expanded
+            end
+            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}"
+                    else
+                        packages << w
+                    end
+                end
+            end
+
+            result = packages.map do |dep|
+                dep = dep.strip
+                if dep =~ /^(#{PACKAGE_NAME_RX})\s*([=<>]+.*)/
+                    PkgConfig.get($1, $2.strip)
+                else
+                    PkgConfig.get(dep)
+                end
+            end
+            result
+        end
+
+        SHELL_VARS = %w{Cflags Libs Libs.private}
+
+        # Loads the information contained in +path+
+        def load(path)
+            @path = path
+            @file = File.readlines(path).map(&:strip)
+
+            raw_variables = Hash.new
+            raw_fields    = Hash.new
+            file.each do |line|
+                line.gsub! /\s*#.*$/, ''
+                next if line.empty?
+
+                case line
+                when /^(#{VAR_NAME_RX})\s*=(.*)/
+                    raw_variables[$1] = $2.strip
+                when /^(#{FIELD_NAME_RX}):\s*(.*)/
+                    raw_fields[$1] = $2.strip
+                else
+                    raise NotImplementedError, "cannot parse pkg-config line #{line.inspect}"
+                end
+            end
+
+            # Resolve the variables
+            while variables.size != raw_variables.size
+                raw_variables.each do |name, value|
+                    value = expand_variables(value, raw_variables, name)
+                    raw_variables[name] = value
+                    if value !~ /\$\{#{VAR_NAME_RX}\}/
+                        variables[name] = value
+                    end
+                end
+            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)
+                    value.map! do |v|
+                        expand_variables(v, variables, name)
+                    end
+                else
+                    value = expand_variables(value, variables, name)
+                end
+
+                fields[name] = value
+            end
+
+            # 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'] || '')
+
+            # And finally resolve the compilation flags
+            @cflags = fields['Cflags'] || []
+            @requires.each do |pkg|
+                @cflags.concat(pkg.raw_cflags)
+            end
+            @requires_private.each do |pkg|
+                @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!
+
+            @ldflags_with_requires = {
+                true => @ldflags[true].dup,
+                false => @ldflags[false].dup
+            }
+            @requires.each do |pkg|
+                @ldflags_with_requires[true].concat(pkg.raw_ldflags_with_requires[true])
+                @ldflags_with_requires[false].concat(pkg.raw_ldflags_with_requires[false])
+            end
+            @requires_private.each do |pkg|
+                @ldflags_with_requires[true].concat(pkg.raw_ldflags_with_requires[true])
+            end
+        end
+
+	def self.define_pkgconfig_action(action) # :nodoc:
+            class_eval <<-EOD
+            def pkgconfig_#{action.gsub(/-/, '_')}(static = false)
+                if static
+                    `pkg-config --#{action} --static \#{name}`.strip
+                else
+                    `pkg-config --#{action} \#{name}`.strip
+                end
+            end
+            EOD
 	    nil
 	end
 
+        def pkgconfig_variable(varname)
+            `pkg-config --variable=#{varname}`.strip
+        end
+
         # Returns the list of include directories listed in the Cflags: section
         # of the pkgconfig file
         def include_dirs
@@ -79,37 +302,98 @@ module Utilrb
         end
 
 	ACTIONS = %w{cflags cflags-only-I cflags-only-other 
-		    libs libs-only-L libs-only-l libs-only-other static}
-	ACTIONS.each { |action| define_action(action) }
+		    libs libs-only-L libs-only-l libs-only-other}
+	ACTIONS.each { |action| define_pkgconfig_action(action) }
+
+        def raw_cflags
+            @cflags
+        end
+
+        def cflags
+            @cflags.join(" ")
+        end
+
+        def cflags_only_I
+            @cflags.grep(/^-I/).join(" ")
+        end
+
+        def cflags_only_other
+            @cflags.find_all { |s| s !~ /^-I/ }.join(" ")
+        end
+
+        def raw_ldflags
+            @ldflags
+        end
+
+        def raw_ldflags_with_requires
+            @ldflags_with_requires
+        end
+
+        def libs(static = false)
+            @ldflags_with_requires[static].join(" ")
+        end
+
+        def libs_only_L(static = false)
+            @ldflags_with_requires[static].grep(/^-L/).join(" ")
+        end
+
+        def libs_only_l(static = false)
+            @ldflags_with_requires[static].grep(/^-l/).join(" ")
+        end
+
+        def libs_only_other(static = false)
+            @ldflags[static].find_all { |s| s !~ /^-[lL]/ }.join(" ")
+        end
 
 	def method_missing(varname, *args, &proc) # :nodoc:
 	    if args.empty?
-		@variables[varname] ||= `pkg-config --variable=#{varname} #{name}`.chomp.strip
+                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)
+            end
+            yield('/usr/local/lib/pkgconfig')
+            yield('/usr/lib/pkgconfig')
+            yield('/usr/share/pkgconfig')
+        end
+
+        # Returns true if there is a package with this name
+        def self.find_all_package_files(name)
+            result = []
+            each_pkgconfig_directory do |dir|
+                path = File.join(dir, "#{name}.pc")
+                if File.exists?(path)
+                    result << path
+                end
+            end
+            result
+        end
+
         # Returns true if there is a package with this name
         def self.has_package?(name)
-            enum_for(:each_package, name).find { true }
+            !find_all_package_files(name).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)
-            `pkg-config --list-all`.chomp.split.
-                each do |line|
-                    line =~ /^([^\s]+)/
-                    name = $1
-                    if regex
-                        if regex === name
-                            yield(name)
-                        end
-                    else
-                        yield(name)
-                    end
+            seen = Set.new
+            each_pkgconfig_directory do |dir|
+                Dir.glob(File.join(dir, '*.pc')) do |file|
+                    puts file
+                    pkg_name = File.basename(file, ".pc")
+                    next if seen.include?(pkg_name)
+                    next if regex && pkg_name !~ regex
+
+                    seen << pkg_name
+                    yield(pkg_name)
                 end
+            end
         end
     end
 end

data/lib/utilrb/symbol/to_str.rb

@@ -0,0 +1,5 @@
+class Symbol
+    def to_str
+        to_s
+    end
+end

data/lib/utilrb/value_set.rb

@@ -24,5 +24,17 @@ Utilrb.require_ext("ValueSet") do
 	def self._load(str)
 	    Marshal.load(str).to_value_set
 	end
+
+        def eql?(obj)
+            self == obj
+        end
+
+        def hash
+            result = ValueSet.hash / size
+            for obj in self
+                result = result ^ obj.hash
+            end
+            result
+        end
     end
 end

data/test/data/test_pkgconfig_empty.pc

@@ -0,0 +1,10 @@
+prefix=a_prefix
+
+Name: test_pkgconfig
+Description:
+Version: 4.2
+
+Cflags:
+Libs:
+
+

data/test/test_kernel.rb

@@ -1,8 +1,12 @@
 require 'test_config'
+require 'flexmock'
+require 'tempfile'
 
 require 'utilrb/kernel/options'
 require 'utilrb/kernel/arity'
 require 'utilrb/kernel/swap'
+require 'utilrb/kernel/with_module'
+require 'utilrb/kernel/load_dsl_file'
 
 class TC_Kernel < Test::Unit::TestCase
     def test_validate_options
@@ -45,6 +49,160 @@ class TC_Kernel < Test::Unit::TestCase
 	assert_nothing_raised { check_arity(object.method(:arity_1_more), 2) }
     end
 
+    def test_with_module
+        obj = Object.new
+        c0, c1 = nil
+        mod0 = Module.new do
+            const_set(:Const, c0 = Object.new)
+        end
+        mod1 = Module.new do
+            const_set(:Const, c1 = Object.new)
+        end
+
+        eval_string = "Const"
+        const_val = obj.with_module(mod0, mod1, eval_string)
+        assert_equal(c0, const_val)
+        const_val = obj.with_module(mod1, mod0, eval_string)
+        assert_equal(c1, const_val)
+
+        const_val = obj.with_module(mod0, mod1) { Const }
+        assert_equal(c0, const_val)
+        const_val = obj.with_module(mod1, mod0) { Const }
+        assert_equal(c1, const_val)
+
+        assert_raises(NameError) { Const  }
+    end
+
+    module Mod
+        module Submod
+            class Klass
+            end
+        end
+
+        const_set(:KnownConstant, 10)
+    end
+
+    def test_eval_dsl_file
+        obj = Class.new do
+            def real_method_called?; !!@real_method_called end
+            def name(value)
+            end
+            def real_method
+                @real_method_called = true
+            end
+        end.new
+
+        Tempfile.open('test_eval_dsl_file') do |io|
+            io.puts <<-EOD
+            real_method
+            if KnownConstant != 10
+                raise ArgumentError, "invalid constant value"
+            end
+            class Submod::Klass
+                def my_method
+                end
+            end
+            name('test')
+            unknown_method
+            EOD
+            io.flush
+
+            begin
+                eval_dsl_file(io.path, obj, [], false)
+                assert(obj.real_method_called?, "the block has not been evaluated")
+                flunk("did not raise NameError for KnownConstant")
+            rescue NameError => e
+                assert e.message =~ /KnownConstant/, e.message
+                assert e.backtrace.first =~ /#{io.path}:2/, "wrong backtrace when checking constant resolution: #{e.backtrace.join("\n")}"
+            end
+
+            begin
+                eval_dsl_file(io.path, obj, [Mod], false)
+                flunk("did not raise NoMethodError for unknown_method")
+            rescue NoMethodError => e
+                assert e.message =~ /unknown_method/
+                assert e.backtrace.first =~ /#{io.path}:10/, "wrong backtrace when checking method resolution: #{e.backtrace.join("\n")}"
+            end
+
+            # instance_methods returns strings on 1.8 and symbols on 1.9. Conver
+            # to strings to have the right assertion on both
+            methods = Mod::Submod::Klass.instance_methods(false).map(&:to_s)
+            assert(methods.include?('my_method'), "the 'class K' statement did not refer to the already defined class")
+        end
+    end
+
+    def test_eval_dsl_file_does_not_allow_class_definition
+        obj = Class.new do
+            def real_method
+                @real_method_called = true
+            end
+        end.new
+
+        Tempfile.open('test_eval_dsl_file') do |io|
+            io.puts <<-EOD
+            class NewClass
+            end
+            EOD
+            io.flush
+
+            begin
+                eval_dsl_file(io.path, obj, [], false)
+                flunk("NewClass has been defined")
+            rescue NameError => e
+                assert e.message =~ /NewClass/, e.message
+                assert e.backtrace.first =~ /#{io.path}:1/, "wrong backtrace when checking constant definition detection: #{e.backtrace[0]}, expected #{io.path}:1"
+            end
+        end
+    end
+
+    DSL_EXEC_BLOCK = Proc.new do
+        real_method
+        if KnownConstant != 10
+            raise ArgumentError, "invalid constant value"
+        end
+        class Submod::Klass
+            def my_method
+            end
+        end
+        name('test')
+        unknown_method
+    end
+
+    def test_dsl_exec
+        obj = Class.new do
+            def real_method_called?; !!@real_method_called end
+            def name(value)
+            end
+            def real_method
+                @real_method_called = true
+            end
+        end.new
+
+        begin
+            dsl_exec(obj, [], false, &DSL_EXEC_BLOCK)
+            assert(obj.real_method_called?, "the block has not been evaluated")
+            flunk("did not raise NameError for KnownConstant")
+        rescue NameError => e
+            assert e.message =~ /KnownConstant/, e.message
+            expected = "test_kernel.rb:160"
+            assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking constant resolution: #{e.backtrace[0]}, expected #{expected}"
+        end
+
+        begin
+            dsl_exec(obj, [Mod], false, &DSL_EXEC_BLOCK)
+            flunk("did not raise NoMethodError for unknown_method")
+        rescue NoMethodError => e
+            assert e.message =~ /unknown_method/
+            expected = "test_kernel.rb:168"
+            assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking method resolution: #{e.backtrace[0]}, expected #{expected}"
+        end
+
+        # instance_methods returns strings on 1.8 and symbols on 1.9. Conver
+        # to strings to have the right assertion on both
+        methods = Mod::Submod::Klass.instance_methods(false).map(&:to_s)
+        assert(methods.include?('my_method'), "the 'class K' statement did not refer to the already defined class")
+    end
+
     Utilrb.require_ext('is_singleton?') do
 	def test_is_singleton
 	    klass = Class.new

data/test/test_module.rb

@@ -23,10 +23,20 @@ class TC_Module < Test::Unit::TestCase
         assert(k.respond_to?(:tag))
     end
 
+    Foo = 42
+
     def test_define_or_reuse
 	mod = Module.new
-	new_mod = mod.define_or_reuse(:Foo) { Module.new }
+        klass = Class.new
+
+	new_mod = mod.define_or_reuse(:Foo) { klass.new }
+        assert_kind_of(klass, new_mod)
 	assert_equal(new_mod, mod.define_or_reuse(:Foo) { flunk("block called in #define_under") })
+
+        # Now try with a constant that is widely available
+	new_mod = mod.define_or_reuse('Signal') { klass.new }
+        assert_kind_of(klass, new_mod)
+	assert_equal(new_mod, mod.define_or_reuse('Signal') { flunk("block called in #define_under") })
     end
 
     def test_define_method_with_block
@@ -93,9 +103,6 @@ class TC_Module < Test::Unit::TestCase
 	assert(object.singleton_class.respond_to?(:signatures))
 	object.singleton_class.signatures << :in_singleton
 	assert_equal([:in_singleton], object.singleton_class.signatures)
-        Utilrb.if_ext do
-            assert_equal([:in_singleton, :in_derived, :in_base], object.singleton_class.enum_for(:each_signature).to_a)
-        end
     end
 
     def check_inherited_enumerable(base, derived)
@@ -138,18 +145,12 @@ class TC_Module < Test::Unit::TestCase
             include mod
         end
         child     = Class.new(parent)
-        singleton = child.new.singleton_class
 
         assert(child.has_ancestor?(parent))
         assert(child.has_ancestor?(mod))
         assert(parent.has_ancestor?(mod))
 
-        assert(singleton.has_ancestor?(parent), singleton.superclass)
-        assert(singleton.has_ancestor?(mod))
-        assert(singleton.has_ancestor?(child))
-
         assert(!parent.has_ancestor?(child))
-        assert(!parent.has_ancestor?(singleton))
     end
 end
 

data/test/test_object.rb

@@ -55,34 +55,6 @@ class TC_Object < Test::Unit::TestCase
 	assert_same(obj1.block, obj2.block)
     end
 
-    def test_singleton_class
-	klass	= Class.new do
-	    def bla; 0 end
-	end
-
-	object	= klass.new
-
-	singleton = class << object
-	    class << self
-		def bla
-		    "a"
-		end
-	    end
-	    self
-	end
-
-	assert(! object.has_singleton?)
-	assert_equal(object, object.singleton_class.singleton_instance)
-	assert(object.has_singleton?)
-	assert_equal(klass, object.singleton_class.superclass)
-
-
-        Utilrb.if_ext do
-            assert_equal([object.singleton_class, klass, Object], object.singleton_class.ancestors[0, 3])
-            assert_equal([klass, Object], klass.ancestors[0, 2])
-        end
-    end
-
     def test_attr_predicate
 	klass = Class.new do
 	    attr_predicate :working