dry-logic 1.0.5 → 1.1.1

data/examples/basic.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-
-user_present = Rule::Predicate.build(Predicates[:key?]).curry(:user)
-
-has_min_age = Operations::Key.new(Rule::Predicate.build(Predicates[:gt?]).curry(18), name: [:user, :age])
-
-user_rule = user_present & has_min_age
-
-puts user_rule.(user: { age: 19 }).success?
-
-puts user_rule.(user: { age: 18 }).success?

data/spec/integration/result_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Result do
-  include_context 'predicates'
-
-  describe '#to_s' do
-    shared_examples_for 'string representation' do
-      it 'returns string representation' do
-        expect(rule.(input).to_s).to eql(output)
-      end
-    end
-
-    context 'with a predicate' do
-      let(:rule) { Rule::Predicate.build(gt?, args: [18]) }
-      let(:input) { 17 }
-      let(:output) { 'gt?(18, 17)' }
-
-      it_behaves_like 'string representation'
-    end
-
-    context 'with AND operation' do
-      let(:rule) { Rule::Predicate.build(array?).and(Rule::Predicate.build(empty?)) }
-      let(:input) { '' }
-      let(:output) { 'array?("") AND empty?("")' }
-
-      it_behaves_like 'string representation'
-    end
-
-    context 'with OR operation' do
-      let(:rule) { Rule::Predicate.build(array?).or(Rule::Predicate.build(empty?)) }
-      let(:input) { 123 }
-      let(:output) { 'array?(123) OR empty?(123)' }
-
-      it_behaves_like 'string representation'
-    end
-
-    context 'with XOR operation' do
-      let(:rule) { Rule::Predicate.build(array?).xor(Rule::Predicate.build(empty?)) }
-      let(:input) { [] }
-      let(:output) { 'array?([]) XOR empty?([])' }
-
-      it_behaves_like 'string representation'
-    end
-
-    context 'with THEN operation' do
-      let(:rule) { Rule::Predicate.build(array?).then(Rule::Predicate.build(empty?)) }
-      let(:input) { [1, 2, 3] }
-      let(:output) { 'empty?([1, 2, 3])' }
-
-      it_behaves_like 'string representation'
-    end
-
-    context 'with NOT operation' do
-      let(:rule) { Operations::Negation.new(Rule::Predicate.build(array?)) }
-      let(:input) { 'foo' }
-      let(:output) { 'not(array?("foo"))' }
-
-      it_behaves_like 'string representation'
-    end
-  end
-end

data/spec/integration/rule_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/logic/predicates'
-
-RSpec.shared_examples 'predicates' do
-  let(:nil?) { Dry::Logic::Predicates[:nil?] }
-
-  let(:array?) { Dry::Logic::Predicates[:array?] }
-
-  let(:empty?) { Dry::Logic::Predicates[:empty?] }
-
-  let(:str?) { Dry::Logic::Predicates[:str?] }
-
-  let(:true?) { Dry::Logic::Predicates[:true?] }
-
-  let(:hash?) { Dry::Logic::Predicates[:hash?] }
-
-  let(:int?) { Dry::Logic::Predicates[:int?] }
-
-  let(:filled?) { Dry::Logic::Predicates[:filled?] }
-
-  let(:min_size?) { Dry::Logic::Predicates[:min_size?] }
-
-  let(:lt?) { Dry::Logic::Predicates[:lt?] }
-
-  let(:gt?) { Dry::Logic::Predicates[:gt?] }
-
-  let(:key?) { Dry::Logic::Predicates[:key?] }
-
-  let(:attr?) { Dry::Logic::Predicates[:attr?] }
-
-  let(:eql?) { Dry::Logic::Predicates[:eql?] }
-
-  let(:size?) { Dry::Logic::Predicates[:size?] }
-
-  let(:case?) { Dry::Logic::Predicates[:case?] }
-
-  let(:equal?) { Dry::Logic::Predicates[:equal?] }
-end
-
-RSpec.shared_examples 'a passing predicate' do
-  let(:predicate) { Dry::Logic::Predicates[predicate_name] }
-
-  it do
-    arguments_list.each do |args|
-      expect(predicate.call(*args)).to be(true)
-    end
-  end
-end
-
-RSpec.shared_examples 'a failing predicate' do
-  let(:predicate) { Dry::Logic::Predicates[predicate_name] }
-
-  it do
-    arguments_list.each do |args|
-      expect(predicate.call(*args)).to be(false)
-    end
-  end
-end

data/spec/shared/rule.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for Dry::Logic::Rule do
-  let(:arity) { 2 }
-  let(:predicate) { double(:predicate, arity: arity, name: predicate_name) }
-  let(:rule_type) { described_class }
-  let(:predicate_name) { :good? }
-
-  describe '#arity' do
-    it 'returns its predicate arity' do
-      rule = rule_type.build(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.build(-> foo, bar { true }, args: [312])
-
-      expect(rule.parameters).to eql([[:req, :foo], [:req, :bar]])
-    end
-  end
-
-  describe '#call' do
-    let(:arity) { 1 }
-
-    it 'returns success for valid input' do
-      rule = rule_type.build(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.build(predicate)
-
-      expect(predicate).to receive(:[]).with(2).and_return(false)
-
-      expect(rule.(2)).to be_failure
-    end
-  end
-
-  describe '#[]' do
-    let(:arity) { 1 }
-
-    it 'delegates to its predicate' do
-      rule = rule_type.build(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.build(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.build(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,30 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter '/spec/'
-  end
-end
-
-begin
-  require 'pry-byebug'
-rescue LoadError; end
-
-require 'dry-logic'
-require 'dry/core/constants'
-require 'pathname'
-
-SPEC_ROOT = Pathname(__dir__)
-
-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!
-
-  config.warnings = true
-end

data/spec/support/mutant.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Selector
-    class Expression < self
-      def call(_subject)
-        integration.all_tests
-      end
-    end
-  end
-end

data/spec/unit/operations/and_spec.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Operations::And do
-  subject(:operation) { Operations::And.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.(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.with(hints: false).('18').to_ast).to eql(
-        [:predicate, [:int?, [[: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.build(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.build(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

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-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.build(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.build(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.build(str?), keys: [:email])
-    end
-
-    it 'returns ast' do
-      expect(operation.to_ast).to eql(
-        [:check, [[:email], [:predicate, [:str?, [[:input, Undefined]]]]]]
-      )
-    end
-  end
-end