speculation 0.1.0

data/lib/speculation/conj.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Speculation
+  # @private
+  module Conj
+    refine Array do
+      def conj(x)
+        self + [x]
+      end
+    end
+
+    refine Set do
+      def conj(x)
+        self + Set[x]
+      end
+    end
+
+    refine Hash do
+      def conj(x)
+        if Utils.array?(x)
+          unless x.count == 2
+            raise ArgumentError, "Array arg to conj must be a pair"
+          end
+
+          merge(x[0] => x[1])
+        else
+          merge(x)
+        end
+      end
+    end
+  end
+end

data/lib/speculation/error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "pp"
+
+module Speculation
+  class Error < StandardError
+    attr_reader :data
+
+    def initialize(message, data)
+      super(message)
+      @data = data.merge(:cause => message)
+    end
+
+    def to_s
+      PP.pp(@data, String.new)
+    end
+  end
+end

data/lib/speculation/gen.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+require "set"
+require "rantly"
+require "rantly/property"
+require "rantly/shrinks"
+require "concurrent/delay"
+require "date"
+
+module Speculation
+  using NamespacedSymbols.refine(self)
+
+  module Gen
+    # @private
+    GEN_BUILTINS = {
+      Integer    => ->(r) { r.integer },
+      String     => ->(r) { r.sized(r.range(0, 100)) { string(:alpha) } },
+      Float      => ->(_r) { rand(Float::MIN..Float::MAX) },
+      Numeric    => ->(r) { r.branch(Gen.gen_for_pred(Integer), Gen.gen_for_pred(Float)) },
+      Symbol     => ->(r) { r.sized(r.range(0, 100)) { string(:alpha).to_sym } },
+      TrueClass  => ->(_r) { true },
+      FalseClass => ->(_r) { false },
+      Date       => ->(r) { Gen.gen_for_pred(Time).call(r).to_date },
+      Time       => ->(r) { Time.at(r.range(-569001744000, 569001744000)) }, # 20k BC => 20k AD
+      Array      => ->(r) do
+        size = r.range(0, 20)
+
+        r.array(size) do
+          gen = Gen.gen_for_pred(r.choose(Integer, String, Float, Symbol, Date, Time, Set[true, false]))
+          gen.call(r)
+        end
+      end,
+      Set        => ->(r) do
+        gen = Gen.gen_for_pred(Array)
+        Set.new(gen.call(r))
+      end,
+      Hash       => ->(r) do
+        kgen = Gen.gen_for_pred(r.choose(Integer, String, Float, Symbol, Date, Time))
+        vgen = Gen.gen_for_pred(r.choose(Integer, String, Float, Symbol, Date, Time, Set[true, false]))
+        size = r.range(0, 20)
+
+        h = {}
+        r.each(size) do
+          k = kgen.call(r)
+          r.guard(!h.key?(k))
+          h[k] = vgen.call(r)
+        end
+        h
+      end,
+      Enumerable => ->(r) do
+        klass = r.choose(Array, Hash, Set)
+        gen = Gen.gen_for_pred(klass)
+        gen.call(r)
+      end
+    }.freeze
+
+    # Adds `pred` as a Rantly `guard` to generator `gen`.
+    # @param pred
+    # @param gen [Proc]
+    # @return [Proc]
+    # @see https://github.com/abargnesi/rantly Rantly
+    def self.such_that(pred, gen)
+      ->(rantly) do
+        gen.call(rantly).tap { |val| rantly.guard(pred.call(val)) }
+      end
+    end
+
+    # @param gen [Proc] Rantly generator
+    # @param limit [Integer]  specifies how many times `gen` can fail to produce a valid value.
+    # @return single value using gen
+    # @see https://github.com/abargnesi/rantly Rantly
+    def self.generate(gen, limit = 100)
+      Rantly.value(limit, &gen)
+    end
+
+    # Generate `n` values using `gen`
+    # @param gen [Proc] Rantly generator
+    # @param limit [Integer] specifies how many times `gen` can fail to produce a valid value.
+    # @return [Array] array of generated values using gne
+    # @see https://github.com/abargnesi/rantly Rantly
+    def self.sample(gen, n, limit = 100)
+      Rantly.map(n, limit, &gen)
+    end
+
+    # Given a predicate, returns a built-in generator if one exists.
+    # @param pred
+    # @return [Proc] built-in generator for pred
+    # @return nil if no built-in generator found
+    # @see https://github.com/abargnesi/rantly Rantly
+    def self.gen_for_pred(pred)
+      if pred.is_a?(Set)
+        ->(r) { r.choose(*pred) }
+      else
+        GEN_BUILTINS[pred]
+      end
+    end
+
+    # @private
+    def self.delay(&block)
+      delayed = Concurrent::Delay.new(&block)
+
+      ->(rantly) do
+        delayed.value.call(rantly)
+      end
+    end
+  end
+end

data/lib/speculation/identifier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Speculation
+  # @private
+  class Identifier
+    attr_reader :namespace, :name
+
+    def initialize(namespace, name, instance_method)
+      @namespace = namespace
+      @name = name
+      @instance_method = instance_method
+    end
+
+    def instance_method?
+      @instance_method
+    end
+
+    def get_method
+      @instance_method ? @namespace.instance_method(@name) : @namespace.method(@name)
+    end
+
+    def redefine_method!(new_method)
+      if @instance_method
+        name = @name
+        @namespace.class_eval { define_method(name, new_method) }
+      else
+        @namespace.define_singleton_method(@name, new_method)
+      end
+    end
+
+    def hash
+      [@namespace, @name, @instance_method].hash
+    end
+
+    def ==(other)
+      self.class === other &&
+        other.hash == hash
+    end
+    alias eql? ==
+
+    def to_s
+      sep = @instance_method ? "#" : "."
+      "#{@namespace}#{sep}#{@name}"
+    end
+    alias inspect to_s
+  end
+end

data/lib/speculation/namespaced_symbols.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Speculation
+  module NamespacedSymbols
+    def self.refine(namespace)
+      Module.new do
+        refine Symbol do
+          define_method(:ns) do |mod = nil|
+            if mod
+              :"#{mod}/#{self}"
+            else
+              :"#{namespace}/#{self}"
+            end
+          end
+
+          def name
+            to_s.split("/").last
+          end
+
+          def namespace
+            parts = to_s.split("/")
+            parts.first if parts.count == 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/speculation/pmap.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Speculation
+  # @private
+  module Pmap
+    refine Array do
+      if RUBY_PLATFORM == "java"
+        def pmap(&block)
+          Pmap.pmap_jruby(self, &block)
+        end
+      else
+        alias_method :pmap, :map
+      end
+    end
+
+    def self.pmap_jruby(array, &block)
+      thread_count = [1, Concurrent.processor_count - 1].max
+      pool = Concurrent::FixedThreadPool.new(thread_count, :auto_terminate  => true,
+                                                           :fallback_policy => :abort)
+
+      array.
+        map { |x| Concurrent::Future.execute(:executor => pool) { block.call(x) } }.
+        map { |f| f.value || f.reason }
+    ensure
+      pool.shutdown
+    end
+  end
+end

data/lib/speculation/spec_impl/and_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Speculation
+  using NamespacedSymbols.refine(self)
+
+  # @private
+  class AndSpec < SpecImpl
+    S = Speculation
+
+    def initialize(preds)
+      @preds = preds
+      @specs = Concurrent::Delay.new do
+        preds.map { |pred| S.send(:specize, pred) }
+      end
+    end
+
+    def conform(value)
+      @specs.value.each do |spec|
+        value = spec.conform(value)
+
+        return :invalid.ns if S.invalid?(value)
+      end
+
+      value
+    end
+
+    def explain(path, via, inn, value)
+      S.explain_pred_list(@preds, path, via, inn, value)
+    end
+
+    def gen(overrides, path, rmap)
+      if @gen
+        @gen
+      else
+        S.gensub(@preds.first, overrides, path, rmap)
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl/every_spec.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+module Speculation
+  using NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class EverySpec < SpecImpl
+    S = Speculation
+
+    def initialize(predicate, options)
+      @predicate = predicate
+      @options = options
+
+      collection_predicates = [options.fetch(:kind, Enumerable)]
+
+      if options.key?(:count)
+        collection_predicates.push(->(coll) { coll.count == options[:count] })
+      elsif options.key?(:min_count) || options.key?(:max_count)
+        collection_predicates.push(->(coll) do
+          min = options.fetch(:min_count, 0)
+          max = options.fetch(:max_count, Float::INFINITY)
+
+          coll.count.between?(min, max)
+        end)
+      end
+
+      @collection_predicate = ->(coll) { collection_predicates.all? { |f| f === coll } }
+      @delayed_spec = Concurrent::Delay.new { S.send(:specize, predicate) }
+      @kfn = options.fetch(:kfn.ns, ->(i, _v) { i })
+      @conform_keys, @conform_all, @kind, @gen_into, @gen_max, @distinct, @count, @min_count, @max_count =
+        options.values_at(:conform_keys, :conform_all.ns, :kind, :into, :gen_max, :distinct, :count, :min_count, :max_count)
+      @gen_max ||= 20
+      @conform_into = @gen_into
+
+      # returns a tuple of [init add complete] fns
+      @cfns = ->(x) do
+        if Utils.array?(x) && (!@conform_into || Utils.array?(@conform_into))
+          [:itself.to_proc,
+           ->(ret, i, v, cv) { v.equal?(cv) ? ret : ret.tap { |r| r[i] = cv } },
+           :itself.to_proc]
+        elsif Utils.hash?(x) && ((@kind && !@conform_into) || Utils.hash?(@conform_into))
+          [@conform_keys ? Utils.method(:empty) : :itself.to_proc,
+           ->(ret, _i, v, cv) {
+             if v.equal?(cv) && !@conform_keys
+               ret
+             else
+               ret.merge((@conform_keys ? cv : v).first => cv.last)
+             end
+           },
+           :itself.to_proc]
+        else
+          [->(init) { Utils.empty(@conform_into || init) },
+           ->(ret, _i, _v, cv) { ret.conj(cv) },
+           :itself.to_proc]
+        end
+      end
+    end
+
+    def conform(value)
+      return :invalid.ns unless @collection_predicate.call(value)
+
+      spec = @delayed_spec.value
+
+      if @conform_all
+        init, add, complete = @cfns.call(value)
+
+        return_value = init.call(value)
+
+        value.each_with_index do |val, index|
+          conformed_value = spec.conform(val)
+
+          if S.invalid?(conformed_value)
+            return :invalid.ns
+          else
+            return_value = add.call(return_value, index, val, conformed_value)
+          end
+        end
+
+        complete.call(return_value)
+      else
+        # OPTIMIZE: check if value is indexed (array, hash etc.) vs not indexed (list, custom enumerable)
+        limit = S.coll_check_limit
+
+        value.each_with_index do |item, index|
+          return value if index == limit
+          return :invalid.ns unless S.valid?(spec, item)
+        end
+
+        value
+      end
+    end
+
+    def explain(path, via, inn, value)
+      probs = collection_problems(value, @kind, @distinct, @count, @min_count, @max_count, path, via, inn)
+      return probs if probs
+
+      spec = @delayed_spec.value
+
+      probs = value.lazy.each_with_index.flat_map { |v, i|
+        k = @kfn.call(i, v)
+
+        unless S.valid?(spec, v)
+          S.explain1(@predicate, path, via, inn.conj(k), v)
+        end
+      }
+
+      probs = @conform_all ? probs.to_a : probs.take(S.coll_error_limit)
+      probs.compact
+    end
+
+    def gen(overrides, path, rmap)
+      return @gen if @gen
+
+      pgen = S.gensub(@predicate, overrides, path, rmap)
+
+      ->(rantly) do
+        init = if @gen_into
+                 Utils.empty(@gen_into)
+               elsif @kind
+                 Utils.empty(S.gensub(@kind, overrides, path, rmap).call(rantly))
+               else
+                 []
+               end
+
+        val = if @distinct
+                if @count
+                  rantly.array(@count, &pgen).tap { |arr| rantly.guard(Utils.distinct?(arr)) }
+                else
+                  min = @min_count || 0
+                  max = @max_count || [@gen_max, 2 * min].max
+                  count = rantly.range(min, max)
+
+                  rantly.array(count, &pgen).tap { |arr| rantly.guard(Utils.distinct?(arr)) }
+                end
+              elsif @count
+                rantly.array(@count, &pgen)
+              elsif @min_count || @max_count
+                min = @min_count || 0
+                max = @max_count || [@gen_max, 2 * min].max
+                count = rantly.range(min, max)
+
+                rantly.array(count, &pgen)
+              else
+                count = rantly.range(0, @gen_max)
+                rantly.array(count, &pgen)
+              end
+
+        Utils.into(init, val)
+      end
+    end
+
+    private
+
+    def collection_problems(x, kfn, distinct, count, min_count, max_count, path, via, inn)
+      pred = kfn || Utils.method(:collection?)
+
+      unless S.pvalid?(pred, x)
+        return S.explain1(pred, path, via, inn, x)
+      end
+
+      if count && count != x.count
+        return [{ :path => path, :pred => "count == x.count", :val => x, :via => via, :in => inn }]
+      end
+
+      if min_count || max_count
+        if x.count.between?(min_count || 0, max_count || Float::Infinity)
+          return [{ :path => path, :pred => "count.between?(min_count || 0, max_count || Float::Infinity)", :val => x, :via => via, :in => inn }]
+        end
+      end
+
+      if distinct && !x.empty? && Utils.distinct?(x)
+        [{ :path => path, :pred => "distinct?", :val => x, :via => via, :in => inn }]
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl/f_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Speculation
+  using NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class FSpec < SpecImpl
+    S = Speculation
+
+    attr_reader :argspec, :retspec, :fnspec, :blockspec
+
+    def initialize(argspec: nil, retspec: nil, fnspec: nil, blockspec: nil)
+      @argspec = argspec
+      @retspec = retspec
+      @fnspec = fnspec
+      @blockspec = blockspec
+    end
+
+    def conform(f)
+      raise "Can't conform fspec without args spec: #{inspect}" unless @argspec
+
+      return :invalid.ns unless f.is_a?(Proc) || f.is_a?(Method)
+
+      specs = { :args => @argspec, :ret => @retspec, :fn => @fnspec, :block => @blockspec }
+
+      if f.equal?(FSpec.validate_fn(f, specs, S.fspec_iterations))
+        f
+      else
+        :invalid.ns
+      end
+    end
+
+    def explain(path, via, inn, f)
+      unless f.respond_to?(:call)
+        return [{ :path => path, :pred => "respond_to?(:call)", :val => f, :via => via, :in => inn }]
+      end
+
+      specs = { :args => @argspec, :ret => @retspec, :fn => @fnspec, :block => @blockspec }
+      args, block = FSpec.validate_fn(f, specs, 100)
+      return if f.equal?(args)
+
+      ret = begin
+              f.call(*args, &block)
+            rescue => e
+              e
+            end
+
+      if ret.is_a?(Exception)
+        val = block ? [args, block] : args
+        return [{ :path => path, :pred => "f.call(*args)", :val => val, :reason => ret.message.chomp, :via => via, :in => inn }]
+      end
+
+      cret = S.dt(@retspec, ret)
+      return S.explain1(@retspec, path.conj(:ret), via, inn, ret) if S.invalid?(cret)
+
+      if @fnspec
+        cargs = S.conform(@argspec, args)
+        S.explain1(@fnspec, path.conj(:fn), via, inn, :args => cargs, :ret => cret)
+      end
+    end
+
+    def gen(overrides, _path, _rmap)
+      return @gen if @gen
+
+      ->(_rantly) do
+        ->(*args, &block) do
+          unless S.pvalid?(@argspec, args)
+            raise S.explain_str(@argspec, args)
+          end
+
+          if @blockspec && !S.pvalid?(@blockspec, block)
+            raise S.explain_str(@blockspec, block)
+          end
+
+          S::Gen.generate(S.gen(@retspec, overrides))
+        end
+      end
+    end
+
+    # @private
+    # returns f if valid, else smallest
+    def self.validate_fn(f, specs, iterations)
+      args_gen = S.gen(specs[:args])
+
+      block_gen = if specs[:block]
+                    S.gen(specs[:block])
+                  else
+                    Utils.constantly(nil)
+                  end
+
+      combined = ->(r) { [args_gen.call(r), block_gen.call(r)] }
+
+      ret = S::Test.send(:rantly_quick_check, combined, iterations) { |(args, block)|
+        call_valid?(f, specs, args, block)
+      }
+
+      smallest = ret[:shrunk] && ret[:shrunk][:smallest]
+      smallest || f
+    end
+
+    def self.call_valid?(f, specs, args, block)
+      cargs = S.conform(specs[:args], args)
+      return if S.invalid?(cargs)
+
+      if specs[:block]
+        cblock = S.conform(specs[:block], block)
+        return if S.invalid?(cblock)
+      end
+
+      ret = f.call(*args, &block)
+
+      cret = S.conform(specs[:ret], ret)
+      return if S.invalid?(cret)
+
+      return true unless specs[:fn]
+
+      S.pvalid?(specs[:fn], :args => cargs, :block => block, :ret => cret)
+    end
+  end
+end