utilrb 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30f3b27613076cc9f327bccee358f2bc55bcd826
-  data.tar.gz: ef980585fef480c37de10056afec1bd714df4683
+  metadata.gz: dfc6c628c67691e4051455e910ea27774e48d1f8
+  data.tar.gz: 3985cf51ce618e65f82a503ec1d3708a76986c0d
 SHA512:
-  metadata.gz: df1fab4bfabbe73e7d657a7564022042d3f16c84293474ed441c1c9b1452481c2393aa76d38b820a398731fc605aa5d0a8ea6e30c089b7ef3b2ca2279145bbd2
-  data.tar.gz: 1efd86909aff5ea2802c1ff9a04db0e5eb052cbed3412858d1d051245b47baf82d329a200102318e8067396f1175f319247062942bd4bab4d22a72818ac06408
+  metadata.gz: 7c0826bbdc14832b30ee1f08585b04f8ae203bcaca23eebf9b2a8441e2c63599a12e8d9a774c673b01652530f0aff811162dc21840cc3aed36d5950878a70243
+  data.tar.gz: 7a2e844418cc195a2515bb2575f684ed4d264c481a2ed19713e688c7ada8802d06c85feca9b30009e1579b012f87920d444a366487dc1ccb0d0915e19636d95b

data/.travis.yml

@@ -1,9 +1,11 @@
 sudo: false
+dist: trusty
 language: ruby
 rvm:
   - 2.0.0
-  - 2.1.6
-  - 2.2.2
+  - 2.1.9
+  - 2.2.5
+  - 2.3.1
 script:
     - bundle exec rake
     - bundle exec rake test

data/lib/utilrb/kernel/arity.rb

@@ -1,15 +1,20 @@
 module Kernel
     # Raises if +object+ can accept calls with exactly +arity+ arguments. 
     # object should respond to #arity
-    def check_arity(object, arity)
-        if object.respond_to?(:lambda?) # For ruby 1.9 compatibility on blocks without arguments
-            if !object.lambda? && object.arity == 0
-                return
+    def check_arity(object, arity, strict: nil)
+        if strict.nil?
+            if object.respond_to?(:lambda?)
+                strict = object.lambda?
+            else strict = true
             end
         end
 
-        unless object.arity == arity || (object.arity < 0 && object.arity > - arity - 2)
-            raise ArgumentError, "#{object} does not accept to be called with #{arity} argument(s)", caller(2)
+        if strict
+            if object.arity >= 0 && object.arity != arity
+                raise ArgumentError, "#{object} requests #{object.arity} arguments, but #{arity} was requested"
+            elsif -object.arity-1 > arity
+                raise ArgumentError, "#{object} requests at least #{object.arity} arguments, but #{arity} was requested"
+            end
         end
     end
 end

data/lib/utilrb/kernel/load_dsl_file.rb

@@ -116,13 +116,13 @@ module Kernel
     # The caller of this method should call it at the end of its definition
     # file, or the translation method may not be robust at all
     def eval_dsl_file(file, proxied_object, context, full_backtrace, *exceptions, &block)
+        file = File.expand_path(file)
         if !File.readable?(file)
             raise ArgumentError, "#{file} does not exist"
         end
 
-        loaded_file = file.gsub(/^#{Regexp.quote(Dir.pwd)}\//, '')
         file_content = File.read(file)
-        eval_dsl_file_content(loaded_file, file_content, proxied_object, context, full_backtrace, *exceptions, &block)
+        eval_dsl_file_content(file, file_content, proxied_object, context, full_backtrace, *exceptions, &block)
     end
 
     # Same than eval_dsl_file, but will not load the same file twice

data/lib/utilrb/logger/forward.rb

@@ -15,6 +15,16 @@ class Logger
             EOF
         end
 
+        # The logger level
+        def log_level
+            logger.level
+        end
+
+        # Sets the logger's level
+        def log_level=(level)
+            logger.level = level
+        end
+
         # Forwarded to {Logger#silent}
         def log_silent(&block)
             logger.silent(&block)

data/lib/utilrb/logger/hierarchy.rb

@@ -2,6 +2,7 @@ require 'facets/module/spacename'
 require 'facets/kernel/constant'
 require 'utilrb/object/attribute'
 require 'utilrb/logger/forward'
+require 'weakref'
 
 class Logger
     module HierarchyElement
@@ -23,13 +24,30 @@ class Logger
             self.logger = new_logger
         end
 
+        def register_log_child(child)
+            log_children << WeakRef.new(child)
+        end
+
+        def each_log_child
+            return enum_for(__method__) if !block_given?
+
+            log_children.delete_if do |ref|
+                begin
+                    yield(ref.__getobj__)
+                    false
+                rescue WeakRef::RefError
+                    true
+                end
+            end
+        end
+
         # Allows to change the logger object at this level of the hierarchy
         #
         # This is usually not used directly: a new logger can be created with
         # Hierarchy#make_own_logger and removed with Hierarchy#reset_own_logger
         def logger=(new_logger)
             @logger = new_logger
-            log_children.each do |child|
+            each_log_child do |child|
                 child.reset_default_logger
             end
         end
@@ -38,14 +56,14 @@ class Logger
         # logging methods will now access the parent's module logger.
         def reset_own_logger
             @logger = nil
-            log_children.each do |child|
+            each_log_child do |child|
                 child.reset_default_logger
             end
         end
 
         def reset_default_logger
             @__utilrb_hierarchy__default_logger = nil
-            log_children.each do |child|
+            each_log_child do |child|
                 child.reset_default_logger
             end
         end
@@ -130,8 +148,13 @@ class Logger
                                 break
                             end
                         end
+
                         if m.respond_to?(:superclass)
                             m = m.superclass
+                            if m.respond_to?(:logger)
+                                parent_module = m
+                                break
+                            end
                         else
                             m = nil; break
                         end
@@ -140,8 +163,8 @@ class Logger
                     if !m
                         raise NoParentLogger, "cannot find a logger for #{self}"
                     end
-                    if parent_module.respond_to? :log_children
-                        parent_module.log_children << self
+                    if parent_module.respond_to? :register_log_child
+                        parent_module.register_log_child(self)
                     end
                     parent_module.logger
                 else

data/lib/utilrb/logger/root.rb

@@ -1,19 +1,19 @@
 require 'utilrb/logger/hierarchy'
+
 class Logger
-    HAS_COLOR =
+    LEVEL_TO_COLOR =
         begin
-            require 'highline'
-            @console = HighLine.new
+            require 'pastel'
+            colorizer = Pastel.new
+            { 'DEBUG' => ->(t) { t },
+              'INFO' =>  ->(t) { t },
+              'WARN' =>  colorizer.magenta.detach,
+              'ERROR' => colorizer.red.detach,
+              'FATAL' => colorizer.red.bold.detach }
         rescue LoadError
+            Hash.new
         end
 
-    LEVEL_TO_COLOR =
-        { 'DEBUG' => [],
-          'INFO' => [],
-          'WARN' => [:magenta],
-          'ERROR' => [:red],
-          'FATAL' => [:red, :bold] }
-
     # Defines a logger on a module, allowing to use that module as a root in a
     # hierarchy (i.e. having submodules use the Logger::Hierarchy support)
     #
@@ -56,9 +56,9 @@ class Logger
         console = @console
         formatter =
             if block then lambda(&block)
-            elsif HAS_COLOR
+            elsif !LEVEL_TO_COLOR.empty?
                 lambda do |severity, time, name, msg|
-                    console.color("#{name}[#{severity}]: #{msg}\n", *LEVEL_TO_COLOR[severity])
+                    LEVEL_TO_COLOR[severity].call("#{name}[#{severity}]: #{msg}\n")
                 end
             else lambda { |severity, time, name, msg| "#{name}[#{severity}]: #{msg}\n" }
             end

data/lib/utilrb/marshal.rb

@@ -0,0 +1,3 @@
+require 'utilrb/kernel/require'
+require_dir(__FILE__)
+

data/lib/utilrb/marshal/load_with_missing_constants.rb

@@ -1,26 +1,32 @@
 module Marshal
-    if defined? BasicObject
-        class BlackHole < BasicObject
-        end
-    end
-
     class BlackHole
         class << self
-            :name
+            attr_reader :name
         end
 
         def initialize(*args)
         end
 
+        def hash
+            __id__
+        end
+
+        def eql?(obj)
+            equal?(obj)
+        end
+
         attr_reader :__content__
         def method_missing(*args)
+            ::Kernel.puts args.inspect
+            ::Kernel.puts ::Kernel.caller
         end
         def self._load(*args)
             hole = BlackHole.new
             hole.instance_variable_set(:@__content__, args)
         end
 
-        def self.method_missing(*args)
+        def self.method_missing(*args, **options)
+            BlackHole.new
         end
     end
 
@@ -32,20 +38,11 @@ module Marshal
         self.load(str_or_io)
     rescue Exception => e
         case e.message
-        when /undefined class\/module ((?:\w+::)+)$/
-            names = $1.split('::')
-            missing = names.pop
-            base = names.inject(Object) { |m, n| m.const_get(n) }
-            base.const_set(missing, Module.new)
-
-            if original_pos
-                str_or_io.seek(original_pos)
-            end
-            retry
-        when /undefined class\/module ((?:\w+::)+)(\w+)$/
-            mod, klass   = $1, $2
-            full_name = "#{mod}#{klass}"
-            mod = mod.split('::').inject(Object) { |m, n| m.const_get(n) }
+        when /undefined class\/module ((?:\w+)(?:::\w+)*)(?:::)?$/
+            full_name = $1
+            path = $1.split('::')
+            *path, klass = *path
+            mod = path.inject(Object) { |m, n| m.const_get(n) }
 
             blackhole = Class.new(BlackHole) do
                 @name = full_name

data/lib/utilrb/pkgconfig.rb

@@ -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,41 @@ 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)
+            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 = Array.new
-                paths.each do |p|
-                    candidates << PkgConfig.load(p, preset_variables)
-                end
-                loaded_packages[name] = candidates
+            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)
+                match
             else
                 raise NotFound, "found #{candidates.size} packages for #{name}, but none match the version specification #{version_spec}"
             end
+
+            if !minimal
+                match.load_fields
+            end
+            match
         end
 
         # Finds the provided package and optional version and returns its
@@ -140,7 +144,6 @@ module Utilrb
         end
 
 
-        attr_reader :file
         attr_reader :path
 	
 	# The module name
@@ -151,10 +154,17 @@ module Utilrb
         # 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
 
+        # 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)
@@ -169,7 +179,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
@@ -211,16 +221,23 @@ module Utilrb
 
         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?
@@ -240,54 +257,90 @@ module Utilrb
             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
-
-            # 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)
+            variables
+        end
+        
+        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 load_variables(path, preset_variables = Hash.new)
+            raw_variables, raw_fields = parse(path)
+            raw_variables = preset_variables.merge(raw_variables)
+            expand_variables(raw_variables)
+        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)
+            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
+            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
@@ -326,6 +379,14 @@ module Utilrb
             end
         end
 
+        # 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)
@@ -346,7 +407,7 @@ 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
@@ -356,7 +417,7 @@ module Utilrb
         # 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
@@ -371,18 +432,27 @@ module Utilrb
             @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,20 +461,38 @@ 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:
@@ -415,17 +503,22 @@ module Utilrb
 	    end
 	end
 
-        def self.each_pkgconfig_directory(&block)
-            if path = ENV['PKG_CONFIG_PATH']
-                path.split(':').each(&block)
+        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?
+            if pkg_config_path
+                pkg_config_path.split(':').each(&block)
             end
             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 +527,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 +538,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)

data/lib/utilrb/test.rb

@@ -4,10 +4,10 @@ if ENV['TEST_ENABLE_COVERAGE'] != '0'
     begin
         require 'simplecov'
         require 'coveralls'
-        SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-            SimpleCov::Formatter::HTMLFormatter,
-            Coveralls::SimpleCov::Formatter
-        ]
+        SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+            [SimpleCov::Formatter::HTMLFormatter,
+             Coveralls::SimpleCov::Formatter]
+        )
         SimpleCov.start do
             add_filter "/test/"
         end

data/lib/utilrb/timepoints.rb

@@ -15,8 +15,15 @@ module Utilrb
         end
 
         def format_timepoints
+            start_points = Hash.new
             result = []
             @timepoints.inject(@timepoints.first.first) do |last_t, (t, name)|
+                if name.last == 'start'
+                    start_points[name[0..-2]] = t
+                elsif name.last == 'done'
+                    total = t - start_points.delete(name[0..-2])
+                    name = name + ["total=%.3f" % total]
+                end
                 result << name + [t - last_t]
                 t
             end

data/lib/utilrb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: utilrb
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-09 00:00:00.000000000 Z
+date: 2018-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facets
@@ -152,6 +152,7 @@ files:
 - lib/utilrb/logger/log_pp.rb
 - lib/utilrb/logger/root.rb
 - lib/utilrb/logger/silent.rb
+- lib/utilrb/marshal.rb
 - lib/utilrb/marshal/load_with_missing_constants.rb
 - lib/utilrb/module.rb
 - lib/utilrb/module/ancestor_p.rb