raap 0.2.0 → 0.4.0

data/sig/raap.rbs

@@ -7,7 +7,7 @@ module RaaP
 
   module BindCall
     def self.define_singleton_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
-    def self.respond_to?: (untyped, Symbol, ?bool) -> bool
+    def self.respond_to?: (untyped, untyped, ?boolish) -> bool
     def self.instance_of?: (untyped, Module) -> bool
     def self.is_a?: (untyped, Module) -> bool
     def self.extend: (untyped, Module) -> void
@@ -19,15 +19,15 @@ module RaaP
 
   class CLI
     class Option < ::Struct[untyped]
-      def self.new: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer) -> instance
+      def self.new: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?skips: ::Array[::String]) -> instance
 
-      def self.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer) -> instance
+      def self.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?skips: ::Array[::String]) -> instance
 
       def self.keyword_init?: () -> true
 
-      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private, :skips]
 
-      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private, :skips]
 
       attr_accessor dirs: ::Array[String]
 
@@ -42,35 +42,45 @@ module RaaP
       attr_accessor size_to: ::Integer
 
       attr_accessor size_by: ::Integer
+
+      attr_accessor allow_private: bool
+
+      attr_accessor skips: ::Array[String]
     end
 
+    type property_result = [Integer, Symbol, ::RBS::MethodType, StringIO?]
+
+    DEFAULT_SKIP: ::Set[String]
+
     @argv: Array[String]
+    @results:  Array[{ method: ::RBS::Definition::Method, properties: Array[property_result] }]
 
     def self.option: () -> Option
     def self.option=: (Option) -> void
 
     def initialize: (Array[String]) -> void
     def load: () -> self
+    def run: () -> Integer
 
-    type property_result = [Integer, Symbol, ::RBS::MethodType]
-    def run: () -> self
-    def run_by: (tag: String) -> Array[Array[property_result]]
-    def run_by_instance: (tag: String) -> Array[Array[property_result]]
-    def run_by_singleton: (tag: String) -> Array[Array[property_result]]
-    def run_by_type_name: (tag: String) -> Array[Array[property_result]]
-    def run_by_type_name_with_search: (tag: String) -> Array[Array[property_result]]
-    def property: (receiver_type: Type, type_params_decl: Array[::RBS::AST::TypeParam], method_name: Symbol, method_type: ::RBS::MethodType) -> property_result
+    private
+
+    def run_by: (kind: (:instance | :singleton), tag: String) -> void
+    def run_by_type_name: (tag: String) -> void
+    def run_by_type_name_with_search: (tag: String) -> void
+    def property: (receiver_type: Type, type_params_decl: Array[::RBS::AST::TypeParam], type_args: Array[::RBS::Types::t], method_name: Symbol, method_type: ::RBS::MethodType) -> property_result
+    def report: () -> Integer
   end
 
   class FunctionType
     @fun: ::RBS::Types::Function
 
     def initialize: (::RBS::Types::Function) -> void
-    def pick_arguments: (?size: Integer, ?eval: bool) -> [Array[untyped], Hash[Symbol, untyped]]
+    def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
+    def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
 
     private
 
-    def recursive_pick: (untyped, size: Integer, eval: bool) -> untyped
+    def to_symbolic_call_recursive: (untyped, size: Integer) -> untyped
     def build_args_type: () -> Array[Type]
     def build_kwargs_type: () -> Hash[Symbol, Type]
   end
@@ -80,19 +90,23 @@ module RaaP
       attr_accessor success: Integer
       attr_accessor skip: Integer
       attr_accessor exception: Integer
+      attr_accessor break: bool
     end
-    attr_reader receiver_type: Type
-    attr_reader method_name: Symbol
-    attr_reader method_type: MethodType
-    attr_reader size_step: _Each[Integer]
-    attr_reader timeout: (Integer | Float | nil)
-    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil)) -> void
+
+    @receiver_type: Type
+    @method_name: Symbol
+    @method_type: MethodType
+    @size_step: _Each[Integer]
+    @timeout: (Integer | Float | nil)
+    @allow_private: bool
+
+    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil), ?allow_private: bool) -> void
     def run: () { (Result::Success | Result::Failure | Result::Skip | Result::Exception) -> void } -> Stats
 
     private
 
     def call: (size: Integer, stats: Stats) -> (Result::Success | Result::Failure | Result::Skip | Result::Exception)
-    def check_return: (receiver_value: untyped, return_value: untyped, method_type: MethodType) -> bool
+    def check_return: (receiver_value: untyped, return_value: untyped) -> ([Symbol] | [Symbol, Exception])
     def return_type: () -> RBS::Types::t
   end
 
@@ -101,35 +115,12 @@ module RaaP
     @fun_type: FunctionType
 
     def initialize: (::RBS::MethodType | String method, ?type_params_decl: Array[untyped], ?type_args: Array[untyped], ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> void
-    def pick_arguments: (?size: Integer, ?eval: bool) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
-    def pick_block: (?size: Integer, ?eval: bool) -> ::Proc?
+    def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
+    def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
+    def pick_block: (?size: Integer) -> ::Proc?
     def check_return: (untyped) -> bool
   end
 
-  class MethodValue < Data
-    def self.new: (untyped receiver_value, [Array[untyped], Hash[Symbol, untyped], ::Proc?] arguments, Symbol method_name, Integer size) -> instance
-                | (receiver_value: untyped, arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?], method_name: Symbol, size: Integer) -> instance
-
-    def self.[]: (untyped receiver_value, [Array[untyped], Hash[Symbol, untyped], ::Proc?] arguments, Symbol method_name, Integer size) -> instance
-               | (receiver_value: untyped, arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?], method_name: Symbol, size: Integer) -> instance
-
-    def self.members: () -> [ :receiver_value, :arguments, :method_name, :size ]
-    def members: () -> [ :receiver_value, :arguments, :method_name, :size ]
-
-    attr_reader receiver_value: untyped
-    attr_reader arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?]
-    attr_reader method_name: Symbol
-    attr_reader size: Integer
-
-    def to_symbolic_call: () -> symbolic_call
-    def call_str: () -> String
-
-    private
-
-    def argument_str: () -> String
-    def block_str: () -> String?
-  end
-
   module Minitest
   end
 
@@ -142,37 +133,46 @@ module RaaP
     def self.env: () -> ::RBS::Environment
     def self.loader: () -> ::RBS::EnvironmentLoader
     def self.parse_type: (String) -> ::RBS::Types::t
+    def self.parse_method_type: (String) -> ::RBS::MethodType
+    def self.find_alias_decl: (::RBS::TypeName, Symbol) -> ::RBS::AST::Members::Alias?
   end
 
   module Result
-    interface _MethodValueReturnValue
-      def method_value: () -> MethodValue
+    interface _ReturnValue
       def return_value: () -> untyped
     end
-    module CalledStr : _MethodValueReturnValue
-      def called_str: () -> String
+
+    module ReturnValueWithType : _ReturnValue
+      def return_value_with_type: () -> String
+
+      private
+
+      def return_value_to_type: (untyped) -> String
     end
+
     class Success < Data
-      def self.new: (method_value: MethodValue, return_value: untyped) -> instance
-      attr_reader method_value: MethodValue
+      include ReturnValueWithType
+      def self.new: (symbolic_call: symbolic_call, return_value: untyped) -> instance
+      attr_reader symbolic_call: symbolic_call
       attr_reader return_value: untyped
-      include CalledStr
+      def called_str: () -> String
     end
     class Failure < Data
-      def self.new: (method_value: MethodValue, return_value: untyped, symbolic_call: symbolic_call) -> instance
-      attr_reader method_value: MethodValue
-      attr_reader return_value: untyped
+      include ReturnValueWithType
+      def self.new: (symbolic_call: symbolic_call, return_value: untyped, ?exception: ::Exception?) -> instance
       attr_reader symbolic_call: symbolic_call
-      include CalledStr
+      attr_reader return_value: untyped
+      attr_reader exception: ::Exception?
+      def called_str: () -> String
     end
     class Skip < Data
-      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
-      attr_reader method_value: MethodValue?
+      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
+      attr_reader symbolic_call: symbolic_call?
       attr_reader exception: ::Exception
     end
     class Exception < Data
-      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
-      attr_reader method_value: MethodValue?
+      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
+      attr_reader symbolic_call: symbolic_call?
       attr_reader exception: ::Exception
     end
   end
@@ -196,14 +196,18 @@ module RaaP
     end
 
     attr_reader symbolic_call: untyped
-    def initialize: (untyped) -> void
+    attr_reader allow_private: bool
+
+    def initialize: (untyped, ?allow_private: bool) -> void
     def eval: () -> untyped
-    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
+    def call_str: () -> String
     def to_lines: () -> Array[String]
 
     private
 
-    def _walk: (untyped) ?{ (symbolic_call) -> untyped} -> untyped
+    def try_eval: (untyped) -> untyped
+    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
+    def _walk: (untyped, bool is_last) ?{ (symbolic_call) -> untyped} -> untyped
     def eval_one: (symbolic_call) -> untyped
     def var_name: (Module) -> String
     def printable?: (untyped) -> bool
@@ -237,9 +241,11 @@ module RaaP
 
     GENERATORS: Hash[String, ^() -> Sized[untyped]]
     SIMPLE_SOURCE: Array[String]
-    RECURSION: Hash[String, :found | :logged]
 
     def self.register: (String) { () [self: instance] -> Sized[untyped] } -> void
+    def self.random: () -> Type
+    def self.random_without_basic_object: () -> Type
+
     attr_reader type: ::RBS::Types::t
     attr_reader range: Range[untyped]
 
@@ -250,13 +256,14 @@ module RaaP
     def such_that: () { (untyped) -> boolish } -> self
 
     # Basic API for materializing values
-    def pick: (?size: Integer, ?eval: bool) -> untyped
+    def pick: (?size: Integer) -> untyped
+    def to_symbolic_caller: (?size: Integer) -> SymbolicCaller
     def to_symbolic_call: (?size: Integer) -> untyped
     def sized: [T] () { (Integer size) -> T } -> Sized[T]
 
     private
 
-    def pick_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> (symbolic_call | Value::Module)
+    def to_symbolic_call_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> (symbolic_call | Value::Module)
     def parse: (String | ::RBS::Types::t) -> ::RBS::Types::t?
     def try: (times: Integer, size: Integer) { (Integer size) -> untyped } -> untyped
 
@@ -269,9 +276,9 @@ module RaaP
     def string: () -> Sized[String]
     def symbol: () -> Sized[Symbol]
     def array: (Type) -> Sized[Array[untyped]]
+    def dict: (Type, Type) -> Sized[Hash[untyped, untyped]]
     def encoding: () -> Sized[symbolic_call]
     def bool: () -> Sized[bool]
-    def untyped: () -> Sized[untyped]
     def temp_method_object: () -> ::Method
   end
 
@@ -285,8 +292,11 @@ module RaaP
       @type: ::RBS::Types::Interface
       @size: Integer
       @definition: ::RBS::Definition
+      @fixed_return_value: untyped
+      @fixed_block_arguments: Array[untyped]
 
-      def initialize: (String | ::RBS::Types::Interface, ?size: Integer) -> void
+      def initialize: (String | ::RBS::Types::Interface | String, ?size: Integer) -> void
+      def respond_to?: (Symbol, ?boolish) -> bool
       def inspect: () -> String
       def class: () -> class
     end
@@ -296,15 +306,19 @@ module RaaP
       @children: Array[Type]
       @size: Integer
 
-      def initialize: (::RBS::Types::Intersection, size: Integer) -> void
+      def initialize: (::RBS::Types::Intersection | String, ?size: Integer) -> void
+      def respond_to?: (Symbol, ?boolish) -> bool
       def inspect: () -> String
       def class: () -> class
     end
 
     class Module < BasicObject
-      attr_reader type: ::RBS::Types::ClassInstance
+      @type: ::RBS::Types::ClassInstance
+      @size: Integer
+      @self_type: untyped
 
-      def initialize: (::RBS::Types::ClassInstance) -> void
+      def initialize: (::RBS::Types::ClassInstance | String, ?size: Integer) -> void
+      def respond_to?: (Symbol, ?boolish) -> bool
       def inspect: () -> String
       def class: () -> class
     end
@@ -317,7 +331,7 @@ module RaaP
     class Variable < BasicObject
       attr_reader type: ::RBS::Types::Variable
 
-      def initialize: (::RBS::Types::Variable) -> void
+      def initialize: (::RBS::Types::Variable | String | Symbol) -> void
       def inspect: () -> String
       def class: () -> class
     end

data/sig/shims.rbs

@@ -0,0 +1,4 @@
+module Timeout
+  class ExitException < Exception
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-23 00:00:00.000000000 Z
+date: 2024-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -28,16 +28,16 @@ dependencies:
   name: timeout
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
 description: Property based testing tool with RBS
 email:
 - co000ri@gmail.com
@@ -46,6 +46,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
@@ -59,7 +60,6 @@ files:
 - lib/raap/function_type.rb
 - lib/raap/method_property.rb
 - lib/raap/method_type.rb
-- lib/raap/method_value.rb
 - lib/raap/minitest.rb
 - lib/raap/rbs.rb
 - lib/raap/result.rb
@@ -76,16 +76,16 @@ files:
 - lib/raap/value/variable.rb
 - lib/raap/value/void.rb
 - lib/raap/version.rb
+- public/jacket.webp
 - rbs_collection.lock.yaml
 - rbs_collection.yaml
 - sig/raap.rbs
+- sig/shims.rbs
 homepage: https://github.com/ksss/raap
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/ksss/raap
-  source_code_uri: https://github.com/ksss/raap
-  changelog_uri: https://github.com/ksss/raap
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/raap/method_value.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RaaP
-  class MethodValue < Data.define(
-    :receiver_value,
-    :arguments,
-    :method_name,
-    :size
-  )
-    def to_symbolic_call
-      args, kwargs, block = arguments
-      [:call, receiver_value, method_name, args, kwargs, block]
-    end
-
-    def call_str
-      r = SymbolicCaller.new(receiver_value).eval
-      "#{BindCall.inspect(r)}.#{method_name}(#{argument_str})#{block_str}"
-    end
-
-    private
-
-    def argument_str
-      args, kwargs, _ = SymbolicCaller.new(arguments).eval
-
-      r = []
-      r << args.map(&:inspect).join(', ') if !args.empty?
-      r << kwargs.map { |k ,v| "#{k}: #{BindCall.inspect(v)}" }.join(', ') if !kwargs.empty?
-      r.join(', ')
-    end
-
-    def block_str
-      _, _, block = SymbolicCaller.new(arguments).eval
-      if block
-        "{ }"
-      end
-    end
-  end
-end