hypothesis-specs 0.0.3

data/src/lib.rs

@@ -0,0 +1,170 @@
+// "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;
+
+mod engine;
+mod data;
+mod distributions;
+
+use std::mem;
+
+use engine::Engine;
+use data::{DataSource, Status};
+use distributions::Repeat;
+
+ruby! {
+  class HypothesisCoreDataSource {
+    struct {
+      source: Option<DataSource>,
+    }
+
+    def initialize(helix, engine: &mut HypothesisCoreEngine){
+      let mut result = HypothesisCoreDataSource{helix, source: None};
+      mem::swap(&mut result.source, &mut engine.pending);
+      return result;
+    }
+  }
+
+  class HypothesisCoreEngine {
+    struct {
+      engine: Engine,
+      pending: Option<DataSource>,
+    }
+
+    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,
+      }
+    }
+
+    def new_source(&mut self) -> Option<HypothesisCoreDataSource> {
+      match self.engine.next_source() {
+        None => None,
+        Some(source) => {
+          self.pending = Some(source);
+          Some(HypothesisCoreDataSource::new(self))
+        },
+      }
+    }
+
+    def failing_example(&mut self) -> Option<HypothesisCoreDataSource> {
+      if let Some(source) = self.engine.best_source() {
+        self.pending = Some(source);
+        return Some(HypothesisCoreDataSource::new(self));
+      } else {
+        return None;
+      }
+    }
+
+    def 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);
+    }
+
+    def finish_invalid(&mut self, child: &mut HypothesisCoreDataSource){
+      mark_child_status(&mut self.engine, child, Status::Invalid);
+    }
+
+    def finish_interesting(&mut self, child: &mut HypothesisCoreDataSource){
+      mark_child_status(&mut self.engine, child, Status::Interesting);
+    }
+
+    def finish_valid(&mut self, child: &mut HypothesisCoreDataSource){
+      mark_child_status(&mut self.engine, child, Status::Valid);
+    }
+  }
+
+  class HypothesisCoreBitPossible{
+    struct {
+      n_bits: u64,
+    }
+
+    def initialize(helix, n_bits: u64){
+      return HypothesisCoreBitPossible{helix, n_bits: n_bits};
+    }
+
+    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(),
+      }
+    }
+  }
+
+  class HypothesisCoreRepeatValues{
+    struct {
+      repeat: Repeat,
+    }
+
+    def initialize(helix, min_count: u64, max_count: u64, expected_count: f64){
+      return HypothesisCoreRepeatValues{
+        helix, repeat: Repeat::new(min_count, max_count, expected_count)
+      }
+    }
+
+    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()
+      })
+    }
+
+    def reject(&mut self){
+      self.repeat.reject();
+    }
+  }
+
+  class HypothesisCoreIntegers{
+    struct {
+        bitlengths: distributions::Sampler,
+    }
+    def initialize(helix){
+      return HypothesisCoreIntegers{helix,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()
+      })
+    }
+  }
+
+  class HypothesisCoreBoundedIntegers{
+    struct {
+        max_value: u64,
+    }
+    def initialize(helix, max_value: u64){
+      return HypothesisCoreBoundedIntegers{helix, max_value: max_value};
+    }
+
+    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()
+      })
+    }
+  }
+}
+
+fn mark_child_status(engine: &mut Engine, child: &mut HypothesisCoreDataSource, status: Status) {
+    let mut replacement = None;
+    mem::swap(&mut replacement, &mut child.source);
+
+    match replacement {
+        Some(source) => engine.mark_finished(source, status),
+        None => (),
+    }
+}

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: hypothesis-specs
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- David R. Maciver
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: helix_runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 'A port of the Hypothesis property-based testing library to Ruby
+
+'
+email: david@drmaciver.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Cargo.toml
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- ext/Makefile
+- ext/extconf.rb
+- lib/hypothesis.rb
+- lib/hypothesis/engine.rb
+- lib/hypothesis/errors.rb
+- lib/hypothesis/possible.rb
+- lib/hypothesis/testcase.rb
+- lib/hypothesis/world.rb
+- src/data.rs
+- src/distributions.rs
+- src/engine.rs
+- src/lib.rs
+homepage: http://github.com/HypothesisWorks/hypothesis-ruby
+licenses:
+- MPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: A port of the Hypothesis property-based testing library to Ruby
+test_files: []