dry-logic 0.6.1 → 1.0.6

data/spec/support/mutant.rb

@@ -1,9 +0,0 @@
-module Mutant
-  class Selector
-    class Expression < self
-      def call(_subject)
-        integration.all_tests
-      end
-    end
-  end
-end

data/spec/unit/operations/and_spec.rb

@@ -1,68 +0,0 @@
-RSpec.describe Operations::And do
-  subject(:operation) { Operations::And.new(left, right) }
-
-  include_context 'predicates'
-
-  let(:left) { Rule::Predicate.build(int?) }
-  let(:right) { Rule::Predicate.build(gt?).curry(18) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(operation.(18)).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:and, [[:predicate, [:int?, [[:input, Undefined]]]], [:predicate, [:gt?, [[:num, 18], [:input, Undefined]]]]]]
-      )
-    end
-
-    it 'returns result ast' do
-      expect(operation.('18').to_ast).to eql(
-        [:and, [[:predicate, [:int?, [[:input, '18']]]], [:hint, [:predicate, [:gt?, [[:num, 18], [:input, '18']]]]]]]
-      )
-
-      expect(operation.with(hints: false).('18').to_ast).to eql(
-        [:predicate, [:int?, [[:input, '18']]]]
-      )
-
-      expect(operation.(18).to_ast).to eql(
-        [:predicate, [:gt?, [[:num, 18], [:input, 18]]]]
-      )
-    end
-
-    it 'returns failure result ast' do
-      expect(operation.with(id: :age).('18').to_ast).to eql(
-        [:failure, [:age, [:and, [[:predicate, [:int?, [[:input, '18']]]], [:hint, [:predicate, [:gt?, [[:num, 18], [:input, '18']]]]]]]]]
-      )
-
-      expect(operation.with(id: :age).(18).to_ast).to eql(
-        [:failure, [:age, [:predicate, [:gt?, [[:num, 18], [:input, 18]]]]]]
-      )
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Rule::Predicate.build(lt?).curry(30) }
-
-    it 'creates and with the other' do
-      expect(operation.and(other).(31)).to be_failure
-    end
-  end
-
-  describe '#or' do
-    let(:other) { Rule::Predicate.build(lt?).curry(14) }
-
-    it 'creates or with the other' do
-      expect(operation.or(other).(13)).to be_success
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('int? AND gt?(18)')
-    end
-  end
-end

data/spec/unit/operations/attr_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe Operations::Attr do
-  subject(:operation) { Operations::Attr.new(Rule::Predicate.build(str?), name: :name) }
-
-  include_context 'predicates'
-
-  let(:model) { Struct.new(:name) }
-
-  describe '#call' do
-    it 'applies predicate to the value' do
-      expect(operation.(model.new('Jane'))).to be_success
-      expect(operation.(model.new(nil))).to be_failure
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Operations::Attr.new(Rule::Predicate.build(min_size?).curry(3), name: :name) }
-
-    it 'returns and where value is passed to the right' do
-      present_and_string = operation.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/operations/check_spec.rb

@@ -1,49 +0,0 @@
-RSpec.describe Operations::Check do
-  include_context 'predicates'
-
-  describe '#call' do
-    context 'with 1-level nesting' do
-      subject(:operation) do
-        Operations::Check.new(Rule::Predicate.build(eql?).curry(1), id: :compare, keys: [:num])
-      end
-
-      it 'applies predicate to args extracted from the input' do
-        expect(operation.(num: 1)).to be_success
-        expect(operation.(num: 2)).to be_failure
-      end
-    end
-
-    context 'with 2-levels nesting' do
-      subject(:operation) do
-        Operations::Check.new(Rule::Predicate.build(eql?), id: :compare, keys: [[:nums, :left], [:nums, :right]])
-      end
-
-      it 'applies predicate to args extracted from the input' do
-        expect(operation.(nums: { left: 1, right: 1 })).to be_success
-        expect(operation.(nums: { left: 1, right: 2 })).to be_failure
-      end
-
-      it 'curries args properly' do
-        result = operation.(nums: { left: 1, right: 2 })
-
-        expect(result.to_ast).to eql(
-          [:failure, [:compare, [:check, [
-            [[:nums, :left], [:nums, :right]], [:predicate, [:eql?, [[:left, 1], [:right, 2]]]]]
-          ]]]
-        )
-      end
-    end
-  end
-
-  describe '#to_ast' do
-    subject(:operation) do
-      Operations::Check.new(Rule::Predicate.build(str?), keys: [:email])
-    end
-
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:check, [[:email], [:predicate, [:str?, [[:input, Undefined]]]]]]
-      )
-    end
-  end
-end

data/spec/unit/operations/each_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe Operations::Each do
-  subject(:operation) { Operations::Each.new(is_string) }
-
-  include_context 'predicates'
-
-  let(:is_string) { Rule::Predicate.build(str?) }
-
-  describe '#call' do
-    it 'applies its rules to all elements in the input' do
-      expect(operation.(['Address'])).to be_success
-
-      expect(operation.([nil, 'Address'])).to be_failure
-      expect(operation.([:Address, 'Address'])).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql([:each, [:predicate, [:str?, [[:input, Undefined]]]]])
-    end
-
-    it 'returns result ast' do
-      expect(operation.([nil, 12, nil]).to_ast).to eql(
-        [:set, [
-          [:key, [0, [:predicate, [:str?, [[:input, nil]]]]]],
-          [:key, [1, [:predicate, [:str?, [[:input, 12]]]]]],
-          [:key, [2, [:predicate, [:str?, [[:input, nil]]]]]]
-        ]]
-      )
-    end
-
-    it 'returns failure result ast' do
-      expect(operation.with(id: :tags).([nil, 'red', 12]).to_ast).to eql(
-        [:failure, [:tags, [:set, [
-          [:key, [0, [:predicate, [:str?, [[:input, nil]]]]]],
-          [:key, [2, [:predicate, [:str?, [[:input, 12]]]]]]
-        ]]]]
-      )
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('each(str?)')
-    end
-  end
-end

data/spec/unit/operations/implication_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe Operations::Implication do
-  subject(:operation) { Operations::Implication.new(left, right) }
-
-  include_context 'predicates'
-
-  let(:left) { Rule::Predicate.build(int?) }
-  let(:right) { Rule::Predicate.build(gt?).curry(18) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(operation.('19')).to be_success
-      expect(operation.(19)).to be_success
-      expect(operation.(18)).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:implication, [[:predicate, [:int?, [[:input, Undefined]]]], [:predicate, [:gt?, [[:num, 18], [:input, Undefined]]]]]]
-      )
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('int? THEN gt?(18)')
-    end
-  end
-end

data/spec/unit/operations/key_spec.rb

@@ -1,133 +0,0 @@
-RSpec.describe Operations::Key do
-  subject(:operation) { Operations::Key.new(predicate, name: :user) }
-
-  include_context 'predicates'
-
-  let(:predicate) do
-    Rule::Predicate.build(key?).curry(:age)
-  end
-
-  describe '#call' do
-    context 'with a plain predicate' do
-      it 'returns a success for valid input' do
-        expect(operation.(user: { age: 18 })).to be_success
-      end
-
-      it 'returns a failure for invalid input' do
-        result = operation.(user: {})
-
-        expect(result).to be_failure
-
-        expect(result.to_ast).to eql(
-          [:failure, [:user, [:key, [:user,
-            [:predicate, [:key?, [[:name, :age], [:input, {}]]]]
-          ]]]]
-        )
-      end
-    end
-
-    context 'with a set rule as predicate' do
-      subject(:operation) do
-        Operations::Key.new(predicate, name: :address)
-      end
-
-      let(:predicate) do
-        Operations::Set.new(Rule::Predicate.build(key?).curry(:city), Rule::Predicate.build(key?).curry(:zipcode))
-      end
-
-      it 'applies set rule to the value that passes' do
-        result = operation.(address: { city: 'NYC', zipcode: '123' })
-
-        expect(result).to be_success
-      end
-
-      it 'applies set rule to the value that fails' do
-        result = operation.(address: { city: 'NYC' })
-
-        expect(result).to be_failure
-
-        expect(result.to_ast).to eql(
-          [:failure, [:address, [:key, [:address, [:set, [
-            [:predicate, [:key?, [[:name, :zipcode], [:input, { city: 'NYC' }]]]]
-          ]]]]]]
-        )
-      end
-    end
-
-    context 'with an each rule as predicate' do
-      subject(:operation) do
-        Operations::Key.new(predicate, name: :nums)
-      end
-
-      let(:predicate) do
-        Operations::Each.new(Rule::Predicate.build(str?))
-      end
-
-      it 'applies each rule to the value that passses' do
-        result = operation.(nums: %w(1 2 3))
-
-        expect(result).to be_success
-      end
-
-      it 'applies each rule to the value that fails' do
-        failure = operation.(nums: [1, '3', 3])
-
-        expect(failure).to be_failure
-
-        expect(failure.to_ast).to eql(
-          [:failure, [:nums, [:key, [:nums, [:set, [
-            [:key, [0, [:predicate, [:str?, [[:input, 1]]]]]],
-            [:key, [2, [:predicate, [:str?, [[:input, 3]]]]]]
-          ]]]]]]
-        )
-      end
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:key, [:user, [:predicate, [:key?, [[:name, :age], [:input, Undefined]]]]]]
-      )
-    end
-  end
-
-  describe '#ast' do
-    it 'returns ast without the input' do
-      expect(operation.ast).to eql(
-        [:key, [:user, [:predicate, [:key?, [[:name, :age], [:input, Undefined]]]]]]
-      )
-    end
-
-    it 'returns ast with the input' do
-      expect(operation.ast(user: 'jane')).to eql(
-        [:key, [:user, [:predicate, [:key?, [[:name, :age], [:input, 'jane']]]]]]
-      )
-    end
-  end
-
-  describe '#and' do
-    subject(:operation) do
-      Operations::Key.new(Rule::Predicate.build(str?), name: [:user, :name])
-    end
-
-    let(:other) do
-      Operations::Key.new(Rule::Predicate.build(filled?), name: [:user, :name])
-    end
-
-    it 'returns and rule where value is passed to the right' do
-      present_and_string = operation.and(other)
-
-      expect(present_and_string.(user: { name: 'Jane' })).to be_success
-
-      expect(present_and_string.(user: {})).to be_failure
-      expect(present_and_string.(user: { name: 1 })).to be_failure
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('key[user](key?(:age))')
-    end
-  end
-end

data/spec/unit/operations/negation_spec.rb

@@ -1,49 +0,0 @@
-RSpec.describe Operations::Negation do
-  subject(:operation) { Operations::Negation.new(is_int) }
-
-  include_context 'predicates'
-
-  let(:is_int) { Rule::Predicate.build(int?) }
-
-  describe '#call' do
-    it 'negates its rule' do
-      expect(operation.('19')).to be_success
-      expect(operation.(17)).to be_failure
-    end
-
-    context 'double negation' do
-      subject(:double_negation) { Operations::Negation.new(operation) }
-
-      it 'works as rule' do
-        expect(double_negation.('19')).to be_failure
-        expect(double_negation.(17)).to be_success
-      end
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:not, [:predicate, [:int?, [[:input, Undefined]]]]]
-      )
-    end
-
-    it 'returns result ast' do
-      expect(operation.(17).to_ast).to eql(
-        [:not, [:predicate, [:int?, [[:input, 17]]]]]
-      )
-    end
-
-    it 'returns result ast with an :id' do
-      expect(operation.with(id: :age).(17).to_ast).to eql(
-        [:failure, [:age, [:not, [:predicate, [:int?, [[:input, 17]]]]]]]
-      )
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('not(int?)')
-    end
-  end
-end

data/spec/unit/operations/or_spec.rb

@@ -1,73 +0,0 @@
-RSpec.describe Operations::Or do
-  subject(:operation) { Operations::Or.new(left, right) }
-
-  include_context 'predicates'
-
-  let(:left) { Rule::Predicate.build(nil?) }
-  let(:right) { Rule::Predicate.build(gt?).curry(18) }
-
-  let(:other) do
-    Rule::Predicate.build(int?) & Rule::Predicate.build(lt?).curry(14)
-  end
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(operation.(nil)).to be_success
-      expect(operation.(19)).to be_success
-      expect(operation.(18)).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:or, [
-          [:predicate, [:nil?, [[:input, Undefined]]]],
-          [:predicate, [:gt?, [[:num, 18], [:input, Undefined]]]]]
-        ]
-      )
-    end
-
-    it 'returns result ast' do
-      expect(operation.(17).to_ast).to eql(
-        [:or, [
-          [:predicate, [:nil?, [[:input, 17]]]],
-          [:predicate, [:gt?, [[:num, 18], [:input, 17]]]]]
-        ]
-      )
-    end
-
-    it 'returns failure result ast' do
-      expect(operation.with(id: :age).(17).to_ast).to eql(
-        [:failure, [:age, [:or, [
-          [:predicate, [:nil?, [[:input, 17]]]],
-          [:predicate, [:gt?, [[:num, 18], [:input, 17]]]]]
-        ]]]
-      )
-    end
-  end
-
-  describe '#and' do
-    it 'creates and with the other' do
-      expect(operation.and(other).(nil)).to be_failure
-      expect(operation.and(other).(19)).to be_failure
-      expect(operation.and(other).(13)).to be_failure
-      expect(operation.and(other).(14)).to be_failure
-    end
-  end
-
-  describe '#or' do
-    it 'creates or with the other' do
-      expect(operation.or(other).(nil)).to be_success
-      expect(operation.or(other).(19)).to be_success
-      expect(operation.or(other).(13)).to be_success
-      expect(operation.or(other).(14)).to be_failure
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('nil? OR gt?(18)')
-    end
-  end
-end