rgot 1.1.0 → 1.3.0

data/sig/rgot.rbs

@@ -0,0 +1,232 @@
+module Rgot
+  VERSION: "1.2.0"
+
+  def self.now: () -> Float
+  def self.benchmark: (?Hash[Symbol, String] opts_hash) { (B) -> void } -> BenchmarkResult
+  def self.verbose?: () -> bool
+
+  class Cli
+    @argv: Array[String]
+
+    def initialize: (untyped argv) -> void
+    def run: () -> void
+
+    private
+
+    def parse_option: (Rgot::M::Options opts) -> void
+    def main_process: (Rgot::M::Options opts) -> void
+    def testing_files: () -> Array[String]
+    def child_process: (Rgot::M::Options opts, String testing_file) -> Integer
+    # `node` is RubyVM::AbstractSyntaxTree::Node
+    def find_toplevel_name: (untyped node) -> Symbol
+  end
+
+  class Common
+    @failed: bool
+    @skipped: bool
+    @finished: bool
+    @start: Float
+    @mutex: Thread::Mutex
+
+    attr_accessor output: String
+
+    def initialize: () -> void
+
+    def failed?: () -> bool
+    def skipped?: () -> bool
+    def finished?: () -> bool
+    def fail!: () -> void
+    def skip!: () -> void
+    def finish!: () -> void
+    def log: (*untyped) -> nil
+    def logf: (*untyped) -> nil
+    def error: (*untyped) -> nil
+    def errorf: (*untyped) -> nil
+    def fatal: (*untyped) -> bot
+    def fatalf: (*untyped) -> bot
+    def skip: (*untyped) -> bot
+    def skipf: (*untyped) -> bot
+    def skip_now: () -> bot
+    def fail_now: () -> bot
+
+    private
+
+    def decorate: (String) -> String
+    def internal_log: (String msg) -> void
+  end
+
+  class M
+    class Options
+      attr_accessor bench: String?
+      attr_accessor benchtime: String?
+      attr_accessor timeout: String?
+      attr_accessor cpu: String?
+      attr_accessor thread: String?
+      attr_accessor fuzz: String?
+      attr_accessor fuzztime: String?
+    end
+
+    @tests: Array[InternalTest]
+    @benchmarks: Array[InternalBenchmark]
+    @examples: Array[InternalExample]
+    @fuzz_targets: Array[InternalFuzzTarget]
+    @fs: Array[F]
+    @test_module: Module?
+    @opts: M::Options
+    @cpu_list: Array[Integer]
+    @thread_list: Array[Integer]
+
+    def initialize: (
+      tests: Array[InternalTest],
+      benchmarks: Array[InternalBenchmark],
+      examples: Array[InternalExample],
+      fuzz_targets: Array[InternalFuzzTarget],
+      ?test_module: Module?,
+      ?opts: Options
+    ) -> void
+    def run: () -> Integer
+
+    private
+
+    def run_tests: () -> bool
+    def run_benchmarks: () -> bool
+    def run_fuzz_tests: () -> bool
+    def run_fuzzing: () -> bool
+    def run_examples: () -> bool
+  end
+
+  class T < Common
+    @module: Module
+    @name: Symbol
+
+    def initialize: (Module test_module, Symbol name) -> void
+    def run: () -> void
+    def report: () -> void
+    def call: () -> void
+  end
+
+  class B < Common
+    class Options
+      attr_accessor procs: Integer
+      attr_accessor threads: Integer
+      attr_accessor benchtime: String?
+    end
+
+    @module: Module?
+    @name: Symbol?
+    @opts: B::Options
+    @timer_on: bool
+    @duration: Float
+
+    attr_accessor n: Integer
+
+    def initialize: (Module? benchmark_module, Symbol? name, ?B::Options opts) -> void
+    def start_timer: () -> void
+    def stop_timer: () -> void
+    def reset_timer: () -> void
+    def run: () ?{ (B) -> void } -> BenchmarkResult
+    def run_parallel: () { (PB) -> void } -> void
+
+    private
+
+    def run_n: (Integer n, ?Proc? block) -> void
+  end
+
+  class F < Common
+    class Options
+      attr_accessor fuzz: String?
+      attr_accessor fuzztime: String?
+      def initialize: (fuzz: String?, fuzztime: String?) -> void
+    end
+    class CorpusEntry
+      attr_accessor values: Array[untyped]
+      attr_accessor is_seed: bool
+      attr_accessor path: String
+      def initialize: (values: Array[untyped], is_seed: bool, path: String) -> void
+      def mutate_values: () -> Array[untyped]
+    end
+    class Coordinator
+      attr_accessor count: Integer
+      attr_accessor interesting_count: Integer
+      def initialize: (warmup_input_count: Integer) -> void
+      @warmup_input_count: Integer
+      @before_cov: Integer
+      @start_time: Float
+      @count: Integer
+      @interesting_count: Integer
+      @count_last_log: Integer
+      @time_last_log: Float
+      def start_logger: () -> void
+      def diff_coverage: () -> Integer
+      def log_stats: () -> void
+      private
+      def elapsed: () -> Integer
+    end
+    SUPPORTED_TYPES: Hash[untyped, ^(untyped) -> untyped]
+    @fuzz_target: InternalFuzzTarget
+    @fuzz_block: Proc?
+    @opts: F::Options
+    @corpus: Array[CorpusEntry]
+    @module: Module
+    attr_reader name: Symbol
+    def initialize: (fuzz_target: InternalFuzzTarget, opts: F::Options) -> void
+    def run: () -> void
+    def run_testing: () -> void
+    def run_fuzzing: () -> void
+    def add: (*untyped) -> void
+    def fuzz: () { (*untyped) -> void } -> void
+    def fuzz?: () -> bool
+    def report: () -> void
+
+    private
+
+    def call: () -> void
+  end
+
+  class PB
+    @bn: Integer
+    def initialize: (bn: Integer) -> void
+    def next: () -> bool
+  end
+
+  class BenchmarkResult
+    attr_reader n: Integer    # int           // The number of iterations.
+    attr_reader t: Float      # time.Duration // The total time taken.
+    def initialize: (n: Integer, t: Float) -> void
+  end
+
+  class ExampleParser < Ripper
+    @in_def: bool
+    @has_output: bool
+    @output: String
+    attr_accessor examples: Array[ExampleOutput]
+  end
+
+  class OptionError < StandardError
+  end
+
+  class InternalTest
+    attr_accessor module: Module
+    attr_accessor name: Symbol
+  end
+
+  class InternalBenchmark
+    attr_accessor module: Module
+    attr_accessor name: Symbol
+  end
+
+  class InternalExample
+    attr_accessor module: Module
+    attr_accessor name: Symbol
+  end
+
+  class InternalFuzzTarget
+    attr_accessor module: Module
+    attr_accessor name: Symbol
+  end
+
+  class ExampleOutput
+    attr_accessor output: String
+    attr_accessor name: Symbol
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgot
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-25 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -49,9 +49,11 @@ files:
 - ".github/workflows/main.yml"
 - ".gitignore"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - bin/rgot
 - lib/rgot.rb
 - lib/rgot/b.rb
@@ -59,11 +61,16 @@ files:
 - lib/rgot/cli.rb
 - lib/rgot/common.rb
 - lib/rgot/example_parser.rb
+- lib/rgot/f.rb
 - lib/rgot/m.rb
 - lib/rgot/pb.rb
 - lib/rgot/t.rb
 - lib/rgot/version.rb
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
 - rgot.gemspec
+- sig/patch.rbs
+- sig/rgot.rbs
 homepage: https://github.com/ksss/rgot
 licenses:
 - MIT
@@ -83,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Ruby + Golang Testing = Rgot