dry-logic 1.0.5 → 1.1.1

data/spec/unit/operations/each_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-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,32 +0,0 @@
-# frozen_string_literal: true
-
-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,135 +0,0 @@
-# frozen_string_literal: true
-
-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,51 +0,0 @@
-# frozen_string_literal: true
-
-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,75 +0,0 @@
-# frozen_string_literal: true
-
-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

data/spec/unit/operations/set_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Operations::Set do
-  subject(:operation) { Operations::Set.new(is_int, gt_18) }
-
-  include_context 'predicates'
-
-  let(:is_int) { Rule::Predicate.build(int?) }
-  let(:gt_18) { Rule::Predicate.build(gt?, args: [18]) }
-
-  describe '#call' do
-    it 'applies all its rules to the input' do
-      expect(operation.(19)).to be_success
-      expect(operation.(17)).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:set, [[:predicate, [:int?, [[:input, Undefined]]]], [:predicate, [:gt?, [[:num, 18], [:input, Undefined]]]]]]
-      )
-    end
-
-    it 'returns result ast' do
-      expect(operation.(17).to_ast).to eql(
-        [:set, [[:predicate, [:gt?, [[:num, 18], [:input, 17]]]]]]
-      )
-    end
-
-    it 'returns result ast with an :id' do
-      expect(operation.with(id: :age).(17).to_ast).to eql(
-        [:failure, [:age, [:set, [[:predicate, [:gt?, [[:num, 18], [:input, 17]]]]]]]]
-      )
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('set(int?, gt?(18))')
-    end
-  end
-end

data/spec/unit/operations/xor_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Operations::Xor do
-  subject(:operation) { Operations::Xor.new(left, right) }
-
-  include_context 'predicates'
-
-  let(:left) { Rule::Predicate.build(array?) }
-  let(:right) { Rule::Predicate.build(empty?) }
-
-  let(:other) do
-    Rule::Predicate.build(str?)
-  end
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(operation.(nil)).to be_success
-      expect(operation.('')).to be_success
-      expect(operation.([])).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:xor, [[:predicate, [:array?, [[:input, Undefined]]]], [:predicate, [:empty?, [[:input, Undefined]]]]]]
-      )
-    end
-
-    it 'returns result ast' do
-      expect(operation.([]).to_ast).to eql(
-        [:xor, [[:predicate, [:array?, [[:input, []]]]], [:predicate, [:empty?, [[:input, []]]]]]]
-      )
-    end
-
-    it 'returns failure result ast' do
-      expect(operation.with(id: :name).([]).to_ast).to eql(
-        [:failure, [:name, [:xor, [[:predicate, [:array?, [[:input, []]]]], [:predicate, [:empty?, [[:input, []]]]]]]]]
-      )
-    end
-  end
-
-  describe '#and' do
-    it 'creates conjunction with the other' do
-      expect(operation.and(other).(nil)).to be_failure
-      expect(operation.and(other).(19)).to be_failure
-      expect(operation.and(other).('')).to be_success
-    end
-  end
-
-  describe '#or' do
-    it 'creates disjunction with the other' do
-      expect(operation.or(other).([])).to be_failure
-      expect(operation.or(other).('')).to be_success
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns string representation' do
-      expect(operation.to_s).to eql('array? XOR empty?')
-    end
-  end
-end