dry-logic 0.3.0 → 0.4.0

data/spec/unit/operations/negation_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe Operations::Negation do
+  subject(:operation) { Operations::Negation.new(is_int) }
+
+  include_context 'predicates'
+
+  let(:is_int) { Rule::Predicate.new(int?) }
+
+  describe '#call' do
+    it 'negates its rule' 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(
+        [: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

@@ -0,0 +1,73 @@
+RSpec.describe Operations::Or do
+  subject(:operation) { Operations::Or.new(left, right) }
+
+  include_context 'predicates'
+
+  let(:left) { Rule::Predicate.new(none?) }
+  let(:right) { Rule::Predicate.new(gt?).curry(18) }
+
+  let(:other) do
+    Rule::Predicate.new(int?) & Rule::Predicate.new(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, [:none?, [[:input, Undefined]]]],
+          [:predicate, [:gt?, [[:num, 18], [:input, Undefined]]]]]
+        ]
+      )
+    end
+
+    it 'returns result ast' do
+      expect(operation.(17).to_ast).to eql(
+        [:or, [
+          [:predicate, [:none?, [[: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, [:none?, [[: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('none? OR gt?(18)')
+    end
+  end
+end

data/spec/unit/operations/set_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe Operations::Set do
+  subject(:operation) { Operations::Set.new(is_int, gt_18) }
+
+  include_context 'predicates'
+
+  let(:is_int) { Rule::Predicate.new(int?) }
+  let(:gt_18) { Rule::Predicate.new(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

@@ -0,0 +1,61 @@
+RSpec.describe Operations::Xor do
+  subject(:operation) { Operations::Xor.new(left, right) }
+
+  include_context 'predicates'
+
+  let(:left) { Rule::Predicate.new(array?) }
+  let(:right) { Rule::Predicate.new(empty?) }
+
+  let(:other) do
+    Rule::Predicate.new(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

data/spec/unit/predicates_spec.rb

@@ -0,0 +1,23 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Predicates do
+  it 'can be included in another module' do
+    mod = Module.new { include Predicates }
+
+    expect(mod[:key?]).to be_a(Method)
+  end
+
+  describe '.predicate' do
+    it 'defines a predicate method' do
+      mod = Module.new {
+        include Predicates
+
+        predicate(:test?) do |foo|
+          true
+        end
+      }
+
+      expect(mod.test?('arg')).to be(true)
+    end
+  end
+end

data/spec/unit/rule/predicate_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe Rule::Predicate do
+  subject(:rule) { Rule::Predicate.new(predicate) }
+
+  let(:predicate) { str? }
+
+  include_context 'predicates'
+
+  it_behaves_like Rule
+
+  describe '#name' do
+    it 'returns predicate identifier' do
+      expect(rule.name).to be(:str?)
+    end
+  end
+
+  describe '#to_ast' do
+    context 'without a result' do
+      it 'returns rule ast' do
+        expect(rule.to_ast).to eql([:predicate, [:str?, [[:input, Undefined]]]])
+      end
+
+      it 'returns :failure with an id' do
+        email = rule.with(id: :email)
+
+        expect(email.(11).to_ast).to eql([:failure, [:email, [:predicate, [:str?, [[:input, 11]]]]]])
+      end
+    end
+
+    context 'with a result' do
+      it 'returns success ast' do
+        expect(rule.('foo').to_ast).to eql([:predicate, [:str?, [[:input, 'foo']]]])
+      end
+
+      it 'returns ast' do
+        expect(rule.(5).to_ast).to eql([:predicate, [:str?, [[:input, 5]]]])
+      end
+    end
+
+    context 'with a zero-arity predicate' do
+      let(:predicate) { Module.new { def self.test?; true; end }.method(:test?) }
+
+      it 'returns ast' do
+        expect(rule.to_ast).to eql([:predicate, [:test?, []]])
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns string representation' do
+      expect(rule.curry('foo').to_s).to eql('str?("foo")')
+    end
+  end
+end

data/spec/unit/rule_compiler_spec.rb

@@ -11,117 +11,117 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
       one: predicate }
   }
 
-  let(:predicate) { double(:predicate).as_null_object }
-
-  let(:val_rule) { Rule::Value.new(predicate) }
-  let(:key_rule) { Rule::Key.new(predicate, name: :email) }
-  let(:attr_rule) { Rule::Attr.new(predicate, name: :email) }
-  let(:not_key_rule) { Rule::Key.new(predicate, name: :email).negation }
-  let(:check_rule) { Rule::Check.new(predicate, name: :email, keys: [:email]) }
-  let(:and_rule) { key_rule & val_rule }
-  let(:or_rule) { key_rule | val_rule }
-  let(:xor_rule) { key_rule ^ val_rule }
-  let(:set_rule) { Rule::Set.new([val_rule]) }
-  let(:each_rule) { Rule::Each.new(val_rule) }
+  let(:predicate) { double(:predicate, name: :test?, arity: 2).as_null_object }
+
+  let(:rule) { Rule::Predicate.new(predicate) }
+  let(:key_op) { Operations::Key.new(rule, name: :email) }
+  let(:attr_op) { Operations::Attr.new(rule, name: :email) }
+  let(:check_op) { Operations::Check.new(rule, keys: [:email]) }
+  let(:not_key_op) { Operations::Negation.new(key_op) }
+  let(:and_op) { key_op.curry(:email) & rule }
+  let(:or_op) { key_op.curry(:email) | rule }
+  let(:xor_op) { key_op.curry(:email) ^ rule }
+  let(:set_op) { Operations::Set.new(rule) }
+  let(:each_op) { Operations::Each.new(rule) }
 
   it 'compiles key rules' do
-    ast = [[:key, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]
+    ast = [[:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([key_rule])
+    expect(rules).to eql([key_op])
   end
 
   it 'compiles attr rules' do
-    ast = [[:attr, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]
+    ast = [[:attr, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([attr_rule])
+    expect(rules).to eql([attr_op])
   end
 
   it 'compiles check rules' do
-    ast = [[:check, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]
+    ast = [[:check, [[:email], [:predicate, [:filled?, [[:input, Undefined]]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([check_rule])
+    expect(rules).to eql([check_op])
   end
 
   it 'compiles attr rules' do
-    ast = [[:attr, [:email, [:predicate, [:attr?, [[:name, :email]]]]]]]
+    ast = [[:attr, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([attr_rule])
+    expect(rules).to eql([attr_op])
   end
 
   it 'compiles negated rules' do
-    ast = [[:not, [:key, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]]
+    ast = [[:not, [:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([not_key_rule])
+    expect(rules).to eql([not_key_op])
   end
 
-  it 'compiles conjunction rules' do
+  it 'compiles and rules' do
     ast = [
       [
         :and, [
-          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, nil]]]]]],
-          [:val, [:predicate, [:filled?, [[:input, nil]]]]]
+          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
+          [:predicate, [:filled?, [[:input, Undefined]]]]
         ]
       ]
     ]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([and_rule])
+    expect(rules).to eql([and_op])
   end
 
-  it 'compiles disjunction rules' do
+  it 'compiles or rules' do
     ast = [
       [
         :or, [
-          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, nil]]]]]],
-          [:val, [:predicate, [:filled?, [[:input, nil]]]]]
+          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
+          [:predicate, [:filled?, [[:input, Undefined]]]]
         ]
       ]
     ]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([or_rule])
+    expect(rules).to eql([or_op])
   end
 
-  it 'compiles exclusive disjunction rules' do
+  it 'compiles exclusive or rules' do
     ast = [
       [
         :xor, [
-          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, nil]]]]]],
-          [:val, [:predicate, [:filled?, [[:input, nil]]]]]
+          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
+          [:predicate, [:filled?, [[:input, Undefined]]]]
         ]
       ]
     ]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([xor_rule])
+    expect(rules).to eql([xor_op])
   end
 
   it 'compiles set rules' do
-    ast = [[:set, [[:val, [:predicate, [:filled?, [[:input, nil]]]]]]]]
+    ast = [[:set, [[:predicate, [:filled?, [[:input, nil]]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([set_rule])
+    expect(rules).to eql([set_op])
   end
 
   it 'compiles each rules' do
-    ast = [[:each, [:val, [:predicate, [:filled?, [[:input, nil]]]]]]]
+    ast = [[:each, [:predicate, [:filled?, [[:input, nil]]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([each_rule])
+    expect(rules).to eql([each_op])
   end
 end