dry-logic 0.3.0 → 0.4.0

data/spec/integration/rule_spec.rb

@@ -0,0 +1,53 @@
+require 'dry-logic'
+
+RSpec.describe 'Rules' do
+  specify 'defining an anonymous rule with an arbitrary predicate' do
+    rule = Dry::Logic.Rule { |value| value.is_a?(Integer) }
+
+    expect(rule.(1)).to be_success
+    expect(rule[1]).to be(true)
+  end
+
+  specify 'defining a conjunction' do
+    rule = Dry::Logic.Rule(&:even?) & Dry::Logic.Rule { |v| v > 4 }
+
+    expect(rule.(3)).to be_failure
+    expect(rule.(4)).to be_failure
+    expect(rule.(5)).to be_failure
+    expect(rule.(6)).to be_success
+  end
+
+  specify 'defining a disjunction' do
+    rule = Dry::Logic.Rule { |v| v < 4 } | Dry::Logic.Rule { |v| v > 6 }
+
+    expect(rule.(5)).to be_failure
+    expect(rule.(3)).to be_success
+    expect(rule.(7)).to be_success
+  end
+
+  specify 'defining an implication' do
+    rule = Dry::Logic.Rule(&:empty?) > Dry::Logic.Rule { |v| v.is_a?(Array) }
+
+    expect(rule.('foo')).to be_success
+    expect(rule.([1, 2])).to be_success
+    expect(rule.([])).to be_success
+    expect(rule.('')).to be_failure
+  end
+
+  specify 'defining an exclusive disjunction' do
+    rule = Dry::Logic.Rule(&:empty?) ^ Dry::Logic.Rule { |v| v.is_a?(Array) }
+
+    expect(rule.('foo')).to be_failure
+    expect(rule.([])).to be_failure
+    expect(rule.([1, 2])).to be_success
+    expect(rule.('')).to be_success
+  end
+
+  specify 'defining a rule with options' do
+    rule = Dry::Logic::Rule(id: :empty?) { |value| value.empty? }
+
+    expect(rule.('foo')).to be_failure
+    expect(rule.('')).to be_success
+    expect(rule.ast('foo')).to eql([:predicate, [:empty?, [[:value, 'foo']]]])
+  end
+end

data/spec/shared/predicates.rb

@@ -3,6 +3,10 @@ require 'dry/logic/predicates'
 RSpec.shared_examples 'predicates' do
   let(:none?) { Dry::Logic::Predicates[:none?] }
 
+  let(:array?) { Dry::Logic::Predicates[:array?] }
+
+  let(:empty?) { Dry::Logic::Predicates[:empty?] }
+
   let(:str?) { Dry::Logic::Predicates[:str?] }
 
   let(:true?) { Dry::Logic::Predicates[:true?] }
@@ -24,6 +28,8 @@ RSpec.shared_examples 'predicates' do
   let(:attr?) { Dry::Logic::Predicates[:attr?] }
 
   let(:eql?) { Dry::Logic::Predicates[:eql?] }
+
+  let(:size?) { Dry::Logic::Predicates[:size?] }
 end
 
 RSpec.shared_examples 'a passing predicate' do

data/spec/shared/rule.rb

@@ -0,0 +1,67 @@
+shared_examples_for Dry::Logic::Rule do
+  let(:predicate) { double(:predicate, arity: 2, name: predicate_name) }
+  let(:rule_type) { described_class }
+  let(:predicate_name) { :good? }
+
+  describe '#arity' do
+    it 'returns its predicate arity' do
+      rule = rule_type.new(predicate)
+
+      expect(rule.arity).to be(2)
+    end
+  end
+
+  describe '#parameters' do
+    it 'returns a list of args with their names' do
+      rule = rule_type.new(-> foo, bar { true }, args: [312])
+
+      expect(rule.parameters).to eql([[:req, :foo], [:req, :bar]])
+    end
+  end
+
+  describe '#call' do
+    it 'returns success for valid input' do
+      rule = rule_type.new(predicate)
+
+      expect(predicate).to receive(:[]).with(2).and_return(true)
+
+      expect(rule.(2)).to be_success
+    end
+
+    it 'returns failure for invalid input' do
+      rule = rule_type.new(predicate)
+
+      expect(predicate).to receive(:[]).with(2).and_return(false)
+
+      expect(rule.(2)).to be_failure
+    end
+  end
+
+  describe '#[]' do
+    it 'delegates to its predicate' do
+      rule = rule_type.new(predicate)
+
+      expect(predicate).to receive(:[]).with(2).and_return(true)
+      expect(rule[2]).to be(true)
+    end
+  end
+
+  describe '#curry' do
+    it 'returns a curried rule' do
+      rule = rule_type.new(predicate).curry(3)
+
+      expect(predicate).to receive(:[]).with(3, 2).and_return(true)
+      expect(rule.args).to eql([3])
+
+      expect(rule.(2)).to be_success
+    end
+
+    it 'raises argument error when arity does not match' do
+      expect(predicate).to receive(:arity).and_return(2)
+
+      expect { rule_type.new(predicate).curry(3, 2, 1) }.to raise_error(
+        ArgumentError, 'wrong number of arguments (3 for 2)'
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,11 @@
-if RUBY_ENGINE == "rbx"
-    require "codeclimate-test-reporter"
-      CodeClimate::TestReporter.start
+if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.3.1'
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
 end
 
 begin
@@ -8,6 +13,7 @@ begin
 rescue LoadError; end
 
 require 'dry-logic'
+require 'dry/core/constants'
 require 'pathname'
 
 SPEC_ROOT = Pathname(__dir__)
@@ -16,6 +22,7 @@ Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:require))
 Dir[SPEC_ROOT.join('support/**/*.rb')].each(&method(:require))
 
 include Dry::Logic
+include Dry::Core::Constants
 
 RSpec.configure do |config|
   config.disable_monkey_patching!

data/spec/support/mutant.rb

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

data/spec/unit/operations/and_spec.rb

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

@@ -0,0 +1,27 @@
+RSpec.describe Operations::Attr do
+  subject(:operation) { Operations::Attr.new(Rule::Predicate.new(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.new(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

@@ -0,0 +1,49 @@
+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.new(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.new(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.new(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

@@ -0,0 +1,47 @@
+RSpec.describe Operations::Each do
+  subject(:operation) { Operations::Each.new(is_string) }
+
+  include_context 'predicates'
+
+  let(:is_string) { Rule::Predicate.new(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

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

@@ -0,0 +1,119 @@
+RSpec.describe Operations::Key do
+  subject(:operation) { Operations::Key.new(predicate, name: :user) }
+
+  include_context 'predicates'
+
+  let(:predicate) do
+    Rule::Predicate.new(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.new(key?).curry(:city), Rule::Predicate.new(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.new(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 '#and' do
+    subject(:operation) do
+      Operations::Key.new(Rule::Predicate.new(str?), name: [:user, :name])
+    end
+
+    let(:other) do
+      Operations::Key.new(Rule::Predicate.new(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