hypothesis-specs 0.1.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e514de73ab86bfeae1d5e5801ee47e8865c4a06d90f2053f4318f9dd9df19cb
-  data.tar.gz: 1aff7880e50e37ee73f287ac2cd318a9201cf2ba09d45ca79ad9b778eeb2d3bd
+  metadata.gz: 8be81d7cc1c3be388507a5776c3ec411b382e8292be1678bc30ffcccac5678f7
+  data.tar.gz: 269f363638fe7d27823b159564772edd31a078127d04ac65fc04dd6b1404f2f0
 SHA512:
-  metadata.gz: fef51bf7876fc9b0b27363e8f73f84fa4ffde68a6ac2312b9f70bd780da1dd9a8923eeff14e092679c52d1fc74136a2529ae468a4e748ad021212e391846156b
-  data.tar.gz: 1ba9eb0a28cde4f29a127086ecb2fdce722566cc38b3cd4cfc741ec91b704501d293c10b00828ae7efcd4df931e44518e01e312da15b8a55ef0b946573b90c6b
+  metadata.gz: 34ec25611305e1742428cbba1f1a171d2b5fc5068d96a6bacf565c24fe38c7ad4b5ff3100cb86138f744bd7276a413e3c03935704593be352063d176dacbb9ba
+  data.tar.gz: 27212f3409766297782d0e7025aff4012d72bf20c61325e456172adee58076cd48b159ea912c06fe7b3c5045f99631f987df79aa5f65139d7f39b70705a658f6

data/CHANGELOG.md

@@ -1,3 +1,43 @@
+# Hypothesis for Ruby 0.6.0 (2021-01-27)
+
+Adds support for skipping shrinking. While shrinking is extremely helpful and important in general, it has the potential to be quite time consuming. It can be useful to observe a raw failure before choosing to allow the engine to try to shrink. [hypothesis-python](https://hypothesis.readthedocs.io/en/latest/settings.html#phases) already provides the ability to skip shrinking, so there is precedent for this being useful. While `hypothesis-ruby` does not have the concept of other "Phases" yet, we can still start off the API by using this concept.
+
+Usage:
+
+```
+hypothesis(phases: Phase.excluding(:shrink)) do
+  # Failures here will be displayed directly and shrinking will be avoided
+end
+```
+
+# Hypothesis for Ruby 0.5.0 (2021-01-25)
+
+Adds support for skipping shrinking. While shrinking is extremely helpful and important in general, it has the potential to be quite time consuming. It can be useful to observe a raw failure before choosing to allow the engine to try to shrink. [hypothesis-python](https://hypothesis.readthedocs.io/en/latest/settings.html#phases) already provides the ability to skip shrinking, so there is precedent for this being useful. While `hypothesis-ruby` does not have the concept of other "Phases" yet, we can still start off the API by using this concept.
+
+Usage:
+
+```
+hypothesis(phases: Phase.excluding(:shrink)) do
+  # Failures here will be displayed directly and shrinking will be avoided
+end
+```
+
+# Hypothesis for Ruby 0.4.0 (2021-01-12)
+
+This removes hypothesis-ruby's dependence on RSpec. Now, it can be used with any Ruby test runner.
+
+# 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.

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 Weisberger <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.3.0'
+conjecture = '0.6.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
@@ -71,7 +71,7 @@ Right now this is really more to allow you to try it out and provide feedback th
 The more feedback we get, the sooner it will get there!
 
 Note that in order to use Hypothesis for Ruby, you will need a rust toolchain installed.
-Please go to [https://www.rustup.rs](https://www.rustup.rs) and follow the instructions if you do not already have one.
+Please go to [https://www.rustup.rs](https://www.rustup.rs) and follow the instructions if you do not already have one. You will most likely need to compile your Ruby executable with the `--enable-shared` option. See [here](https://github.com/danielpclark/rutie#dynamic-vs-static-builds).
 
 ## Project Status
 

data/Rakefile

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'rubygems'
-require 'helix_runtime/build_task'
 require 'date'
 require 'open3'
 
+task :build do
+  sh('cargo build --release')
+end
+
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:spec)
@@ -17,10 +20,24 @@ begin
   end
 
   task test: %i[build spec minitests]
+  task rspec: %i[build spec]
+  task minitest: %i[build without_rspec] do
+    begin
+      Rake::Task['minitests'].execute
+    ensure
+      Rake::Task['with_rspec'].execute
+    end
+  end
 rescue LoadError
 end
 
-HelixRuntime::BuildTask.new
+task :without_rspec do
+  sh('bundle config set without rspec')
+end
+
+task :with_rspec do
+  sh('bundle config unset without')
+end
 
 def rubocop(fix:)
   sh "bundle exec rubocop #{'-a' if fix} lib spec minitests " \

data/lib/hypothesis.rb

@@ -7,6 +7,28 @@ require_relative 'hypothesis/testcase'
 require_relative 'hypothesis/engine'
 require_relative 'hypothesis/world'
 
+module Phase
+  SHRINK = :shrink
+
+  module_function
+
+  def all
+    [SHRINK]
+  end
+
+  def excluding(*phases)
+    unknown_phases = phases.reject { |phase| Phase.all.include?(phase) }
+    unless unknown_phases.empty?
+      raise(
+        ArgumentError,
+        "Attempting to exclude unknown phases: #{unknown_phases}"
+      )
+    end
+
+    all - phases
+  end
+end
+
 # This is the main module for using Hypothesis.
 # It is expected that you will include this in your
 # tests, but its methods are also available on the
@@ -19,6 +41,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
@@ -140,12 +179,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:
   #
@@ -170,13 +218,27 @@ 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,
+    phases: Phase.all,
+    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,
+        phases: phases,
+        database: database
       )
       World.current_engine.run(&block)
     ensure

data/lib/hypothesis/engine.rb

@@ -1,22 +1,29 @@
 # frozen_string_literal: true
 
-require 'helix_runtime'
-
-require_relative '../hypothesis-ruby/native'
-
-require 'rspec/expectations'
+require 'rutie'
 
 module Hypothesis
-  class Engine
-    include RSpec::Matchers
+  DEFAULT_DATABASE_PATH = File.join(Dir.pwd, '.hypothesis', 'examples')
 
+  class Engine
     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),
+        options.fetch(:phases)
       )
 
       @exceptions_to_tags = Hash.new { |h, k| h[k] = h.size }

data/src/lib.rs

@@ -1,184 +1,487 @@
-// "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::convert::TryFrom;
 use std::mem;
 
+use rutie::{
+    AnyException, AnyObject, Array, Boolean, Class, Exception, Float, Integer, NilClass, Object,
+    RString, Symbol, VM,
+};
+
 use conjecture::data::{DataSource, Status, TestResult};
-use conjecture::distributions::Repeat;
+use conjecture::database::{BoxedDatabase, DirectoryDatabase, NoDatabase};
 use conjecture::distributions;
-use conjecture::engine::Engine;
+use conjecture::distributions::Repeat;
+use conjecture::engine::{Engine, Phase};
+
+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();
 
-ruby! {
-  class HypothesisCoreDataSource {
-    struct {
-      source: Option<DataSource>,
+        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,
+        phases: Vec<Phase>,
+    ) -> 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, phases, &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>,
-      interesting_examples: Vec<TestResult>,
+    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,
-        interesting_examples: Vec::new(),
-      }
+    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 => {
-          self.interesting_examples = self.engine.list_minimized_examples();
-          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 count_failing_examples(&self) -> usize {
-      self.interesting_examples.len()
+    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,
+        phases: Array
+    ) -> AnyObject {
+        let rust_phases = safe_access(phases)
+            .into_iter()
+            .map(|ruby_phase| {
+                let phase_sym = safe_access(ruby_phase.try_convert_to::<Symbol>());
+                let phase = Phase::try_from(phase_sym.to_str())
+                    .map_err(|e| AnyException::new("ArgumentError", Some(&e)));
+
+                safe_access(phase)
+            })
+            .collect();
 
-    def failing_example(&mut self, i: usize) -> HypothesisCoreDataSource {
-      self.pending = Some(
-        DataSource::from_vec(self.interesting_examples[i].record.clone())
-      );
-      HypothesisCoreDataSource::new(self)
+        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(),
+            rust_phases,
+        );
+
+        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);
 
-    def was_unsatisfiable(&mut self) -> bool {
-      self.engine.was_unsatisfiable()
+        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, label: u64){
-      mark_child_status(&mut self.engine, child, Status::Interesting(label));
+        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.1.2
+  version: 0.6.0
 platform: ruby
 authors:
 - David R. Maciver
+- Alex Weisberger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-24 00:00:00.000000000 Z
+date: 2021-01-27 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.7
 signing_key: 
 specification_version: 4
 summary: Hypothesis is a powerful, flexible, and easy to use library for property-based