hypothesis-specs 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c8b0daf467cfba3ff5d8713fca58165154c19dbe24a9c063337da10244a4858
-  data.tar.gz: 5220bf53ee4d96028f54ffc0cb3513f263e06b5edb53a549a00bc3e4720ddbaf
+  metadata.gz: 748dfd8fb0c05573aecd17da1fb658a3d3add0ae731e16dc8f3f9274cd5db006
+  data.tar.gz: ffd23f44bd8fa7eaca616cc00bc497033d6c9557761c8ffacdc756d3b6bad080
 SHA512:
-  metadata.gz: a33f06784dec07894b9d0bb3ff0bd8366c78d0a332e25c9fac5e5589b6026f7cacc22a12575c1010416116f3527e07b9603a2da96e763148b9bdaa3ca1d085b9
-  data.tar.gz: a92b046f6384b42a6e28d836a29b6f654944fc9a8cccd6ff27ff6b8682a9d9588a7c326177aca48e6376866754fcda85c15b0734e728cc905d69fae146ac7683
+  metadata.gz: a1e26c552c6baaf4fcf3fa1ef3784ad911c5a06c1582b3153daf09b6f618900656ac08f2377c9fba834e5a1ecd2a2ae90d6f33a542b457fb23db30760265b058
+  data.tar.gz: 2fd4b38d077f32f978010612c72a613b4692f6299b4d5b66885afffe6b22180a4f834d5769f456b29f00a7eb3dc2b31246cae7a7410e2532d183aa61c5651b02

data/CHANGELOG.md

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

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.3.0'
+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
@@ -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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'hypothesis/junkdrawer'
-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
@@ -19,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
@@ -122,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.
@@ -140,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:
   #
@@ -170,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,20 +1,25 @@
 # frozen_string_literal: true
 
-require 'helix_runtime'
-require '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)
       )
 
       @exceptions_to_tags = Hash.new { |h, k| h[k] = h.size }

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,187 +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 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;
 
-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();
+        }
     }
 
-    def initialize(helix, engine: &mut HypothesisCoreEngine){
-      let mut result = HypothesisCoreDataSource{helix, source: None};
-      mem::swap(&mut result.source, &mut engine.pending);
-      return result;
+    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();
 
-    def start_draw(&mut self){
-      if let &mut Some(ref mut source) = &mut self.source {
-        source.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 stop_draw(&mut self){
-      if let &mut Some(ref mut source) = &mut self.source {
-        source.stop_draw();
-      }
+        NilClass::new()
     }
-  }
+);
 
-  class HypothesisCoreEngine {
-    struct {
-      engine: Engine,
-      pending: Option<DataSource>,
-      interesting_examples: Vec<TestResult>,
+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(),
+        }
     }
 
-    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 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 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 count_failing_examples(&self) -> usize {
+        self.interesting_examples.len()
     }
 
-    def 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 failing_example(&mut self, i: usize) -> HypothesisCoreDataSource {
-      self.pending = Some(
-        DataSource::from_vec(self.interesting_examples[i].record.clone())
-      );
-      HypothesisCoreDataSource::new(self)
+    fn was_unsatisfiable(&mut self) -> bool {
+        self.engine.was_unsatisfiable()
     }
 
-    def was_unsatisfiable(&mut self) -> bool {
-      self.engine.was_unsatisfiable()
+    fn finish_overflow(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Overflow);
     }
 
-    def finish_overflow(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Overflow);
+    fn finish_valid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Valid);
     }
 
-    def finish_invalid(&mut self, child: &mut HypothesisCoreDataSource){
-      mark_child_status(&mut self.engine, child, Status::Invalid);
+    fn finish_invalid(&mut self, child: &mut HypothesisCoreDataSourceStruct) {
+        mark_child_status(&mut self.engine, child, Status::Invalid);
+    }
+
+    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::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);
+
+        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);
+
+        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);
 
-    def finish_interesting(&mut self, child: &mut HypothesisCoreDataSource, label: u64){
-      mark_child_status(&mut self.engine, child, Status::Interesting(label));
+        core_engine.finish_interesting(data_source, safe_access(label).to_u64());
+
+        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())
     }
+);
 
-    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(),
-      }
+pub struct HypothesisCoreIntegersStruct {
+    bitlengths: distributions::Sampler,
+}
+
+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()
+        })
     }
+}
 
-    def initialize(helix, min_count: u64, max_count: u64, expected_count: f64){
-      return HypothesisCoreRepeatValues{
-        helix, repeat: Repeat::new(min_count, max_count, expected_count)
-      }
+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();
+
+        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(),
+        }
     }
+);
+
+pub struct HypothesisCoreRepeatValuesStruct {
+    repeat: Repeat,
+}
 
-    def reject(&mut self){
-      self.repeat.reject();
+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);
 
-  class HypothesisCoreBoundedIntegers{
-    struct {
-        max_value: u64,
+        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(),
+        }
     }
-    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()
     }
+);
+
+pub struct HypothesisCoreBoundedIntegersStruct {
+    max_value: u64,
+}
 
-    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 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(),
+        };
 
-    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.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - David R. Maciver
+- Alex Weisberger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-16 00:00:00.000000000 Z
+date: 2021-01-12 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.5
 signing_key: 
 specification_version: 4
 summary: Hypothesis is a powerful, flexible, and easy to use library for property-based