dry-validation 0.4.1 → 0.5.0

data/lib/dry/validation/predicate_set.rb

@@ -1,22 +0,0 @@
-require 'dry/validation/predicate'
-
-module Dry
-  module Validation
-    module PredicateSet
-      module Methods
-        def predicate(name, &block)
-          register(name) { Predicate.new(name, &block) }
-        end
-
-        def import(predicate_set)
-          merge(predicate_set)
-        end
-      end
-
-      def self.extended(other)
-        super
-        other.extend(Methods, Dry::Container::Mixin)
-      end
-    end
-  end
-end

data/lib/dry/validation/predicates.rb

@@ -1,125 +0,0 @@
-require 'dry/validation/predicate_set'
-
-module Dry
-  module Validation
-    module Predicates
-      extend PredicateSet
-
-      def self.included(other)
-        super
-        other.extend(PredicateSet)
-        other.import(self)
-      end
-
-      predicate(:none?) do |input|
-        input.nil?
-      end
-
-      predicate(:key?) do |name, input|
-        input.key?(name)
-      end
-
-      predicate(:empty?) do |input|
-        case input
-        when String, Array, Hash then input.empty?
-        when nil then true
-        else
-          false
-        end
-      end
-
-      predicate(:filled?) do |input|
-        !self[:empty?].(input)
-      end
-
-      predicate(:bool?) do |input|
-        input.is_a?(TrueClass) || input.is_a?(FalseClass)
-      end
-
-      predicate(:date?) do |input|
-        input.is_a?(Date)
-      end
-
-      predicate(:date_time?) do |input|
-        input.is_a?(DateTime)
-      end
-
-      predicate(:time?) do |input|
-        input.is_a?(Time)
-      end
-
-      predicate(:int?) do |input|
-        input.is_a?(Fixnum)
-      end
-
-      predicate(:float?) do |input|
-        input.is_a?(Float)
-      end
-
-      predicate(:decimal?) do |input|
-        input.is_a?(BigDecimal)
-      end
-
-      predicate(:str?) do |input|
-        input.is_a?(String)
-      end
-
-      predicate(:hash?) do |input|
-        input.is_a?(Hash)
-      end
-
-      predicate(:array?) do |input|
-        input.is_a?(Array)
-      end
-
-      predicate(:lt?) do |num, input|
-        input < num
-      end
-
-      predicate(:gt?) do |num, input|
-        input > num
-      end
-
-      predicate(:lteq?) do |num, input|
-        !self[:gt?].(num, input)
-      end
-
-      predicate(:gteq?) do |num, input|
-        !self[:lt?].(num, input)
-      end
-
-      predicate(:size?) do |size, input|
-        case size
-        when Fixnum then size == input.size
-        when Range, Array then size.include?(input.size)
-        else
-          raise ArgumentError, "+#{size}+ is not supported type for size? predicate"
-        end
-      end
-
-      predicate(:min_size?) do |num, input|
-        input.size >= num
-      end
-
-      predicate(:max_size?) do |num, input|
-        input.size <= num
-      end
-
-      predicate(:inclusion?) do |list, input|
-        list.include?(input)
-      end
-
-      predicate(:exclusion?) do |list, input|
-        !self[:inclusion?].(list, input)
-      end
-
-      predicate(:eql?) do |left, right|
-        left.eql?(right)
-      end
-
-      predicate(:format?) do |regex, input|
-        !regex.match(input).nil?
-      end
-    end
-  end
-end

data/lib/dry/validation/rule.rb

@@ -1,90 +0,0 @@
-module Dry
-  module Validation
-    class Rule
-      include Dry::Equalizer(:name, :predicate)
-
-      attr_reader :name, :predicate
-
-      class Negation < Rule
-        include Dry::Equalizer(:rule)
-
-        attr_reader :rule
-
-        def initialize(rule)
-          @rule = rule
-        end
-
-        def call(*args)
-          rule.(*args).negated
-        end
-
-        def to_ary
-          [:not, rule.to_ary]
-        end
-      end
-
-      def initialize(name, predicate)
-        @name = name
-        @predicate = predicate
-      end
-
-      def predicate_id
-        predicate.id
-      end
-
-      def type
-        :rule
-      end
-
-      def call(*args)
-        Validation.Result(args, predicate.call, self)
-      end
-
-      def to_ary
-        [type, [name, predicate.to_ary]]
-      end
-      alias_method :to_a, :to_ary
-
-      def and(other)
-        Conjunction.new(self, other)
-      end
-      alias_method :&, :and
-
-      def or(other)
-        Disjunction.new(self, other)
-      end
-      alias_method :|, :or
-
-      def xor(other)
-        ExclusiveDisjunction.new(self, other)
-      end
-      alias_method :^, :xor
-
-      def then(other)
-        Implication.new(self, other)
-      end
-      alias_method :>, :then
-
-      def negation
-        Negation.new(self)
-      end
-
-      def new(predicate)
-        self.class.new(name, predicate)
-      end
-
-      def curry(*args)
-        self.class.new(name, predicate.curry(*args))
-      end
-    end
-  end
-end
-
-require 'dry/validation/rule/key'
-require 'dry/validation/rule/value'
-require 'dry/validation/rule/each'
-require 'dry/validation/rule/set'
-require 'dry/validation/rule/composite'
-require 'dry/validation/rule/check'
-require 'dry/validation/rule/group'
-require 'dry/validation/rule/result'

data/lib/dry/validation/rule/check.rb

@@ -1,15 +0,0 @@
-module Dry
-  module Validation
-    class Rule::Check < Rule
-      alias_method :result, :predicate
-
-      def call(*)
-        Validation.Result(nil, result.call, self)
-      end
-
-      def type
-        :check
-      end
-    end
-  end
-end

data/lib/dry/validation/rule/composite.rb

@@ -1,63 +0,0 @@
-module Dry
-  module Validation
-    class Rule::Composite < Rule
-      include Dry::Equalizer(:left, :right)
-
-      attr_reader :name, :left, :right
-
-      def initialize(left, right)
-        @left = left
-        @right = right
-      end
-
-      def name
-        :"#{left.name}_#{type}_#{right.name}"
-      end
-
-      def to_ary
-        [type, [left.to_ary, right.to_ary]]
-      end
-      alias_method :to_a, :to_ary
-    end
-
-    class Rule::Implication < Rule::Composite
-      def call(*args)
-        left.(*args) > right
-      end
-
-      def type
-        :implication
-      end
-    end
-
-    class Rule::Conjunction < Rule::Composite
-      def call(*args)
-        left.(*args).and(right)
-      end
-
-      def type
-        :and
-      end
-    end
-
-    class Rule::Disjunction < Rule::Composite
-      def call(*args)
-        left.(*args).or(right)
-      end
-
-      def type
-        :or
-      end
-    end
-
-    class Rule::ExclusiveDisjunction < Rule::Composite
-      def call(*args)
-        left.(*args).xor(right)
-      end
-
-      def type
-        :xor
-      end
-    end
-  end
-end

data/lib/dry/validation/rule/each.rb

@@ -1,13 +0,0 @@
-module Dry
-  module Validation
-    class Rule::Each < Rule
-      def call(input)
-        Validation.Result(input, input.map { |element| predicate.(element) }, self)
-      end
-
-      def type
-        :each
-      end
-    end
-  end
-end

data/lib/dry/validation/rule/group.rb

@@ -1,21 +0,0 @@
-module Dry
-  module Validation
-    class Rule::Group < Rule
-      attr_reader :rules
-
-      def initialize(identifier, predicate)
-        name, rules = identifier.to_a.first
-        @rules = rules
-        super(name, predicate)
-      end
-
-      def call(*input)
-        Validation.Result(input, predicate.(*input), self)
-      end
-
-      def type
-        :group
-      end
-    end
-  end
-end

data/lib/dry/validation/rule/key.rb

@@ -1,17 +0,0 @@
-module Dry
-  module Validation
-    class Rule::Key < Rule
-      def self.new(name, predicate)
-        super(name, predicate.curry(name))
-      end
-
-      def type
-        :key
-      end
-
-      def call(input)
-        Validation.Result(input[name], predicate.(input), self)
-      end
-    end
-  end
-end

data/lib/dry/validation/rule/result.rb

@@ -1,119 +0,0 @@
-module Dry
-  module Validation
-    def self.Result(input, value, rule)
-      case value
-      when Rule::Result then value.class.new(value.input, value.success?, rule)
-      when Array then Rule::Result::Set.new(input, value, rule)
-      else Rule::Result::Value.new(input, value, rule)
-      end
-    end
-
-    class Rule::Result
-      include Dry::Equalizer(:success?, :input, :rule)
-
-      attr_reader :input, :value, :rule, :name
-
-      class Rule::Result::Set < Rule::Result
-        def success?
-          value.all?(&:success?)
-        end
-
-        def to_ary
-          indices = value.map { |v| v.failure? ? value.index(v) : nil }.compact
-          [:input, [rule.name, input, value.values_at(*indices).map(&:to_ary)]]
-        end
-      end
-
-      class Rule::Result::Value < Rule::Result
-        def to_ary
-          [:input, [rule.name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
-      end
-
-      class Rule::Result::Verified < Rule::Result
-        attr_reader :predicate_id
-
-        def initialize(result, predicate_id)
-          @input = result.input
-          @value = result.value
-          @rule = result.rule
-          @name = result.name
-          @predicate_id = predicate_id
-        end
-
-        def call
-          Validation.Result(input, success?, rule)
-        end
-
-        def to_ary
-          [:input, [name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
-
-        def success?
-          rule.predicate_id == predicate_id
-        end
-      end
-
-      def initialize(input, value, rule)
-        @input = input
-        @value = value
-        @rule = rule
-        @name = rule.name
-      end
-
-      def call
-        self
-      end
-
-      def curry(predicate_id = nil)
-        if predicate_id
-          Rule::Result::Verified.new(self, predicate_id)
-        else
-          self
-        end
-      end
-
-      def negated
-        self.class.new(input, !value, rule)
-      end
-
-      def >(other)
-        if success?
-          other.(input)
-        else
-          Validation.Result(input, true, rule)
-        end
-      end
-
-      def and(other)
-        if success?
-          other.(input)
-        else
-          self
-        end
-      end
-
-      def or(other)
-        if success?
-          self
-        else
-          other.(input)
-        end
-      end
-
-      def xor(other)
-        Validation.Result(input, success? ^ other.(input).success?, rule)
-      end
-
-      def success?
-        @value
-      end
-
-      def failure?
-        ! success?
-      end
-    end
-  end
-end