dry-logic 1.0.5 → 1.0.6

data/bin/console

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-
-require "irb"
-IRB.start

data/docsite/source/index.html.md

@@ -1,54 +0,0 @@
----
-title: Introduction
-description: Predicate logic with composable rules
-layout: gem-single
-type: gem
-name: dry-logic
-sections:
-  - predicates
-  - operations
----
-
-Predicate logic and rule composition used by:
-
-* [dry-types](https://github.com/dry-rb/dry-types) for constrained types
-* [dry-validation](https://github.com/dry-rb/dry-validation) for composing validation rules
-* your project...?
-
-## Synopsis
-
-``` ruby
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-
-# Rule::Predicate will only apply its predicate to its input, that’s all
-
-# require input to have the key :user
-user_present = Rule::Predicate.new(Predicates[:key?]).curry(:user)
-# curry allows us to prepare predicates with args, without the input
-
-# require value to be greater than 18
-min_18 = Rule::Predicate.new(Predicates[:gt?]).curry(18)
-
-# use the min_18 predicate on the the value of user[:age]
-has_min_age = Operations::Key.new(min_18, name: [:user, :age])
-
-user_rule = user_present & has_min_age
-
-user_rule.(user: { age: 19 }).success?
-# => true
-
-user_rule.(user: { age: 18 }).success?
-# => false
-
-user_rule.(user: { age: 'seventeen' })
-# => ArgumentError: comparison of String with 18 failed
-
-user_rule.(user: { })
-# => NoMethodError: undefined method `>' for nil:NilClass
-
-user_rule.({}).success?
-# => false
-```

data/docsite/source/operations.html.md

@@ -1,62 +0,0 @@
----
-title: Operations
-layout: gem-single
-name: dry-logic
----
-
-Dry-logic uses operations to interact with the input passed to the different rules.
-
-``` ruby
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-
-user_present = Rule::Predicate.new(Predicates[:key?]).curry(:user)
-
-min_18 = Rule::Predicate.new(Predicates[:gt?]).curry(18)
-
-# Here Operations::Key and Rule::Predicate are use to compose and logic based on the value of a given key e.g [:user, :age]
-has_min_age = Operations::Key.new(min_18, name: [:user, :age])
-# => #<Dry::Logic::Operations::Key rules=[#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#gt?> options={:args=>[18]}>] options={:name=>[:user, :age], :evaluator=>#<Dry::Logic::Evaluator::Key path=[:user, :age]>, :path=>[:user, :age]}>
-
-# Thanks to the composable structure of the library we can use multiple Rules and Operations to create custom logic
-user_rule = user_present & has_min_age
-
-user_rule.(user: { age: 19 }).success?
-# => true
-```
-
-* Built-in:
-  - `and`
-  - `or`
-  - `key`
-  - `attr`
-  - `binary`
-  - `check`
-  - `each`
-  - `implication`
-  - `negation`
-  - `set`
-  - `xor`
-
-Another example, lets create the `all?` method from the `Enumerable` module.
-
-``` ruby
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-
-def all?(value)
-  Operations::Each.new(Rule::Predicate.new(Predicates[:gt?]).curry(value))
-end
-
-all_6 = all?(6)
-
-all_6.([6,7,8,9]).success?
-# => true
-
-all_6.([1,2,3,4]).success?
-# => false
-```

data/docsite/source/predicates.html.md

@@ -1,102 +0,0 @@
----
-title: Predicates
-layout: gem-single
-name: dry-logic
----
-
-Dry-logic comes with a lot predicates to compose multiple rules:
-
-``` ruby
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-```
-
-Now you can access all built-in predicates:
-
-``` ruby
-Predicates[:key?]
-# => #<Method: Module(Dry::Logic::Predicates::Methods)#key?>
-```
-
-In the end predicates return true or false.
-
-```ruby
-Predicates[:key?].(:name, {name: 'John'})
-# => true
-```
-
-* Built-in:
-  - `type?`
-  - `none?`
-  - `key?`
-  - `attr?`
-  - `empty?`
-  - `filled?`
-  - `bool?`
-  - `date?`
-  - `date_time?`
-  - `time?`
-  - `number?`
-  - `int?`
-  - `float?`
-  - `decimal?`
-  - `str?`
-  - `hash?`
-  - `array?`
-  - `odd?`
-  - `even?`
-  - `lt?`
-  - `gt?`
-  - `lteq?`
-  - `gteq?`
-  - `size?`
-  - `min_size?`
-  - `max_size?`
-  - `bytesize?`
-  - `min_bytesize?`
-  - `max_bytesize?`
-  - `inclusion?`
-  - `exclusion?`
-  - `included_in?`
-  - `excluded_from?`
-  - `includes?`
-  - `excludes?`
-  - `eql?`
-  - `not_eql?`
-  - `is?`
-  - `case?`
-  - `true?`
-  - `false?`
-  - `format?`
-  - `respond_to?`
-  - `predicate`
-  - `uuid_v4?`
-
-With predicates you can build more composable and complex operations:
-For example, let's say we want to check that a given input is a hash and has a specify key.
-
-``` ruby
-require 'dry/logic'
-require 'dry/logic/predicates'
-
-include Dry::Logic
-
-is_hash = Rule::Predicate.new(Predicates[:type?]).curry(Hash)
-# => #<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#type?> options={:args=>[:hash]}>
-name_key = Rule::Predicate.new(Predicates[:key?]).curry(:name)
-# => #<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#key?> options={:args=>[:name]}>
-
-hash_with_key = is_hash & name_key
-# => #<Dry::Logic::Operations::And rules=[#<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#type?> options={:args=>[:hash]}>, #<Dry::Logic::Rule::Predicate predicate=#<Method: Module(Dry::Logic::Predicates::Methods)#key?> options={:args=>[:name]}>] options={}>
-
-hash_with_key.(name: 'John').success?
-# => true
-
-hash_with_key.(not_valid: 'John').success?
-# => false
-
-hash_with_key.([1,2]).success?
-# => false
-```

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