speculation 0.4.0 → 0.4.2

data/lib/speculation/spec/merge_spec.rb

@@ -19,12 +19,16 @@ module Speculation
       ms = @preds.map { |pred| S.dt(pred, x) }
 
       if ms.any?(&S.method(:invalid?))
-        S::INVALID
+        :"Speculation/invalid"
       else
         ms.reduce(&:merge)
       end
     end
 
+    def unform(x)
+      @preds.reverse.map { |pred| S.unform(pred, x) }.reduce(&:merge)
+    end
+
     def explain(path, via, inn, x)
       @preds.
         flat_map { |pred| S.explain1(pred, path, via, inn, x) }.
@@ -36,7 +40,7 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       gens = @preds.
         map { |pred| S.gensub(pred, overrides, path, rmap) }

data/lib/speculation/spec/nilable_spec.rb

@@ -20,12 +20,16 @@ module Speculation
       value.nil? ? value : @delayed_spec.value!.conform(value)
     end
 
+    def unform(value)
+      value.nil? ? nil : @delayed_spec.value!.unform(value)
+    end
+
     def explain(path, via, inn, value)
       return if S.pvalid?(@delayed_spec.value!, value) || value.nil?
 
       Utils.conj(
-        S.explain1(@pred, Utils.conj(path, ns(S, :pred)), via, inn, value),
-        :path => Utils.conj(path, ns(S, :nil)), :pred => [NilClass, [value]], :val => value, :via => via, :in => inn
+        S.explain1(@pred, Utils.conj(path, :pred), via, inn, value),
+        :path => Utils.conj(path, :nil), :pred => [NilClass, [value]], :val => value, :via => via, :in => inn
       )
     end
 
@@ -34,11 +38,11 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       ->(rantly) do
         rantly.freq([1, Gen.delay { Utils.constantly(nil) }],
-                    [9, Gen.delay { S.gensub(@pred, overrides, Utils.conj(path, ns(S, :pred)), rmap) }])
+                    [9, Gen.delay { S.gensub(@pred, overrides, Utils.conj(path, :pred), rmap) }])
       end
     end
   end

data/lib/speculation/spec/nonconforming_spec.rb

@@ -19,7 +19,11 @@ module Speculation
     def conform(value)
       ret = @delayed_spec.value!.conform(value)
 
-      S.invalid?(ret) ? S::INVALID : value
+      S.invalid?(ret) ? :"Speculation/invalid" : value
+    end
+
+    def unform(value)
+      value
     end
 
     def explain(path, via, inn, value)

data/lib/speculation/spec/or_spec.rb

@@ -33,13 +33,20 @@ module Speculation
         end
       end
 
-      S::INVALID
+      :"Speculation/invalid"
+    end
+
+    def unform(value)
+      spec_name, conformed_val = value
+      spec = @named_specs.fetch(spec_name)
+
+      S.unform(spec, conformed_val)
     end
 
     def explain(path, via, inn, value)
       return if S.pvalid?(self, value)
 
-      @keys.zip(@preds).flat_map do |(key, pred)|
+      @named_specs.flat_map do |(key, pred)|
         next if S.pvalid?(pred, value)
         S.explain1(pred, Utils.conj(path, key), via, inn, value)
       end
@@ -50,7 +57,7 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       gs = @keys.zip(@preds).
         map { |(k, p)|

data/lib/speculation/spec/predicate_spec.rb

@@ -10,10 +10,11 @@ module Speculation
     include NamespacedSymbols
     S = Speculation
 
-    def initialize(predicate, should_conform, gen = nil)
+    def initialize(predicate, should_conform, gen, unconformer)
       @predicate = predicate
       @should_conform = should_conform
       @gen = gen
+      @unconformer = unconformer
     end
 
     def conform(value)
@@ -26,7 +27,17 @@ module Speculation
       if @should_conform
         ret
       else
-        ret ? value : S::INVALID
+        ret ? value : :"Speculation/invalid"
+      end
+    end
+
+    def unform(value)
+      return value unless @should_conform
+
+      if @unconformer
+        @unconformer.call(value)
+      else
+        raise "no unformer for conformer"
       end
     end
 
@@ -37,12 +48,12 @@ module Speculation
     end
 
     def with_gen(gen)
-      self.class.new(@predicate, @should_conform, gen)
+      self.class.new(@predicate, @should_conform, gen, @unconformer)
     end
 
     def gen(_, _, _)
       if @gen
-        @gen
+        @gen.call
       else
         Gen.gen_for_pred(@predicate)
       end

data/lib/speculation/spec/regex_spec.rb

@@ -16,15 +16,19 @@ module Speculation
     end
 
     def conform(value)
-      if value.nil? || Utils.collection?(value)
+      if value.nil? || Predicates.collection?(value)
         S.re_conform(@regex, value)
       else
-        S::INVALID
+        :"Speculation/invalid"
       end
     end
 
+    def unform(value)
+      S.op_unform(@regex, value)
+    end
+
     def explain(path, via, inn, value)
-      if value.nil? || Utils.collection?(value)
+      if value.nil? || Predicates.collection?(value)
         S.re_explain(path, via, inn, @regex, value || [])
       else
         [{ :path => path, :val => value, :via => via, :in => inn }]
@@ -36,7 +40,7 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       S.re_gen(@regex, overrides, path, rmap)
     end

data/lib/speculation/spec/tuple_spec.rb

@@ -22,8 +22,8 @@ module Speculation
     def conform(collection)
       specs = @delayed_specs.value!
 
-      unless Utils.array?(collection) && collection.count == specs.count
-        return S::INVALID
+      unless Predicates.array?(collection) && collection.count == specs.count
+        return :"Speculation/invalid"
       end
 
       return_value = collection.class.new
@@ -32,7 +32,7 @@ module Speculation
         conformed_value = spec.conform(value)
 
         if S.invalid?(conformed_value)
-          return S::INVALID
+          return :"Speculation/invalid"
         else
           return_value += [conformed_value]
         end
@@ -41,9 +41,17 @@ module Speculation
       return_value
     end
 
+    def unform(value)
+      unless Predicates.array?(value) && value.count == @preds.count
+        raise ArgumentError, "unform value must be an array of length #{@preds.count}"
+      end
+
+      @preds.zip(value).map { |(pred, val)| S.unform(pred, val) }
+    end
+
     def explain(path, via, inn, value)
-      if !Utils.array?(value)
-        [{ :path => path, :val => value, :via => via, :in => inn, :pred => [Utils.method(:array?), [value]] }]
+      if !Predicates.array?(value)
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => [Predicates.method(:array?), [value]] }]
       elsif @preds.count != value.count
         [{ :path => path, :val => value, :via => via, :in => inn, :pred => [Utils.method(:count_eq), [@preds, value.count]] }]
       else
@@ -62,7 +70,7 @@ module Speculation
     end
 
     def gen(overrides, path, rmap)
-      return @gen if @gen
+      return @gen.call if @gen
 
       gens = @preds.each_with_index.
         map { |p, i| S.gensub(p, overrides, Utils.conj(path, i), rmap) }

data/lib/speculation/test.rb

@@ -148,7 +148,7 @@ module Speculation
     #   * :result     optional boolean as to whether all generative tests passed
     #   * :num_tests  optional number of generative tests ran
     #
-    #   :failure is a hash that will contain a :"Speculation/failure" key with possible values:
+    #   :failure is a hash that will contain a :failure key with possible values:
     #
     #   * :check_failed   at least one checked return did not conform
     #   * :no_args_spec   no :args spec provided
@@ -174,11 +174,11 @@ module Speculation
     # @return [Hash]
     def self.abbrev_result(x)
       if x[:failure]
-        x.reject { |k, _| k == ns(:ret) }.
+        x.reject { |k, _| k == :ret }.
           merge(:spec    => x[:spec].inspect,
                 :failure => unwrap_failure(x[:failure]))
       else
-        x.reject { |k, _| [:spec, ns(:ret)].include?(k) }
+        x.reject { |k, _| [:spec, :ret].include?(k) }
       end
     end
 
@@ -223,30 +223,30 @@ module Speculation
           conformed_args = S.conform(fspec.args, args)
           conformed_block = S.conform(fspec.block, block) if fspec.block
 
-          if conformed_args == S::INVALID
+          if conformed_args == :"Speculation/invalid"
             backtrace = backtrace_relevant_to_instrument(caller)
 
             ed = S.
               _explain_data(fspec.args, [:args], [], [], args).
-              merge(ns(S, :args) => args, ns(S, :failure) => :instrument, ns(:caller) => backtrace.first)
+              merge(:args => args, :failure => :instrument, :caller => backtrace.first)
 
             io = StringIO.new
             S.explain_out(ed, io)
             msg = io.string
 
-            raise Speculation::Error.new("Call to '#{ident}' did not conform to spec:\n #{msg}", ed)
-          elsif conformed_block == S::INVALID
+            raise Speculation::Error.new("Call to '#{ident}' did not conform to spec:\n#{msg}", ed)
+          elsif conformed_block == :"Speculation/invalid"
             backtrace = backtrace_relevant_to_instrument(caller)
 
             ed = S.
               _explain_data(fspec.block, [:block], [], [], block).
-              merge(ns(S, :block) => block, ns(S, :failure) => :instrument, ns(:caller) => backtrace.first)
+              merge(:block => block, :failure => :instrument, :caller => backtrace.first)
 
             io = StringIO.new
             S.explain_out(ed, io)
             msg = io.string
 
-            raise Speculation::Error.new("Call to '#{ident}' did not conform to spec:\n #{msg}", ed)
+            raise Speculation::Error.new("Call to '#{ident}' did not conform to spec:\n#{msg}", ed)
           end
         end
 
@@ -271,7 +271,7 @@ module Speculation
       end
 
       def no_fspec(ident, spec)
-        S::Error.new("#{ident} not spec'ed", :method => ident, :spec => spec, ns(S, :failure) => :no_fspec)
+        S::Error.new("#{ident} not spec'ed", :method => ident, :spec => spec, :failure => :no_fspec)
       end
 
       def instrument1(ident, opts)
@@ -343,9 +343,9 @@ module Speculation
       def explain_check(args, spec, v, role)
         data = unless S.valid?(spec, v)
                  S._explain_data(spec, [role], [], [], v).
-                   merge(ns(:args)       => args,
-                         ns(:val)        => v,
-                         ns(S, :failure) => :check_failed)
+                   merge(:args    => args,
+                         :val     => v,
+                         :failure => :check_failed)
                end
 
         S::Error.new("Specification-based check failed", data).tap do |e|
@@ -355,17 +355,17 @@ module Speculation
 
       # Returns true if call passes specs, otherwise returns a hash with
       # :backtrace, :cause and :data keys. :data will have a
-      # :"Speculation/failure" key.
+      # :failure key.
       def check_call(method, spec, args, block)
         conformed_args = S.conform(spec.args, args) if spec.args
 
-        if conformed_args == S::INVALID
+        if conformed_args == :"Speculation/invalid"
           return explain_check(args, spec.args, args, :args)
         end
 
         conformed_block = S.conform(spec.block, block) if spec.block
 
-        if conformed_block == S::INVALID
+        if conformed_block == :"Speculation/invalid"
           return explain_check(block, spec.block, block, :block)
         end
 
@@ -373,7 +373,7 @@ module Speculation
 
         conformed_ret = S.conform(spec.ret, ret) if spec.ret
 
-        if conformed_ret == S::INVALID
+        if conformed_ret == :"Speculation/invalid"
           return explain_check(args, spec.ret, ret, :ret)
         end
 
@@ -415,9 +415,9 @@ module Speculation
       end
 
       def make_check_result(method, spec, check_result)
-        result = { :spec    => spec,
-                   ns(:ret) => check_result,
-                   :method  => method }
+        result = { :spec   => spec,
+                   :ret    => check_result,
+                   :method => method }
 
         if check_result[:result] && check_result[:result] != true
           result[:failure] = check_result[:result]
@@ -440,8 +440,8 @@ module Speculation
           check_result = quick_check(method, spec, opts)
           make_check_result(method, spec, check_result)
         else
-          failure = { :info        => "No :args spec",
-                      ns(:failure) => :no_args_spec }
+          failure = { :info    => "No :args spec",
+                      :failure => :no_args_spec }
 
           { :failure => failure,
             :method  => method,
@@ -540,7 +540,7 @@ module Speculation
       ### check reporting ###
 
       def failure_type(x)
-        x.data[ns(S, :failure)] if x.is_a?(S::Error)
+        x.data[:failure] if x.is_a?(S::Error)
       end
 
       def unwrap_failure(x)
@@ -548,7 +548,7 @@ module Speculation
       end
 
       # Returns the type of the check result. This can be any of the
-      # :"Speculation/failure" symbols documented in 'check', or:
+      # :failure symbols documented in 'check', or:
       #
       # :check_passed   all checked method returns conformed
       # :check_raised   checked fn threw an exception

data/lib/speculation/utils.rb

@@ -5,18 +5,6 @@ require "set"
 module Speculation
   # @private
   module Utils
-    def self.hash?(x)
-      x.respond_to?(:store)
-    end
-
-    def self.array?(x)
-      x.respond_to?(:at)
-    end
-
-    def self.collection?(xs)
-      xs.respond_to?(:each)
-    end
-
     def self.itself(x)
       x
     end
@@ -25,24 +13,6 @@ module Speculation
       ->(*) { x }
     end
 
-    def self.complement(&f)
-      ->(*args) { !f.call(*args) }
-    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.ident?(x)
       x.is_a?(Symbol) || x.is_a?(MethodIdentifier)
     end
@@ -59,22 +29,6 @@ module Speculation
       from.reduce(to) { |memo, obj| conj(memo, obj) }
     end
 
-    def self.count_eq?(coll, count)
-      coll.count == count
-    end
-
-    def self.count_between?(coll, min_count, max_count)
-      coll.count.between?(min_count, max_count)
-    end
-
-    def self.key?(hash, key)
-      hash.key?(key)
-    end
-
-    def self.empty?(coll)
-      coll.empty?
-    end
-
     def self.conj(a, b)
       case a
       when Array, Set
@@ -87,5 +41,9 @@ module Speculation
       else raise ArgumentError, "#{a}: must be an Array, Set or Hash"
       end
     end
+
+    def self.sort_descending(coll)
+      coll.sort { |a, b| yield(b) <=> yield(a) }
+    end
   end
 end