raap 0.1.0

data/sig/raap.rbs

@@ -0,0 +1,313 @@
+module RaaP
+  type symbolic_call = [:call, untyped, Symbol, Array[untyped], Hash[Symbol, untyped], Proc?]
+  VERSION: String
+
+  def self.logger: () -> ::Logger
+  def self.logger=: (::Logger) -> void
+
+  module BindCall
+    def self.define_singleton_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
+    def self.respond_to?: (untyped, Symbol, ?bool) -> bool
+    def self.instance_of?: (untyped, Module) -> bool
+    def self.is_a?: (untyped, Module) -> bool
+    def self.extend: (untyped, Module) -> void
+    def self.name: (Module) -> String?
+    def self.to_s: (untyped) -> String
+    def self.class: (untyped) -> untyped
+    def self.inspect: (untyped) -> String
+  end
+
+  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.[]: (?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.keyword_init?: () -> true
+
+      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+
+      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+
+      attr_accessor dirs: ::Array[String]
+
+      attr_accessor requires: ::Array[String]
+
+      attr_accessor libraries: ::Array[String]
+
+      attr_accessor timeout: (Integer | Float | nil)
+
+      attr_accessor size_from: ::Integer
+
+      attr_accessor size_to: ::Integer
+
+      attr_accessor size_by: ::Integer
+    end
+
+    @argv: Array[String]
+
+    def self.option: () -> Option
+    def self.option=: (Option) -> void
+
+    def initialize: (Array[String]) -> void
+    def load: () -> self
+
+    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
+  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]]
+
+    private
+
+    def recursive_pick: (untyped, size: Integer, eval: bool) -> untyped
+    def build_args_type: () -> Array[Type]
+    def build_kwargs_type: () -> Hash[Symbol, Type]
+  end
+
+  class MethodProperty
+    class Stats
+      attr_accessor success: Integer
+      attr_accessor skip: Integer
+      attr_accessor exception: Integer
+    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
+    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 return_type: () -> RBS::Types::t
+  end
+
+  class MethodType
+    attr_reader rbs: ::RBS::MethodType
+    @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?
+  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 RBS
+    def self.builder: () -> ::RBS::DefinitionBuilder
+    def self.env: () -> ::RBS::Environment
+    def self.loader: () -> ::RBS::EnvironmentLoader
+    def self.parse_type: (String) -> ::RBS::Types::t
+  end
+
+  module Result
+    interface _MethodValueReturnValue
+      def method_value: () -> MethodValue
+      def return_value: () -> untyped
+    end
+    module CalledStr : _MethodValueReturnValue
+      def called_str: () -> String
+    end
+    class Success < Data
+      def self.new: (method_value: MethodValue, return_value: untyped) -> instance
+      attr_reader method_value: MethodValue
+      attr_reader return_value: untyped
+      include CalledStr
+    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
+      attr_reader symbolic_call: symbolic_call
+      include CalledStr
+    end
+    class Skip < Data
+      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
+      attr_reader method_value: MethodValue?
+      attr_reader exception: ::Exception
+    end
+    class Exception < Data
+      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
+      attr_reader method_value: MethodValue?
+      attr_reader exception: ::Exception
+    end
+  end
+
+  interface _Pick[T]
+    def pick: (size: Integer) -> T
+  end
+
+  class Sized
+    @block: ::Proc
+    @such_that: ::Proc?
+
+    def initialize: () { (Integer) -> untyped } -> void
+    include _Pick[untyped]
+    def such_that: () { (untyped) -> boolish } -> self
+    def such_that_loop: [R] () { (Integer) -> R } -> R
+  end
+
+  class SymbolicCaller
+    attr_reader symbolic_call: untyped
+    def initialize: (untyped) -> void
+    def eval: () -> untyped
+    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
+    def to_lines: () -> Array[String]
+
+    private
+
+    def _walk: (untyped) ?{ (symbolic_call) -> untyped} -> untyped
+    def eval_one: (symbolic_call) -> untyped
+    def var_name: (Module) -> String
+    def printable?: (untyped) -> bool
+    def printable: (untyped) -> String
+  end
+
+  class TypeSubstitution
+    @type_params: ::Array[::RBS::AST::TypeParam]
+    @type_args: ::Array[::RBS::Types::t]
+
+    def initialize: (::Array[::RBS::AST::TypeParam], ::Array[::RBS::Types::t]) -> void
+    def build: () -> ::RBS::Substitution
+    def method_type_sub: (::RBS::MethodType, ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType
+
+    private
+
+    interface _MapType
+      def map_type: { (untyped) -> untyped } -> untyped
+    end
+
+    def sub: (_MapType search, self_type: ::RBS::Types::ClassInstance?, instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> untyped
+  end
+
+  class Type
+    module Arithmetic
+      def self.float: () -> Float
+      def self.positive_float: () -> Float
+    end
+
+    GENERATORS: Hash[String, ^() -> _Pick[untyped] | Proc]
+    SIMPLE_SOURCE: Array[String]
+    RECURSION: Hash[String, :found | :logged]
+
+    def self.register: (String) { () [self: instance] -> _Pick[untyped] } -> void
+    attr_reader type: ::RBS::Types::t
+    attr_reader range: Range[untyped]
+
+    def initialize: (String | ::RBS::Types::t, ?range: Range[untyped]) -> void
+
+    include _Pick[untyped]
+    def pick: (?size: Integer, ?eval: bool) -> untyped | ...
+    def to_symbolic_call: (?size: Integer) -> untyped
+    def pick_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> untyped
+    def sized: () { (Integer size) -> untyped } -> _Pick[untyped]
+
+    private
+
+    def parse: (String | ::RBS::Types::t) -> ::RBS::Types::t?
+    def try: (times: Integer, size: Integer) { (Integer size) -> untyped } -> untyped
+
+    def numeric: () -> _Pick[Numeric]
+    def integer: () -> _Pick[Integer]
+    def none_zero_integer: () -> _Pick[Integer]
+    def float: () -> _Pick[Float]
+    def rational: () -> _Pick[Rational]
+    def complex: () -> _Pick[Complex]
+    def string: () -> _Pick[String]
+    def symbol: () -> _Pick[Symbol]
+    def array: (Type) -> _Pick[Array[untyped]]
+    def encoding: () -> _Pick[Encoding]
+    def bool: () -> _Pick[bool]
+    def untyped: () -> _Pick[untyped]
+    def temp_method_object: () -> ::Method
+  end
+
+  module Value
+    class Bottom < BasicObject
+      def inspect: () -> String
+      def class: () -> class
+    end
+
+    class Interface < BasicObject
+      @type: ::RBS::Types::Interface
+      @size: Integer
+      @definition: ::RBS::Definition
+
+      def initialize: (String | ::RBS::Types::Interface, ?size: Integer) -> void
+      def inspect: () -> String
+      def class: () -> class
+    end
+
+    class Intersection < BasicObject
+      @type: ::RBS::Types::Intersection
+      @children: Array[Type]
+      @size: Integer
+
+      def initialize: (::RBS::Types::Intersection, size: Integer) -> void
+      def inspect: () -> String
+      def class: () -> class
+    end
+
+    class Module < BasicObject
+      attr_reader type: ::RBS::Types::ClassInstance
+
+      def initialize: (::RBS::Types::ClassInstance) -> void
+      def inspect: () -> String
+      def class: () -> class
+    end
+
+    class Top < BasicObject
+      def inspect: () -> String
+      def class: () -> class
+    end
+
+    class Variable < BasicObject
+      attr_reader type: ::RBS::Types::Variable
+
+      def initialize: (::RBS::Types::Variable) -> void
+      def inspect: () -> String
+      def class: () -> class
+    end
+
+    class Void < BasicObject
+      def inspect: () -> String
+      def class: () -> class
+    end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: raap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ksss
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: timeout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Property based testing tool with RBS
+email:
+- co000ri@gmail.com
+executables:
+- raap
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- exe/raap
+- lib/raap.rb
+- lib/raap/bind_call.rb
+- lib/raap/cli.rb
+- lib/raap/function_type.rb
+- lib/raap/method_property.rb
+- lib/raap/method_type.rb
+- lib/raap/method_value.rb
+- lib/raap/rbs.rb
+- lib/raap/result.rb
+- lib/raap/sized.rb
+- lib/raap/symbolic_caller.rb
+- lib/raap/type.rb
+- lib/raap/type_substitution.rb
+- lib/raap/value.rb
+- lib/raap/value/bottom.rb
+- lib/raap/value/interface.rb
+- lib/raap/value/intersection.rb
+- lib/raap/value/module.rb
+- lib/raap/value/top.rb
+- lib/raap/value/variable.rb
+- lib/raap/value/void.rb
+- lib/raap/version.rb
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
+- sig/raap.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
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: RBS as a Property
+test_files: []