utilrb 3.0.1 → 3.2.0

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/marshal.rb

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

data/lib/utilrb/module/dsl_attribute.rb

@@ -1,10 +1,13 @@
-class Module
+# frozen_string_literal: true
+
+class Module # rubocop:disable Style/Documentation
     # call-seq:
     #   dsl_attribute(name)
     #   dsl_attribute(name,name2,name3)
     #   dsl_attribute(name) { |value| ... }
     #
-    # This defines a +name+ instance method on the given class which accepts zero or one argument
+    # This defines a +name+ instance method on the given class which accepts
+    # zero or one argument
     #
     # Without any argument, it acts as a getter for the +@name+ attribute. With
     # one argument, it acts instead as a setter for the same attribute and
@@ -13,8 +16,8 @@ class Module
     # instance variable.  This block can therefore both filter the value
     # (convert it to a desired form) and validate it.
     #
-    # The goal of this method is to have a nicer way to handle attribute in DSLs: instead
-    # of 
+    # The goal of this method is to have a nicer way to handle attribute in
+    # DSLs: instead of
     #
     #    model = create_model do
     #	    self.my_model_attribute = 'bla'
@@ -35,37 +38,46 @@ class Module
     #	 end
     #
     def dsl_attribute(*names, &filter_block)
-        if names.size > 1 && filter_block
-            raise ArgumentError, "multiple names as argument are only supported if no block is given"
+        if names.size > 1
+            if filter_block
+                raise ArgumentError,
+                      "multiple names as argument are only supported if no block is given"
+            end
+
+            names.each { |name| dsl_attribute(name) }
+            return
         end
-        names.each do |name|
-	class_eval do
+
+        name = names.first
+
+        class_eval do
             if filter_block
                 define_method("__dsl_attribute__#{name}__filter__", &filter_block)
             end
 
-	    define_method(name) do |*value|
-		if value.empty?
-		    instance_variable_get("@#{name}")
-		elsif filter_block
-                    if filter_block.arity >= 0 && value.size != filter_block.arity
-                        raise ArgumentError, "too many arguments. Got #{value.size}, expected #{filter_block.arity}"
-                    end
-
-		    filtered_value = send("__dsl_attribute__#{name}__filter__", *value)
-		    instance_variable_set("@#{name}", filtered_value)
-		    self
-		else
+            define_method(name) do |*value, **kw|
+                if value.empty? && kw.empty?
+                    instance_variable_get("@#{name}")
+                elsif filter_block
+                    # Ruby 2.7 madness. The second version would pass {} as
+                    # second argument
+                    filtered_value =
+                        if kw.empty?
+                            send("__dsl_attribute__#{name}__filter__", *value)
+                        else
+                            send("__dsl_attribute__#{name}__filter__", *value, **kw)
+                        end
+                    instance_variable_set("@#{name}", filtered_value)
+                    self
+                else
                     if value.size == 1
                         instance_variable_set("@#{name}", value.first)
                     else
                         instance_variable_set("@#{name}", value)
                     end
-		    self
-		end
-	    end
-	end
+                    self
+                end
+            end
         end
     end
 end
-

data/lib/utilrb/object/address.rb

@@ -1,8 +1,20 @@
 
 class Object
-    # Return the object address (for non immediate
-    # objects). 
-    def address; Object.address_from_id(object_id) end
+    if RUBY_VERSION < "2.7.0"
+        # Return the object address (for non immediate
+        # objects).
+        def address
+            Object.address_from_id(object_id)
+        end
+    else
+        BUILTIN_OBJECT_TO_S = Object.instance_method(:to_s)
+        def address
+            to_s = BUILTIN_OBJECT_TO_S.bind(self).call
+            if (m = /:(0x[0-9a-f]+)/.match(to_s))
+                Integer(m[1])
+            end
+        end
+    end
 
     # Converts the object_id of a non-immediate object
     # to its memory address

data/lib/utilrb/object/attribute.rb

@@ -27,6 +27,8 @@ class Object
         class_eval <<-EOD, __FILE__, __LINE__+1
         def #{name}
             if instance_variable_defined?(:@#{name}) then @#{name}
+            elsif frozen?
+                #{name}_defval
             else @#{name} = #{name}_defval
             end
         end
@@ -40,4 +42,3 @@ class Object
 	singleton_class.class_eval { attribute(attr_def, &init) }
     end
 end
-