rgot 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 368b98f9969eee4d2608df53e668eaaed9f06320ecd5b26096ff05c0f81dc16e
-  data.tar.gz: b045a87ffcb3f18338ce0286e2f22b71921b5bab011e4049c203164b9ab7a077
+  metadata.gz: e2f0075689755b0a44db0674a5069769d1ee4c2567774d7bb7422ba5b27c8960
+  data.tar.gz: 9ddd64091ca0daeff256fcc5c305aad378a92472f4522b875512fb35915d74aa
 SHA512:
-  metadata.gz: 7a3d443886aa26702be0720d8bdf8abf38dd938e3707d595ac1bf21b1edd0f3cb52f64f29e4ca11996357d8671bfaaa4edc94500560510b67c393244202a2db3
-  data.tar.gz: 13d8fcdf048c4c82da186f96dc7bfef3eb78a35fb5df04a2f6f17badda63100587df8cd175dc0618d823d613526b9e60aeec8e18cc09075c8bf3c8c218d58841
+  metadata.gz: 2e24662ccc2f6f4644eec95f9764975b86d2ea40f49c3c8ae569f428809ca08df79e6517d2bbcf0ec7d08e610867972133a1a9ab5df245cf36896afb8ace7e63
+  data.tar.gz: ac5c041deb124812d911d0af697a06a398ced2c79bc54f6058ec4cb2499af9dd814007f3e0c8951c50448892ba0fbc0a6846dfd879c3497601b4aebf5d00116e

data/.github/workflows/main.yml

@@ -17,6 +17,7 @@ jobs:
           - '2.7.7'
           - '3.0.5'
           - '3.1.3'
+          - '3.2.0'
 
     steps:
     - uses: actions/checkout@v3

data/.gitignore

@@ -1,2 +1,3 @@
 pkg
 tmp
+/.gem_rbs_collection

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem "rbs"
+gem "steep"
+gem "debug"

data/Gemfile.lock

@@ -1,20 +1,73 @@
 PATH
   remote: .
   specs:
-    rgot (1.2.0)
+    rgot (1.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    concurrent-ruby (1.1.10)
+    csv (3.2.6)
+    debug (1.7.1)
+    ffi (1.15.5)
+    fileutils (1.7.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.2)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.5.3)
+    minitest (5.17.0)
+    parallel (1.22.1)
+    parser (3.2.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
     rake (13.0.6)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rbs (2.8.2)
+    securerandom (0.2.2)
+    steep (1.3.0)
+      activesupport (>= 5.1)
+      csv (>= 3.0.9)
+      fileutils (>= 1.1.0)
+      json (>= 2.1.0)
+      language_server-protocol (>= 3.15, < 4.0)
+      listen (~> 3.0)
+      logger (>= 1.3.0)
+      parallel (>= 1.0.0)
+      parser (>= 3.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rbs (>= 2.8.0)
+      securerandom (>= 0.1)
+      strscan (>= 1.0.0)
+      terminal-table (>= 2, < 4)
+    strscan (3.0.5)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler
+  debug
   rake
+  rbs
   rgot!
+  steep
 
 BUNDLED WITH
-   2.3.26
+   2.4.2

data/README.md

@@ -93,6 +93,33 @@ ok	FooTest	2.782s
 
 `b.n` is automatically adjusted.
 
+## Fuzzing
+
+```
+$ rgot target_file_test.rb --fuzz . --fuzztime 1
+```
+
+Fuzzing tests are also supported.
+Please refer to the gloang documentation for details.
+
+https://go.dev/security/fuzz/
+
+```ruby
+module FooTest
+  # To enable fuzzing, the method name
+  # should be prefixed with `fuzz`.
+  def fuzz_any_func(f)
+    f.add(5, "hello")
+    f.fuzz do |t, i, s|
+      out, err = foo(i, s)
+      if err != nil && out != ""
+        t.errorf("%s, %s", out, err)
+      end
+    end
+  end
+end
+```
+
 ## Example
 
 Rgot's example feature is the best and if you want to write the sample code of your library.
@@ -189,6 +216,8 @@ Method name should be set `test_*` for testing.
 
 And benchmark method should be set `benchmark_*`.
 
+And fuzz method should be set `fuzz_*`.
+
 And example method should be set `example_*`.
 
 ```ruby
@@ -199,6 +228,9 @@ module XxxTest
   def benchmark_any_name(b)
   end
 
+  def fuzz_any_name(f)
+  end
+
   def example_any_name
   end
 end
@@ -218,6 +250,8 @@ Usage: rgot [options]
         --thread [count,...]         set thread counts of comma split
         --require [path]             load some code before running
         --load-path [path]           Specify $LOAD_PATH directory
+        --fuzz [regexp]              run the fuzz test matching `regexp`
+        --fuzztime [sec]             time to spend fuzzing; default is to run indefinitely
 ```
 
 ## Basic
@@ -515,3 +549,39 @@ def benchmark_foo(b)
   end
 end
 ```
+
+## Rgot::F (Fuzzing)
+
+### Rgot::F#add
+
+Set the sample value with `#add`. This value is also used as a test. It guesses the type from the value and generates a random value.
+
+### Rgot::F#fuzz
+
+Generate the random value generated by `#fuzz` and execute the code.
+The `t` becomes an instance of `Rgot::T` and the test can be run as usual.
+
+```ruby
+def fuzz_foo(f)
+  f.add(100, "hello")
+  f.fuzz do |t, i, s|
+    i #=> 100, 84, 17, 9, 66, ...
+    s #=> "hello", "Y\xD5\xAB\xBA\x8E", "r\x95D\xA5\xF7", "\xCEj=\x9C\xBD", ...
+    if !foo(i, s)
+      t.error("fail with i=#{i}, s=#{s}")
+    end
+  end
+end
+```
+
+# TODO
+
+- [ ] Support to save and load fuzzing data
+
+## v2
+
+- [ ] Support sub testing
+- [ ] Fix duration argument unit
+- [ ] Refactoring
+  - [ ] Fix M#initialize argument
+  - [ ] Fix internal class API

data/Rakefile

@@ -7,6 +7,7 @@ task :test do |t|
     "test/rgot_test.rb",
     "test/rgot_benchmark_test.rb",
     "test/rgot_example_test.rb",
+    "test/rgot_fuzzing_test.rb",
   ]
   ruby "bin/rgot -v #{targets.join(' ')}"
 end

data/Steepfile

@@ -0,0 +1,4 @@
+target :lib do
+  check "lib"
+  signature "sig"
+end

data/lib/rgot/b.rb

@@ -2,13 +2,15 @@
 
 module Rgot
   class B < Common
-    Options = Struct.new(
+    Options = _ = Struct.new(
       :procs,
       :threads,
       :benchtime,
     )
 
+    # @dynamic n, n=
     attr_accessor :n
+
     def initialize(benchmark_module, name, opts = Options.new)
       super()
       @n = 1
@@ -16,7 +18,7 @@ module Rgot
       @name = name
       @opts = opts
       @timer_on = false
-      @duration = 0
+      @duration = 0.0
       @module.extend @module if @module
     end
 
@@ -38,34 +40,34 @@ module Rgot
       if @timer_on
         @start = Rgot.now
       end
-      @duration = 0
+      @duration = 0.0
     end
 
     def run(&block)
       n = 1
       benchtime = (@opts.benchtime || 1).to_f
       catch(:skip) do
-        run_n(n.to_i, block)
-        while !failed? && @duration < benchtime && @n < 1e9
+        run_n(n, block)
+        while !failed? && @duration < benchtime && n < 1e9
           if @duration < (benchtime / 100.0)
-            @n *= 100
+            n *= 100
           elsif @duration < (benchtime / 10.0)
-            @n *= 10
+            n *= 10
           elsif @duration < (benchtime / 5.0)
-            @n *= 5
+            n *= 5
           elsif @duration < (benchtime / 2.0)
-            @n *= 2
+            n *= 2
           else
-            if @n.to_i == 1
+            if n == 1
               break
             end
-            @n *= 1.2
+            n = [(n * 1.2).to_i, n + 1].max || raise
           end
-          run_n(@n.to_i, block)
+          run_n(n, block)
         end
       end
 
-      BenchmarkResult.new(n: @n, t: @duration)
+      BenchmarkResult.new(n: n, t: @duration)
     end
 
     def run_parallel
@@ -83,7 +85,6 @@ module Rgot
           }.each(&:join)
         end
       end
-      @n *= procs * threads
       Process.waitall
     end
 

data/lib/rgot/benchmark_result.rb

@@ -2,6 +2,10 @@
 
 module Rgot
   class BenchmarkResult
+    # @dynamic n, t
+    attr_reader :n
+    attr_reader :t
+
     def initialize(n:, t:)
       @n = n
       @t = t

data/lib/rgot/cli.rb

@@ -52,6 +52,15 @@ module Rgot
         o.on '--load-path [path]', "Specify $LOAD_PATH directory" do |arg|
           $LOAD_PATH.unshift(arg)
         end
+        o.on '--fuzz [regexp]', "run the fuzz test matching `regexp`" do |arg|
+          unless arg
+            raise Rgot::OptionError, "missing argument for flag --fuzz"
+          end
+          opts.fuzz = arg
+        end
+        o.on '--fuzztime [sec]', "time to spend fuzzing; default is to run indefinitely" do |arg|
+          opts.fuzztime = arg
+        end
       end
       parser.parse!(@argv)
 
@@ -93,12 +102,18 @@ module Rgot
       node = RubyVM::AbstractSyntaxTree.parse_file(testing_file).children[2]
       test_module_name = find_toplevel_name(node)
 
+      if opts.fuzz
+        # fuzzing observes changes in coverage.
+        require 'coverage'
+        Coverage.start(oneshot_lines: true)
+      end
       load testing_file
 
       test_module = Object.const_get(test_module_name)
       tests = []
       benchmarks = []
       examples = []
+      fuzz_targets = []
       main = nil
       methods = test_module.public_instance_methods
       methods.grep(/\Atest_/).each do |m|
@@ -117,7 +132,18 @@ module Rgot
         examples << Rgot::InternalExample.new(test_module, m)
       end
 
-      m = Rgot::M.new(test_module: test_module, tests: tests, benchmarks: benchmarks, examples: examples, opts: opts)
+      methods.grep(/\Afuzz_/).each do |m|
+        fuzz_targets << Rgot::InternalFuzzTarget.new(test_module, m)
+      end
+
+      m = Rgot::M.new(
+        test_module: test_module,
+        tests: tests,
+        benchmarks: benchmarks,
+        examples: examples,
+        fuzz_targets: fuzz_targets,
+        opts: opts
+      )
       if main
         main.module.extend main.module
         main.module.instance_method(:test_main).bind(main.module).call(m)
@@ -126,8 +152,6 @@ module Rgot
       end
     end
 
-    private
-
     def find_toplevel_name(node)
       case node.type
       when :MODULE

data/lib/rgot/common.rb

@@ -5,6 +5,7 @@ require 'pathname'
 
 module Rgot
   class Common
+    # @dynamic output, output=
     attr_accessor :output
 
     def initialize
@@ -13,7 +14,7 @@ module Rgot
       @skipped = false
       @finished = false
       @start = Rgot.now
-      @mutex = Mutex.new
+      @mutex = Thread::Mutex.new
     end
 
     def failed?
@@ -100,7 +101,7 @@ module Rgot
       # internal_log -> synchronize -> internal_log -> other log -> running method
       c = caller[4]
       path = c.sub(/:.*/, '')
-      line = c.match(/:(\d+?):/)[1]
+      line = c.match(/:(\d+?):/)&.[](1)
       relative_path = Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
       # Every line is indented at least 4 spaces.
       "    #{relative_path}:#{line}: #{str}\n"

data/lib/rgot/example_parser.rb

@@ -4,7 +4,10 @@ require 'ripper'
 
 module Rgot
   class ExampleParser < Ripper
+
+    # @dynamic examples, examples=
     attr_accessor :examples
+
     def initialize(code)
       super
       @examples = []

data/lib/rgot/f.rb

@@ -0,0 +1,230 @@
+module Rgot
+  # def fuzz_foo(f)
+  #   f.add(5, "hello")
+  #   f.fuzz do |t, i, s|
+  #     ...
+  #   end
+  class F < Common
+    class Options
+      # @dynamic fuzz, fuzz=, fuzztime, fuzztime=
+      attr_accessor :fuzz
+      attr_accessor :fuzztime
+      def initialize(fuzz:, fuzztime:)
+        @fuzz = fuzz
+        @fuzztime = fuzztime
+      end
+    end
+
+    class CorpusEntry
+      # @dynamic values, values=, is_seed, is_seed=, path, path=
+      attr_accessor :values
+      attr_accessor :is_seed
+      attr_accessor :path
+      def initialize(values:, is_seed:, path:)
+        @values = values
+        @is_seed = is_seed
+        @path = path
+      end
+
+      def mutate_values
+        @values.map do |value|
+          if generator = SUPPORTED_TYPES[value.class]
+            generator.call(value)
+          else
+            raise "unsupported type #{value.class}"
+          end
+        end
+      end
+    end
+
+    class Coordinator
+      # @dynamic count, count=, interesting_count, interesting_count=
+      attr_accessor :count
+      attr_accessor :interesting_count
+
+      def initialize(warmup_input_count:)
+        @warmup_input_count = warmup_input_count
+        @before_cov = 0
+        @start_time = Rgot.now
+        @count = 0
+        @interesting_count = 0
+        @count_last_log = 0
+        @time_last_log = 0.0
+      end
+
+      def start_logger
+        Thread.new do
+          loop do
+            log_stats
+            sleep 3
+          end
+        end
+      end
+
+      def diff_coverage
+        current_cov = Coverage.peek_result.sum do |path, hash|
+          hash.map do |_, covs|
+            covs.length
+          end.sum
+        end
+        (current_cov - @before_cov).tap { @before_cov = current_cov }
+      end
+
+      def log_stats
+        rate = Float(count - @count_last_log) / (Rgot.now - @time_last_log)
+        total = @warmup_input_count + interesting_count
+        printf "fuzz: elapsed: %ds, execs: %d (%d/sec), new interesting: %d (total: %d)\n",
+          elapsed, count, rate, interesting_count, total
+
+        duration = Rgot.now - @time_last_log
+        @count_last_log = count
+        @time_last_log = Rgot.now
+      end
+
+      private
+
+      def elapsed
+        (Rgot.now - @start_time).round
+      end
+    end
+
+    SUPPORTED_TYPES = {
+      TrueClass => ->(v) { [true, false].sample },
+      FalseClass => ->(v) { [true, false].sample },
+      Integer => ->(v) { Random.rand(v) },
+      Float => ->(v) { Random.rand(v) },
+      String => ->(v) { Random.bytes(v.length) },
+    }
+
+    # @dynamic name
+    attr_reader :name
+
+    def initialize(fuzz_target:, opts:)
+      super()
+      @opts = opts
+      @fuzz_target = fuzz_target
+      @fuzz_block = nil
+      @module = fuzz_target.module
+      @name = fuzz_target.name
+      @corpus = []
+    end
+
+    # TODO: DRY with T
+    def run
+      catch(:skip) { call }
+      finish!
+    rescue => e
+      fail!
+      raise e
+    end
+
+    def run_testing
+      run
+      report if !fuzz? || failed?
+    end
+
+    def run_fuzzing
+      return unless fuzz?
+      raise("must call after #fuzz") unless @fuzz_block
+
+      coordinator = Coordinator.new(
+        warmup_input_count: @corpus.length
+      )
+      coordinator.start_logger
+
+      t = T.new(@fuzz_target.module, @fuzz_target.name)
+
+      begin
+        Timeout.timeout(@opts.fuzztime.to_f) do
+          loop do
+            @corpus.each do |entry|
+              values = entry.mutate_values
+
+              @fuzz_block.call(t, *values)
+
+              if 0 < coordinator.diff_coverage
+                coordinator.interesting_count += 1
+              end
+              coordinator.count += 1
+              fail! if t.failed?
+            end
+          end
+        end
+      rescue Timeout::Error, Interrupt
+        coordinator.log_stats
+      end
+
+      report
+    end
+
+    def add(*args)
+      args.each do |arg|
+        unless SUPPORTED_TYPES.key?(arg.class)
+          raise "unsupported type to Add #{arg.class}"
+        end
+      end
+      entry = CorpusEntry.new(
+        values: args.dup,
+        is_seed: true,
+        path: "seed##{@corpus.length}"
+      )
+      @corpus.push(entry)
+    end
+
+    def fuzz(&block)
+      unless block
+        raise LocalJumpError, "must set block"
+      end
+      unless 2 <= block.arity
+        raise "fuzz target must receive at least two arguments"
+      end
+
+      t = T.new(@fuzz_target.module, @fuzz_target.name)
+
+      @corpus.each do |entry|
+        unless entry.values.length == (block.arity - 1)
+          raise "wrong number of values in corpus entry: #{entry.values.length}, want #{block.arity - 1}"
+        end
+        block.call(t, *entry.values.dup)
+        fail! if t.failed?
+      end
+
+      @fuzz_block = block
+
+      nil
+    end
+
+    def fuzz?
+      return false unless @opts.fuzz
+      return false unless Regexp.new(@opts.fuzz.to_s).match?(@fuzz_target.name)
+      true
+    end
+
+    def report
+      puts @output if Rgot.verbose? && !@output.empty?
+      duration = Rgot.now - @start
+      template = "--- \e[%sm%s\e[m: %s (%.2fs)\n"
+      if failed?
+        printf template, [41, 1].join(';'), "FAIL", @name, duration
+      elsif Rgot.verbose?
+        if skipped?
+          printf template, [44, 1].join(';'), "SKIP", @name, duration
+        else
+          printf template, [42, 1].join(';'), "PASS", @name, duration
+        end
+      end
+    end
+
+    private
+
+    def call
+      test_method = @module.instance_method(@name).bind(@module)
+      if test_method.arity == 0
+        path, line = test_method.source_location
+        warn "#{path}:#{line} `#{test_method.name}' is not running. It's a testing method name, But not have argument"
+      else
+        test_method.call(self)
+      end
+    end
+  end
+end

data/lib/rgot/m.rb

@@ -12,9 +12,15 @@ module Rgot
       :timeout,
       :cpu,
       :thread,
+      :fuzz,
+      :fuzztime,
     ); end
 
-    def initialize(tests:, benchmarks:, examples:, test_module: nil, opts: Options.new)
+    def initialize(tests:, benchmarks:, examples:, fuzz_targets: nil, test_module: nil, opts: Options.new)
+      unless fuzz_targets
+        raise "Require `fuzz_targets` keyword" if Gem::Version.new("2.0") <= Gem::Version.new(Rgot::VERSION)
+        warn "`Rgot::M#initialize` will require the `fuzz_targets` keyword in the next major version."
+      end
       unless test_module
         raise "Require `test_module` keyword" if Gem::Version.new("2.0") <= Gem::Version.new(Rgot::VERSION)
         warn "`Rgot::M#initialize` will require the `test_module` keyword in the next major version."
@@ -23,18 +29,30 @@ module Rgot
       @tests = tests
       @benchmarks = benchmarks
       @examples = examples
+      @fuzz_targets = fuzz_targets || []
       @test_module = test_module
       @opts = opts
-      @cpu_list = nil
-      @thread_list = nil
+
+      @cpu_list = []
+      @thread_list = []
+      @fs = @fuzz_targets.map do |fuzz_target|
+        F.new(
+          fuzz_target: fuzz_target,
+          opts: F::Options.new(
+            fuzz: opts.fuzz,
+            fuzztime: opts.fuzztime,
+          )
+        )
+      end
     end
 
     def run
       duration = Rgot.now
       test_ok = false
+      fuzz_targets_ok = false
       example_ok = false
 
-      if @tests.empty? && @benchmarks.empty? && @examples.empty?
+      if @tests.empty? && @benchmarks.empty? && @examples.empty? && @fuzz_targets.empty?
         warn "rgot: warning: no tests to run"
       end
 
@@ -47,22 +65,29 @@ module Rgot
 
       Timeout.timeout(@opts.timeout.to_f) do
         test_ok = run_tests
+        fuzz_targets_ok = run_fuzz_tests
         example_ok = run_examples
       end
 
-      if !test_ok || !example_ok
+      if !test_ok || !example_ok || !fuzz_targets_ok
         puts "FAIL"
         puts "exit status 1"
         puts sprintf("%s\t%s\t%.3fs", "FAIL", @test_module, Rgot.now - duration)
+        return 1
+      end
 
-        1
-      else
-        puts "PASS"
-        run_benchmarks
-        puts sprintf("%s\t%s\t%.3fs", "ok  ", @test_module, Rgot.now - duration)
-
-        0
+      if !run_fuzzing()
+        puts "FAIL"
+        puts "exit status 1"
+        puts sprintf("%s\t%s\t%.3fs", "FAIL", @test_module, Rgot.now - duration)
+        return 1
       end
+
+      puts "PASS"
+      run_benchmarks
+      puts sprintf("%s\t%s\t%.3fs", "ok  ", @test_module, Rgot.now - duration)
+
+      0
     end
 
     private
@@ -90,9 +115,7 @@ module Rgot
           puts "=== RUN   #{test.name}"
         end
         t.run
-        if t.failed?
-          ok = false
-        end
+        ok = ok && !t.failed?
       end
       ok
     end
@@ -130,6 +153,50 @@ module Rgot
       ok
     end
 
+    def run_fuzz_tests
+      ok = true
+      @fs.each do |f|
+        if Rgot.verbose?
+          if f.fuzz?
+            puts "=== FUZZ  #{f.name}"
+          else
+            puts "=== RUN   #{f.name}"
+          end
+        end
+        f.run_testing
+        ok = ok && !f.failed?
+      end
+      ok
+    end
+
+    def run_fuzzing
+      if @fuzz_targets.empty? || @opts.fuzz.nil?
+        return true
+      end
+
+      fuzzing_fs = @fs.select(&:fuzz?)
+
+      if fuzzing_fs.empty?
+        puts "rgot: warning: no fuzz tests to fuzz"
+        return true
+      end
+
+      if fuzzing_fs.length > 1
+        names = fuzzing_fs.map(&:name)
+        puts "rgot: will not fuzz, --fuzz matches more than one fuzz test: #{names.inspect}"
+        return false
+      end
+
+      ok = true
+
+      fuzzing_fs.each do |f|
+        f.run_fuzzing
+        ok = ok && !f.failed?
+      end
+
+      ok
+    end
+
     def run_examples
       ok = true
       @examples.each do |example|
@@ -143,13 +210,13 @@ module Rgot
         out, _ = capture do
           method.call
         end
-        file = method.source_location[0]
-        r = ExampleParser.new(File.read(file))
-        r.parse
-        e = r.examples.find { |re| re.name == example.name }
+        file = method.source_location&.[](0) or raise("bug")
+        example_parser = ExampleParser.new(File.read(file))
+        example_parser.parse
+        e = example_parser.examples.find { |er| er.name == example.name } or raise("bug")
 
         duration = Rgot.now - start
-        if e && e.output.strip != out.strip
+        if e.output.strip != out.strip
           printf("--- FAIL: %s (%.2fs)\n", e.name, duration)
           ok = false
           puts "got:"

data/lib/rgot/pb.rb

@@ -2,8 +2,6 @@
 
 module Rgot
   class PB
-    attr_accessor :bn
-
     def initialize(bn:)
       @bn = bn
     end

data/lib/rgot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rgot
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/rgot.rb

@@ -8,12 +8,14 @@ module Rgot
   autoload :B, 'rgot/b'
   autoload :PB, 'rgot/pb'
   autoload :BenchmarkResult, 'rgot/benchmark_result'
+  autoload :F, 'rgot/f'
   autoload :ExampleParser, 'rgot/example_parser'
 
   OptionError = Class.new(StandardError)
   InternalTest = Struct.new(:module, :name)
   InternalBenchmark = Struct.new(:module, :name)
   InternalExample = Struct.new(:module, :name)
+  InternalFuzzTarget = Struct.new(:module, :name)
   ExampleOutput = Struct.new(:name, :output)
 
   class << self

data/rbs_collection.lock.yaml

@@ -0,0 +1,49 @@
+---
+sources:
+- name: ruby/gem_rbs_collection
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  revision: main
+  repo_dir: gems
+path: ".gem_rbs_collection"
+gems:
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: timeout
+  version: '0'
+  source:
+    type: stdlib
+- name: etc
+  version: '0'
+  source:
+    type: stdlib
+- name: coverage
+  version: '0'
+  source:
+    type: stdlib
+- name: concurrent-ruby
+  version: '1.1'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 9576ce5b109170f1ba8a42671bfafb64ab95bd23
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: io-console
+  version: '0'
+  source:
+    type: stdlib
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,53 @@
+# Download sources
+sources:
+  - name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  - name: pathname
+  - name: optparse
+  - name: timeout
+  - name: etc
+  - name: coverage
+
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: rbs
+    ignore: true
+  - name: steep
+    ignore: true
+  - name: activesupport
+    ignore: true
+  - name: ast
+    ignore: true
+  - name: csv
+    ignore: true
+  - name: i18n
+    ignore: true
+  - name: json
+    ignore: true
+  - name: listen
+    ignore: true
+  - name: fileutils
+    ignore: true
+  - name: minitest
+    ignore: true
+  - name: parallel
+    ignore: true
+  - name: rainbow
+    ignore: true
+  - name: rgot
+    ignore: true
+  - name: securerandom
+    ignore: true
+  - name: strscan
+    ignore: true
+  - name: forwardable
+    ignore: true
+  - name: mutex_m
+    ignore: true

data/sig/patch.rbs

@@ -0,0 +1,3 @@
+# patch
+class Ripper
+end

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.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-27 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - bin/rgot
 - lib/rgot.rb
 - lib/rgot/b.rb
@@ -60,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
@@ -84,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Ruby + Golang Testing = Rgot