raap 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94f0ec4ff924c5089f8e307002dd5f3cd778f04e686acd8b46466139c3c1aebd
-  data.tar.gz: e9a06fb3c71cfc6cd605031fe8cb899a123dc82a94ef00586d39e8329c45beac
+  metadata.gz: 5780226ede8755c1ef7f82e18b7e8d96a63d2ab6eb253bc8964f5745776f993f
+  data.tar.gz: 6e9dd39a302f555cac12ecb6232a7c2f39d206911fcee7a30650d5fe4a9cbc63
 SHA512:
-  metadata.gz: ed0d647fefa8591c0a03981232c84d64bf7c70bcf9207d2dd6471a9f3369747b5dd3adcc3cd60a8e1d65f0e1543ed7a5f5108eef6523c7d306cfc399d0bc63e4
-  data.tar.gz: 537c5dfbb65bb12064e46c47fb75a60321ee0f16296f1272ef27d68927f4f9f3d5875ea6f3ac2225c76a2d274fbe393bff20f573b8d138b52a6ced8027528e1f
+  metadata.gz: 2841e75bc0b03742cc0d9268f9ec2ae69f2f9c6e1f579ec6e794db5e9b8f80d763fac4ce28abd7361e19ada8f6289e594b6a9a3cdc63b1806181a69a9f49bb6a
+  data.tar.gz: a3057811c5d13ac4f891fc2c2082b91f33a1a8d35d3c9b6e1ccb1871c268127811caa6f2708c878ef35ae4cc25143db62c4e5801ded32cfad9a1db50387753a6

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.3
+  TargetRubyVersion: 3.0
   NewCops: enable
   Include:
   - 'lib/**/*.rb'

data/README.md

@@ -70,7 +70,7 @@ $ raap 'MyClass'                  # Run only RBS of MyClass
 $ raap 'MyClass::*'               # Run each class under MyClass
 $ raap 'MyClass.singleton_method' # Run only MyClass.singleton_method
 $ raap 'MyClass#instance_method'  # Run only MyClass#instance_method
-$ raap 'MyClass' '!MyClass#skip'  # Run method MyClass without #skip
+$ raap 'MyClass' '!MyClass#skip'  # Run methods MyClass without #skip
 ```
 
 ```
@@ -81,6 +81,13 @@ MyClass
 $ raap $(cat test/raap.txt)   # You can manage the methods to be tested in a file
 ```
 
+## Log level definition
+
+- error: Information on status of inability to continue execution.
+- warn: Information on partial corrections required.
+- info: A somewhat visualized representation of the execution state.
+- debug: All information including stack traces.
+
 ## Size
 
 Random values are determined based on size.

data/Rakefile

@@ -4,7 +4,9 @@ require "bundler/gem_tasks"
 require "minitest/test_task"
 require "rubocop/rake_task"
 
-Minitest::TestTask.create
+Minitest::TestTask.create do |t|
+  t.test_prelude = 'require "test/test_helper"'
+end
 
 RuboCop::RakeTask.new
 

data/lib/raap/cli.rb

@@ -104,7 +104,7 @@ module RaaP
 
       # Search skip tag
       @argv.each do |tag|
-        if tag.start_with?('!') && (tag.include?('#') || tag.include?('.'))
+        if tag.start_with?('!')
           t = tag[1..] or raise
           t = "::#{t}" unless t.start_with?('::')
           t or raise
@@ -118,13 +118,13 @@ module RaaP
 
         case
         when tag.include?('#')
-          run_by(kind: :instance, tag:)
+          run_by(kind: :instance, tag: tag)
         when tag.include?('.')
-          run_by(kind: :singleton, tag:)
+          run_by(kind: :singleton, tag: tag)
         when tag.end_with?('*')
-          run_by_type_name_with_search(tag:)
+          run_by_type_name_with_search(tag: tag)
         else
-          run_by_type_name(tag:)
+          run_by_type_name(tag: tag)
         end
       end
 
@@ -198,9 +198,10 @@ module RaaP
 
       RaaP.logger.info("# #{type}")
       @results << {
-        method:,
+        method: method,
         properties: method.method_types.map do |method_type|
-          property(receiver_type:, type_params_decl:, type_args:, method_type:, method_name:)
+          property(receiver_type: receiver_type, type_params_decl: type_params_decl, type_args: type_args, method_type: method_type,
+                   method_name: method_name)
         end
       }
     end
@@ -238,9 +239,10 @@ module RaaP
 
         RaaP.logger.info("# #{type_name}.#{method_name}")
         @results << {
-          method:,
+          method: method,
           properties: method.method_types.map do |method_type|
-            property(receiver_type: Type.new("singleton(#{type.name})"), type_params_decl:, type_args:, method_type:, method_name:)
+            property(receiver_type: Type.new("singleton(#{type.name})"), type_params_decl: type_params_decl, type_args: type_args,
+                     method_type: method_type, method_name: method_name)
           end
         }
       end
@@ -257,9 +259,10 @@ module RaaP
 
         RaaP.logger.info("# #{type_name}##{method_name}")
         @results << {
-          method:,
+          method: method,
           properties: method.method_types.map do |method_type|
-            property(receiver_type: Type.new(type.name), type_params_decl:, type_args:, method_type:, method_name:)
+            property(receiver_type: Type.new(type.name), type_params_decl: type_params_decl, type_args: type_args, method_type: method_type,
+                     method_name: method_name)
           end
         }
       end
@@ -283,12 +286,12 @@ module RaaP
       status = 0
       reason = nil
       prop = MethodProperty.new(
-        receiver_type:,
-        method_name:,
+        receiver_type: receiver_type,
+        method_name: method_name,
         method_type: MethodType.new(
           method_type,
-          type_params_decl:,
-          type_args:,
+          type_params_decl: type_params_decl,
+          type_args: type_args,
           self_type: rtype,
           instance_type: ::RBS::Types::ClassInstance.new(name: rtype.name, args: type_args, location: nil),
           class_type: ::RBS::Types::ClassSingleton.new(name: rtype.name, location: nil),

data/lib/raap/function_type.rb

@@ -7,12 +7,12 @@ module RaaP
     end
 
     def pick_arguments(size: 10)
-      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
+      SymbolicCaller.new(arguments_to_symbolic_call(size: size)).eval
     end
 
     def arguments_to_symbolic_call(size: 10)
-      a = to_symbolic_call_recursive(build_args_type, size:)
-      k = to_symbolic_call_recursive(build_kwargs_type, size:)
+      a = to_symbolic_call_recursive(build_args_type, size: size)
+      k = to_symbolic_call_recursive(build_kwargs_type, size: size)
 
       [a, k]
     end
@@ -24,11 +24,11 @@ module RaaP
       when type.nil?
         nil
       when type.respond_to?(:each_pair)
-        type.each_pair.to_h { |k, v| [k, to_symbolic_call_recursive(v, size:)] }
+        type.each_pair.to_h { |k, v| [k, to_symbolic_call_recursive(v, size: size)] }
       when type.respond_to?(:each)
-        type.each.map { |v| to_symbolic_call_recursive(v, size:) }
+        type.each.map { |v| to_symbolic_call_recursive(v, size: size) }
       else
-        type.to_symbolic_call(size:)
+        type.to_symbolic_call(size: size)
       end
     end
 

data/lib/raap/method_property.rb

@@ -2,7 +2,7 @@
 
 module RaaP
   class MethodProperty
-    class Stats < Struct.new(:success, :skip, :exception, :break)
+    class Stats < Struct.new(:success, :skip, :exception, :break, keyword_init: true)
       def initialize(success: 0, skip: 0, exception: 0, break: false)
         super
       end
@@ -23,7 +23,7 @@ module RaaP
         Timeout.timeout(@timeout) do
           catch(:break) do
             @size_step.each do |size|
-              call(size:, stats:).tap do |ret|
+              call(size: size, stats: stats).tap do |ret|
                 case ret
                 when Result::Success
                   stats.success += 1
@@ -55,8 +55,8 @@ module RaaP
         stats.break = true
         throw :break
       end
-      receiver_value = @receiver_type.to_symbolic_call(size:)
-      args, kwargs, block = @method_type.arguments_to_symbolic_call(size:)
+      receiver_value = @receiver_type.to_symbolic_call(size: size)
+      args, kwargs, block = @method_type.arguments_to_symbolic_call(size: size)
       # @type var symbolic_call: symbolic_call
       symbolic_call = [:call, receiver_value, @method_name, args, kwargs, block]
       symbolic_caller = SymbolicCaller.new(symbolic_call, allow_private: @allow_private)
@@ -77,25 +77,25 @@ module RaaP
           end
         else
           return_value = symbolic_caller.eval
-          check = check_return(receiver_value:, return_value:)
+          check = check_return(receiver_value: receiver_value, return_value: return_value)
         end
         case check
         in [:success]
-          Result::Success.new(symbolic_call:, return_value:)
+          Result::Success.new(symbolic_call: symbolic_call, return_value: return_value)
         in [:failure]
-          Result::Failure.new(symbolic_call:, return_value:)
+          Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value)
         in [:exception, exception]
-          Result::Exception.new(symbolic_call:, exception:)
+          Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
         end
       rescue TypeError => exception
-        Result::Failure.new(symbolic_call:, return_value:, exception:)
+        Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value, exception: exception)
       end
 
     # not ensure symbolic_call
     rescue NoMethodError, NotImplementedError => exception
-      Result::Skip.new(symbolic_call:, exception:)
+      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
     rescue NameError => e
-      RaaP.logger.error("[#{e.class}] #{e.detailed_message}")
+      RaaP.logger.warn("[#{e.class}] #{e.detailed_message}")
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
       RaaP.logger.warn("Implementation is not found #{msg} maybe.")
       RaaP.logger.debug(e.backtrace&.join("\n"))
@@ -103,9 +103,9 @@ module RaaP
       throw :break
     rescue SystemStackError => exception
       RaaP.logger.info "Found recursive type definition."
-      Result::Skip.new(symbolic_call:, exception:)
+      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
     rescue => exception
-      Result::Exception.new(symbolic_call:, exception:)
+      Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
     end
 
     def check_return(receiver_value:, return_value:)
@@ -126,8 +126,8 @@ module RaaP
         instance_class = BindCall.class(receiver_value)
       end
       type_check = ::RBS::Test::TypeCheck.new(
-        self_class:,
-        instance_class:,
+        self_class: self_class,
+        instance_class: instance_class,
         class_class: Module,
         builder: RBS.builder,
         sample_size: 100,

data/lib/raap/method_type.rb

@@ -20,17 +20,17 @@ module RaaP
       params = (type_params_decl + rbs.type_params).uniq
       ts = TypeSubstitution.new(params, type_args)
 
-      @rbs = ts.method_type_sub(rbs, self_type:, instance_type:, class_type:)
+      @rbs = ts.method_type_sub(rbs, self_type: self_type, instance_type: instance_type, class_type: class_type)
       @fun_type = FunctionType.new(@rbs.type)
     end
 
     def pick_arguments(size: 10)
-      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
+      SymbolicCaller.new(arguments_to_symbolic_call(size: size)).eval
     end
 
     def arguments_to_symbolic_call(size: 10)
-      args, kwargs = @fun_type.arguments_to_symbolic_call(size:)
-      block = pick_block(size:)
+      args, kwargs = @fun_type.arguments_to_symbolic_call(size: size)
+      block = pick_block(size: size)
 
       [args, kwargs, block]
     end
@@ -40,7 +40,7 @@ module RaaP
       return nil if block.nil?
       return nil if (block.required == false) && [true, false].sample
 
-      fixed_return_value = Type.new(block.type.return_type).pick(size:)
+      fixed_return_value = Type.new(block.type.return_type).pick(size: size)
       Proc.new { fixed_return_value }
     end
 

data/lib/raap/minitest.rb

@@ -13,7 +13,7 @@ module RaaP
         method_type = RaaP::MethodType.new(type)
         size_step.each do |size|
           # TODO assert_send_type
-          args, kwargs, _block = method_type.pick_arguments(size:)
+          args, kwargs, _block = method_type.pick_arguments(size: size)
           return_value = yield(*args, **kwargs)
           i = BindCall.inspect(return_value)
           c = BindCall.class(return_value)
@@ -30,7 +30,7 @@ module RaaP
           end
         end
         size_step.each do |size|
-          values = types.map { |t| t.pick(size:) }
+          values = types.map { |t| t.pick(size: size) }
           assert yield(*values)
         end
       end

data/lib/raap/symbolic_caller.rb

@@ -121,8 +121,8 @@ module RaaP
       symbolic_call
     end
 
-    def walk(&)
-      _walk(@symbolic_call, true, &)
+    def walk(&block)
+      _walk(@symbolic_call, true, &block)
     end
 
     def _walk(symbolic_call, is_last, &block)

data/lib/raap/type.rb

@@ -52,21 +52,21 @@ module RaaP
         method_type = MethodType.new(maped_rbs_method_type)
 
         begin
-          args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
+          args, kwargs, block = method_type.arguments_to_symbolic_call(size: size)
           [:call, base, :new, args, kwargs, block]
         rescue
           $stderr.puts "Fail with `#{rbs_method_type}`"
           raise
         end
       else
-        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
+        [:call, Value::Module, :new, [type.to_s], { size: size }, nil]
       end
     end
 
     # Special class case
     register("::Array") do
       instance = __skip__ = type
-      t = instance.args[0] ? Type.new(instance.args[0], range:) : Type.random
+      t = instance.args[0] ? Type.new(instance.args[0], range: range) : Type.random
       array(t)
     end
     register("::Binding") { sized { binding } }
@@ -87,7 +87,7 @@ module RaaP
     register("::NilClass") { sized { nil } }
     register("::Proc") { sized { Proc.new {} } }
     register("::Rational") { rational }
-    register("::Regexp") { sized { |size| Regexp.new(string.pick(size:)) } }
+    register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
     register("::String") { string }
     register("::Struct") { sized { Struct.new(:foo, :bar).new } }
     register("::Symbol") { symbol }
@@ -118,11 +118,11 @@ module RaaP
     end
 
     def pick(size: 10)
-      to_symbolic_caller(size:).eval
+      to_symbolic_caller(size: size).eval
     end
 
     def to_symbolic_caller(size: 10)
-      SymbolicCaller.new(to_symbolic_call(size:))
+      SymbolicCaller.new(to_symbolic_call(size: size))
     end
 
     def to_symbolic_call(size: 10)
@@ -131,20 +131,20 @@ module RaaP
 
       case type
       when ::RBS::Types::Tuple
-        type.types.map { |t| Type.new(t).to_symbolic_call(size:) }
+        type.types.map { |t| Type.new(t).to_symbolic_call(size: size) }
       when ::RBS::Types::Union
-        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size:) }
+        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size: size) }
       when ::RBS::Types::Intersection
         if type.free_variables.empty?
-          [:call, Value::Intersection, :new, [type.to_s], { size: }, nil]
+          [:call, Value::Intersection, :new, [type.to_s], { size: size }, nil]
         else
-          [:call, Value::Intersection, :new, [type], { size: }, nil]
+          [:call, Value::Intersection, :new, [type], { size: size }, nil]
         end
       when ::RBS::Types::Interface
         if type.free_variables.empty?
-          [:call, Value::Interface, :new, [type.to_s], { size: }, nil]
+          [:call, Value::Interface, :new, [type.to_s], { size: size }, nil]
         else
-          [:call, Value::Interface, :new, [type], { size: }, nil]
+          [:call, Value::Interface, :new, [type], { size: size }, nil]
         end
       when ::RBS::Types::Variable
         [:call, Value::Variable, :new, [type.to_s], {}, nil]
@@ -162,7 +162,7 @@ module RaaP
       when ::RBS::Types::Alias
         case gen = GENERATORS[type.name.absolute!.to_s]
         in Proc then instance_exec(&gen)
-        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size:)
+        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size: size)
         end
       when ::RBS::Types::Bases::Class
         RaaP.logger.warn("Unresolved `class` type, use Object instead.")
@@ -176,19 +176,19 @@ module RaaP
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
         case gen = GENERATORS[type.name.absolute!.to_s]
-        in Proc then instance_exec(&gen).pick(size:)
-        in nil then to_symbolic_call_from_initialize(type, size:)
+        in Proc then instance_exec(&gen).pick(size: size)
+        in nil then to_symbolic_call_from_initialize(type, size: size)
         end
       when ::RBS::Types::Record
         type.fields.transform_values { |t| Type.new(t).to_symbolic_call(size: size / 2) }
       when ::RBS::Types::Proc
-        Proc.new { Type.new(type.type.return_type).to_symbolic_call(size:) }
+        Proc.new { Type.new(type.type.return_type).to_symbolic_call(size: size) }
       when ::RBS::Types::Literal
         type.literal
       when ::RBS::Types::Bases::Bool
-        bool.pick(size:)
+        bool.pick(size: size)
       when ::RBS::Types::Bases::Any
-        Type.random.to_symbolic_call(size:)
+        Type.random.to_symbolic_call(size: size)
       when ::RBS::Types::Bases::Nil
         nil
       else
@@ -201,7 +201,7 @@ module RaaP
     def to_symbolic_call_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
-      Type.call_new_from(const, type, size:)
+      Type.call_new_from(const, type, size: size)
     end
 
     def parse(type)
@@ -216,7 +216,7 @@ module RaaP
     end
 
     def integer
-      sized { |size| float.pick(size:).round }
+      sized { |size| float.pick(size: size).round }
     end
 
     def none_zero_integer
@@ -240,16 +240,16 @@ module RaaP
 
     def rational
       sized do |size|
-        a = integer.pick(size:)
-        b = none_zero_integer.pick(size:)
+        a = integer.pick(size: size)
+        b = none_zero_integer.pick(size: size)
         [:call, Kernel, :Rational, [a, b], {}, nil]
       end
     end
 
     def complex
       sized do |size|
-        a = integer.pick(size:)
-        b = none_zero_integer.pick(size:)
+        a = integer.pick(size: size)
+        b = none_zero_integer.pick(size: size)
         [:call, Kernel, :Complex, [a, b], {}, nil]
       end
     end
@@ -274,13 +274,13 @@ module RaaP
 
     def symbol
       sized do |size|
-        string.pick(size:).to_sym
+        string.pick(size: size).to_sym
       end
     end
 
     def array(type)
       sized do |size|
-        Array.new(integer.pick(size:).abs) do
+        Array.new(integer.pick(size: size).abs) do
           type.to_symbolic_call(size: size / 2)
         end
       end
@@ -291,7 +291,7 @@ module RaaP
     def dict(key_type, value_type)
       sized do |size|
         csize = size / 2
-        Array.new(integer.pick(size:).abs).to_h do
+        Array.new(integer.pick(size: size).abs).to_h do
           [
             key_type.to_symbolic_call(size: csize),
             value_type.to_symbolic_call(size: csize)

data/lib/raap/type_substitution.rb

@@ -27,8 +27,8 @@ module RaaP
       sub = build
       ::RBS::MethodType.new(
         type_params: [],
-        type: method_type.type.sub(sub).then { |ty| sub(ty, self_type:, instance_type:, class_type:) },
-        block: method_type.block&.sub(sub)&.then { |bl| sub(bl, self_type:, instance_type:, class_type:) },
+        type: method_type.type.sub(sub).then { |ty| sub(ty, self_type: self_type, instance_type: instance_type, class_type: class_type) },
+        block: method_type.block&.sub(sub)&.then { |bl| sub(bl, self_type: self_type, instance_type: instance_type, class_type: class_type) },
         location: method_type.location
       )
     end
@@ -49,7 +49,7 @@ module RaaP
         when ::RBS::Types::Bases::Class
           class_type || ty
         else
-          sub(ty, self_type:, instance_type:, class_type:)
+          sub(ty, self_type: self_type, instance_type: instance_type, class_type: class_type)
         end
       end
     end

data/lib/raap/value/interface.rb

@@ -20,14 +20,14 @@ module RaaP
             method_type = method.method_types.sample or ::Kernel.raise
             type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
             ts = TypeSubstitution.new(type_params, type.args)
-            subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
+            subed_method_type = ts.method_type_sub(method_type, self_type: self_type, instance_type: instance_type, class_type: class_type)
 
             BindCall.define_method(base_class, name) do |*_, &b|
               @fixed_return_value ||= {}
               @fixed_return_value[name] ||= if self_type == subed_method_type.type.return_type
                                               self
                                             else
-                                              Type.new(subed_method_type.type.return_type).pick(size:)
+                                              Type.new(subed_method_type.type.return_type).pick(size: size)
                                             end
               # @type var b: Proc?
               if b
@@ -35,7 +35,7 @@ module RaaP
                 @fixed_block_arguments[name] ||= if subed_method_type.block
                                                    size.times.map do
                                                      FunctionType.new(subed_method_type.block.type)
-                                                                 .pick_arguments(size:)
+                                                                 .pick_arguments(size: size)
                                                    end
                                                  else
                                                    []
@@ -51,10 +51,10 @@ module RaaP
 
         def new(type, size: 3)
           temp_class = ::Class.new(Interface) do |c|
-            define_method_from_interface(c, type, size:)
+            define_method_from_interface(c, type, size: size)
           end
           instance = temp_class.allocate
-          instance.__send__(:initialize, type, size:)
+          instance.__send__(:initialize, type, size: size)
           instance
         end
       end

data/lib/raap/value/intersection.rb

@@ -29,11 +29,11 @@ module RaaP
           end
 
           interfaces.each do |interface|
-            Interface.define_method_from_interface(self, interface, size:)
+            Interface.define_method_from_interface(self, interface, size: size)
           end
         end
         type = ::RBS::Types::ClassInstance.new(name: TypeName(base.name), args: [], location: nil)
-        SymbolicCaller.new(Type.call_new_from(c, type, size:)).eval
+        SymbolicCaller.new(Type.call_new_from(c, type, size: size)).eval
       end
     end
   end

data/lib/raap/value/module.rb

@@ -35,7 +35,7 @@ module RaaP
                          if !ts.include?('::BasicObject') || ts.any? { |t| t.split('::').last&.start_with?('_') }
                            ts.unshift('Object')
                          end
-                         Type.new(ts.uniq.join(' & ')).pick(size:)
+                         Type.new(ts.uniq.join(' & ')).pick(size: size)
                        end
                      end
         const = ::Object.const_get(@type.name.absolute!.to_s)

data/lib/raap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaaP
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/raap.rb

@@ -9,6 +9,7 @@ require 'logger'
 
 require_relative 'raap/version'
 require_relative 'raap/value'
+require_relative 'shims'
 
 module RaaP
   class << self

data/lib/shims.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Ruby 3.2
+unless Exception.method_defined?(:detailed_message)
+  class Exception
+    alias detailed_message message
+  end
+end
+
+# Ruby 3.2
+unless defined?(Data)
+  class Data
+    class << self
+      def define(*syms)
+        _ = Class.new do |c|
+          define_method(:initialize) do |*args, **kwargs|
+            if !args.empty?
+              syms.zip(args).each do |sym, arg|
+                instance_variable_set("@#{sym}", arg)
+              end
+            end
+            if !kwargs.empty?
+              kwargs.each do |k, v|
+                instance_variable_set("@#{k}", v)
+              end
+            end
+          end
+
+          syms.each do |sym|
+            c.define_method(sym) do
+              instance_variable_get("@#{sym}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbs_collection.lock.yaml

@@ -10,7 +10,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: base64
@@ -26,7 +26,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: connection_pool
@@ -34,7 +34,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: date
@@ -54,7 +54,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: io-console
@@ -94,7 +94,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -76,6 +76,7 @@ files:
 - lib/raap/value/variable.rb
 - lib/raap/value/void.rb
 - lib/raap/version.rb
+- lib/shims.rb
 - public/jacket.webp
 - rbs_collection.lock.yaml
 - rbs_collection.yaml
@@ -94,14 +95,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: RBS as a Property