speculation 0.1.0

data/lib/speculation/spec_impl/hash_spec.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+module Speculation
+  using Speculation::NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class HashSpec < SpecImpl
+    S = Speculation
+
+    attr_reader :id
+
+    def initialize(req, opt, req_un, opt_un)
+      @id = SecureRandom.uuid
+      @req = req
+      @opt = opt
+      @req_un = req_un
+      @opt_un = opt_un
+
+      req_keys     = req.flat_map(&method(:extract_keys))
+      req_un_specs = req_un.flat_map(&method(:extract_keys))
+
+      unless (req_keys + req_un_specs + opt + opt_un).all? { |s| s.is_a?(Symbol) && s.namespace }
+        raise "all keys must be namespaced Symbols"
+      end
+
+      req_specs = req_keys + req_un_specs
+      req_keys += req_un_specs.map(&method(:unqualify_key))
+
+      pred_exprs = [Utils.method(:hash?)]
+      pred_exprs.push(->(v) { parse_req(req, v, :itself.to_proc) == true }) if req.any?
+      pred_exprs.push(->(v) { parse_req(req_un, v, method(:unqualify_key)) == true }) if req_un.any?
+
+      @req_keys        = req_keys
+      @req_specs       = req_specs
+      @opt_keys        = opt + opt_un.map(&method(:unqualify_key))
+      @opt_specs       = opt + opt_un
+      @keys_pred       = ->(v) { pred_exprs.all? { |p| p.call(v) } }
+      @key_to_spec_map = Hash[req_keys.concat(@opt_keys).zip(req_specs.concat(@opt_specs))]
+    end
+
+    def conform(value)
+      return :invalid.ns unless @keys_pred.call(value)
+
+      reg = S.registry
+      ret = value
+
+      value.each do |key, v|
+        spec_name = @key_to_spec_map.fetch(key, key)
+        spec = reg[spec_name]
+
+        next unless spec
+
+        conformed_value = S.conform(spec, v)
+
+        if S.invalid?(conformed_value)
+          return :invalid.ns
+        else
+          unless conformed_value.equal?(v)
+            ret = ret.merge(key => conformed_value)
+          end
+        end
+      end
+
+      ret
+    end
+
+    def explain(path, via, inn, value)
+      unless Utils.hash?(value)
+        return [{ :path => path, :pred => :hash?, :val => value, :via => via, :in => inn }]
+      end
+
+      problems = []
+
+      if @req.any?
+        valid_or_failure = parse_req(@req, value, :itself.to_proc)
+
+        unless valid_or_failure == true
+          valid_or_failure.each do |failure_sexp|
+            pred = sexp_to_rb(failure_sexp)
+            problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
+          end
+        end
+      end
+
+      if @req_un.any?
+        valid_or_failure = parse_req(@req_un, value, method(:unqualify_key))
+
+        unless valid_or_failure == true
+          valid_or_failure.each do |failure_sexp|
+            pred = sexp_to_rb(failure_sexp)
+            problems << { :path => path, :pred => pred, :val => value, :via => via, :in => inn }
+          end
+        end
+      end
+
+      problems += value.flat_map { |(k, v)|
+        next unless S.registry.key?(@key_to_spec_map[k])
+
+        unless S.pvalid?(@key_to_spec_map.fetch(k), v)
+          S.explain1(@key_to_spec_map.fetch(k), path.conj(k), via, inn.conj(k), v)
+        end
+      }
+
+      problems.compact
+    end
+
+    def specize
+      self
+    end
+
+    def gen(overrides, path, rmap)
+      return @gen if @gen
+
+      rmap = S.inck(rmap, @id)
+
+      reqs = @req_keys.zip(@req_specs).
+        reduce({}) { |m, (k, s)|
+          m.merge(k => S.gensub(s, overrides, path.conj(k), rmap))
+        }
+
+      opts = @opt_keys.zip(@opt_specs).
+        reduce({}) { |m, (k, s)|
+          if S.recur_limit?(rmap, @id, path, k)
+            m
+          else
+            m.merge(k => Gen.delay { S.gensub(s, overrides, path.conj(k), rmap) })
+          end
+        }
+
+      ->(rantly) do
+        count = rantly.range(0, opts.count)
+        opts = opts.to_a.shuffle.take(count).to_h
+
+        reqs.merge(opts).each_with_object({}) { |(k, spec_gen), h|
+          h[k] = spec_gen.call(rantly)
+        }
+      end
+    end
+
+    private
+
+    def sexp_to_rb(sexp, level = 0)
+      if sexp.is_a?(Array)
+        op, *keys = sexp
+        rb_string = String.new
+
+        rb_string << "(" unless level.zero?
+
+        keys.each_with_index do |key, i|
+          unless i.zero?
+            rb_string << " #{op.name} "
+          end
+
+          rb_string << sexp_to_rb(key, level + 1)
+        end
+
+        rb_string << ")" unless level.zero?
+
+        rb_string
+      else
+        ":#{sexp}"
+      end
+    end
+
+    def extract_keys(symbol_or_arr)
+      if symbol_or_arr.is_a?(Array)
+        symbol_or_arr[1..-1].flat_map(&method(:extract_keys))
+      else
+        symbol_or_arr
+      end
+    end
+
+    def unqualify_key(x)
+      x.name.to_sym
+    end
+
+    def parse_req(ks, v, f)
+      key, *ks = ks
+
+      ret = if key.is_a?(Array)
+              op, *kks = key
+              case op
+              when :or.ns
+                if kks.one? { |k| parse_req([k], v, f) == true }
+                  true
+                else
+                  [key]
+                end
+              when :and.ns
+                if kks.all? { |k| parse_req([k], v, f) == true }
+                  true
+                else
+                  [key]
+                end
+              else
+                raise "Expected or, and, got #{op}"
+              end
+            elsif v.key?(f.call(key))
+              true
+            else
+              [key]
+            end
+
+      if ks.any?
+        if ret == true
+          parse_req(ks, v, f)
+        else
+          ret + parse_req(ks, v, f)
+        end
+      else
+        ret
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl/merge_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Speculation
+  using NamespacedSymbols.refine(self)
+
+  # @private
+  class MergeSpec < SpecImpl
+    S = Speculation
+
+    def initialize(preds)
+      @preds = preds
+    end
+
+    def conform(x)
+      ms = @preds.map { |pred| S.dt(pred, x) }
+
+      if ms.any?(&S.method(:invalid?))
+        :invalid.ns(S)
+      else
+        ms.reduce(&:merge)
+      end
+    end
+
+    def explain(path, via, inn, x)
+      @preds.
+        flat_map { |pred| S.explain1(pred, path, via, inn, x) }.
+        compact
+    end
+
+    def gen(overrides, path, rmap)
+      return @gen if @gen
+
+      gens = @preds.
+        map { |pred| S.gensub(pred, overrides, path, rmap) }
+
+      ->(r) do
+        gens.map { |gen| gen.call(r) }.reduce(&:merge)
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl/nilable_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Speculation
+  using NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class NilableSpec < SpecImpl
+    S = Speculation
+
+    def initialize(pred)
+      @pred = pred
+      @delayed_spec = Concurrent::Delay.new { S.send(:specize, pred) }
+    end
+
+    def conform(value)
+      value.nil? ? value : @delayed_spec.value.conform(value)
+    end
+
+    def explain(path, via, inn, value)
+      return if S.pvalid?(@delayed_spec.value, value) || value.nil?
+
+      S.
+        explain1(@pred, path.conj(:pred.ns), via, inn, value).
+        conj(:path => path.conj(:nil.ns), :pred => NilClass, :val => value, :via => via, :in => inn)
+    end
+
+    def gen(overrides, path, rmap)
+      return @gen if @gen
+
+      ->(rantly) do
+        rantly.freq([1, Gen.delay { Utils.constantly(nil) }],
+                    [9, Gen.delay { S.gensub(@pred, overrides, path.conj(:pred.ns), rmap) }])
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl/or_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module Speculation
+  using NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class OrSpec < SpecImpl
+    S = Speculation
+
+    attr_reader :id
+
+    def initialize(named_specs)
+      @id = SecureRandom.uuid
+      @named_specs = named_specs
+      @keys = named_specs.keys
+      @preds = preds = named_specs.values
+
+      @delayed_specs = Concurrent::Delay.new do
+        preds.map { |spec| S.send(:specize, spec) }
+      end
+    end
+
+    def conform(value)
+      @delayed_specs.value.each_with_index do |spec, index|
+        conformed = spec.conform(value)
+
+        unless S.invalid?(conformed)
+          return [@keys[index], conformed]
+        end
+      end
+
+      :invalid.ns
+    end
+
+    def explain(path, via, inn, value)
+      return if S.pvalid?(self, value)
+
+      @keys.zip(@preds).flat_map do |(key, pred)|
+        next if S.pvalid?(pred, value)
+        S.explain1(pred, path.conj(key), via, inn, value)
+      end
+    end
+
+    def gen(overrides, path, rmap)
+      return gen if @gen
+
+      gs = @keys.zip(@preds).
+        map { |(k, p)|
+          rmap = S.inck(rmap, @id)
+
+          unless S.recur_limit?(rmap, @id, path, k)
+            Gen.delay { S.gensub(p, overrides, path.conj(k), rmap) }
+          end
+        }.
+        compact
+
+      unless gs.empty?
+        ->(rantly) { rantly.branch(*gs) }
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl/regex_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Speculation
+  using NamespacedSymbols.refine(self)
+
+  # @private
+  class RegexSpec < SpecImpl
+    S = Speculation
+
+    def initialize(regex)
+      @regex = regex
+    end
+
+    def conform(value)
+      if value.nil? || Utils.collection?(value)
+        S.re_conform(@regex, value)
+      else
+        :invalid.ns
+      end
+    end
+
+    def explain(path, via, inn, value)
+      if value.nil? || Utils.collection?(value)
+        S.re_explain(path, via, inn, @regex, value || [])
+      else
+        [{ :path => path, :val => value, :via => via, :in => inn }]
+      end
+    end
+
+    def gen(overrides, path, rmap)
+      return @gen if @gen
+
+      S.re_gen(@regex, overrides, path, rmap)
+    end
+  end
+end

data/lib/speculation/spec_impl/spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Speculation
+  using Speculation::NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class Spec < SpecImpl
+    S = Speculation
+
+    def initialize(predicate, should_conform)
+      @predicate = predicate
+      @should_conform = should_conform
+    end
+
+    def conform(value)
+      ret = case @predicate
+            when Set            then @predicate.include?(value)
+            when Regexp, Module then @predicate === value
+            else                     @predicate.call(value)
+            end
+
+      if @should_conform
+        ret
+      else
+        ret ? value : :invalid.ns
+      end
+    end
+
+    def explain(path, via, inn, value)
+      if S.invalid?(S.dt(@predicate, value))
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => @predicate }]
+      end
+    end
+
+    def gen(_, _, _)
+      if @gen
+        @gen
+      else
+        Gen.gen_for_pred(@predicate)
+      end
+    end
+
+    def inspect
+      "#{self.class}(#{@name || @predicate.inspect})"
+    end
+  end
+end

data/lib/speculation/spec_impl/tuple_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module Speculation
+  using Speculation::NamespacedSymbols.refine(self)
+  using Conj
+
+  # @private
+  class TupleSpec < SpecImpl
+    S = Speculation
+
+    def initialize(preds)
+      @preds = preds
+
+      @delayed_specs = Concurrent::Delay.new do
+        preds.map { |pred| S.send(:specize, pred) }
+      end
+    end
+
+    def conform(collection)
+      specs = @delayed_specs.value
+
+      unless Utils.array?(collection) && collection.count == specs.count
+        return :invalid.ns
+      end
+
+      return_value = collection.class.new
+
+      collection.zip(specs).each do |(value, spec)|
+        conformed_value = spec.conform(value)
+
+        if S.invalid?(conformed_value)
+          return :invalid.ns
+        else
+          return_value += [conformed_value]
+        end
+      end
+
+      return_value
+    end
+
+    def explain(path, via, inn, value)
+      if !Utils.array?(value)
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => "array?" }]
+      elsif @preds.count != value.count
+        [{ :path => path, :val => value, :via => via, :in => inn, :pred => "count == predicates.count" }]
+      else
+        probs = @preds.zip(value).each_with_index.flat_map { |(pred, x), index|
+          unless S.pvalid?(pred, x)
+            S.explain1(pred, path.conj(index), via, inn.conj(index), x)
+          end
+        }
+
+        probs.compact
+      end
+    end
+
+    def gen(overrides, path, rmap)
+      return @gen if @gen
+
+      gens = @preds.each_with_index.
+        map { |p, i| S.gensub(p, overrides, path.conj(i), rmap) }
+
+      ->(rantly) do
+        gens.map { |g| g.call(rantly) }
+      end
+    end
+  end
+end

data/lib/speculation/spec_impl.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Speculation
+  # @private
+  class SpecImpl
+    attr_accessor :name, :gen
+    attr_reader :id
+
+    def conform(_x)
+      raise NotImplementedError
+    end
+
+    def explain(_path, _via, _inn, _value)
+      raise NotImplementedError
+    end
+
+    def gen(_overrides, _path, _rmap)
+      raise NotImplementedError
+    end
+
+    def inspect
+      "#{self.class}(#{name})"
+    end
+  end
+end
+
+require_relative "spec_impl/hash_spec"
+require_relative "spec_impl/spec"
+require_relative "spec_impl/tuple_spec"
+require_relative "spec_impl/or_spec"
+require_relative "spec_impl/and_spec"
+require_relative "spec_impl/merge_spec"
+require_relative "spec_impl/every_spec"
+require_relative "spec_impl/regex_spec"
+require_relative "spec_impl/f_spec"
+require_relative "spec_impl/nilable_spec"