dry-logic 0.5.0 → 1.5.0

data/spec/shared/rule.rb

@@ -1,67 +0,0 @@
-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,34 +0,0 @@
-if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
-  require 'yaml'
-  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
-  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
-
-  if RUBY_VERSION == latest_mri
-    require 'simplecov'
-    SimpleCov.start do
-      add_filter '/spec/'
-    end
-  end
-end
-
-begin
-  require '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,9 +0,0 @@
-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,64 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

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

@@ -1,47 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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 '#ast' do
-    it 'returns ast without the input' do
-      expect(operation.ast).to eql(
-        [:key, [:user, [:predicate, [:key?, [[:name, :age], [:input, Undefined]]]]]]
-      )
-    end
-
-    it 'returns ast with the input' do
-      expect(operation.ast(user: 'jane')).to eql(
-        [:key, [:user, [:predicate, [:key?, [[:name, :age], [:input, 'jane']]]]]]
-      )
-    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

data/spec/unit/operations/negation_spec.rb

@@ -1,49 +0,0 @@
-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
-
-    context 'double negation' do
-      subject(:double_negation) { Operations::Negation.new(operation) }
-
-      it 'works as rule' do
-        expect(double_negation.('19')).to be_failure
-        expect(double_negation.(17)).to be_success
-      end
-    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

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

data/spec/unit/operations/set_spec.rb

@@ -1,41 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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