propr 0.2.0

data/lib/propr/random/array.rb

@@ -0,0 +1,19 @@
+class Array
+  def random(options = {}, m = Propr::Random)
+    m.bind(m.rand(size)) do |index|
+      m.unit(self[index])
+    end
+  end
+end
+
+class << Array
+  def random(options = {}, m = Propr::Random)
+    min  = options[:min] || 0
+    max  = options[:max] || 10
+    item = yield
+
+    m.bind(Integer.random(min: min, max: max, center: min)) do |size|
+      m.sequence([item]*size)
+    end
+  end
+end

data/lib/propr/random/bigdecimal.rb

@@ -0,0 +1,43 @@
+require "bigdecimal"
+
+class << BigDecimal
+  INF = BigDecimal("Infinity")
+  NAN = BigDecimal("NaN")
+
+  # @return [BigDecimal]
+  def random(options = {}, m = Propr::Random)
+    min = BigDecimal(options[:min] || -INF)
+    max = BigDecimal(options[:max] ||  INF)
+
+    min_ = if min.finite? then min else BigDecimal(-Float::MAX, 0) end
+    max_ = if max.finite? then max else BigDecimal( Float::MAX, 0) end
+
+    range  = max_ - min_
+    center = options.fetch(:center, :mid)
+    center =
+      case center
+      when :mid then min_ + (max_ - min_).div(2)
+      when :min then min_
+      when :max then max_
+      when Numeric
+        raise ArgumentError,
+          "center < min" if center < min
+        raise ArgumentError,
+          "center > max" if center > max
+        center
+      else raise ArgumentError,
+        "center must be :min, :mid, :max, or min <= Integer <= max"
+      end
+
+    # @todo: -INF, +INF, -0.0, NAN
+    m.bind(m.rand(range)) do |a|
+      m.bind(m.rand(max_ - min_)) do |b|
+        c  = BigDecimal(a) + BigDecimal(min_, 0)
+        c += c / BigDecimal(b) # not 0..1
+        c  = max if c > max
+        c  = min if c < min
+        m.scale(c, range, center)
+      end
+    end
+  end
+end

data/lib/propr/random/boolean.rb

@@ -0,0 +1,7 @@
+class Boolean
+  def self.random(m = Propr::Random)
+    m.bind(m.rand) do |n|
+      m.unit(n > 0.5)
+    end
+  end
+end

data/lib/propr/random/date.rb

@@ -0,0 +1,17 @@
+require "date"
+
+class << Date
+  MIN = Date.jd(1721058) # 0000-01-01
+  MAX = Date.jd(5373484) # 9999-12-31
+
+  def random(options = {}, m = Propr::Random)
+    # These would be constants but `jd` is only defined
+    # after `require "date"`.
+    min = (options[:min] || MIN).jd
+    max = (options[:max] || MAX).jd
+
+    m.bind(Integer.random(options.merge(min: min, max: max))) do |n|
+      m.unit(jd(n))
+    end
+  end
+end

data/lib/propr/random/float.rb

@@ -0,0 +1,60 @@
+require "bigdecimal"
+
+class << Float
+  # @return [Float]
+  def random(options = {}, m = Propr::Random)
+    min = (options[:min] || -Float::INFINITY).to_f
+    max = (options[:max] ||  Float::INFINITY).to_f
+
+    min_ = if min.finite? then min else -Float::MAX end
+    max_ = if max.finite? then max else  Float::MAX end
+
+    range  = max_.to_i - min_.to_i
+    center = options.fetch(:center, :mid)
+    center =
+      case center
+      when :min then min
+      when :max then max
+      when :mid
+        if (max_ - min_).finite?
+          min_ + (max_ - min_).fdiv(2)
+        else
+          (min_ + max_).fdiv(2)
+        end
+      when Numeric
+        raise ArgumentError,
+          "center < min" if center < min
+        raise ArgumentError,
+          "center > max" if center > max
+        center
+      else raise ArgumentError,
+        "center must be :min, :mid, :max, or min <= Integer <= max"
+      end
+
+    # @todo: -Float::INFINITY, +Float::INFINITY, -0.0, Float::NAN
+
+    # One approach is to count all `n` possible Float values inside
+    # the [min, max] interval (n <= 2^64 for double precision), then
+    # generate a Fixnum inside [0, n] and map it back to the nth
+    # Float value in [min, max].
+    #
+    # Instead, this method just counts the `n` possible whole values
+    # inside [min, max], generates a Fixnum inside [0, n - 1], then
+    # maps that back to the nth whole value inside [min, max - 1].
+    # Next we tack on a random fractional value inside [0, 1).
+    m.bind(m.rand(range)) do |whole|
+      m.bind(m.rand) do |fraction|
+        # Need to perform scaling on BigDecimal to prevent floating
+        # point underflow and overflow (e.g., BIG / HUGE == 0.0, and
+        # BIG + small == BIG).
+        value  = BigDecimal(min_, 15) + whole
+        value += BigDecimal(fraction, 0)
+        center = BigDecimal(center, 0)
+
+        m.bind(m.scale(value, range, center)) do |d|
+          m.unit(d.to_f)
+        end
+      end
+    end
+  end
+end

data/lib/propr/random/hash.rb

@@ -0,0 +1,55 @@
+class Hash
+  def random(m = Propr::Random)
+    m.bind(keys.random) do |k|
+      m.unit([k, self[k]])
+    end
+  end
+end
+
+class << Hash
+
+  # @example
+  #   Hash.random do
+  #     m.bind(Integer.random){|k| m.bind(String.random){|v| m.unit([k,v]) }}
+  #   end
+  #
+  # @example
+  #   Hash.random do
+  #     m.sequence([Integer.random, String.random])
+  #   end
+  #
+  def random(options = {}, m = Propr::Random)
+    min  = options[:min] || 0
+    max  = options[:max] || 10
+    pair = yield
+
+    # @todo: Be sure we created enough *unique* keys
+    #
+    #   Hash.random(min: 10) do
+    #     # key space could have at most 6 elements
+    #     m.sequence([Integer.random(min: 0, max: 5), String.random])
+    #   end
+    #
+    m.bind(Integer.random(options.merge(min: min, max: max))) do |size|
+      m.bind(m.sequence([pair]*size)) do |pairs|
+        m.unit(Hash[pairs])
+      end
+    end
+  end
+
+  # @example
+  #   Hash.random_vals \
+  #     name:   String.random,
+  #     count:  Integer.random(min: 0),
+  #     weight: Float.random
+  #
+  def random_vals(hash, m = Propr::Random)
+    # Convert hash of key => generator to a list of pair-generators,
+    # where the pairs correspond to the original set of [key, value]
+    pairs = hash.map{|k,v| m.bind(v){|v| m.unit([k, v]) }}
+
+    m.bind(m.sequence(pairs)) do |pairs|
+      m.unit(Hash[pairs])
+    end
+  end
+end

data/lib/propr/random/integer.rb

@@ -0,0 +1,38 @@
+class Integer
+  MAX = 2 ** (0.size * 8 - 2) - 1
+  MIN = -MAX + 1
+end
+
+class << Integer
+  def random(options = {}, m = Propr::Random)
+    min = (options[:min] || Integer::MIN).to_i
+    max = (options[:max] || Integer::MAX).to_i
+
+    raise ArgumentError,
+      "min > max" if min > max
+
+    range  = max - min
+    center = options.fetch(:center, :mid)
+    center =
+      case center
+      when :mid then min + (max - min).div(2)
+      when :min then min
+      when :max then max
+      when Numeric
+        raise ArgumentError,
+          "center < min" if center < min
+        raise ArgumentError,
+          "center > max" if center > max
+        center
+      else raise ArgumentError,
+        "center must be :min, :mid, :max, or min <= Integer <= max"
+      end
+
+    m.bind(m.rand(range + 1)) do |rnd|
+      m.bind(m.scale(rnd + min, range, BigDecimal(center))) do |n|
+        # Round up or down to integer nearest center
+        m.unit(n > center ? n.floor : n.ceil)
+      end
+    end
+  end
+end

data/lib/propr/random/nil.rb

@@ -0,0 +1,8 @@
+class NilClass
+end
+
+class << NilClass
+  def random(m = Propr::Random)
+    m.unit(nil)
+  end
+end

data/lib/propr/random/range.rb

@@ -0,0 +1,32 @@
+class Range
+  def random(options = {})
+    # @todo: This won't work for some types, e.g. String.
+    # @todo: Should this be skewed/scaled?
+    min.class.random(options.merge(min: min, max: max))
+  end
+end
+
+class << Range
+  def random(options = {}, m = Propr::Random)
+    random =
+      if block_given?
+        yield
+      else
+        min = options[:min]
+        max = options[:max]
+        min or max or raise ArgumentError,
+          "must provide min, max, or block"
+        (min or max).class.random(options)
+      end
+
+    m.bind(random) do |a|
+      m.bind(random) do |b|
+        if options.fetch(:inclusive?, rand > 0.5)
+          m.unit(a..b)
+        else
+          m.unit(a...b)
+        end
+      end
+    end
+  end
+end

data/lib/propr/random/set.rb

@@ -0,0 +1,22 @@
+class Set
+  def random(options = {}, m = Propr::Random)
+    m.bind(m.rand(size)) do |index|
+      m.unit(self.to_a[index])
+    end
+  end
+end
+
+class << Set
+  def random(options = {}, m = Propr::Random)
+    min  = options[:min] || 0
+    max  = options[:max] || 10
+    item = yield
+
+    # @todo: Be sure we created enough *unique* elements
+    m.bind(Integer.random(options.merge(min: min, max: max))) do |size|
+      m.bind(m.sequence([item]*size)) do |xs|
+        m.unit(xs.to_set)
+      end
+    end
+  end
+end

data/lib/propr/random/string.rb

@@ -0,0 +1,41 @@
+class << String
+  module Characters
+    ASCII = (0..127).inject("", &:<<)
+    ALL   = (0..255).inject("", &:<<)
+
+    def self.of(regexp, set = Characters::ALL)
+      CLASSES[regexp] || set.scan(regexp)
+    end
+
+    CLASSES = Hash.new
+    CLASSES.update \
+      :any    => ALL.split(//),
+      :ascii  => ASCII.split(//),
+      :alnum  => Characters.of(/[[:alnum:]]/),
+      :alpha  => Characters.of(/[[:alpha:]]/),
+      :blank  => Characters.of(/[[:blank:]]/),
+      :cntrl  => Characters.of(/[[:cntrl:]]/),
+      :digit  => Characters.of(/[[:digit:]]/),
+      :graph  => Characters.of(/[[:graph:]]/),
+      :lower  => Characters.of(/[[:lower:]]/),
+      :print  => Characters.of(/[[:print:]]/),
+      :punct  => Characters.of(/[[:punct:]]/),
+      :space  => Characters.of(/[[:space:]]/),
+      :upper  => Characters.of(/[[:upper:]]/),
+      :xdigit => Characters.of(/[[:xdigit:]]/)
+  end
+
+  # @return [String]
+  def random(options = {}, m = Propr::Random)
+    min     = options[:min] || 0
+    max     = options[:max] || 10
+    options = Hash[center: min].merge(options)
+    charset = Characters.of(options.fetch(:charset, :print))
+
+    m.bind(Integer.random(options.merge(min: min, max: max))) do |size|
+      m.bind(m.sequence(size.times.map { charset.random })) do |chars|
+        m.unit(chars.join)
+      end
+    end
+  end
+end

data/lib/propr/random/symbol.rb

@@ -0,0 +1,13 @@
+class << Symbol
+  # @note: Beware of memory consumption. Symbols are never garbage
+  # collected, and we're generating them at random!
+  #
+  def random(options = {}, m = Propr::Random)
+    min = options[:min] || 0
+    max = options[:max] || 10
+    options = Hash[charset: /[a-z_]/]
+    m.bind(String.random(options)) do |s|
+      m.unit(s.to_sym)
+    end
+  end
+end

data/lib/propr/random/time.rb

@@ -0,0 +1,14 @@
+class << Time
+# MIN = Time.at(0)            # 1969-12-31 00:00:00 UTC
+  MIN = Time.at(-30610224000) # 1000-01-01 00:00:00 UTC
+  MAX = Time.at(253402300799) # 9999-12-31 23:59:59 UTC
+
+  def random(options = {}, m = Propr::Random)
+    min = (options[:min] || MIN).to_f
+    max = (options[:max] || MAX).to_f
+
+    m.bind(Float.random(options.merge(min: min, max: max))) do |ms|
+      m.unit(at(ms))
+    end
+  end
+end

data/lib/propr/rspec.rb

@@ -0,0 +1,97 @@
+module Propr
+
+  class RSpecAdapter
+    def initialize(group, options, property)
+      @options, @group, @property =
+        options, group, property
+
+      # Run each property 100 times, allow 50 retries, and
+      # start the scale at 0, grow suddenly towards the end
+      @runner = Runner.new(100, 50,
+      # lambda{|p,s,t,_| (p+s <= t ? p+s : t) / t })
+        lambda{|p,s,t,_| (BigDecimal(p+s <= t ? p+s : t) / t) })
+    end
+
+    def check(*args, &generator)
+      m        = self
+      runner   = @runner
+      property = @property
+
+      if block_given?
+        location = location(generator)
+
+        @group.example(@property.name, @options.merge(caller: location)) do
+          success, passed, skipped, counterex =
+            runner.run(property, generator)
+
+          unless success
+            if skipped >= runner.maxskip
+              raise NoMoreTries.new(runner.maxskip), nil, location
+            else
+              raise Falsifiable.new(counterex, m.shrink(counterex), passed, skipped), nil, location
+            end
+          end
+        end
+      else
+        location = location(caller)
+
+        @group.example(@property.name, @options.merge(caller: location)) do
+          unless property.call(*args)
+            raise Falsifiable.new(args, m.shrink(args), 0, 0), nil, location
+          end
+        end
+      end
+
+      # Return `self` to allow chaining calls to `check`
+      self
+    end
+
+    # TODO: this method is not RSpec specific
+    def shrink(counterex)
+      if @property.arity.zero?
+        return []
+      end
+
+      xs = [counterex]
+
+      while true
+        # Generate simpler examples
+        ys = Array.bind(xs) do |args|
+          head, *tail = args.map{|x| x.respond_to?(:shrink) ? x.shrink : [x] }
+          head.product(*tail)
+        end
+
+        zs = []
+
+        # Collect counter examples
+        until ys.empty? or zs.length >= 10
+          args = ys.delete_at(rand(ys.size))
+
+          unless @property.call(*args)
+            zs.push(args)
+          end
+        end
+
+        if zs.empty?
+          # No simpler counter examples
+          return xs.first
+        else
+          # Try to further simplify these
+          xs = zs
+        end
+      end
+    end
+
+  private
+
+    def location(data)
+      case data
+      when Proc
+        ["#{data.source_location.join(":")}"]
+      when Array
+        [data.first]
+      end
+    end
+  end
+
+end