dry-logic 0.3.0 → 0.4.0

data/spec/unit/rule/conjunction_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe Rule::Composite::Conjunction do
-  include_context 'predicates'
-
-  subject(:rule) { Rule::Composite::Conjunction.new(left, right) }
-
-  let(:left) { Rule::Value.new(int?) }
-  let(:right) { Rule::Value.new(gt?.curry(18)) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.(18)).to be_failure
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Rule::Value.new(lt?.curry(30)) }
-
-    it 'creates conjunction with the other' do
-      expect(rule.and(other).(31)).to be_failure
-    end
-  end
-
-  describe '#or' do
-    let(:other) { Rule::Value.new(lt?.curry(14)) }
-
-    it 'creates disjunction with the other' do
-      expect(rule.or(other).(13)).to be_success
-    end
-  end
-end

data/spec/unit/rule/disjunction_spec.rb

@@ -1,38 +0,0 @@
-RSpec.describe Rule::Composite::Disjunction do
-  include_context 'predicates'
-
-  subject(:rule) { Rule::Composite::Disjunction.new(left, right) }
-
-  let(:left) { Rule::Value.new(none?) }
-  let(:right) { Rule::Value.new(gt?.curry(18)) }
-
-  let(:other) do
-    Rule::Value.new(int?) & Rule::Value.new(lt?.curry(14))
-  end
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.(nil)).to be_success
-      expect(rule.(19)).to be_success
-      expect(rule.(18)).to be_failure
-    end
-  end
-
-  describe '#and' do
-    it 'creates conjunction with the other' do
-      expect(rule.and(other).(nil)).to be_failure
-      expect(rule.and(other).(19)).to be_failure
-      expect(rule.and(other).(13)).to be_failure
-      expect(rule.and(other).(14)).to be_failure
-    end
-  end
-
-  describe '#or' do
-    it 'creates disjunction with the other' do
-      expect(rule.or(other).(nil)).to be_success
-      expect(rule.or(other).(19)).to be_success
-      expect(rule.or(other).(13)).to be_success
-      expect(rule.or(other).(14)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/each_spec.rb

@@ -1,31 +0,0 @@
-require 'dry/logic/rule'
-
-RSpec.describe Dry::Logic::Rule::Each do
-  include_context 'predicates'
-
-  subject(:address_rule) do
-    Dry::Logic::Rule::Each.new(is_string)
-  end
-
-  let(:is_string) { Dry::Logic::Rule::Value.new(str?) }
-
-  describe '#call' do
-    it 'applies its rules to all elements in the input' do
-      expect(address_rule.(['Address'])).to be_success
-
-      expect(address_rule.([nil, 'Address'])).to be_failure
-      expect(address_rule.([:Address, 'Address'])).to be_failure
-    end
-
-    it 'returns result ast' do
-      expect(address_rule.([nil, nil]).to_ast).to eql([
-        :result, [[nil, nil], [
-          :each, [
-            [:el, [0, [:result, [nil, [:val, [:predicate, [:str?, [[:input, nil]]]]]]]]],
-            [:el, [1, [:result, [nil, [:val, [:predicate, [:str?, [[:input, nil]]]]]]]]]
-          ]
-        ]]
-      ])
-    end
-  end
-end

data/spec/unit/rule/exclusive_disjunction_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Rule::ExclusiveDisjunction do
-  include_context 'predicates'
-
-  subject(:rule) do
-    Rule::ExclusiveDisjunction.new(left, right)
-  end
-
-  let(:left) { Rule::Key.new(true?, name: :eat_cake) }
-  let(:right) { Rule::Key.new(true?, name: :have_cake) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.(eat_cake: true, have_cake: false)).to be_success
-      expect(rule.(eat_cake: false, have_cake: true)).to be_success
-      expect(rule.(eat_cake: false, have_cake: false)).to be_failure
-      expect(rule.(eat_cake: true, have_cake: true)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/implication_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Rule::Composite::Implication do
-  include_context 'predicates'
-
-  subject(:rule) { Rule::Composite::Implication.new(left, right) }
-
-  let(:left) { Rule::Value.new(int?) }
-  let(:right) { Rule::Value.new(gt?.curry(18)) }
-
-  describe '#call' do
-    it 'calls left and right' do
-      expect(rule.('19')).to be_success
-      expect(rule.(19)).to be_success
-      expect(rule.(18)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/key_spec.rb

@@ -1,121 +0,0 @@
-require 'dry/logic/rule'
-
-RSpec.describe Rule::Key do
-  include_context 'predicates'
-
-  subject(:rule) do
-    Rule::Key.new(predicate, name: :user)
-  end
-
-  let(:predicate) do
-    key?.curry(:name)
-  end
-
-  describe '#call' do
-    context 'with a plain predicate' do
-      it 'applies predicate to the value' do
-        expect(rule.(user: { name: 'Jane' })).to be_success
-        expect(rule.(user: {})).to be_failure
-      end
-
-      context 'with a custom predicate' do
-        let(:predicate) { -> input { double(success?: true, to_ast: [:foo]) } }
-
-        let(:result) { rule.(test: true) }
-
-        it 'delegates to_ast to response' do
-          expect(result.to_ast).to eql([:foo])
-        end
-      end
-    end
-
-    context 'with a set rule as predicate' do
-      subject(:rule) do
-        Rule::Key.new(predicate, name: :address)
-      end
-
-      let(:predicate) do
-        Rule::Set.new(
-          [Rule::Value.new(key?.curry(:city)), Rule::Value.new(key?.curry(:zipcode))]
-        )
-      end
-
-      it 'applies set rule to the value that passes' do
-        result = rule.(address: { city: 'NYC', zipcode: '123' })
-
-        expect(result).to be_success
-      end
-
-      it 'applies set rule to the value that fails' do
-        result = rule.(address: { city: 'NYC' })
-
-        expect(result).to be_failure
-
-        expect(result.to_ast).to eql([
-          :input, [
-            :address,
-              [:result, [
-                { city: "NYC" },
-                [:set, [[:result, [{ city: 'NYC' }, [:val, [:predicate, [:key?, [[:name, :zipcode], [:input, {:city=>"NYC"}]]]]]]]]]
-              ]]
-            ]
-        ])
-      end
-    end
-
-    context 'with an each rule as predicate' do
-      subject(:rule) do
-        Rule::Key.new(predicate, name: :nums)
-      end
-
-      let(:predicate) do
-        Rule::Each.new(Rule::Value.new(str?))
-      end
-
-      it 'applies each rule to the value that passses' do
-        result = rule.(nums: %w(1 2 3))
-
-        expect(result).to be_success
-
-        expect(result.to_ast).to eql([
-          :input, [:nums, [:result, [%w(1 2 3), [:each, []]]]]
-        ])
-      end
-
-      it 'applies each rule to the value that fails' do
-        failure = rule.(nums: [1, '3', 3])
-
-        expect(failure).to be_failure
-
-        expect(failure.to_ast).to eql([
-          :input, [
-            :nums, [
-              :result, [
-                [1, '3', 3],
-                [:each, [
-                  [:el, [0, [:result, [1, [:val, [:predicate, [:str?, [[:input, 1]]]]]]]]],
-                  [:el, [2, [:result, [3, [:val, [:predicate, [:str?, [[:input, 3]]]]]]]]]
-                ]]
-              ]
-            ]
-          ]
-        ])
-      end
-    end
-  end
-
-  describe '#and' do
-    let(:other) do
-      Rule::Key.new(str?, name: [:user, :name])
-    end
-
-    it 'returns conjunction rule where value is passed to the right' do
-      present_and_string = rule.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
-end

data/spec/unit/rule/set_spec.rb

@@ -1,30 +0,0 @@
-require 'dry/logic/rule'
-
-RSpec.describe Dry::Logic::Rule::Set do
-  include_context 'predicates'
-
-  subject(:rule) do
-    Dry::Logic::Rule::Set.new([is_string, min_size.curry(6)])
-  end
-
-  let(:is_string) { Dry::Logic::Rule::Value.new(str?) }
-  let(:min_size) { Dry::Logic::Rule::Value.new(min_size?) }
-
-  describe '#call' do
-    it 'applies its rules to the input' do
-      expect(rule.('Address')).to be_success
-      expect(rule.('Addr')).to be_failure
-    end
-  end
-
-  describe '#to_ast' do
-    it 'returns an array representation' do
-      expect(rule.to_ast).to eql([
-        :set, [
-          [:val, [:predicate, [:str?, [[:input, Predicate::Undefined]]]]],
-          [:val, [:predicate, [:min_size?, [[:num, 6], [:input, Predicate::Undefined]]]]]
-        ]
-      ])
-    end
-  end
-end

data/spec/unit/rule/value_spec.rb

@@ -1,99 +0,0 @@
-require 'dry/logic/rule'
-
-RSpec.describe Dry::Logic::Rule::Value do
-  include_context 'predicates'
-
-  let(:is_nil) { Dry::Logic::Rule::Value.new(none?) }
-
-  let(:is_string) { Dry::Logic::Rule::Value.new(str?) }
-
-  let(:min_size) { Dry::Logic::Rule::Value.new(min_size?) }
-
-  describe '#call' do
-    it 'returns result of a predicate' do
-      expect(is_string.(1)).to be_failure
-      expect(is_string.('1')).to be_success
-    end
-
-    context 'with a composite rule' do
-      subject(:rule) { Dry::Logic::Rule::Value.new(is_nil | is_string) }
-
-      it 'returns a success for valid input' do
-        expect(rule.(nil)).to be_success
-        expect(rule.('foo')).to be_success
-      end
-
-      it 'returns a failure for invalid input' do
-        expect(rule.(312)).to be_failure
-      end
-
-      it 'returns a failure result with curried args' do
-        expect(rule.(312).to_ast).to eql(
-          [:result, [312, [:val, [:predicate, [:str?, [[:input, 312]]]]]]]
-        )
-      end
-    end
-
-    context 'with a custom predicate' do
-      subject(:rule) { Dry::Logic::Rule::Value.new(predicate) }
-
-      let(:response) { double("response", success?: true) }
-      let(:predicate) { double("predicate", arity: 1, curry: curried, call: Result.new(response, double("rule"), test: true)) }
-      let(:curried) { double("curried", arity: 1, call: Result.new(response, double("rule"), test: true)) }
-
-      let(:result) { rule.(test: true) }
-
-      it 'calls its predicate returning custom result' do
-        expect(result).to be_success
-      end
-
-      it 'exposes access to nested result' do
-        expect(response).to receive(:[]).with(:foo).and_return(:bar)
-        expect(result[:foo]).to be(:bar)
-      end
-
-      it 'returns nil from [] when response does not respond to it' do
-        expect(result[:foo]).to be(nil)
-      end
-
-      it 'has no name by default' do
-        expect(result.name).to be(nil)
-      end
-
-      context "works with predicates.arity == 0" do
-        subject(:rule) { Dry::Logic::Rule::Value.new(predicate) }
-
-        let(:predicate) { Dry::Logic::Predicate.new(:without_args) { true } }
-        let(:result) { rule.('sutin') }
-
-        it "calls its predicate without any args" do
-          expect(result).to be_success
-        end
-      end
-    end
-  end
-
-  describe '#and' do
-    it 'returns a conjunction' do
-      string_and_min_size = is_string.and(min_size.curry(3))
-
-      expect(string_and_min_size.('abc')).to be_success
-      expect(string_and_min_size.('abcd')).to be_success
-
-      expect(string_and_min_size.(1)).to be_failure
-      expect(string_and_min_size.('ab')).to be_failure
-    end
-  end
-
-  describe '#or' do
-    it 'returns a disjunction' do
-      nil_or_string = is_nil.or(is_string)
-
-      expect(nil_or_string.(nil)).to be_success
-      expect(nil_or_string.('abcd')).to be_success
-
-      expect(nil_or_string.(true)).to be_failure
-      expect(nil_or_string.(1)).to be_failure
-    end
-  end
-end