speculation 0.4.0 → 0.4.2

data/lib/speculation/gen.rb

@@ -76,6 +76,13 @@ module Speculation
       end
     end
 
+    # @private
+    def self.fmap(gen)
+      ->(rantly) do
+        yield gen.call(rantly)
+      end
+    end
+
     # @private
     GEN_BUILTINS = {
       Integer    => ->(r) { r.integer },
@@ -101,6 +108,10 @@ module Speculation
         gen = Gen.gen_for_pred(Array)
         Set.new(gen.call(r))
       end,
+      SortedSet  => ->(r) do
+        gen = Gen.gen_for_pred(Array)
+        SortedSet.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]))

data/lib/speculation/namespaced_symbols.rb

@@ -13,17 +13,19 @@ module Speculation
         namespace = name_or_namespace
       else
         name = name_or_namespace
-        namespace = is_a?(Module) ? self.name : self.class.name
+        namespace = is_a?(Module) ? self : self.class
       end
 
       NamespacedSymbols.symbol(namespace, name)
     end
 
     def self.symbol(ns, name)
+      ns = ns.name if ns.is_a?(Module)
+
       :"#{ns}/#{name}"
     end
 
-    def self.name(sym)
+    def self.namespaced_name(sym)
       sym.to_s.split("/").last
     end
 

data/lib/speculation/predicates.rb

@@ -0,0 +1,48 @@
+module Speculation
+  # Collection of predicate methods used within Speculation.
+  # These may appear as the value for the `:pred` key in the return value of
+  # `Speculation.explain_data`.
+  module Predicates
+    def self.hash?(x)
+      x.respond_to?(:store) && x.respond_to?(:key?) && x.respond_to?(:[])
+    end
+
+    def self.array?(x)
+      x.respond_to?(:at) && x.respond_to?(:[])
+    end
+
+    def self.collection?(xs)
+      xs.respond_to?(:each)
+    end
+
+    def self.distinct?(xs)
+      seen = Set[]
+
+      xs.each do |x|
+        if seen.include?(x)
+          return false
+        else
+          seen << x
+        end
+      end
+
+      true
+    end
+
+    def self.count_eq?(count, coll)
+      coll.count == count
+    end
+
+    def self.count_between?(min_count, max_count, coll)
+      coll.count.between?(min_count, max_count)
+    end
+
+    def self.key?(hash, key)
+      hash.key?(key)
+    end
+
+    def self.empty?(coll)
+      coll.empty?
+    end
+  end
+end

data/lib/speculation/spec.rb

@@ -10,6 +10,10 @@ module Speculation
       raise NotImplementedError
     end
 
+    def unform(_x)
+      raise NotImplementedError
+    end
+
     def explain(_path, _via, _inn, _value)
       raise NotImplementedError
     end

data/lib/speculation/spec/and_spec.rb

@@ -22,12 +22,16 @@ module Speculation
       @specs.value!.each do |spec|
         value = spec.conform(value)
 
-        return S::INVALID if S.invalid?(value)
+        return :"Speculation/invalid" if S.invalid?(value)
       end
 
       value
     end
 
+    def unform(value)
+      @preds.reverse.reduce(value) { |val, pred| S.unform(pred, val) }
+    end
+
     def explain(path, via, inn, value)
       S.explain_pred_list(@preds, path, via, inn, value)
     end
@@ -38,7 +42,7 @@ module Speculation
 
     def gen(overrides, path, rmap)
       if @gen
-        @gen
+        @gen.call
       else
         S.gensub(@preds.first, overrides, path, rmap)
       end

data/lib/speculation/spec/every_spec.rb

@@ -28,21 +28,27 @@ module Speculation
         end)
       end
 
+      if options[:distinct]
+        collection_predicates.push(->(coll) do
+          coll.empty? || Predicates.distinct?(coll)
+        end)
+      end
+
       @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(ns(S, :kfn), ->(i, _v) { i })
+      @kfn = options.fetch(:kfn, ->(i, _v) { i })
       @conform_keys, @conform_all, @kind, @gen_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)
+        options.values_at(:conform_keys, :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))
-          [Utils.method(:itself),
+        if Predicates.array?(x) && (!@conform_into || Predicates.array?(@conform_into))
+          [->(init) { init.dup },
            ->(ret, i, v, cv) { v.equal?(cv) ? ret : ret.tap { |r| r[i] = cv } },
            Utils.method(:itself)]
-        elsif Utils.hash?(x) && ((@kind && !@conform_into) || Utils.hash?(@conform_into))
+        elsif Predicates.hash?(x) && ((@kind && !@conform_into) || Predicates.hash?(@conform_into))
           [@conform_keys ? Utils.method(:empty) : Utils.method(:itself),
            ->(ret, _i, v, cv) {
              if v.equal?(cv) && !@conform_keys
@@ -61,7 +67,7 @@ module Speculation
     end
 
     def conform(value)
-      return S::INVALID unless @collection_predicate.call(value)
+      return :"Speculation/invalid" unless @collection_predicate.call(value)
 
       spec = @delayed_spec.value!
 
@@ -74,7 +80,7 @@ module Speculation
           conformed_value = spec.conform(val)
 
           if S.invalid?(conformed_value)
-            return S::INVALID
+            return :"Speculation/invalid"
           else
             return_value = add.call(return_value, index, val, conformed_value)
           end
@@ -87,13 +93,30 @@ module Speculation
 
         value.each_with_index do |item, index|
           return value if index == limit
-          return S::INVALID unless S.valid?(spec, item)
+          return :"Speculation/invalid" unless S.valid?(spec, item)
         end
 
         value
       end
     end
 
+    def unform(value)
+      if @conform_all
+        spec = @delayed_spec.value!
+        init, add, complete = @cfns.call(value)
+
+        ret = value.
+          each_with_index.
+          reduce(init.call(value)) { |memo, (val, index)|
+            add.call(memo, index, val, spec.unform(val))
+          }
+
+        complete.call(ret)
+      else
+        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
@@ -117,7 +140,7 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       pgen = S.gensub(@predicate, overrides, path, rmap)
 
@@ -132,13 +155,13 @@ module Speculation
 
         val = if @distinct
                 if @count
-                  rantly.array(@count, &pgen).tap { |arr| rantly.guard(Utils.distinct?(arr)) }
+                  rantly.array(@count, &pgen).tap { |arr| rantly.guard(Predicates.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)) }
+                  rantly.array(count, &pgen).tap { |arr| rantly.guard(Predicates.distinct?(arr)) }
                 end
               elsif @count
                 rantly.array(@count, &pgen)
@@ -160,26 +183,26 @@ module Speculation
     private
 
     def collection_problems(x, kfn, distinct, count, min_count, max_count, path, via, inn)
-      pred = kfn || Utils.method(:collection?)
+      pred = kfn || Predicates.method(:collection?)
 
       unless S.pvalid?(pred, x)
         return S.explain1(pred, path, via, inn, x)
       end
 
-      if count && !Utils.count_eq?(x, count)
-        return [{ :path => path, :pred => [Utils.method(:count_eq?), [x, count]], :val => x, :via => via, :in => inn }]
+      if count && !Predicates.count_eq?(count, x)
+        return [{ :path => path, :pred => [Predicates.method(:count_eq?), [count, x]], :val => x, :via => via, :in => inn }]
       end
 
       if min_count || max_count
         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 }]
+        unless Predicates.count_between?(min_count, max_count, x)
+          return [{ :path => path, :pred => [Predicates.method(:count_between?), [min_count, max_count, x]], :val => x, :via => via, :in => inn }]
         end
       end
 
-      if distinct && !x.empty? && !Utils.distinct?(x)
-        [{ :path => path, :pred => [Utils.method(:distinct?), [x]], :val => x, :via => via, :in => inn }]
+      if distinct && !x.empty? && !Predicates.distinct?(x)
+        [{ :path => path, :pred => [Predicates.method(:distinct?), [x]], :val => x, :via => via, :in => inn }]
       end
     end
   end

data/lib/speculation/spec/f_spec.rb

@@ -14,7 +14,7 @@ module Speculation
 
     def initialize(args: nil, ret: nil, fn: nil, block: nil, gen: nil)
       @args  = args
-      @ret   = ret
+      @ret   = ret || :"Speculation/any"
       @fn    = fn
       @block = block
       @gen   = gen
@@ -23,17 +23,21 @@ module Speculation
     def conform(f)
       raise "Can't conform fspec without args spec: #{inspect}" unless @args
 
-      return S::INVALID unless f.is_a?(Proc) || f.is_a?(Method)
+      return :"Speculation/invalid" unless f.is_a?(Proc) || f.is_a?(Method)
 
       specs = { :args => @args, :ret => @ret, :fn => @fn, :block => @block }
 
       if f.equal?(FSpec.validate_fn(f, specs, S.fspec_iterations))
         f
       else
-        S::INVALID
+        :"Speculation/invalid"
       end
     end
 
+    def unform(f)
+      f
+    end
+
     def explain(path, via, inn, f)
       unless f.respond_to?(:call)
         return [{ :path => path, :pred => [f.method(:respond_to?), [:call]], :val => f, :via => via, :in => inn }]
@@ -66,7 +70,7 @@ module Speculation
     end
 
     def gen(overrides, _path, _rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       ->(_rantly) do
         ->(*args, &block) do

data/lib/speculation/spec/hash_spec.rb

@@ -31,7 +31,7 @@ module Speculation
       req_specs = req_keys + req_un_specs
       req_keys += req_un_specs.map(&method(:unqualify_key))
 
-      pred_exprs = [Utils.method(:hash?)]
+      pred_exprs = [Predicates.method(:hash?)]
       pred_exprs.push(->(v) { parse_req(req, v, Utils.method(:itself)).empty? }) if req.any?
       pred_exprs.push(->(v) { parse_req(req_un, v, method(:unqualify_key)).empty? }) if req_un.any?
 
@@ -44,43 +44,61 @@ module Speculation
     end
 
     def conform(value)
-      return S::INVALID unless @keys_pred.call(value)
+      return :"Speculation/invalid" unless @keys_pred.call(value)
 
       reg = S.registry
-      ret = value
 
-      value.each do |key, v|
-        spec_name = @key_to_spec_map.fetch(key, key)
+      value.reduce(value) do |ret, (key, v)|
+        spec_name = key_to_spec_name(key)
         spec = reg[spec_name]
 
-        next unless spec
+        if spec
+          conformed_value = S.conform(spec, v)
 
-        conformed_value = S.conform(spec, v)
-
-        if S.invalid?(conformed_value)
-          return S::INVALID
-        else
-          unless conformed_value.equal?(v)
-            ret = ret.merge(key => conformed_value)
+          if S.invalid?(conformed_value)
+            break :"Speculation/invalid"
+          elsif conformed_value.equal?(v)
+            ret
+          else
+            ret.merge(key => conformed_value)
           end
+        else
+          ret
         end
       end
+    end
 
-      ret
+    def unform(value)
+      reg = S.registry
+
+      value.reduce(value) do |ret, (key, conformed_value)|
+        if reg.key?(key_to_spec_name(key))
+          unformed_value = S.unform(key_to_spec_name(key), conformed_value)
+
+          if conformed_value.equal?(unformed_value)
+            ret
+          else
+            ret.merge(key => unformed_value)
+          end
+        else
+          ret
+        end
+      end
     end
 
     def explain(path, via, inn, value)
-      unless Utils.hash?(value)
-        return [{ :path => path, :pred => [Utils.method(:hash?), [value]], :val => value, :via => via, :in => inn }]
+      unless Predicates.hash?(value)
+        return [{ :path => path, :pred => [Predicates.method(:hash?), [value]], :val => value, :via => via, :in => inn }]
       end
 
+      reg = S.registry
       problems = []
 
       if @req.any?
         failures = parse_req(@req, value, Utils.method(:itself))
 
         failures.each do |failure_sexp|
-          pred = [Utils.method(:key?), [failure_sexp]]
+          pred = [Predicates.method(:key?), [failure_sexp]]
           problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
         end
       end
@@ -89,17 +107,16 @@ module Speculation
         failures = parse_req(@req_un, value, method(:unqualify_key))
 
         failures.each do |failure_sexp|
-          pred = [Utils.method(:key?), [failure_sexp]]
+          pred = [Predicates.method(:key?), [failure_sexp]]
           problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
         end
       end
 
       problems += value.flat_map { |(k, v)|
-        next unless S.registry.key?(@key_to_spec_map[k])
+        next unless reg.key?(key_to_spec_name(k))
+        next if S.pvalid?(key_to_spec_name(k), v)
 
-        unless S.pvalid?(@key_to_spec_map.fetch(k), v)
-          S.explain1(@key_to_spec_map.fetch(k), Utils.conj(path, k), via, Utils.conj(inn, k), v)
-        end
+        S.explain1(key_to_spec_name(k), Utils.conj(path, k), via, Utils.conj(inn, k), v)
       }
 
       problems.compact
@@ -110,7 +127,7 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       rmap = S.inck(rmap, @id)
 
@@ -149,7 +166,7 @@ module Speculation
     end
 
     def unqualify_key(x)
-      NamespacedSymbols.name(x).to_sym
+      NamespacedSymbols.namespaced_name(x).to_sym
     end
 
     def parse_req(ks, v, f)
@@ -158,20 +175,20 @@ module Speculation
       ret = if key.is_a?(Array)
               op, *kks = key
               case op
-              when ns(S, :or)
+              when :"Speculation/or"
                 if kks.any? { |k| parse_req([k], v, f).empty? }
                   []
                 else
                   transform_keys([key], f)
                 end
-              when ns(S, :and)
+              when :"Speculation/and"
                 if kks.all? { |k| parse_req([k], v, f).empty? }
                   []
                 else
                   transform_keys([key], f)
                 end
               else
-                raise "Expected or, and, got #{op}"
+                raise "Expected Speculation/or, Speculation/and, got #{op}"
               end
             elsif v.key?(f.call(key))
               []
@@ -190,10 +207,14 @@ module Speculation
       keys.map { |key|
         case key
         when Array then transform_keys(key, f)
-        when ns(S, :and), ns(S, :or) then key
+        when :"Speculation/and", :"Speculation/or" then key
         else f.call(key)
         end
       }
     end
+
+    def key_to_spec_name(k)
+      @key_to_spec_map.fetch(k, k)
+    end
   end
 end