dry-logic 0.6.1 → 1.0.5

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
@@ -10,4 +12,5 @@ group :tools do
   gem 'pry-byebug', platform: :mri
   gem 'benchmark-ips', platform: :mri
   gem 'hotch', platform: :mri
+  gem 'ossy', git: 'https://github.com/solnic/ossy.git', branch: 'master'
 end

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Ruby Object Mapper
+Copyright (c) 2015-2019 dry-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,5 +1,5 @@
 [gem]: https://rubygems.org/gems/dry-logic
-[travis]: https://travis-ci.org/dry-rb/dry-logic
+[ci]: https://github.com/dry-rb/dry-logic/actions?query=workflow%3Aci
 [codeclimate]: https://codeclimate.com/github/dry-rb/dry-logic
 [chat]: https://dry-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-logic
@@ -7,20 +7,20 @@
 # dry-logic [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/dry-logic.svg)][gem]
-[![Build Status](https://travis-ci.org/dry-rb/dry-logic.svg?branch=master)][travis]
+[![Build Status](https://github.com/dry-rb/dry-logic/workflows/ci/badge.svg)][ci]
 [![Code Climate](https://codeclimate.com/github/dry-rb/dry-logic/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/dry-rb/dry-logic/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-logic.svg?branch=master)][inchpages]
 
 Predicate logic and rule composition used by:
 
-* [dry-types](https://github.com/dry-rb/dry-types) for constrained types
-* [dry-schema](https://github.com/dry-rb/dry-schema) and [dry-validation](https://github.com/dry-rb/dry-validation) for composing validation rules
-* your project...?
+- [dry-types](https://github.com/dry-rb/dry-types) for constrained types
+- [dry-schema](https://github.com/dry-rb/dry-schema) and [dry-validation](https://github.com/dry-rb/dry-validation) for composing validation rules
+- your project...?
 
 ## Links
 
-* [Documentation](http://dry-rb.org/gems/dry-logic)
+- [Documentation](http://dry-rb.org/gems/dry-logic)
 
 ## Contributing
 

data/Rakefile

@@ -1,4 +1,6 @@
 #!/usr/bin/env rake
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))

data/benchmarks/rule_application.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'setup'
 
 unless Dry::Logic::Rule.respond_to?(:build)

data/benchmarks/setup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'benchmark/ips'
 require 'hotch'
 ENV['HOTCH_VIEWER'] ||= 'open'

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require 'dry/logic'

data/docsite/source/index.html.md

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

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

@@ -0,0 +1,102 @@
+---
+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/dry-logic.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../lib/dry/logic/version', __FILE__)
 
 Gem::Specification.new do |spec|
@@ -12,6 +14,12 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0")
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.4.0'
+  
+  spec.metadata = {
+    'source_code_uri' => 'https://github.com/dry-rb/dry-logic',
+    'changelog_uri' => 'https://github.com/dry-rb/dry-logic/blob/master/CHANGELOG.md'
+  }
 
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_runtime_dependency 'dry-core', '~> 0.2'

data/examples/basic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic'
 require 'dry/logic/predicates'
 

data/lib/dry-logic.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'dry/logic'

data/lib/dry/logic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A collection of micro-libraries, each intended to encapsulate
 # a common task in Ruby
 module Dry

data/lib/dry/logic/appliable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dry
   module Logic
     module Appliable

data/lib/dry/logic/evaluator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/equalizer'
 
 module Dry

data/lib/dry/logic/operations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operations/and'
 require 'dry/logic/operations/or'
 require 'dry/logic/operations/xor'

data/lib/dry/logic/operations/abstract.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/core/constants'
 require 'dry/equalizer'
 require 'dry/logic/operators'
@@ -24,15 +26,15 @@ module Dry
         end
 
         def curry(*args)
-          new(rules.map { |rule| rule.curry(*args) }, options)
+          new(rules.map { |rule| rule.curry(*args) }, **options)
         end
 
         def new(rules, **new_options)
-          self.class.new(*rules, options.merge(new_options))
+          self.class.new(*rules, **options, **new_options)
         end
 
         def with(new_options)
-          new(rules, options.merge(new_options))
+          new(rules, **options, **new_options)
         end
 
         def to_ast

data/lib/dry/logic/operations/and.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operations/binary'
 require 'dry/logic/result'
 
@@ -7,7 +9,7 @@ module Dry
       class And < Binary
         attr_reader :hints
 
-        def initialize(*)
+        def initialize(*, **)
           super
           @hints = options.fetch(:hints, true)
         end

data/lib/dry/logic/operations/attr.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operations/key'
 
 module Dry

data/lib/dry/logic/operations/binary.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operations/abstract'
 
 module Dry

data/lib/dry/logic/operations/check.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operations/unary'
 require 'dry/logic/evaluator'
 require 'dry/logic/result'
@@ -15,7 +17,7 @@ module Dry
             keys = options.fetch(:keys)
             evaluator = Evaluator::Set.new(keys)
 
-            super(rule, options.merge(evaluator: evaluator))
+            super(rule, **options, evaluator: evaluator)
           end
         end
 

data/lib/dry/logic/operations/each.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operations/unary'
 require 'dry/logic/result'