dry-logic 0.1.0

data/spec/unit/predicates/key_spec.rb

@@ -0,0 +1,29 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#key?' do
+    let(:predicate_name) { :key? }
+
+    context 'when key is present in value' do
+      let(:arguments_list) do
+        [
+          [:name, { name: 'John' }],
+          [:age, { age: 18 }]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with key is not present in value' do
+      let(:arguments_list) do
+        [
+          [:name, { age: 18 }],
+          [:age, { name: 'Jill' }]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/lt_spec.rb

@@ -0,0 +1,40 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#lt?' do
+    let(:predicate_name) { :lt? }
+
+    context 'when value is less than n' do
+      let(:arguments_list) do
+        [
+          [13, 12],
+          [13.37, 13.36],
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value is equal to n' do
+      let(:arguments_list) do
+        [
+          [13, 13],
+          [13.37, 13.37]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+
+    context 'with value is greater than n' do
+      let(:arguments_list) do
+        [
+          [13, 14],
+          [13.37, 13.38]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/lteq_spec.rb

@@ -0,0 +1,40 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#lteq?' do
+    let(:predicate_name) { :lteq? }
+
+    context 'when value is less than n' do
+      let(:arguments_list) do
+        [
+          [13, 12],
+          [13.37, 13.36]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value is equal to n' do
+      let(:arguments_list) do
+        [
+          [13, 13],
+          [13.37, 13.37]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with value is greater than n' do
+      let(:arguments_list) do
+        [
+          [13, 14],
+          [13.37, 13.38]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/max_size_spec.rb

@@ -0,0 +1,49 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#max_size?' do
+    let(:predicate_name) { :max_size? }
+
+    context 'when value size is less than n' do
+      let(:arguments_list) do
+        [
+          [3, [1, 2]],
+          [5, 'Jill'],
+          [3, { 1 => 'st', 2 => 'nd' }],
+          [9, 1],
+          [6, 1..5]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value size is equal to n' do
+      let(:arguments_list) do
+        [
+          [2, [1, 2]],
+          [4, 'Jill'],
+          [2, { 1 => 'st', 2 => 'nd' }],
+          [8, 1],
+          [5, 1..5]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with value size is greater than n' do
+      let(:arguments_list) do
+        [
+          [1, [1, 2]],
+          [3, 'Jill'],
+          [1, { 1 => 'st', 2 => 'nd' }],
+          [7, 1],
+          [4, 1..5]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/min_size_spec.rb

@@ -0,0 +1,49 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#min_size?' do
+    let(:predicate_name) { :min_size? }
+
+    context 'when value size is greater than n' do
+      let(:arguments_list) do
+        [
+          [1, [1, 2]],
+          [3, 'Jill'],
+          [1, { 1 => 'st', 2 => 'nd' }],
+          [7, 1],
+          [4, 1..5]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value size is equal to n' do
+      let(:arguments_list) do
+        [
+          [2, [1, 2]],
+          [4, 'Jill'],
+          [2, { 1 => 'st', 2 => 'nd' }],
+          [8, 1],
+          [5, 1..5]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with value size is less than n' do
+      let(:arguments_list) do
+        [
+          [3, [1, 2]],
+          [5, 'Jill'],
+          [3, { 1 => 'st', 2 => 'nd' }],
+          [9, 1],
+          [6, 1..5]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/none_spec.rb

@@ -0,0 +1,28 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#none?' do
+    let(:predicate_name) { :none? }
+
+    context 'when value is nil' do
+      let(:arguments_list) { [[nil]] }
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value is not nil' do
+      let(:arguments_list) do
+        [
+          [''],
+          [true],
+          [false],
+          [0],
+          [:symbol],
+          [[]],
+          [{}],
+          [String]
+        ]
+      end
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/size_spec.rb

@@ -0,0 +1,55 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#size?' do
+    let(:predicate_name) { :size? }
+
+    context 'when value size is equal to n' do
+      let(:arguments_list) do
+        [
+          [[8], 2],
+          [4, 'Jill'],
+          [2, { 1 => 'st', 2 => 'nd' }],
+          [8, 8],
+          [1..8, 5]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value size is greater than n' do
+      let(:arguments_list) do
+        [
+          [[1, 2], 3],
+          [5, 'Jill'],
+          [3, { 1 => 'st', 2 => 'nd' }],
+          [1, 9],
+          [1..5, 6]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+
+    context 'with value size is less than n' do
+      let(:arguments_list) do
+        [
+          [[1, 2], 1],
+          [3, 'Jill'],
+          [1, { 1 => 'st', 2 => 'nd' }],
+          [1, 7],
+          [1..5, 4]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+
+    context 'with an unsupported size' do
+      it 'raises an error' do
+        expect { Predicates[:size?].call('oops', 1) }.to raise_error(ArgumentError, /oops/)
+      end
+    end
+  end
+end

data/spec/unit/predicates/str_spec.rb

@@ -0,0 +1,32 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#str?' do
+    let(:predicate_name) { :str? }
+
+    context 'when value is a string' do
+      let(:arguments_list) do
+        [
+          [''],
+          ['John']
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with value is not a string' do
+      let(:arguments_list) do
+        [
+          [[]],
+          [{}],
+          [nil],
+          [:symbol],
+          [String]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/time_spec.rb

@@ -0,0 +1,31 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#time?' do
+    let(:predicate_name) { :time? }
+
+    context 'when value is a date' do
+      let(:arguments_list) do
+        [[Time.now]]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with value is not an integer' do
+      let(:arguments_list) do
+        [
+          [''],
+          [[]],
+          [{}],
+          [nil],
+          [:symbol],
+          [String],
+          [1]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/rule/check_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe Rule::Check do
+  subject(:rule) { Rule::Check.new(:name, other.(input).curry(predicate)) }
+
+  include_context 'predicates'
+
+  let(:other) do
+    Rule::Value.new(:name, none?).or(Rule::Value.new(:name, filled?))
+  end
+
+  describe '#call' do
+    context 'when a given predicate passed' do
+      let(:input) { 'Jane' }
+      let(:predicate) { :filled? }
+
+      it 'returns a success' do
+        expect(rule.()).to be_success
+      end
+    end
+
+    context 'when a given predicate did not pass' do
+      let(:input) { nil }
+      let(:predicate) { :filled? }
+
+      it 'returns a failure' do
+        expect(rule.()).to be_failure
+      end
+    end
+  end
+end

data/spec/unit/rule/conjunction_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Rule::Composite::Conjunction do
+  include_context 'predicates'
+
+  subject(:rule) { Rule::Composite::Conjunction.new(left, right) }
+
+  let(:left) { Rule::Value.new(:age, int?) }
+  let(:right) { Rule::Value.new(:age, 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(:age, 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(:age, 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

@@ -0,0 +1,38 @@
+RSpec.describe Rule::Composite::Disjunction do
+  include_context 'predicates'
+
+  subject(:rule) { Rule::Composite::Disjunction.new(left, right) }
+
+  let(:left) { Rule::Value.new(:age, none?) }
+  let(:right) { Rule::Value.new(:age, gt?.curry(18)) }
+
+  let(:other) do
+    Rule::Value.new(:age, int?) & Rule::Value.new(:age, 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