dry-logic 0.3.0 → 0.4.0

data/lib/dry/logic/rule/attr.rb

@@ -1,13 +0,0 @@
-module Dry
-  module Logic
-    class Rule::Attr < Rule::Key
-      def self.evaluator(name)
-        Evaluator::Attr.new(name)
-      end
-
-      def type
-        :attr
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'dry/logic/evaluator'
-
-module Dry
-  module Logic
-    class Rule::Check < Rule::Value
-      attr_reader :name, :evaluator
-
-      def self.new(predicate, options)
-        keys = options.fetch(:keys)
-        evaluator = Evaluator::Set.new(keys)
-
-        super(predicate, options.merge(evaluator: evaluator))
-      end
-
-      def initialize(predicate, options)
-        super
-        @name = options.fetch(:name)
-        @evaluator = options[:evaluator]
-      end
-
-      def call(input)
-        args = evaluator[input].reverse
-        *head, tail = args
-        Logic.Result(predicate.curry(*head).(tail), curry(*args), input)
-      end
-
-      def evaluate(input)
-        evaluator[input].first
-      end
-
-      def type
-        :check
-      end
-
-      def to_ast
-        [type, [name, predicate.to_ast]]
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-module Dry
-  module Logic
-    class Rule::Composite < Rule
-      include Dry::Equalizer(:left, :right)
-
-      attr_reader :left, :right
-
-      def initialize(left, right)
-        @left = left
-        @right = right
-      end
-
-      def arity
-        -1
-      end
-
-      def input
-        Predicate::Undefined
-      end
-
-      def curry(*args)
-        self.class.new(left.curry(*args), right.curry(*args))
-      end
-
-      def name
-        :"#{left.name}_#{type}_#{right.name}"
-      end
-
-      def to_ast
-        [type, [left.to_ast, right.to_ast]]
-      end
-      alias_method :to_a, :to_ast
-    end
-
-    class Rule::Implication < Rule::Composite
-      def call(input)
-        if left.(input).success?
-          right.(input)
-        else
-          Logic.Result(true, left, input)
-        end
-      end
-
-      def type
-        :implication
-      end
-    end
-
-    class Rule::Conjunction < Rule::Composite
-      def call(input)
-        result = left.(input)
-
-        if result.success?
-          right.(input)
-        else
-          result
-        end
-      end
-
-      def type
-        :and
-      end
-    end
-
-    class Rule::Disjunction < Rule::Composite
-      def call(input)
-        result = left.(input)
-
-        if result.success?
-          result
-        else
-          right.(input)
-        end
-      end
-
-      def type
-        :or
-      end
-    end
-
-    class Rule::ExclusiveDisjunction < Rule::Composite
-      def call(input)
-        Logic.Result(left.(input).success? ^ right.(input).success?, self, input)
-      end
-
-      def type
-        :xor
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Dry
-  module Logic
-    class Rule::Each < Rule::Value
-      def apply(input)
-        Hash[input.map.with_index { |element, index| [index, predicate.(element)] }]
-      end
-
-      def type
-        :each
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'dry/logic/evaluator'
-
-module Dry
-  module Logic
-    class Rule::Key < Rule::Value
-      attr_reader :name, :evaluator
-
-      def self.new(predicate, options)
-        name = options.fetch(:name)
-        eval = options.fetch(:evaluator, evaluator(name))
-        super(predicate, evaluator: eval, name: name)
-      end
-
-      def self.evaluator(name)
-        Evaluator::Key.new(name)
-      end
-
-      def initialize(predicate, options)
-        super
-        @name = options[:name]
-        @evaluator = options[:evaluator]
-      end
-
-      def evaluate(input)
-        evaluator[input]
-      end
-
-      def type
-        :key
-      end
-
-      def to_ast
-        [type, [name, predicate.to_ast]]
-      end
-    end
-  end
-end

data/lib/dry/logic/rule/negation.rb

@@ -1,15 +0,0 @@
-module Dry
-  module Logic
-    class Rule
-      class Negation < Rule::Value
-        def type
-          :not
-        end
-
-        def call(input)
-          predicate.(input).negated
-        end
-      end
-    end
-  end
-end

data/lib/dry/logic/rule/set.rb

@@ -1,31 +0,0 @@
-module Dry
-  module Logic
-    class Rule::Set < Rule::Value
-      alias_method :rules, :predicate
-
-      def type
-        :set
-      end
-
-      def arity
-        -1
-      end
-
-      def apply(input)
-        rules.map { |rule| rule.(input) }
-      end
-
-      def curry(*args)
-        new(rules.map { |r| r.curry(*args) })
-      end
-
-      def at(*args)
-        new(rules.values_at(*args))
-      end
-
-      def to_ast
-        [type, rules.map { |rule| rule.to_ast }]
-      end
-    end
-  end
-end

data/lib/dry/logic/rule/value.rb

@@ -1,48 +0,0 @@
-module Dry
-  module Logic
-    class Rule::Value < Rule
-      def type
-        :val
-      end
-
-      def nulary?
-        arity == 0
-      end
-
-      def arity
-        @arity ||= predicate.arity
-      end
-
-      def args
-        @args ||= predicate.args
-      end
-
-      def input
-        predicate.args.last
-      end
-
-      def call(input)
-        if nulary?
-          Logic.Result(predicate.(), self, input)
-        else
-          evaled = evaluate(input)
-          result = apply(evaled)
-          rule = result == true ? self : curry(evaled)
-          Logic.Result(result, rule, input)
-        end
-      end
-
-      def apply(input)
-        predicate.(input)
-      end
-
-      def evaluate(input)
-        input
-      end
-
-      def to_ast
-        [type, predicate.to_ast]
-      end
-    end
-  end
-end

data/spec/unit/predicate_spec.rb

@@ -1,115 +0,0 @@
-require 'dry/logic/predicate'
-
-RSpec.describe Predicate do
-  describe '.new' do
-    it 'can be initialized with empty args' do
-      predicate = Predicate.new(:id) { |v| v.is_a?(Integer) }
-
-      expect(predicate.to_ast).to eql([:predicate, [:id, [[:v, Predicate::Undefined]]]])
-    end
-
-    it 'can be initialized with args' do
-      predicate = Predicate.new(:id, args: [1]) { |v| v.is_a?(Integer) }
-
-      expect(predicate.to_ast).to eql([:predicate, [:id, [[:v, 1]]]])
-    end
-
-    it 'can be initialized with fn as the last arg' do
-      predicate = Predicate.new(:id, args: [1], fn: -> v { v.is_a?(Integer) })
-
-      expect(predicate.to_ast).to eql([:predicate, [:id, [[:v, 1]]]])
-    end
-  end
-
-  describe '#bind' do
-    it 'returns a predicate bound to a specific object' do
-      fn = String.instance_method(:empty?)
-
-      expect(Dry::Logic.Predicate(fn).bind("").()).to be(true)
-      expect(Dry::Logic.Predicate(fn).bind("foo").()).to be(false)
-    end
-  end
-
-  describe '#call' do
-    it 'returns result of the predicate function' do
-      is_empty = Dry::Logic::Predicate.new(:is_empty) { |str| str.empty? }
-
-      expect(is_empty.('')).to be(true)
-
-      expect(is_empty.('filled')).to be(false)
-    end
-
-    it "raises argument error when incorrect number of args provided" do
-      min_age = Dry::Logic::Predicate.new(:min_age) { |age, input| input >= age }
-
-      expect { min_age.curry(10, 12, 14) }.to raise_error(ArgumentError)
-      expect { min_age.(18, 19, 20, 30) }.to raise_error(ArgumentError)
-      expect { min_age.curry(18).(19, 20) }.to raise_error(ArgumentError)
-    end
-
-    it "predicates should work without any args" do
-      is_empty = Dry::Logic::Predicate.new(:is_empty) { true }
-
-      expect(is_empty.()).to be(true)
-    end
-  end
-
-  describe '#arity' do
-    it 'returns arity of the predicate function' do
-      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
-
-      expect(is_equal.arity).to eql(2)
-    end
-  end
-
-  describe '#parameters' do
-    it 'returns arity of the predicate function' do
-      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
-
-      expect(is_equal.parameters).to eql([[:opt, :left], [:opt, :right]])
-    end
-  end
-
-  describe '#arity' do
-    it 'returns arity of the predicate function' do
-      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
-
-      expect(is_equal.arity).to eql(2)
-    end
-  end
-
-  describe '#parameters' do
-    it 'returns arity of the predicate function' do
-      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
-
-      expect(is_equal.parameters).to eql([[:opt, :left], [:opt, :right]])
-    end
-  end
-
-  describe '#curry' do
-    it 'returns curried predicate' do
-      min_age = Dry::Logic::Predicate.new(:min_age) { |age, input| input >= age }
-
-      min_age_18 = min_age.curry(18)
-
-      expect(min_age_18.args).to eql([18])
-
-      expect(min_age_18.(18)).to be(true)
-      expect(min_age_18.(19)).to be(true)
-      expect(min_age_18.(17)).to be(false)
-    end
-
-    it 'can curry again & again' do
-      min_age = Dry::Logic::Predicate.new(:min_age) { |age, input| input >= age }
-
-      min_age_18 = min_age.curry(18)
-
-      expect(min_age_18.args).to eql([18])
-
-      actual_age_19 = min_age_18.curry(19)
-
-      expect(actual_age_19.()).to be(true)
-      expect(actual_age_19.args).to eql([18,19])
-    end
-  end
-end

data/spec/unit/rule/attr_spec.rb

@@ -1,29 +0,0 @@
-require 'dry/logic/rule'
-
-RSpec.describe Dry::Logic::Rule::Attr do
-  include_context 'predicates'
-
-  let(:model) { Struct.new(:name) }
-
-  subject(:rule) { described_class.new(str?, name: :name) }
-
-  describe '#call' do
-    it 'applies predicate to the value' do
-      expect(rule.(model.new('Jane'))).to be_success
-      expect(rule.(model.new(nil))).to be_failure
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Dry::Logic::Rule::Attr.new(min_size?.curry(3), name: :name) }
-
-    it 'returns conjunction rule where value is passed to the right' do
-      present_and_string = rule.and(other)
-
-      expect(present_and_string.(model.new('Jane'))).to be_success
-
-      expect(present_and_string.(model.new('Ja'))).to be_failure
-      expect(present_and_string.(model.new(1))).to be_failure
-    end
-  end
-end

data/spec/unit/rule/check_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe Rule::Check do
-  include_context 'predicates'
-
-  describe '#call' do
-    context 'with 1-level nesting' do
-      subject(:rule) do
-        Rule::Check.new(eql?.curry(1), name: :compare, keys: [:num])
-      end
-
-      it 'applies predicate to args extracted from the input' do
-        expect(rule.(num: 1)).to be_success
-        expect(rule.(num: 2)).to be_failure
-
-        expect(rule.(num: 1).to_ast).to eql(
-          [:input, [:compare, [
-            :result, [1, [:check, [:compare, [:predicate, [:eql?, [[:left, 1], [:right, 1]]]]]]]]]
-          ]
-        )
-      end
-    end
-
-    context 'with 2-levels nesting' do
-      subject(:rule) do
-        Rule::Check.new(eql?, name: :compare, keys: [[:nums, :left], [:nums, :right]])
-      end
-
-      it 'applies predicate to args extracted from the input' do
-        expect(rule.(nums: { left: 1, right: 1 })).to be_success
-        expect(rule.(nums: { left: 1, right: 2 })).to be_failure
-      end
-
-      #check rules reverse the order of params to enable cases like `left.gt(right)` to work
-      it 'curries args properly' do
-        result = rule.(nums: { left: 1, right: 2 })
-
-        expect(result.to_ast).to eql([
-          :input, [:compare, [
-            :result, [1, [:check, [:compare, [:predicate, [:eql?, [[:left, 2], [:right, 1]]]]]]]]
-          ]
-        ])
-      end
-    end
-  end
-end