speculation 0.1.0 → 0.2.0

data/lib/speculation/error.rb

@@ -3,15 +3,16 @@ require "pp"
 
 module Speculation
   class Error < StandardError
-    attr_reader :data
+    attr_reader :data, :message
 
     def initialize(message, data)
       super(message)
-      @data = data.merge(:cause => message)
+      @data = data
+      @message = message
     end
 
     def to_s
-      PP.pp(@data, String.new)
+      "#{@message} #{PP.pp(@data, String.new)}"
     end
   end
 end

data/lib/speculation/gen.rb

@@ -5,54 +5,13 @@ require "rantly/property"
 require "rantly/shrinks"
 require "concurrent/delay"
 require "date"
+require "securerandom"
+require "uri"
+require "date"
+require "time"
 
 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]
@@ -77,7 +36,7 @@ module Speculation
     # @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)
+    def self.sample(gen, n = 10, limit = 100)
       Rantly.map(n, limit, &gen)
     end
 
@@ -99,8 +58,53 @@ module Speculation
       delayed = Concurrent::Delay.new(&block)
 
       ->(rantly) do
-        delayed.value.call(rantly)
+        delayed.value!.call(rantly)
       end
     end
+
+    # @private
+    GEN_BUILTINS = {
+      Integer    => ->(r) { r.integer },
+      String     => ->(r) { r.sized(r.range(0, 20)) { 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, 20)) { string(:alpha).to_sym } },
+      TrueClass  => ->(_r) { true },
+      FalseClass => ->(_r) { false },
+      NilClass   => ->(_r) { nil },
+      Date       => Speculation.gen(Speculation.date_in(Date.new(1970, 1, 1)..Date.new(3000, 1, 1))),
+      Time       => Speculation.gen(Speculation.time_in(Time.new(1970, 1, 1)..Time.new(3000, 1, 1))),
+      URI        => ->(_r) { URI("http://#{SecureRandom.uuid}.com") },
+      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
   end
 end

data/lib/speculation/identifier.rb

@@ -5,22 +5,22 @@ module Speculation
   class Identifier
     attr_reader :namespace, :name
 
-    def initialize(namespace, name, instance_method)
+    def initialize(namespace, name, is_instance_method)
       @namespace = namespace
       @name = name
-      @instance_method = instance_method
+      @is_instance_method = is_instance_method
     end
 
     def instance_method?
-      @instance_method
+      @is_instance_method
     end
 
     def get_method
-      @instance_method ? @namespace.instance_method(@name) : @namespace.method(@name)
+      @is_instance_method ? @namespace.instance_method(@name) : @namespace.method(@name)
     end
 
     def redefine_method!(new_method)
-      if @instance_method
+      if @is_instance_method
         name = @name
         @namespace.class_eval { define_method(name, new_method) }
       else
@@ -29,7 +29,7 @@ module Speculation
     end
 
     def hash
-      [@namespace, @name, @instance_method].hash
+      [@namespace, @name, @is_instance_method].hash
     end
 
     def ==(other)
@@ -39,7 +39,7 @@ module Speculation
     alias eql? ==
 
     def to_s
-      sep = @instance_method ? "#" : "."
+      sep = @is_instance_method ? "#" : "."
       "#{@namespace}#{sep}#{@name}"
     end
     alias inspect to_s

data/lib/speculation/namespaced_symbols.rb

@@ -2,27 +2,34 @@
 
 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
+    # @param [#to_s] namespace
+    # @param [#to_s] name
+    # @return [Symbol] concatenation of `namespace` and `name`
+    # @example
+    #     ns(Foo::Bar, :foo)
+    #     # => :"Foo::Bar/baz"
+    def ns(name_or_namespace, name = nil)
+      if name
+        namespace = name_or_namespace
+      else
+        name = name_or_namespace
+        namespace = is_a?(Module) ? self.name : self.class.name
+      end
 
-          def name
-            to_s.split("/").last
-          end
+      NamespacedSymbols.symbol(namespace, name)
+    end
 
-          def namespace
-            parts = to_s.split("/")
-            parts.first if parts.count == 2
-          end
-        end
-      end
+    def self.symbol(ns, name)
+      :"#{ns}/#{name}"
+    end
+
+    def self.name(sym)
+      sym.to_s.split("/").last
+    end
+
+    def self.namespace(sym)
+      parts = sym.to_s.split("/")
+      parts.first if parts.count == 2
     end
   end
 end

data/lib/speculation/pmap.rb

@@ -1,26 +1,25 @@
 # 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
+    if RUBY_PLATFORM == "java"
+      def pmap(coll, &block)
+        Pmap.pmap_jruby(coll, &block)
+      end
+    else
+      def pmap(coll, &block)
+        coll.map(&block)
       end
     end
 
-    def self.pmap_jruby(array, &block)
+    def self.pmap_jruby(coll, &block)
       thread_count = [1, Concurrent.processor_count - 1].max
       pool = Concurrent::FixedThreadPool.new(thread_count, :auto_terminate  => true,
                                                            :fallback_policy => :abort)
 
-      array.
+      coll.
         map { |x| Concurrent::Future.execute(:executor => pool) { block.call(x) } }.
         map { |f| f.value || f.reason }
     ensure

data/lib/speculation/spec_impl/and_spec.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 module Speculation
-  using NamespacedSymbols.refine(self)
-
   # @private
   class AndSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(preds)
@@ -15,10 +14,10 @@ module Speculation
     end
 
     def conform(value)
-      @specs.value.each do |spec|
+      @specs.value!.each do |spec|
         value = spec.conform(value)
 
-        return :invalid.ns if S.invalid?(value)
+        return ns(S, :invalid) if S.invalid?(value)
       end
 
       value

data/lib/speculation/spec_impl/every_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 module Speculation
-  using NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class EverySpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
     def initialize(predicate, options)
@@ -24,22 +22,22 @@ module Speculation
         end)
       end
 
-      @collection_predicate = ->(coll) { collection_predicates.all? { |f| f === coll } }
+      @collection_predicate = ->(coll) { collection_predicates.all? { |f| f.respond_to?(:call) ? f.call(coll) : f === coll } }
       @delayed_spec = Concurrent::Delay.new { S.send(:specize, predicate) }
-      @kfn = options.fetch(:kfn.ns, ->(i, _v) { i })
+      @kfn = options.fetch(ns(S, :kfn), ->(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)
+        options.values_at(:conform_keys, ns(S, :conform_all), :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,
+          [Utils.method(:itself),
            ->(ret, i, v, cv) { v.equal?(cv) ? ret : ret.tap { |r| r[i] = cv } },
-           :itself.to_proc]
+           Utils.method(:itself)]
         elsif Utils.hash?(x) && ((@kind && !@conform_into) || Utils.hash?(@conform_into))
-          [@conform_keys ? Utils.method(:empty) : :itself.to_proc,
+          [@conform_keys ? Utils.method(:empty) : Utils.method(:itself),
            ->(ret, _i, v, cv) {
              if v.equal?(cv) && !@conform_keys
                ret
@@ -47,19 +45,19 @@ module Speculation
                ret.merge((@conform_keys ? cv : v).first => cv.last)
              end
            },
-           :itself.to_proc]
+           Utils.method(:itself)]
         else
           [->(init) { Utils.empty(@conform_into || init) },
-           ->(ret, _i, _v, cv) { ret.conj(cv) },
-           :itself.to_proc]
+           ->(ret, _i, _v, cv) { Utils.conj(ret, cv) },
+           Utils.method(:itself)]
         end
       end
     end
 
     def conform(value)
-      return :invalid.ns unless @collection_predicate.call(value)
+      return ns(S, :invalid) unless @collection_predicate.call(value)
 
-      spec = @delayed_spec.value
+      spec = @delayed_spec.value!
 
       if @conform_all
         init, add, complete = @cfns.call(value)
@@ -70,7 +68,7 @@ module Speculation
           conformed_value = spec.conform(val)
 
           if S.invalid?(conformed_value)
-            return :invalid.ns
+            return ns(S, :invalid)
           else
             return_value = add.call(return_value, index, val, conformed_value)
           end
@@ -83,7 +81,7 @@ module Speculation
 
         value.each_with_index do |item, index|
           return value if index == limit
-          return :invalid.ns unless S.valid?(spec, item)
+          return ns(S, :invalid) unless S.valid?(spec, item)
         end
 
         value
@@ -94,13 +92,13 @@ module Speculation
       probs = collection_problems(value, @kind, @distinct, @count, @min_count, @max_count, path, via, inn)
       return probs if probs
 
-      spec = @delayed_spec.value
+      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)
+          S.explain1(@predicate, path, via, Utils.conj(inn, k), v)
         end
       }
 
@@ -158,18 +156,20 @@ module Speculation
         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 }]
+      if count && !Utils.count_eq?(x, count)
+        return [{ :path => path, :pred => [Utils.method(:count_eq?), [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 }]
+        min_count ||= 0
+        max_count ||= Float::INFINITY
+        unless Utils.count_between?(x, min_count, max_count)
+          return [{ :path => path, :pred => [Utils.method(:count_between?), [x, min_count, max_count]], :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 }]
+      if distinct && !x.empty? && !Utils.distinct?(x)
+        [{ :path => path, :pred => [Utils.method(:distinct?), [x]], :val => x, :via => via, :in => inn }]
       end
     end
   end

data/lib/speculation/spec_impl/f_spec.rb

@@ -1,62 +1,58 @@
 # frozen_string_literal: true
 
 module Speculation
-  using NamespacedSymbols.refine(self)
-  using Conj
-
   # @private
   class FSpec < SpecImpl
+    include NamespacedSymbols
     S = Speculation
 
-    attr_reader :argspec, :retspec, :fnspec, :blockspec
+    attr_reader :args, :ret, :fn, :block
 
-    def initialize(argspec: nil, retspec: nil, fnspec: nil, blockspec: nil)
-      @argspec = argspec
-      @retspec = retspec
-      @fnspec = fnspec
-      @blockspec = blockspec
+    def initialize(args: nil, ret: nil, fn: nil, block: nil)
+      @args = args
+      @ret = ret
+      @fn = fn
+      @block = block
     end
 
     def conform(f)
-      raise "Can't conform fspec without args spec: #{inspect}" unless @argspec
+      raise "Can't conform fspec without args spec: #{inspect}" unless @args
 
-      return :invalid.ns unless f.is_a?(Proc) || f.is_a?(Method)
+      return ns(S, :invalid) unless f.is_a?(Proc) || f.is_a?(Method)
 
-      specs = { :args => @argspec, :ret => @retspec, :fn => @fnspec, :block => @blockspec }
+      specs = { :args => @args, :ret => @ret, :fn => @fn, :block => @block }
 
       if f.equal?(FSpec.validate_fn(f, specs, S.fspec_iterations))
         f
       else
-        :invalid.ns
+        ns(S, :invalid)
       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 }]
+        return [{ :path => path, :pred => [f.method(: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)
+      specs = { :args => @args, :ret => @ret, :fn => @fn, :block => @block }
+      validate_fn_result = FSpec.validate_fn(f, specs, 100)
+      return if f.equal?(validate_fn_result)
 
-      ret = begin
-              f.call(*args, &block)
-            rescue => e
-              e
-            end
+      ret = f.call(*validate_fn_result[:args], &validate_fn_result[:block]) rescue $!
 
       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 }]
+        # no args available for pred
+        pred = [f, validate_fn_result[:args]]
+        pred << validate_fn_result[:block] if validate_fn_result[:block]
+        return [{ :path => path, :pred => pred, :val => validate_fn_result, :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)
+      cret = S.dt(@ret, ret)
+      return S.explain1(@ret, Utils.conj(path, :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)
+      if @fn
+        cargs = S.conform(@args, args)
+        S.explain1(@fn, Utils.conj(path, :fn), via, inn, :args => cargs, :ret => cret)
       end
     end
 
@@ -65,15 +61,15 @@ module Speculation
 
       ->(_rantly) do
         ->(*args, &block) do
-          unless S.pvalid?(@argspec, args)
-            raise S.explain_str(@argspec, args)
+          unless S.pvalid?(@args, args)
+            raise S.explain_str(@args, args)
           end
 
-          if @blockspec && !S.pvalid?(@blockspec, block)
-            raise S.explain_str(@blockspec, block)
+          if @block && !S.pvalid?(@block, block)
+            raise S.explain_str(@block, block)
           end
 
-          S::Gen.generate(S.gen(@retspec, overrides))
+          S::Gen.generate(S.gen(@ret, overrides))
         end
       end
     end
@@ -91,7 +87,8 @@ module Speculation
 
       combined = ->(r) { [args_gen.call(r), block_gen.call(r)] }
 
-      ret = S::Test.send(:rantly_quick_check, combined, iterations) { |(args, block)|
+      generator_guard = ->(genned_val) { S.valid?(specs[:args], genned_val) }
+      ret = S::Test.send(:rantly_quick_check, combined, iterations, generator_guard) { |(args, block)|
         call_valid?(f, specs, args, block)
       }