hypothesis-specs 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ceb7e5a7e7c564c26e971e6e5aacce7599ef8c3b810b879141c8ea9e97f2b7f
-  data.tar.gz: f5de9db4207eea15c790475cc43540faf30d69e5587be623dedf6b954b556f04
+  metadata.gz: 77c742dcfc65dfcab8e0eac24498eff24b10461abf17f502961ac9fc30bd1810
+  data.tar.gz: 6a73fbe38f860e2b2b9f9fd68cde16a33657eb05d0117a3a2e78ab5dfa8e2226
 SHA512:
-  metadata.gz: 79c6389fefaca46af95d01f1b285a6e2cc1f9dc30c185da5efd6363e65b00f00794a9ca21ee5b551e6bb06df235c10b00777b0a8d27b3c09d8e10cdf834944ff
-  data.tar.gz: 5129459dbc559cb3b08354e3c0e36f691a2f9aea7f58dacf01a69760bcd9d6b06d7a7e905ac19b768b31d285ce30a7c587ab8dab54a546eb600e5e14b42d069c
+  metadata.gz: 8b0da0f3b0820c93b32af05eb040fd6d88e86748a8fd99c38609a204944a84b773f2e53bf757c103c0c0f5a6e66097fd65c839ca95c0ec8360c9ac1ae1814153
+  data.tar.gz: 0a2d28a1fbc0e3b87fa96452a6028d0f0f8e00d223eb1440f1daf86eb3e40ec33c25c21222c9a2fc585d053dcca63e9de6d9d0e96ca7eb277e452e0baa77c2ac

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 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,

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.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

@@ -19,6 +19,23 @@ require_relative '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
@@ -188,6 +205,7 @@ module Hypothesis
     unless World.current_engine.nil?
       raise UsageError, 'Cannot nest hypothesis calls'
     end
+
     begin
       World.current_engine = Engine.new(
         hypothesis_stable_identifier,

data/lib/hypothesis/engine.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'helix_runtime'
-
-require_relative '../hypothesis-ruby/native'
+require 'rutie'
 
 require 'rspec/expectations'
 

data/src/lib.rs

@@ -1,190 +1,469 @@
-// "Bridging" root code that exists exclusively to provide
-// a ruby -> Hypothesis engine binding.
-
-#![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 rutie::{AnyException, AnyObject, Boolean, Class, Float, Integer, NilClass, Object, RString, VM};
+
 use conjecture::data::{DataSource, Status, TestResult};
-use conjecture::distributions::Repeat;
+use conjecture::database::{BoxedDatabase, DirectoryDatabase, NoDatabase};
 use conjecture::distributions;
+use conjecture::distributions::Repeat;
 use conjecture::engine::Engine;
-use conjecture::database::{BoxedDatabase, NoDatabase, DirectoryDatabase};
 
-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),
+        }
     }
 
-    def initialize(helix, engine: &mut HypothesisCoreEngine){
-      let mut result = HypothesisCoreDataSource{helix, source: None};
-      mem::swap(&mut result.source, &mut engine.pending);
-      return result;
+    fn start_draw(&mut self) {
+        if let Some(ref mut source) = self.source {
+            source.start_draw();
+        }
     }
 
-    def start_draw(&mut self){
-      if let &mut Some(ref mut source) = &mut self.source {
-        source.start_draw();
-      }
+    fn stop_draw(&mut self) {
+        if let Some(ref mut source) = self.source {
+            source.stop_draw();
+        }
     }
+}
 
-    def stop_draw(&mut self){
-      if let &mut Some(ref mut source) = &mut 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();
 
-  class HypothesisCoreEngine {
-    struct {
-      engine: Engine,
-      pending: Option<DataSource>,
-      interesting_examples: Vec<TestResult>,
+        NilClass::new()
     }
+);
+
+pub struct HypothesisCoreEngineStruct {
+    engine: Engine,
+    pending: Option<DataSource>,
+    interesting_examples: Vec<TestResult>,
+}
 
-    def initialize(helix, name: String, database_path: Option<String>, seed: u64, max_examples: u64){
-      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)),
-      };
+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)),
+        };
 
-      HypothesisCoreEngine{
-        helix,
-        engine: Engine::new(name, max_examples, &xs, db),
-        pending: None,
-        interesting_examples: Vec::new(),
-      }
+        HypothesisCoreEngineStruct {
+            engine: Engine::new(name, max_examples, &xs, db),
+            pending: None,
+            interesting_examples: Vec::new(),
+        }
     }
 
-    def new_source(&mut self) -> Option<HypothesisCoreDataSource> {
-      match self.engine.next_source() {
-        None => {
-          self.interesting_examples = self.engine.list_minimized_examples();
-          None
-        },
-        Some(source) => {
-          self.pending = Some(source);
-          Some(HypothesisCoreDataSource::new(self))
-        },
-      }
+    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))
+            }
+        }
     }
 
-    def count_failing_examples(&self) -> usize {
-      self.interesting_examples.len()
+    fn count_failing_examples(&self) -> usize {
+        self.interesting_examples.len()
     }
 
-    def failing_example(&mut self, i: usize) -> HypothesisCoreDataSource {
-      self.pending = Some(
-        DataSource::from_vec(self.interesting_examples[i].record.clone())
-      );
-      HypothesisCoreDataSource::new(self)
+    fn failing_example(&mut self, i: usize) -> HypothesisCoreDataSourceStruct {
+        self.pending = Some(DataSource::from_vec(
+            self.interesting_examples[i].record.clone(),
+        ));
+        HypothesisCoreDataSourceStruct::new(self)
     }
 
-    def was_unsatisfiable(&mut self) -> bool {
-      self.engine.was_unsatisfiable()
+    fn was_unsatisfiable(&mut self) -> bool {
+        self.engine.was_unsatisfiable()
     }
 
-    def finish_overflow(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Overflow);
+    fn finish_overflow(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Overflow);
     }
 
-    def finish_invalid(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Invalid);
+    fn finish_valid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Valid);
     }
 
-    def finish_interesting(&mut self, child: &mut HypothesisCoreDataSource, label: u64){
-      mark_child_status(&mut self.engine, child, Status::Interesting(label));
+    fn finish_invalid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Invalid);
     }
 
-    def finish_valid(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Valid);
+    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);
+
+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 HypothesisCoreBitPossible{
-    struct {
-      n_bits: 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);
 
-    def initialize(helix, n_bits: u64){
-      return HypothesisCoreBitPossible{helix, n_bits: n_bits};
+        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 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(),
-      }
+        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);
 
-  class HypothesisCoreRepeatValues{
-    struct {
-      repeat: Repeat,
+        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 initialize(helix, min_count: u64, max_count: u64, expected_count: f64){
-      return HypothesisCoreRepeatValues{
-        helix, repeat: Repeat::new(min_count, max_count, expected_count)
-      }
+        NilClass::new()
     }
+    fn ruby_hypothesis_core_engine_count_failing_examples() -> Integer {
+        let core_engine = itself.get_data(&*HYPOTHESIS_CORE_ENGINE_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()
-      })
+        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;
 
-    def reject(&mut self){
-      self.repeat.reject();
+        let data_source = core_engine.failing_example(int);
+
+        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);
 
-  class HypothesisCoreIntegers{
-    struct {
-        bitlengths: distributions::Sampler,
+        Boolean::new(core_engine.was_unsatisfiable())
     }
-    def initialize(helix){
-      return HypothesisCoreIntegers{helix,bitlengths: distributions::good_bitlengths()};
+);
+
+pub struct HypothesisCoreIntegersStruct {
+    bitlengths: distributions::Sampler,
+}
+
+impl HypothesisCoreIntegersStruct {
+    fn new() -> HypothesisCoreIntegersStruct {
+        HypothesisCoreIntegersStruct {
+            bitlengths: distributions::good_bitlengths(),
+        }
     }
-    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()
-      })
+
+    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);
 
-  class HypothesisCoreBoundedIntegers{
-    struct {
-        max_value: u64,
+methods!(
+    HypothesisCoreIntegers,
+    itself,
+    fn ruby_hypothesis_core_integers_new() -> AnyObject {
+        let core_integers = HypothesisCoreIntegersStruct::new();
+
+        Class::from_existing("HypothesisCoreIntegers")
+            .wrap_data(core_integers, &*HYPOTHESIS_CORE_INTEGERS_STRUCT_WRAPPER)
     }
-    def initialize(helix, max_value: u64){
-      return HypothesisCoreBoundedIntegers{helix, max_value: max_value};
+    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);
+
+        match core_integers.provide(data_source) {
+            Some(i) => Integer::new(i).into(),
+            None => NilClass::new().into(),
+        }
     }
+);
+
+pub struct HypothesisCoreRepeatValuesStruct {
+    repeat: Repeat,
+}
 
-    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()
-      })
+impl HypothesisCoreRepeatValuesStruct {
+    fn new(
+        min_count: u64,
+        max_count: u64,
+        expected_count: f64,
+    ) -> HypothesisCoreRepeatValuesStruct {
+        HypothesisCoreRepeatValuesStruct {
+            repeat: Repeat::new(min_count, max_count, expected_count),
+        }
     }
-  }
+
+    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());
+    }
+
+    fn reject(&mut self) {
+        self.repeat.reject();
+    }
+}
+
+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);
+
+        match should_continue {
+            Some(b) => Boolean::new(b).into(),
+            None => NilClass::new().into(),
+        }
+    }
+    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()
+    }
+);
+
+pub struct HypothesisCoreBoundedIntegersStruct {
+    max_value: u64,
 }
 
-fn mark_child_status(engine: &mut Engine, child: &mut HypothesisCoreDataSource, status: Status) {
-    let mut replacement = None;
-    mem::swap(&mut replacement, &mut child.source);
+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())
+    }
+}
+
+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(),
+        };
 
-    match replacement {
-        Some(source) => engine.mark_finished(source, status),
-        None => (),
+        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);
+    });
+
+    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.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - David R. Maciver
+- Alex Weisberger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-24 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
@@ -88,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