hypothesis-specs 0.0.15 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf543607fd313031a5fd77ee32d3e8f7693f374a48e5bcd2c36695ca31f81812
-  data.tar.gz: 572e4cb24ad38caff4a730eff87a8bbbb9aae75e759fade1061cb919214de76d
+  metadata.gz: 77c742dcfc65dfcab8e0eac24498eff24b10461abf17f502961ac9fc30bd1810
+  data.tar.gz: 6a73fbe38f860e2b2b9f9fd68cde16a33657eb05d0117a3a2e78ab5dfa8e2226
 SHA512:
-  metadata.gz: da7954815892f7f17c8bbc41435e15403a7147457ae22ed6d2955d5f0c6a490a9679773862d3fea3e598dac04e5698516bea64e04c236378de4808d6f178fd78
-  data.tar.gz: 2cbe4b43830f9a0ca70aaba5923d2e4c46af72d38a96c56ff67ff4be5ec6d4ae7f206d47e0860480161c78b8d4b9e19baa4862ac68da07517ecc2caa316f777a
+  metadata.gz: 8b0da0f3b0820c93b32af05eb040fd6d88e86748a8fd99c38609a204944a84b773f2e53bf757c103c0c0f5a6e66097fd65c839ca95c0ec8360c9ac1ae1814153
+  data.tar.gz: 0a2d28a1fbc0e3b87fa96452a6028d0f0f8e00d223eb1440f1daf86eb3e40ec33c25c21222c9a2fc585d053dcca63e9de6d9d0e96ca7eb277e452e0baa77c2ac

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+# Hypothesis for Ruby 0.3.0 (2021-01-08)
+
+This release converts Hypothesis for Ruby to use [RuTie](https://github.com/danielpclark/rutie)
+instead of the deprecated [Helix](https://github.com/tildeio/helix), restoring compatibility
+with recent versions of Rust.  Thanks to Alex Weisberger for taking this on!
+
+# Hypothesis for Ruby 0.2.0 (2018-10-24)
+
+This release adds an example database to Hypothesis for Ruby. This means that when a test fails,
+it will automatically reuse the previously shown example when you rerun it, without having to
+manually pass a seed.
+
+# Hypothesis for Ruby 0.1.2 (2018-09-24)
+
+This release makes the code useable via a direct require.
+I.e. no need for rubygems or any special LOAD_PATH.
+
+For example, if the base directory were in /opt, you'd just say:
+require "/opt/hypothesis/hypothesis-ruby/lib/hypothesis"
+
+# Hypothesis for Ruby 0.1.1 (2018-08-31)
+
+This release fixes minor documentation issues.
+
+Thanks to Tessa Bradbury for this contribution.
+
+# Hypothesis for Ruby 0.1.0 (2018-07-16)
+
+This release adds support for reporting multiple exceptions when Hypothesis
+finds more than one way for the test to fail.
+
 # Hypothesis for Ruby 0.0.15 (2018-06-25)
 
 This release fixes an occasional `RuntimeError` that could occur

data/Cargo.toml

@@ -1,12 +1,14 @@
 [package]
 name = "hypothesis-ruby"
 version = "0.1.0"
-authors = ["David R. MacIver <david@drmaciver.com>"]
+authors = ["David R. MacIver <david@drmaciver.com>", "Alex Wiesberger <alex.m.weisberger@gmail.com>"]
 
 [lib]
+name="hypothesis_ruby_core"
 crate-type = ["cdylib"]
 
 [dependencies]
-helix = '0.7.5'
+rutie = {version="0.8.1"}
+lazy_static = "1.4.0"
 rand = '0.3'
-conjecture = '0.2.1'
+conjecture = '0.4.0'

data/LICENSE.txt

@@ -1,7 +1,7 @@
 Copyright (c) 2018, David R. MacIver
 
 All code in this repository except where explicitly noted otherwise is released
-under the Mozilla Public License v 2.0. You can obtain a copy at http://mozilla.org/MPL/2.0/.
+under the Mozilla Public License v 2.0. You can obtain a copy at https://mozilla.org/MPL/2.0/.
 
 Some code in this repository may come from other projects. Where applicable, the
 original copyright and license are noted and any modifications made are released

data/README.markdown

@@ -32,7 +32,7 @@ RSpec.describe "removing an element from a list" do
 
       values.delete_at(values.index(to_remove))
 
-      # Will fail if the value ws duplicated in the list.
+      # Will fail if the value was duplicated in the list.
       expect(values.include?(to_remove)).to be false
       
     end

data/Rakefile

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'rubygems'
-require 'helix_runtime/build_task'
 require 'date'
 require 'open3'
 
+task :build do
+  system('cargo build --release')
+end
+
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:spec)
@@ -20,8 +23,6 @@ begin
 rescue LoadError
 end
 
-HelixRuntime::BuildTask.new
-
 def rubocop(fix:)
   sh "bundle exec rubocop #{'-a' if fix} lib spec minitests " \
   'Rakefile hypothesis-specs.gemspec'

data/lib/hypothesis.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require 'hypothesis/errors'
-require 'hypothesis/possible'
-require 'hypothesis/testcase'
-require 'hypothesis/engine'
-require 'hypothesis/world'
+require_relative 'hypothesis/junkdrawer'
+require_relative 'hypothesis/errors'
+require_relative 'hypothesis/possible'
+require_relative 'hypothesis/testcase'
+require_relative 'hypothesis/engine'
+require_relative 'hypothesis/world'
 
 # This is the main module for using Hypothesis.
 # It is expected that you will include this in your
@@ -18,6 +19,23 @@ require 'hypothesis/world'
 module Hypothesis
   # @!visibility private
   HYPOTHESIS_LOCATION = File.dirname(__FILE__)
+  # rubocop:disable ClassVars
+  @@setup_called = false
+  # rubocop:enable RuleByName
+
+  def self.setup_called
+    @@setup_called == true
+  end
+
+  def self.included(*)
+    if setup_called == false
+      Rutie.new(:hypothesis_ruby_core).init(
+        'Init_rutie_hypothesis_core',
+        __dir__
+      )
+    end
+    @@setup_called = true
+  end
 
   # @!visibility private
   def hypothesis_stable_identifier
@@ -121,7 +139,7 @@ module Hypothesis
   # of the block is a *test case*.
   # A test case has three important features:
   #
-  # * *givens* are the result of a call to self.given, and are the
+  # * *givens* are the result of a call to self.any, and are the
   #   values that make up the test case. These might be values such
   #   as strings, integers, etc. or they might be values specific to
   #   your application such as a User object.
@@ -139,12 +157,21 @@ module Hypothesis
   #
   # A call to hypothesis does the following:
   #
-  # 1. It tries to *generate* a failing test case.
-  # 2. If it succeeded then it will *shrink* that failing test case.
-  # 3. Finally, it will *display* the shrunk failing test case by
+  # 1. It first tries to *reuse* failing test cases for previous runs.
+  # 2. If there were no previous failing test cases then it tries to
+  #    *generate* new failing test cases.
+  # 3. If either of the first two phases found failing test cases then
+  #    it will *shrink* those failing test cases.
+  # 4. Finally, it will *display* the shrunk failing test case by
   #    the error from its failing assertion, modified to show the
   #    givens of the test case.
   #
+  # Reuse uses an internal representation of the test case, so examples
+  # from previous runs will obey all of the usual invariants of generation.
+  # However, this means that if you change your test then reuse may not
+  # work. Test cases that have become invalid or passing will be cleaned
+  # up automatically.
+  #
   # Generation consists of randomly trying test cases until one of
   # three things has happened:
   #
@@ -169,13 +196,21 @@ module Hypothesis
   #
   # @param max_valid_test_cases [Integer] The maximum number of valid test
   #   cases to run without finding a failing test case before stopping.
-  def hypothesis(max_valid_test_cases: 200, &block)
+  #
+  # @param database [String, nil, false] A path to a directory where Hypothesis
+  #   should store previously failing test cases. If it is nil, Hypothesis
+  #   will use a default of .hypothesis/examples in the current directory.
+  #   May also be set to false to disable the database functionality.
+  def hypothesis(max_valid_test_cases: 200, database: nil, &block)
     unless World.current_engine.nil?
       raise UsageError, 'Cannot nest hypothesis calls'
     end
+
     begin
       World.current_engine = Engine.new(
-        max_examples: max_valid_test_cases
+        hypothesis_stable_identifier,
+        max_examples: max_valid_test_cases,
+        database: database
       )
       World.current_engine.run(&block)
     ensure

data/lib/hypothesis/engine.rb

@@ -1,18 +1,32 @@
 # frozen_string_literal: true
 
-require 'helix_runtime'
-require 'hypothesis-ruby/native'
+require 'rutie'
+
+require 'rspec/expectations'
 
 module Hypothesis
+  DEFAULT_DATABASE_PATH = File.join(Dir.pwd, '.hypothesis', 'examples')
+
   class Engine
+    include RSpec::Matchers
+
     attr_reader :current_source
     attr_accessor :is_find
 
-    def initialize(options)
+    def initialize(name, options)
       seed = Random.rand(2**64 - 1)
+
+      database = options.fetch(:database, nil)
+
+      database = DEFAULT_DATABASE_PATH if database.nil?
+
+      database = nil if database == false
+
       @core_engine = HypothesisCoreEngine.new(
-        seed, options.fetch(:max_examples)
+        name, database, seed, options.fetch(:max_examples)
       )
+
+      @exceptions_to_tags = Hash.new { |h, k| h[k] = h.size }
     end
 
     def run
@@ -23,7 +37,7 @@ module Hypothesis
         begin
           result = yield(@current_source)
           if is_find && result
-            @core_engine.finish_interesting(core)
+            @core_engine.finish_interesting(core, 0)
           else
             @core_engine.finish_valid(core)
           end
@@ -31,54 +45,64 @@ module Hypothesis
           @core_engine.finish_invalid(core)
         rescue DataOverflow
           @core_engine.finish_overflow(core)
-        rescue Exception
+        rescue Exception => e
           raise if is_find
-          @core_engine.finish_interesting(core)
+          key = [
+            e.class,
+            HypothesisJunkDrawer.find_first_relevant_line(e.backtrace)
+          ]
+          @core_engine.finish_interesting(core, @exceptions_to_tags[key])
         end
       end
-      @current_source = nil
-      core = @core_engine.failing_example
-      if core.nil?
+      if @core_engine.count_failing_examples.zero?
         raise Unsatisfiable if @core_engine.was_unsatisfiable
+        @current_source = nil
         return
       end
 
       if is_find
+        core = @core_engine.failing_example(0)
         @current_source = TestCase.new(core, record_draws: true)
         yield @current_source
       else
-        @current_source = TestCase.new(core, print_draws: true)
+        exceptions = []
+        (0...@core_engine.count_failing_examples).each do |example|
+          core = @core_engine.failing_example(example)
+          @current_source = TestCase.new(core, print_draws: true)
 
-        begin
-          yield @current_source
-        rescue Exception => e
-          givens = @current_source.print_log
-          given_str = givens.each_with_index.map do |(name, s), i|
-            name = "##{i + 1}" if name.nil?
-            "Given #{name}: #{s}"
-          end.to_a
-
-          if e.respond_to? :hypothesis_data
-            e.hypothesis_data[0] = given_str
-          else
-            original_to_s = e.to_s
-            original_inspect = e.inspect
+          begin
+            yield @current_source
+          rescue Exception => e
+            givens = @current_source.print_log
+            given_str = givens.each_with_index.map do |(name, s), i|
+              name = "##{i + 1}" if name.nil?
+              "Given #{name}: #{s}"
+            end.to_a
 
-            class <<e
-              attr_accessor :hypothesis_data
+            if e.respond_to? :hypothesis_data
+              e.hypothesis_data[0] = given_str
+            else
+              original_to_s = e.to_s
+              original_inspect = e.inspect
 
-              def to_s
-                ['', hypothesis_data[0], '', hypothesis_data[1]].join("\n")
-              end
+              class <<e
+                attr_accessor :hypothesis_data
+
+                def to_s
+                  ['', hypothesis_data[0], '', hypothesis_data[1]].join("\n")
+                end
 
-              def inspect
-                ['', hypothesis_data[0], '', hypothesis_data[2]].join("\n")
+                def inspect
+                  ['', hypothesis_data[0], '', hypothesis_data[2]].join("\n")
+                end
               end
+              e.hypothesis_data = [given_str, original_to_s, original_inspect]
             end
-            e.hypothesis_data = [given_str, original_to_s, original_inspect]
+            raise e if @core_engine.count_failing_examples == 1
+            exceptions.push(e)
           end
-          raise e
         end
+        raise Hypothesis::MultipleExceptionError.new(*exceptions)
       end
     end
   end

data/lib/hypothesis/errors.rb

@@ -25,4 +25,37 @@ module Hypothesis
   # @!visibility private
   class DataOverflow < HypothesisError
   end
+
+  if defined?(RSpec::Core::MultipleExceptionError)
+    MultipleExceptionErrorParent = RSpec::Core::MultipleExceptionError
+  # :nocov:
+  else
+    class MultipleExceptionErrorParent < StandardError
+      def initialize(*exceptions)
+        super()
+
+        @all_exceptions = exceptions.to_a
+      end
+
+      attr_reader :all_exceptions
+    end
+  end
+
+  class MultipleExceptionError < MultipleExceptionErrorParent
+    def message
+      jd = HypothesisJunkDrawer
+      "Test raised #{all_exceptions.length} distinct errors:\n\n" +
+        all_exceptions.map do |e|
+          location = jd.find_first_relevant_line(e.backtrace).sub(/:in.+$/, '')
+          backtrace = jd.prune_backtrace(e.backtrace)
+          "#{e.class} at #{location}:\n" \
+            "#{e.message}\n#{backtrace.map { |s| '  ' + s }
+              .join("\n")}"
+        end.join("\n\n")
+    end
+
+    def backtrace
+      []
+    end
+  end
 end

data/lib/hypothesis/junkdrawer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hypothesis
+  # @!visibility private
+  module HypothesisJunkDrawer
+    HYPOTHESIS_ROOT = File.absolute_path(File.dirname(__FILE__))
+
+    def self.prune_backtrace(backtrace)
+      result = []
+      seen_hypothesis = false
+      backtrace.each do |b|
+        if b.start_with?(HYPOTHESIS_ROOT)
+          seen_hypothesis = true
+        else
+          result.push(b)
+          break if seen_hypothesis
+        end
+      end
+      result
+    end
+
+    def self.find_first_relevant_line(backtrace)
+      backtrace.each do |b|
+        next if b.include?('minitest/assertions.rb')
+        next if b.start_with?(HYPOTHESIS_ROOT)
+        return b
+      end
+      nil
+    end
+  end
+end

data/lib/hypothesis/possible.rb

@@ -111,7 +111,7 @@ module Hypothesis
   # two names: A singular and a plural name. These are
   # simply aliases and are identical in every way, but are
   # provided to improve readability. For example
-  # `any integer` reads better than `given integers`
+  # `any integer` reads better than `any integers`
   # but `arrays(of: integers)` reads better than
   # `arrays(of: integer)`.
   module Possibilities
@@ -124,7 +124,7 @@ module Hypothesis
     # built_as lets you chain multiple Possible values together,
     # by providing whatever value results from its block.
     #
-    # For example the following provides a array plus some
+    # For example the following provides an array plus some
     # element from that array:
     #
     # ```ruby
@@ -135,6 +135,7 @@ module Hypothesis
     #     assume ls.size > 0
     #     i = any element_of(ls)
     #     [ls, i]
+    #   end
     # ```
     #
     # @return [Possible] A Possible whose possible values are
@@ -177,7 +178,7 @@ module Hypothesis
     #   valid.
     # @param min_size [Integer] The smallest valid length for a
     #   provided string
-    # @param max_size [Integer] The smallest valid length for a
+    # @param max_size [Integer] The largest valid length for a
     #   provided string
     def strings(codepoints: nil, min_size: 0, max_size: 10)
       codepoints = self.codepoints if codepoints.nil?
@@ -263,9 +264,9 @@ module Hypothesis
     alias array_of_shape arrays_of_shape
 
     # A Possible Array of variable shape.
-    # This is used for arrays where all of the elements come from
-    # the size may vary and the same values are possible at any position.
-    # For example, arrays(booleans) might provide [false, true, false].
+    # This is used for arrays where the size may vary and the same values
+    # are possible at any position.
+    # For example, arrays(of: booleans) might provide [false, true, false].
     # @return [Possible]
     # @param of [Possible] The possible elements of the array.
     # @param min_size [Integer] The smallest valid size of a provided array

data/src/lib.rs

@@ -1,180 +1,469 @@
-// "Bridging" root code that exists exclusively to provide
-// a ruby -> Hypothesis engine binding. Long term the code
-// in here is the only code that is going to stay in this
-// crate, and everything else is going to get factored out
-// into its own.
-
-#![recursion_limit = "256"]
-#![deny(warnings, missing_debug_implementations)]
-
-extern crate core;
 #[macro_use]
-extern crate helix;
-extern crate rand;
+extern crate rutie;
+#[macro_use]
+extern crate lazy_static;
 extern crate conjecture;
 
 use std::mem;
 
-use conjecture::data::{DataSource, Status};
-use conjecture::distributions::Repeat;
+use rutie::{AnyException, AnyObject, Boolean, Class, Float, Integer, NilClass, Object, RString, VM};
+
+use conjecture::data::{DataSource, Status, TestResult};
+use conjecture::database::{BoxedDatabase, DirectoryDatabase, NoDatabase};
 use conjecture::distributions;
+use conjecture::distributions::Repeat;
 use conjecture::engine::Engine;
 
-ruby! {
-  class HypothesisCoreDataSource {
-    struct {
-      source: Option<DataSource>,
+pub struct HypothesisCoreDataSourceStruct {
+    source: Option<DataSource>,
+}
+
+impl HypothesisCoreDataSourceStruct {
+    fn new(engine: &mut HypothesisCoreEngineStruct) -> HypothesisCoreDataSourceStruct {
+        HypothesisCoreDataSourceStruct {
+            source: mem::take(&mut engine.pending),
+        }
+    }
+
+    fn start_draw(&mut self) {
+        if let Some(ref mut source) = self.source {
+            source.start_draw();
+        }
+    }
+
+    fn stop_draw(&mut self) {
+        if let Some(ref mut source) = self.source {
+            source.stop_draw();
+        }
+    }
+}
+
+wrappable_struct!(
+    HypothesisCoreDataSourceStruct,
+    HypothesisCoreDataSourceStructWrapper,
+    HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER
+);
+
+class!(HypothesisCoreDataSource);
+
+methods!(
+    HypothesisCoreDataSource,
+    itself,
+    fn ruby_hypothesis_core_data_source_start_draw() -> NilClass {
+        itself
+            .get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER)
+            .start_draw();
+
+        NilClass::new()
     }
+    fn ruby_hypothesis_core_data_source_stop_draw() -> NilClass {
+        itself
+            .get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER)
+            .stop_draw();
 
-    def initialize(helix, engine: &mut HypothesisCoreEngine){
-      let mut result = HypothesisCoreDataSource{helix, source: None};
-      mem::swap(&mut result.source, &mut engine.pending);
-      return result;
+        NilClass::new()
     }
+);
 
-    def start_draw(&mut self){
-      if let &mut Some(ref mut source) = &mut self.source {
-        source.start_draw();
-      }
+pub struct HypothesisCoreEngineStruct {
+    engine: Engine,
+    pending: Option<DataSource>,
+    interesting_examples: Vec<TestResult>,
+}
+
+impl HypothesisCoreEngineStruct {
+    fn new(
+        name: String,
+        database_path: Option<String>,
+        seed: u64,
+        max_examples: u64,
+    ) -> HypothesisCoreEngineStruct {
+        let xs: [u32; 2] = [seed as u32, (seed >> 32) as u32];
+        let db: BoxedDatabase = match database_path {
+            None => Box::new(NoDatabase),
+            Some(path) => Box::new(DirectoryDatabase::new(path)),
+        };
+
+        HypothesisCoreEngineStruct {
+            engine: Engine::new(name, max_examples, &xs, db),
+            pending: None,
+            interesting_examples: Vec::new(),
+        }
+    }
+
+    fn new_source(&mut self) -> Option<HypothesisCoreDataSourceStruct> {
+        match self.engine.next_source() {
+            None => {
+                self.interesting_examples = self.engine.list_minimized_examples();
+                None
+            }
+            Some(source) => {
+                self.pending = Some(source);
+                Some(HypothesisCoreDataSourceStruct::new(self))
+            }
+        }
+    }
+
+    fn count_failing_examples(&self) -> usize {
+        self.interesting_examples.len()
+    }
+
+    fn failing_example(&mut self, i: usize) -> HypothesisCoreDataSourceStruct {
+        self.pending = Some(DataSource::from_vec(
+            self.interesting_examples[i].record.clone(),
+        ));
+        HypothesisCoreDataSourceStruct::new(self)
     }
 
-    def stop_draw(&mut self){
-      if let &mut Some(ref mut source) = &mut self.source {
-        source.stop_draw();
-      }
+    fn was_unsatisfiable(&mut self) -> bool {
+        self.engine.was_unsatisfiable()
     }
-  }
 
-  class HypothesisCoreEngine {
-    struct {
-      engine: Engine,
-      pending: Option<DataSource>,
+    fn finish_overflow(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Overflow);
     }
 
-    def initialize(helix, seed: u64, max_examples: u64){
-      let xs: [u32; 2] = [seed as u32, (seed >> 32) as u32];
-      HypothesisCoreEngine{
-        helix,
-        engine: Engine::new(max_examples, &xs),
-        pending: None,
-      }
+    fn finish_valid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Valid);
     }
 
-    def new_source(&mut self) -> Option<HypothesisCoreDataSource> {
-      match self.engine.next_source() {
-        None => None,
-        Some(source) => {
-          self.pending = Some(source);
-          Some(HypothesisCoreDataSource::new(self))
-        },
-      }
+    fn finish_invalid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Invalid);
     }
 
-    def failing_example(&mut self) -> Option<HypothesisCoreDataSource> {
-      if let Some(source) = self.engine.best_source() {
-        self.pending = Some(source);
-        return Some(HypothesisCoreDataSource::new(self));
-      } else {
-        return None;
-      }
+    fn finish_interesting(&mut self, child: &mut HypothesisCoreDataSourceStruct, label: u64) {
+        mark_child_status(&mut self.engine, child, Status::Interesting(label));
     }
+}
+
+wrappable_struct!(
+    HypothesisCoreEngineStruct,
+    HypothesisCoreEngineStructWrapper,
+    HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER
+);
+
+class!(HypothesisCoreEngine);
 
-    def was_unsatisfiable(&mut self) -> bool {
-      self.engine.was_unsatisfiable()
+methods!(
+    HypothesisCoreEngine,
+    itself,
+    fn ruby_hypothesis_core_engine_new(
+        name: RString,
+        database_path: RString,
+        seed: Integer,
+        max_example: Integer
+    ) -> AnyObject {
+        let core_engine = HypothesisCoreEngineStruct::new(
+            safe_access(name).to_string(),
+            database_path.ok().map(|p| p.to_string()),
+            safe_access(seed).to_u64(),
+            safe_access(max_example).to_u64(),
+        );
+
+        Class::from_existing("HypothesisCoreEngine")
+            .wrap_data(core_engine, &*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER)
+    }
+    fn ruby_hypothesis_core_engine_new_source() -> AnyObject {
+        match itself
+            .get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER)
+            .new_source()
+        {
+            Some(ds) => Class::from_existing("HypothesisCoreDataSource")
+                .wrap_data(ds, &*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER),
+            None => NilClass::new().into(),
+        }
     }
+    fn ruby_hypothesis_core_engine_finish_overflow(child: AnyObject) -> NilClass {
+        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
+        let mut rdata_source = safe_access(child);
+        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
+
+        core_engine.finish_overflow(data_source);
+
+        NilClass::new()
+    }
+    fn ruby_hypothesis_core_engine_finish_valid(child: AnyObject) -> NilClass {
+        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
+        let mut rdata_source = safe_access(child);
+        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
+
+        core_engine.finish_valid(data_source);
 
-    def finish_overflow(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Overflow);
+        NilClass::new()
     }
+    fn ruby_hypothesis_core_engine_finish_invalid(child: AnyObject) -> NilClass {
+        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
+        let mut rdata_source = safe_access(child);
+        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
 
-    def finish_invalid(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Invalid);
+        core_engine.finish_invalid(data_source);
+
+        NilClass::new()
     }
+    fn ruby_hypothesis_core_engine_finish_interesting(
+        child: AnyObject,
+        label: Integer
+    ) -> NilClass {
+        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
+        let mut rdata_source = safe_access(child);
+        let data_source = rdata_source.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
+
+        core_engine.finish_interesting(data_source, safe_access(label).to_u64());
 
-    def finish_interesting(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Interesting);
+        NilClass::new()
     }
+    fn ruby_hypothesis_core_engine_count_failing_examples() -> Integer {
+        let core_engine = itself.get_data(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
 
-    def finish_valid(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Valid);
+        Integer::new(core_engine.count_failing_examples() as i64)
     }
-  }
+    fn ruby_hypothesis_core_failing_example(i: Integer) -> AnyObject {
+        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
+        let int = safe_access(i).to_u64() as usize;
+
+        let data_source = core_engine.failing_example(int);
 
-  class HypothesisCoreBitPossible{
-    struct {
-      n_bits: u64,
+        Class::from_existing("HypothesisCoreDataSource")
+            .wrap_data(data_source, &*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER)
     }
+    fn ruby_hypothesis_core_engine_was_unsatisfiable() -> Boolean {
+        let core_engine = itself.get_data_mut(&*HYPOTHESIS_CORE_ENGINE_STRUCT_WRAPPER);
 
-    def initialize(helix, n_bits: u64){
-      return HypothesisCoreBitPossible{helix, n_bits: n_bits};
+        Boolean::new(core_engine.was_unsatisfiable())
     }
+);
+
+pub struct HypothesisCoreIntegersStruct {
+    bitlengths: distributions::Sampler,
+}
 
-    def provide(&mut self, data: &mut HypothesisCoreDataSource) -> Option<u64>{
-      match &mut data.source {
-        &mut None => None,
-        &mut Some(ref mut source) => source.bits(self.n_bits).ok(),
-      }
+impl HypothesisCoreIntegersStruct {
+    fn new() -> HypothesisCoreIntegersStruct {
+        HypothesisCoreIntegersStruct {
+            bitlengths: distributions::good_bitlengths(),
+        }
     }
-  }
 
-  class HypothesisCoreRepeatValues{
-    struct {
-      repeat: Repeat,
+    fn provide(&mut self, data: &mut HypothesisCoreDataSourceStruct) -> Option<i64> {
+        data.source.as_mut().and_then(|ref mut source| {
+            distributions::integer_from_bitlengths(source, &self.bitlengths).ok()
+        })
     }
+}
+
+wrappable_struct!(
+    HypothesisCoreIntegersStruct,
+    HypothesisCoreIntegersStructWrapper,
+    HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER
+);
+
+class!(HypothesisCoreIntegers);
+
+methods!(
+    HypothesisCoreIntegers,
+    itself,
+    fn ruby_hypothesis_core_integers_new() -> AnyObject {
+        let core_integers = HypothesisCoreIntegersStruct::new();
 
-    def initialize(helix, min_count: u64, max_count: u64, expected_count: f64){
-      return HypothesisCoreRepeatValues{
-        helix, repeat: Repeat::new(min_count, max_count, expected_count)
-      }
+        Class::from_existing("HypothesisCoreIntegers")
+            .wrap_data(core_integers, &*HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER)
     }
+    fn ruby_hypothesis_core_integers_provide(data: AnyObject) -> AnyObject {
+        let core_integers = itself.get_data_mut(&*HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER);
+        let mut rdata = safe_access(data);
+        let data_source = rdata.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
 
-    def _should_continue(&mut self, data: &mut HypothesisCoreDataSource) -> Option<bool>{
-      return data.source.as_mut().and_then(|ref mut source| {
-        self.repeat.should_continue(source).ok()
-      })
+        match core_integers.provide(data_source) {
+            Some(i) => Integer::new(i).into(),
+            None => NilClass::new().into(),
+        }
     }
+);
 
-    def reject(&mut self){
-      self.repeat.reject();
+pub struct HypothesisCoreRepeatValuesStruct {
+    repeat: Repeat,
+}
+
+impl HypothesisCoreRepeatValuesStruct {
+    fn new(
+        min_count: u64,
+        max_count: u64,
+        expected_count: f64,
+    ) -> HypothesisCoreRepeatValuesStruct {
+        HypothesisCoreRepeatValuesStruct {
+            repeat: Repeat::new(min_count, max_count, expected_count),
+        }
     }
-  }
 
-  class HypothesisCoreIntegers{
-    struct {
-        bitlengths: distributions::Sampler,
+    fn _should_continue(&mut self, data: &mut HypothesisCoreDataSourceStruct) -> Option<bool> {
+        return data
+            .source
+            .as_mut()
+            .and_then(|ref mut source| self.repeat.should_continue(source).ok());
     }
-    def initialize(helix){
-      return HypothesisCoreIntegers{helix,bitlengths: distributions::good_bitlengths()};
+
+    fn reject(&mut self) {
+        self.repeat.reject();
     }
-    def provide(&mut self, data: &mut HypothesisCoreDataSource) -> Option<i64>{
-      data.source.as_mut().and_then(|ref mut source| {
-        distributions::integer_from_bitlengths(source, &self.bitlengths).ok()
-      })
+}
+
+wrappable_struct!(
+    HypothesisCoreRepeatValuesStruct,
+    HypothesisCoreRepeatValuesStructWrapper,
+    HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER
+);
+
+class!(HypothesisCoreRepeatValues);
+
+methods!(
+    HypothesisCoreRepeatValues,
+    itself,
+    fn ruby_hypothesis_core_repeat_values_new(
+        min_count: Integer,
+        max_count: Integer,
+        expected_count: Float
+    ) -> AnyObject {
+        let repeat_values = HypothesisCoreRepeatValuesStruct::new(
+            safe_access(min_count).to_u64(),
+            safe_access(max_count).to_u64(),
+            safe_access(expected_count).to_f64(),
+        );
+
+        Class::from_existing("HypothesisCoreRepeatValues").wrap_data(
+            repeat_values,
+            &*HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER,
+        )
     }
-  }
+    fn ruby_hypothesis_core_repeat_values_should_continue(data: AnyObject) -> AnyObject {
+        let mut rdata = safe_access(data);
+        let mut data_source = rdata.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
+
+        let should_continue = itself
+            .get_data_mut(&*HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER)
+            ._should_continue(data_source);
 
-  class HypothesisCoreBoundedIntegers{
-    struct {
-        max_value: u64,
+        match should_continue {
+            Some(b) => Boolean::new(b).into(),
+            None => NilClass::new().into(),
+        }
     }
-    def initialize(helix, max_value: u64){
-      return HypothesisCoreBoundedIntegers{helix, max_value: max_value};
+    fn ruby_hypothesis_core_repeat_values_reject() -> NilClass {
+        let repeat_values = itself.get_data_mut(&*HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER);
+
+        repeat_values.reject();
+
+        NilClass::new()
     }
+);
 
-    def provide(&mut self, data: &mut HypothesisCoreDataSource) -> Option<u64>{
-      data.source.as_mut().and_then(|ref mut source| {
-        distributions::bounded_int(source, self.max_value).ok()
-      })
+pub struct HypothesisCoreBoundedIntegersStruct {
+    max_value: u64,
+}
+
+impl HypothesisCoreBoundedIntegersStruct {
+    fn provide(&mut self, data: &mut HypothesisCoreDataSourceStruct) -> Option<u64> {
+        data.source
+            .as_mut()
+            .and_then(|ref mut source| distributions::bounded_int(source, self.max_value).ok())
     }
-  }
 }
 
-fn mark_child_status(engine: &mut Engine, child: &mut HypothesisCoreDataSource, status: Status) {
-    let mut replacement = None;
-    mem::swap(&mut replacement, &mut child.source);
+wrappable_struct!(
+    HypothesisCoreBoundedIntegersStruct,
+    HypothesisCoreBoundedIntegersStructWrapper,
+    HYPOTHESIS_CORE_BOUNDED_INTEGERS_STRUCT_WRAPPER
+);
+
+class!(HypothesisCoreBoundedIntegers);
+
+methods!(
+    HypothesisCoreBoundedIntegers,
+    itself,
+    fn ruby_hypothesis_core_bounded_integers_new(max_value: Integer) -> AnyObject {
+        let bounded_integers = HypothesisCoreBoundedIntegersStruct {
+            max_value: safe_access(max_value).to_u64(),
+        };
+
+        Class::from_existing("HypothesisCoreBoundedIntegers").wrap_data(
+            bounded_integers,
+            &*HYPOTHESIS_CORE_BOUNDED_INTEGERS_STRUCT_WRAPPER,
+        )
+    }
+    fn ruby_hypothesis_core_bounded_integers_provide(data: AnyObject) -> AnyObject {
+        let mut rdata = safe_access(data);
+        let data_source = rdata.get_data_mut(&*HYPOTHESIS_CORE_DATA_SOURCE_STRUCT_WRAPPER);
+        let bounded_integers =
+            itself.get_data_mut(&*HYPOTHESIS_CORE_BOUNDED_INTEGERS_STRUCT_WRAPPER);
+
+        match bounded_integers.provide(data_source) {
+            Some(i) => Integer::from(i).into(),
+            None => NilClass::new().into(),
+        }
+    }
+);
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_rutie_hypothesis_core() {
+    Class::new("HypothesisCoreEngine", None).define(|klass| {
+        klass.def_self("new", ruby_hypothesis_core_engine_new);
+        klass.def("new_source", ruby_hypothesis_core_engine_new_source);
+        klass.def(
+            "count_failing_examples",
+            ruby_hypothesis_core_engine_count_failing_examples,
+        );
+        klass.def("failing_example", ruby_hypothesis_core_failing_example);
+        klass.def(
+            "was_unsatisfiable",
+            ruby_hypothesis_core_engine_was_unsatisfiable,
+        );
+        klass.def(
+            "finish_overflow",
+            ruby_hypothesis_core_engine_finish_overflow,
+        );
+        klass.def("finish_valid", ruby_hypothesis_core_engine_finish_valid);
+        klass.def("finish_invalid", ruby_hypothesis_core_engine_finish_invalid);
+        klass.def(
+            "finish_interesting",
+            ruby_hypothesis_core_engine_finish_interesting,
+        );
+    });
+
+    Class::new("HypothesisCoreDataSource", None).define(|klass| {
+        klass.def("start_draw", ruby_hypothesis_core_data_source_start_draw);
+        klass.def("stop_draw", ruby_hypothesis_core_data_source_stop_draw);
+    });
+
+    Class::new("HypothesisCoreIntegers", None).define(|klass| {
+        klass.def_self("new", ruby_hypothesis_core_integers_new);
+        klass.def("provide", ruby_hypothesis_core_integers_provide);
+    });
+
+    Class::new("HypothesisCoreRepeatValues", None).define(|klass| {
+        klass.def_self("new", ruby_hypothesis_core_repeat_values_new);
+        klass.def(
+            "_should_continue",
+            ruby_hypothesis_core_repeat_values_should_continue,
+        );
+        klass.def("reject", ruby_hypothesis_core_repeat_values_reject);
+    });
 
-    match replacement {
-        Some(source) => engine.mark_finished(source, status),
-        None => (),
+    Class::new("HypothesisCoreBoundedIntegers", None).define(|klass| {
+        klass.def_self("new", ruby_hypothesis_core_bounded_integers_new);
+        klass.def("provide", ruby_hypothesis_core_bounded_integers_provide);
+    });
+}
+
+fn mark_child_status(
+    engine: &mut Engine,
+    child: &mut HypothesisCoreDataSourceStruct,
+    status: Status,
+) {
+    if let Some(source) = mem::take(&mut child.source) {
+        engine.mark_finished(source, status)
     }
 }
+
+fn safe_access<T>(value: Result<T, AnyException>) -> T {
+  value.map_err(VM::raise_ex).unwrap()
+}

metadata

@@ -1,29 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: hypothesis-specs
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.3.0
 platform: ruby
 authors:
 - David R. Maciver
+- Alex Weisberger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-25 00:00:00.000000000 Z
+date: 2021-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: helix_runtime
+  name: rutie
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,6 +65,7 @@ files:
 - lib/hypothesis.rb
 - lib/hypothesis/engine.rb
 - lib/hypothesis/errors.rb
+- lib/hypothesis/junkdrawer.rb
 - lib/hypothesis/possible.rb
 - lib/hypothesis/testcase.rb
 - lib/hypothesis/world.rb
@@ -87,8 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.2.4
 signing_key: 
 specification_version: 4
 summary: Hypothesis is a powerful, flexible, and easy to use library for property-based