dry-logic 1.0.3 → 1.0.8

data/spec/unit/predicates/true_spec.rb

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

data/spec/unit/predicates/type_spec.rb

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

data/spec/unit/predicates/uuid_v4_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/logic/predicates'
-
-RSpec.describe Dry::Logic::Predicates do
-  describe '#uuid_v4?' do
-    let(:predicate_name) { :uuid_v4? }
-
-    context 'when value is a valid V4 UUID' do
-      let(:arguments_list) do
-        [['f2d26c57-e07c-4416-a749-57e937930e04']]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not a valid V4 UUID' do
-      let(:arguments_list) do
-        [
-          ['f2d26c57-e07c-3416-a749-57e937930e04'], # wrong version number (3, not 4)
-          ['20633928-6a07-11e9-a923-1681be663d3e'], # UUID V1
-          ['not-a-uuid-at-all']
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates_spec.rb

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Rule::Predicate do
-  subject(:rule) { Rule::Predicate.build(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' do
-        expect(rule.('foo')).to be_success
-      end
-
-      it 'returns failure 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

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/logic/rule_compiler'
-
-RSpec.describe Dry::Logic::RuleCompiler, '#call' do
-  subject(:compiler) { RuleCompiler.new(predicates) }
-
-  let(:predicates) {
-    { key?: predicate,
-      attr?: predicate,
-      filled?: predicate,
-      gt?: predicate,
-      one: predicate }
-  }
-
-  let(:predicate) { double(:predicate, name: :test?, arity: 2).as_null_object }
-
-  let(:rule) { Rule::Predicate.build(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, Undefined]]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([key_op])
-  end
-
-  it 'compiles attr rules' do
-    ast = [[:attr, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([attr_op])
-  end
-
-  it 'compiles check rules' do
-    ast = [[:check, [[:email], [:predicate, [:filled?, [[:input, Undefined]]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([check_op])
-  end
-
-  it 'compiles attr rules' do
-    ast = [[:attr, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([attr_op])
-  end
-
-  it 'compiles negated rules' do
-    ast = [[:not, [:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([not_key_op])
-  end
-
-  it 'compiles and rules' do
-    ast = [
-      [
-        :and, [
-          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-          [:predicate, [:filled?, [[:input, Undefined]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([and_op])
-  end
-
-  it 'compiles or rules' do
-    ast = [
-      [
-        :or, [
-          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-          [:predicate, [:filled?, [[:input, Undefined]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([or_op])
-  end
-
-  it 'compiles exclusive or rules' do
-    ast = [
-      [
-        :xor, [
-          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-          [:predicate, [:filled?, [[:input, Undefined]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([xor_op])
-  end
-
-  it 'compiles set rules' do
-    ast = [[:set, [[:predicate, [:filled?, [[:input, nil]]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([set_op])
-  end
-
-  it 'compiles each rules' do
-    ast = [[:each, [:predicate, [:filled?, [[:input, nil]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([each_op])
-  end
-end

data/spec/unit/rule_spec.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Logic::Rule do
-  subject(:rule) { Rule.build(predicate, options) }
-
-  let(:predicate) { -> { true } }
-  let(:options) { {} }
-
-  let(:schema) do
-    Class.new do
-      define_method(:class, Kernel.instance_method(:class))
-
-      def method_missing(m, *)
-        if m.to_s.end_with?('?')
-          self.class.new
-        else
-          super
-        end
-      end
-
-      def to_proc
-        -> value { value }
-      end
-
-      def arity
-        1
-      end
-
-      def parameters
-        [[:req, :value]]
-      end
-    end.new
-  end
-
-  it_behaves_like Dry::Logic::Rule
-
-  describe '.new' do
-    it 'accepts an :id' do
-      expect(Rule.build(predicate, id: :check_num).id).to be(:check_num)
-    end
-  end
-
-  describe 'with a function returning truthy value' do
-    it 'is successful for valid input' do
-      expect(Rule.build(-> val { val }).('true')).to be_success
-    end
-
-    it 'is not successful for invalid input' do
-      expect(Rule.build(-> val { val }).(nil)).to be_failure
-    end
-  end
-
-  describe '#ast' do
-    it 'returns predicate node with :id' do
-      expect(Rule.build(-> value { true }).with(id: :email?).ast('oops')).to eql(
-        [:predicate, [:email?, [[:value, 'oops']]]]
-      )
-    end
-
-    it 'returns predicate node with undefined args' do
-      expect(Rule.build(-> value { true }).with(id: :email?).ast).to eql(
-        [:predicate, [:email?, [[:value, Undefined]]]]
-      )
-    end
-  end
-
-  describe '#type' do
-    it 'returns rule type' do
-      expect(rule.type).to be(:rule)
-    end
-  end
-
-  describe '#bind' do
-    let(:bound) { rule.with(id: :bound).bind(object) }
-
-    context 'with an unbound method' do
-      let(:predicate) { klass.instance_method(:test?) }
-      let(:klass) { Class.new { def test?; true; end } }
-      let(:object) { klass.new }
-
-      it 'returns a new rule with its predicate bound to a specific object' do
-        expect(bound.()).to be_success
-      end
-
-      it 'carries id' do
-        expect(bound.id).to be(:bound)
-      end
-    end
-
-    context 'with an arbitrary block' do
-      let(:predicate) { -> value { value == expected } }
-      let(:object) { Class.new { def expected; 'test'; end }.new }
-
-      it 'returns a new with its predicate executed in the context of the provided object' do
-        expect(bound.('test')).to be_success
-        expect(bound.('oops')).to be_failure
-      end
-
-      it 'carries id' do
-        expect(bound.id).to be(:bound)
-      end
-
-      it 'stores arity' do
-        expect(bound.options[:arity]).to be(rule.arity)
-      end
-
-      it 'stores parameters' do
-        expect(bound.options[:parameters]).to eql(rule.parameters)
-      end
-    end
-
-    context 'with a schema instance' do
-      let(:object) { schema }
-      let(:predicate) { schema }
-
-      it 'returns a new with its predicate executed in the context of the provided object' do
-        expect(bound.(true)).to be_success
-        expect(bound.(false)).to be_failure
-      end
-    end
-  end
-
-  describe '#eval_args' do
-    context 'with an unbound method' do
-      let(:options) { { args: [1, klass.instance_method(:num), :foo], arity: 3 } }
-      let(:klass) { Class.new { def num; 7; end } }
-      let(:object) { klass.new }
-
-      it 'evaluates args in the context of the provided object' do
-        expect(rule.eval_args(object).args).to eql([1, 7, :foo])
-      end
-    end
-
-    context 'with a schema instance' do
-      let(:options) { { args: [1, schema, :foo], arity: 3 } }
-      let(:object) { Object.new }
-
-      it 'returns a new with its predicate executed in the context of the provided object' do
-        expect(rule.eval_args(object).args).to eql([1, schema, :foo])
-      end
-    end
-  end
-
-  describe 'arity specialization' do
-    describe '0-arity rule' do
-      let(:options) { { args: [1], arity: 1 } }
-      let(:predicate) { :odd?.to_proc }
-
-      it 'generates interface with the right arity' do
-        expect(rule.method(:call).arity).to be_zero
-        expect(rule.method(:[]).arity).to be_zero
-        expect(rule[]).to be(true)
-        expect(rule.()).to be_success
-      end
-    end
-
-    describe '1-arity rule' do
-      let(:options) { { args: [1], arity: 2 } }
-      let(:predicate) { -> a, b { a + b } }
-
-      it 'generates interface with the right arity' do
-        expect(rule.method(:call).arity).to be(1)
-        expect(rule.method(:[]).arity).to be(1)
-        expect(rule[10]).to be(11)
-        expect(rule.(1)).to be_success
-      end
-    end
-
-    describe 'currying' do
-      let(:options) { { args: [], arity: 2 } }
-      let(:predicate) { -> a, b { a + b } }
-      let(:rule) { super().curry(1) }
-
-      it 'generates correct arity on currying' do
-        expect(rule.method(:call).arity).to be(1)
-        expect(rule.method(:[]).arity).to be(1)
-        expect(rule[10]).to be(11)
-        expect(rule.(1)).to be_success
-      end
-    end
-
-    describe 'arbitrary arity' do
-      let(:arity) { rand(1..20) }
-      let(:curried) { rand(arity) }
-
-      let(:options) { { args: [1] * curried, arity: arity } }
-      let(:predicate) { double(:predicate) }
-
-      it 'generates correct arity' do
-        expect(rule.method(:call).arity).to be(arity - curried)
-        expect(rule.method(:[]).arity).to be(arity - curried)
-      end
-    end
-
-    describe '-1 arity' do
-      let(:options) { { args: [], arity: -1 } }
-
-      it 'accepts variable number of arguments' do
-        expect(rule.method(:call).arity).to be(-1)
-        expect(rule.method(:[]).arity).to be(-1)
-      end
-    end
-
-    describe 'constants' do
-      let(:options) { { args: [], arity: 0 } }
-
-      fit 'accepts variable number of arguments' do
-        expect(rule.method(:call).arity).to be(-1)
-        expect(rule.method(:[]).arity).to be(-1)
-      end
-    end
-  end
-end