hypothesis-specs 0.2.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ceb7e5a7e7c564c26e971e6e5aacce7599ef8c3b810b879141c8ea9e97f2b7f
-  data.tar.gz: f5de9db4207eea15c790475cc43540faf30d69e5587be623dedf6b954b556f04
+  metadata.gz: a79509b16d94eae8514d1601878d3fb5a1ba1885f385ae7caf27673874508a51
+  data.tar.gz: ebc2a3661f7a1d9b82c839faed66006de0f95357e4615645788cbe3fd074674d
 SHA512:
-  metadata.gz: 79c6389fefaca46af95d01f1b285a6e2cc1f9dc30c185da5efd6363e65b00f00794a9ca21ee5b551e6bb06df235c10b00777b0a8d27b3c09d8e10cdf834944ff
-  data.tar.gz: 5129459dbc559cb3b08354e3c0e36f691a2f9aea7f58dacf01a69760bcd9d6b06d7a7e905ac19b768b31d285ce30a7c587ab8dab54a546eb600e5e14b42d069c
+  metadata.gz: dba3693d2d2ad38d5efa17ffecf2c70148b6cc1a5e5e2c8e7c89673a42efb183bd1fb374f2129cd81cffe974da90514a8f44d73e4c46602596e4910d98bc3340
+  data.tar.gz: 7dd4894162024a4bfc45df2de1b2aa72803d835f5e4f90f87b8cf5397e88ac48d9e6806440622f5f89b4a4cb9eea60429568404b7c965a099733c5d8d008e2a3

data/CHANGELOG.md

@@ -1,3 +1,41 @@
+# Hypothesis for Ruby 0.6.1 (2021-02-01)
+
+This patch contains minor performance improvements for `HypothesisCoreIntegers` class instantiation.
+
+# 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,

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.4.0'
+conjecture = '0.7.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
@@ -184,14 +223,21 @@ module 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)
+  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(
         hypothesis_stable_identifier,
         max_examples: max_valid_test_cases,
+        phases: phases,
         database: database
       )
       World.current_engine.run(&block)

data/lib/hypothesis/engine.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
-require 'helix_runtime'
-
-require_relative '../hypothesis-ruby/native'
-
-require 'rspec/expectations'
+require 'rutie'
 
 module Hypothesis
   DEFAULT_DATABASE_PATH = File.join(Dir.pwd, '.hypothesis', 'examples')
 
   class Engine
-    include RSpec::Matchers
-
     attr_reader :current_source
     attr_accessor :is_find
 
@@ -25,7 +19,11 @@ module Hypothesis
       database = nil if database == false
 
       @core_engine = HypothesisCoreEngine.new(
-        name, database, 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,190 +1,492 @@
-// "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::database::{BoxedDatabase, NoDatabase, DirectoryDatabase};
+use conjecture::distributions::Repeat;
+use conjecture::engine::{Engine, Phase};
+
+pub struct HypothesisCoreDataSourceStruct {
+    source: Option<DataSource>,
+}
 
-ruby! {
-  class HypothesisCoreDataSource {
-    struct {
-      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);
+
+#[rustfmt::skip]
+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,
+        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)),
+        };
 
-      HypothesisCoreEngine{
-        helix,
-        engine: Engine::new(name, max_examples, &xs, db),
-        pending: None,
-        interesting_examples: Vec::new(),
-      }
+        HypothesisCoreEngineStruct {
+            engine: Engine::new(name, max_examples, phases, &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);
+
+#[rustfmt::skip]
+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)));
 
-  class HypothesisCoreBitPossible{
-    struct {
-      n_bits: u64,
+                safe_access(phase)
+            })
+            .collect();
+
+        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 initialize(helix, n_bits: u64){
-      return HypothesisCoreBitPossible{helix, n_bits: n_bits};
+        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 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 HypothesisCoreBoundedIntegers{
-    struct {
-        max_value: u64,
+class!(HypothesisCoreIntegers);
+
+#[rustfmt::skip]
+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(),
+        }
     }
+);
 
-    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 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),
+        }
+    }
+
+    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();
     }
-  }
 }
 
-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!(
+    HypothesisCoreRepeatValuesStruct,
+    HypothesisCoreRepeatValuesStructWrapper,
+    HYPOTHESIS_CORE_REPEAT_VALUES_STRUCT_WRAPPER
+);
+
+class!(HypothesisCoreRepeatValues);
+
+#[rustfmt::skip]
+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 replacement {
-        Some(source) => engine.mark_finished(source, status),
-        None => (),
+        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,
+}
+
+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);
+
+#[rustfmt::skip]
+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);
+    });
+
+    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.6.1
 platform: ruby
 authors:
 - David R. Maciver
+- Alex Weisberger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-24 00:00:00.000000000 Z
+date: 2021-02-01 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