propr 0.2.0

data/Rakefile

@@ -0,0 +1,83 @@
+require "pathname"
+abspath = Pathname.new(File.dirname(__FILE__)).expand_path
+relpath = abspath.relative_path_from(Pathname.pwd)
+
+begin
+  require "rubygems"
+  require "bundler/setup"
+rescue LoadError
+  warn "couldn't load bundler:"
+  warn "  #{$!}"
+end
+
+task :console do
+  exec *%w(irb -I lib -r propr)
+end
+
+begin
+  require "rspec/core/rake_task"
+
+  RSpec::Core::RakeTask.new do |t|
+    t.verbose = false
+    t.pattern = "#{relpath}/spec/examples/**/*.example"
+
+    t.rspec_opts  = %w(--color)
+    t.rspec_opts << "--profile"
+    t.rspec_opts << "-I#{abspath}/spec"
+  end
+rescue LoadError
+  task :spec do
+    warn "couldn't load rspec"
+    warn "  #{$!}"
+    exit 1
+  end
+end
+
+begin
+  require "rcov"
+  begin
+    require "rspec/core/rake_task"
+    RSpec::Core::RakeTask.new(:rcov) do |t|
+      t.rcov = true
+      t.rcov_opts = "--exclude spec/,gems/,00401"
+
+      t.verbose = false
+      t.pattern = "#{relpath}/spec/examples/**/*.example"
+
+      t.rspec_opts  = %w(--color --format p)
+      t.rspec_opts << "-I#{abspath}/spec"
+    end
+  rescue LoadError
+    task :rcov do
+      warn "couldn't load rspec"
+      warn "  #{$!}"
+      exit 1
+    end
+  end
+rescue LoadError
+  task :rcov do
+    warn "couldn't load rcov:"
+    warn "  #{$!}"
+    exit 1
+  end
+end
+
+begin
+  require "yard"
+
+  # Note options are loaded from .yardopts
+  YARD::Rake::YardocTask.new(:yard => :clobber_yard)
+
+  task :clobber_yard do
+    rm_rf "#{relpath}/doc/generated"
+    mkdir_p "#{relpath}/doc/generated/images"
+  end
+rescue LoadError
+  task :yard do
+    warn "couldn't load yard:"
+    warn "  #{$!}"
+    exit 1
+  end
+end
+
+task :default => :spec

data/TODO.md

@@ -0,0 +1,64 @@
+Priorities
+
+1. Write unit tests
+2. Write property tests
+3. Write example properties and subclasses (markup)
+4. API documentation
+5. User documentation
+6. Optimization (drop Ruby 1.8)
+7. Publish as rubygem
+8. Update Stupidedi
+
+Specifics
+
+* Organization of common properties
+
+```ruby
+module ShrinkSpecs
+  def self
+    # must hold for all implementations
+    property("no value is smaller than itself"){|x| not x.shrink.member?(x) }
+  end
+end
+
+describe String, "#shrink" do
+  # property holds for all implementations
+  ShrinkSpecs.self
+    .check { String.random ... }
+
+  # property of the String#shrink implementation
+  property("empty"){|s| s.shrink.member?("") }
+    .check { String.random ... }
+
+  # property of the String#shrink implementation
+  property("shorter"){|s| s.shrink.all?{|x| x.length < s.length }}
+    .check { String.random ... }
+end
+
+describe Integer, "#shrink" do
+  # property holds for all implementations
+  ShrinkSpecs.self
+    .check { Integer.random ... }
+
+  # property of the Integer#shrink implementation
+  property("smaller"){|n| n.shrink.all?{|m| m.abs < n.abs }}
+    .check { Integer.random ... }
+end
+```
+
+* Stateful random generation
+  * <del>Re-consider sized values (magntitude, center) or range?</del>
+  * <del>Re-implement sized values</del>
+* Steal `collect` and `classify` from QuickCheck
+
+```ruby
+property("foo") { ... }
+  .check{|rand| rand.integer.tap{|n| classify(n < 0, "negative") }
+                            .tap{|n| classify(n > 0, "positive") }}
+
+property("bar") { ... }
+  check{|rand| rand.array.tap{|xs| collect xs.length }}
+```
+
+* <del>Shrink input with breadth first</del>
+* See also: smallcheck, deepcheck

data/lib/propr.rb

@@ -0,0 +1,123 @@
+module Propr
+  autoload :Property,     "propr/property"
+  autoload :Dsl,          "propr/dsl"
+  autoload :Runner,       "propr/runner"
+  autoload :RSpec,        "propr/rspec"
+  autoload :RSpecAdapter, "propr/rspec"
+
+  require "fr"
+  require "propr/random"
+
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+
+  class GuardFailure < StandardError
+  end
+
+  class Falsifiable < StandardError
+    attr_reader :counterex, :shrunken, :passed, :skipped
+
+    def initialize(counterex, shrunken, passed, skipped)
+      @counterex, @shrunken, @passed, @skipped =
+        counterex, shrunken, passed, skipped
+    end
+
+    def counterex
+      Propr.wrap(@counterex)
+    end
+
+    def shrunken
+      Propr.wrap(@shrunken)
+    end
+
+    def to_s
+      if @shrunken.nil?
+        ["input: #{counterex.map(&:inspect).join(", ")}",
+         "after: #{@passed} passed, #{@skipped} skipped"].join("\n")
+      else
+        ["input:    #{counterex.map(&:inspect).join(", ")}",
+         "shrunken: #{shrunken.map(&:inspect).join(", ")}",
+         "after: #{@passed} passed, #{@skipped} skipped"].join("\n")
+      end
+    end
+  end
+
+  class Failure < StandardError
+    attr_reader :counterex, :shrunken, :passed, :skipped
+
+    def initialize(exception, counterex, shrunken, passed, skipped)
+      @exception, @counterex, @shrunken, @passed, @skipped =
+        exception, counterex, shrunken, passed, skipped
+    end
+
+    def counterex
+      Propr.wrap(@counterex)
+    end
+
+    def shrunken
+      Propr.wrap(@shrunken)
+    end
+
+    def class
+      @exception.class
+    end
+
+    def backtrace
+      @exception.backtrace
+    end
+
+    def to_s
+      if @shrunken.nil?
+        [@exception.message,
+         "input: #{counterex.map(&:inspect).join(", ")}",
+         "after: #{@passed} passed, #{@skipped} skipped"].join("\n")
+      else
+        [@exception.message,
+         "input:    #{counterex.map(&:inspect).join(", ")}",
+         "shrunken: #{shrunken.map(&:inspect).join(", ")}",
+         "after: #{@passed} passed, #{@skipped} skipped"].join("\n")
+      end
+    end
+
+    alias_method :message, :to_s
+  end
+
+  class NoMoreTries < StandardError
+    # @return [Integer]
+    attr_reader :tries
+
+    def initialize(tries)
+      @tries = tries
+    end
+
+    # @return [String]
+    def to_s
+      "Exceeded #{@tries} failed guards"
+    end
+  end
+
+  def self.RSpec(checkdsl, propdsl)
+    Module.new.tap do |m|
+      m.send(:define_method, :property) { raise }
+      m.send(:define_singleton_method, :rand) { rand }
+      m.send(:define_singleton_method, :included) do |scope|
+
+        # @todo: raise an error if body isn't given
+        scope.send(:define_singleton_method, :property) do |name, options = {}, &body|
+          q = Dsl::Property.wrap(body)
+          p = Property.new(name, q)
+          RSpecAdapter.new(self, options, p)
+        end
+      end
+    end
+  end
+
+  RSpec = RSpec(nil, nil)
+end

data/lib/propr/dsl.rb

@@ -0,0 +1,6 @@
+module Propr
+  module Dsl
+    autoload :Check,    "propr/dsl/check"
+    autoload :Property, "propr/dsl/property"
+  end
+end

data/lib/propr/dsl/check.rb

@@ -0,0 +1,49 @@
+module Propr
+  module Dsl
+
+    class Check
+
+      # Generates a monadic action, to be run with Random.eval
+      def self.wrap(block, m = Propr::Random)
+        new(block, m).instance_exec(&block)
+      end
+
+      def initialize(block, m)
+        @context, @m =
+          Kernel.eval("self", block.binding), m
+      end
+
+      def bind(f, &g)
+        @m.bind(f, &g)
+      end
+
+      def unit(value)
+        @m.unit(value)
+      end
+
+      def guard(*conditions)
+        @m.guard(*conditions)
+      end
+
+      def join(value)
+        @m.join(value)
+      end
+
+      def sequence(actions)
+        @m.sequence(actions)
+      end
+
+      def scale(*args)
+        @m.scale(*args)
+      end
+
+    private
+
+      def method_missing(name, *args, &block)
+        @context.__send__(name, *args, &block)
+      end
+
+    end
+
+  end
+end

data/lib/propr/dsl/property.rb

@@ -0,0 +1,62 @@
+module Propr
+  module Dsl
+
+    class Property
+
+      # Properties shouldn't be monadic, as all random data is generated
+      # elsewhere and passed as arguments to the property. However, this
+      # provides a workaround: m.eval, m.unit, m.bind, etc where `m` is
+      # given as an argument to `wrap`.
+      attr_reader :m
+
+      # Generates a new function, which should return a Boolean
+      def self.wrap(block, m = Propr::Random)
+        case block.arity
+        when 0; lambda{|| new(block, m).instance_exec(&block) }
+        when 1; lambda{|a| new(block, m).instance_exec(a,&block) }
+        when 2; lambda{|a,b| new(block, m).instance_exec(a,b,&block) }
+        when 3; lambda{|a,b,c| new(block, m).instance_exec(a,b,c,&block) }
+        when 4; lambda{|a,b,c,d| new(block, m).instance_exec(a,b,c,d &block) }
+        when 5; lambda{|a,b,c,d,e| new(block, m).instance_exec(a,b,c,d,e,&block) }
+        when 6; lambda{|a,b,c,d,e,f| new(block, m).instance_exec(a,b,c,d,e,f,&block) }
+        when 7; lambda{|a,b,c,d,e,f,g| new(block, m).instance_exec(a,b,c,d,e,f,g,&block) }
+        when 8; lambda{|a,b,c,d,e,f,g,h| new(block, m).instance_exec(a,b,c,d,e,f,g,h,&block) }
+        else    lambda{|*args| new(block, m).instance_exec(*args,&block) }
+        end
+      end
+
+      def initialize(block, m)
+        @context, @m =
+          Kernel.eval("self", block.binding), m
+      end
+
+      def error?(type = Exception)
+        begin
+          yield
+          false
+        rescue => e
+          e.is_a?(type)
+        end
+      end
+
+      def guard(*conditions)
+        if index = conditions.index{|x| not x }
+          raise GuardFailure,
+            "guard condition #{index} was false"
+        end
+      end
+
+      def label(value)
+        # @todo
+      end
+
+    private
+
+      def method_missing(name, *args, &block)
+        @context.__send__(name, *args, &block)
+      end
+
+    end
+
+  end
+end

data/lib/propr/property.rb

@@ -0,0 +1,23 @@
+module Propr
+  class Property
+    # @return [Proc]
+    def self.new(name, body)
+      body.instance_variable_set(:@name, name)
+
+      # @return [String]
+      body.define_singleton_method(:name) { @name }
+
+      # @return [Boolean]
+      body.define_singleton_method(:check) do |*args, &block|
+        if block.nil?
+          true == call(*args)
+        else
+          count = args.first || 100
+          count.times.all? { true == call(*block.call) }
+        end
+      end
+
+      body
+    end
+  end
+end

data/lib/propr/random.rb

@@ -0,0 +1,143 @@
+module Propr
+
+  class Random
+  end
+
+  class << Random
+    include Fr::Monad
+
+    # Evaluators
+    #############################################
+
+    def run(computation, scale = BigDecimal(1))
+      computation.call(bound scale)
+    end
+
+    def eval(computation, scale = BigDecimal(1), retries = 0)
+      skipped = 0
+      scale   = bound(scale)
+
+      while true
+        value, _, success = computation.call(scale)
+
+        if success
+          return value
+        elsif (skipped += 1) > retries
+          raise NoMoreTries, retries
+        end
+      end
+    end
+
+    # Combinators
+    #############################################
+
+    def unit(value)
+      lambda do |scale|
+        [value, scale, true]
+      end
+    end
+
+    def bind(f, &g)
+      lambda do |scale|
+        value, scale, success = f.call(scale)
+
+        success ?
+          g.call(value).call(scale) :
+          [value, scale, success]
+      end
+    end
+
+    # Actions
+    #############################################
+
+    # TODO: Make Random an instance of Functor and use Functor.guard?
+    def guard(*conditions)
+      lambda do |scale|
+        [nil, scale, conditions.all?]
+      end
+    end
+
+    # When given two arguments, scales a numeric value around a
+    # given origin `zero`, using the current scale factor (0..1).
+    #
+    def scale(number, range, zero)
+      if range.zero?
+        # No scaling
+        lambda do |scale|
+          [number, scale, true]
+        end
+      else
+        # Shrink range exponentially, and -1 + scale reduces the
+        # rng_ to 0 when scale = 0, but rng_ = range when scale = 1.
+        lambda do |scale|
+          rng_ = (range ** scale) - 1 + scale
+          pct  = (number - zero) / range
+          [zero + rng_ * pct, scale, true]
+        end
+      end
+    end
+
+    # Generate psuedo-random number normally distributed between
+    # 0 <= x < 1. This distribution is not weighted using `scale`.
+    #
+    def rand(limit = nil)
+      if not limit.nil? and limit <= 0
+        raise InvalidArgument, "limit <= 0"
+      end
+
+      lambda do |scale|
+        [Kernel.rand(limit), scale, true]
+      end
+    end
+
+  private
+
+    def bound(scale)
+      if scale > 1
+        scale.coerce(1)[0]
+      elsif scale < 0
+        scale.coerce(0)[0]
+      else
+        scale
+      end
+    end
+
+  end
+end
+
+# Instances of Monad Random
+require "propr/random/array"
+require "propr/random/bigdecimal"
+require "propr/random/boolean"
+require "propr/random/complex"
+require "propr/random/date"
+require "propr/random/float"
+require "propr/random/hash"
+require "propr/random/integer"
+require "propr/random/maybe"
+require "propr/random/nil"
+require "propr/random/range"
+require "propr/random/rational"
+require "propr/random/set"
+require "propr/random/string"
+require "propr/random/symbol"
+require "propr/random/time"
+
+# Instances of Shrink "typeclass"
+require "propr/shrink/object"
+require "propr/shrink/array"
+require "propr/shrink/bigdecimal"
+require "propr/shrink/boolean"
+require "propr/shrink/complex"
+require "propr/shrink/date"
+require "propr/shrink/float"
+require "propr/shrink/hash"
+require "propr/shrink/integer"
+require "propr/shrink/maybe"
+require "propr/shrink/nil"
+require "propr/shrink/range"
+require "propr/shrink/rational"
+require "propr/shrink/set"
+require "propr/shrink/string"
+require "propr/shrink/symbol"
+require "propr/shrink/time"