dry-logic 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ea86d568127098e2777868066c2026dbc380eb9
-  data.tar.gz: 5553735b89ab2ef6a1c5bdd3f24874bab46c2581
+  metadata.gz: 65344930c4a3c0f6a085d583b71530119d1bd81a
+  data.tar.gz: 5ca9b9aa5819f5e8bd962b66efe47aabd865eeac
 SHA512:
-  metadata.gz: c943b1c67b55618b3e3fa1e982e371614a3e34c0ec2ca7457c775e755335a9579f52434d50545b411bf053f3c8e5a72209bdc86a58d7f13abef521df92b1fde5
-  data.tar.gz: 87598a0a72b1196d966464b1a731746922613fa8eb72cfa3d002ecfe3dee917502126bcfb2e506ae67c958335a6343b05db131e7012d1a0c64d74320d4e3d2d6
+  metadata.gz: cdc353eafff80177f44585c8a82130a3f6abb1ea13d186b7da32e1bf0bafb29b2b912f543be022a8a147afe088b65a8542471865817e49ae9e3ac981051fdb1c
+  data.tar.gz: 8a46b78404a2edf942786c1a002be4db7f067c0a2c27190eba5caebafcec55042c76aab90fcd4a347196cec396c3c5a597298455a741c6175224d40239db309c

data/.travis.yml

@@ -5,22 +5,18 @@ bundler_args: --without console tools
 script:
   - bundle exec rake spec
 rvm:
-  - 2.0
   - 2.1
   - 2.2
   - 2.3.0
   - rbx-2
   - jruby-9000
-  - ruby-head
-  - jruby-head
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
 matrix:
   allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
     - rvm: jruby-9000
+    - rvm: rbx-2
 notifications:
   email: false
   webhooks:

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+# v0.4.0 2016-09-21
+
+This is a partial rewrite focused on internal clean up and major performance improvements. This is also the beginning of the work to make this library first-class rather than "just" a rule backend for dry-validation and dry-types.
+
+### Added
+
+* `Rule#[]` which applies a rule and always returns `true` or `false` (solnic)
+* `Rule#bind` which returns a rule with its predicate bound to a given object (solnic)
+* `Rule#eval_args` which evaluates unbound-methods-args in the context of a given object (solnic)
+* `Logic.Rule` builder function (solnic)
+* Nice `#inspect` on rules and operation objects (solnic)
+
+### Changed
+
+* [BRAEKING] New result API (solnic)
+* [BREAKING] `Predicate` is now `Rule::Predicate` (solnic)
+* [BREAKING] `Rule::Conjunction` is now `Operation::And` (solnic)
+* [BREAKING] `Rule::Disjunction` is now `Operation::Or` (solnic)
+* [BREAKING] `Rule::ExlusiveDisjunction` is now `Operation::Xor` (solnic)
+* [BREAKING] `Rule::Implication` is now `Operation::Implication` (solnic)
+* [BREAKING] `Rule::Set` is now `Operation::Set` (solnic)
+* [BREAKING] `Rule::Each` is now `Operation::Each` (solnic)
+* [BREAKING] `Rule.new` accepts a predicate function as its first arg now (solnic)
+* [BREAKING] `Rule#name` is now `Rule#id` (solnic)
+* `Rule#parameters` is public now (solnic)
+
+[Compare v0.3.0...v0.4.0](https://github.com/dryrb/dry-logic/compare/v0.3.0...v0.4.0)
+
 # v0.3.0 2016-07-01
 
 ### Added

data/Gemfile

@@ -3,12 +3,15 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'codeclimate-test-reporter', platform: :rbx
+  gem 'codeclimate-test-reporter', platform: :mri
 end
 
 group :tools do
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'guard-rubocop'
   gem 'byebug', platform: :mri
+  gem 'simplecov', platforms: :mri
+
+  unless ENV['TRAVIS']
+    gem 'mutant', github: 'mbj/mutant'
+    gem 'mutant-rspec', github: 'mbj/mutant'
+  end
 end

data/dry-logic.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'dry-core', '~> 0.1'
   spec.add_runtime_dependency 'dry-container', '~> 0.2', '>= 0.2.6'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
 

data/lib/dry/logic.rb

@@ -1,5 +1,3 @@
-require 'dry-equalizer'
-
 # A collection of micro-libraries, each intended to encapsulate
 # a common task in Ruby
 module Dry
@@ -7,4 +5,5 @@ module Dry
   end
 end
 
-require 'dry/logic/rule'
+require 'dry/logic/rule/predicate'
+require 'dry/logic/operations'

data/lib/dry/logic/appliable.rb

@@ -0,0 +1,33 @@
+module Dry
+  module Logic
+    module Appliable
+      def id
+        options[:id]
+      end
+
+      def result
+        options[:result]
+      end
+
+      def applied?
+        !result.nil?
+      end
+
+      def success?
+        result.equal?(true)
+      end
+
+      def failure?
+        !success?
+      end
+
+      def to_ast
+        if applied? && id
+          [success? ? :success : :failure, [id, ast]]
+        else
+          ast
+        end
+      end
+    end
+  end
+end

data/lib/dry/logic/evaluator.rb

@@ -1,3 +1,5 @@
+require 'dry/equalizer'
+
 module Dry
   module Logic
     class Evaluator

data/lib/dry/logic/operations.rb

@@ -0,0 +1,13 @@
+require 'dry/logic/operations/and'
+require 'dry/logic/operations/or'
+require 'dry/logic/operations/xor'
+require 'dry/logic/operations/implication'
+require 'dry/logic/operations/negation'
+
+require 'dry/logic/operations/key'
+require 'dry/logic/operations/attr'
+require 'dry/logic/operations/each'
+require 'dry/logic/operations/set'
+require 'dry/logic/operations/check'
+
+require 'dry/logic/operators'

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

@@ -0,0 +1,44 @@
+require 'dry/core/constants'
+require 'dry/equalizer'
+require 'dry/logic/operators'
+
+module Dry
+  module Logic
+    module Operations
+      class Abstract
+        include Core::Constants
+        include Dry::Equalizer(:rules, :options)
+        include Operators
+
+        attr_reader :rules
+
+        attr_reader :options
+
+        def initialize(*rules, **options)
+          @rules = rules
+          @options = options
+        end
+
+        def id
+          options[:id]
+        end
+
+        def curry(*args)
+          new(rules.map { |rule| rule.curry(*args) }, options)
+        end
+
+        def new(rules, **new_options)
+          self.class.new(*rules, options.merge(new_options))
+        end
+
+        def with(new_options)
+          new(rules, options.merge(new_options))
+        end
+
+        def to_ast
+          ast
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'dry/logic/operations/binary'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class And < Binary
+        def type
+          :and
+        end
+        alias_method :operator, :type
+
+        def call(input)
+          left_result = left.(input)
+
+          if left_result.success?
+            right_result = right.(input)
+
+            if right_result.success?
+              Result::SUCCESS
+            else
+              Result.new(false, id) { right_result.ast(input) }
+            end
+          else
+            Result.new(false, id) { [type, [left_result.to_ast, [:hint, right.ast(input)]]] }
+          end
+        end
+
+        def [](input)
+          left[input] && right[input]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'dry/logic/operations/key'
+
+module Dry
+  module Logic
+    module Operations
+      class Attr < Key
+        def self.evaluator(name)
+          Evaluator::Attr.new(name)
+        end
+
+        def type
+          :attr
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'dry/logic/operations/abstract'
+
+module Dry
+  module Logic
+    module Operations
+      class Binary < Abstract
+        attr_reader :left
+
+        attr_reader :right
+
+        def initialize(*rules, **options)
+          super
+          @left, @right = rules
+        end
+
+        def ast(input = Undefined)
+          [type, [left.ast(input), right.ast(input)]]
+        end
+
+        def to_s
+          "#{left} #{operator.to_s.upcase} #{right}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'dry/logic/operations/unary'
+require 'dry/logic/evaluator'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Check < Unary
+        attr_reader :evaluator
+
+        def self.new(rule, **options)
+          if options[:evaluator]
+            super(rule, options)
+          else
+            keys = options.fetch(:keys)
+            evaluator = Evaluator::Set.new(keys)
+
+            super(rule, options.merge(evaluator: evaluator))
+          end
+        end
+
+        def initialize(*rules, **options)
+          super
+          @evaluator = options[:evaluator]
+        end
+
+        def type
+          :check
+        end
+
+        def call(input)
+          *head, tail = evaluator[input]
+          result = rule.curry(*head).(tail)
+
+          if result.success?
+            Result::SUCCESS
+          else
+            Result.new(false, id) { [type, [options[:keys], result.to_ast]] }
+          end
+        end
+
+        def [](input)
+          rule[*evaluator[input].reverse]
+        end
+
+        def ast(input = Undefined)
+          [type, [options[:keys], rule.ast(input)]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'dry/logic/operations/unary'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Each < Unary
+        def type
+          :each
+        end
+
+        def call(input)
+          results = input.map { |element| rule.(element) }
+          success = results.all?(&:success?)
+
+          Result.new(success, id) do
+            failures = results
+              .map
+              .with_index { |result, idx| [:key, [idx, result.ast(input[idx])]] if result.failure? }
+              .compact
+
+            [:set, failures]
+          end
+        end
+
+        def [](arr)
+          arr.map { |input| rule[input] }.all?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'dry/logic/operations/binary'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Implication < Binary
+        def type
+          :implication
+        end
+
+        def operator
+          :then
+        end
+
+        def call(input)
+          left_result = left.(input)
+
+          if left_result.success?
+            right_result = right.(input)
+            Result.new(right_result.success?, id) { right_result.to_ast }
+          else
+            Result::SUCCESS
+          end
+        end
+
+        def [](input)
+          if left[input]
+            right[input]
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'dry/logic/operations/unary'
+require 'dry/logic/evaluator'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Key < Unary
+        attr_reader :evaluator
+
+        attr_reader :path
+
+        def self.new(rules, options)
+          if options[:evaluator]
+            super
+          else
+            name = options.fetch(:name)
+            eval = options.fetch(:evaluator, evaluator(name))
+            super(rules, options.merge(evaluator: eval, path: name))
+          end
+        end
+
+        def self.evaluator(name)
+          Evaluator::Key.new(name)
+        end
+
+        def initialize(*rules, **options)
+          super
+          @evaluator = options[:evaluator]
+          @path = options[:path]
+        end
+
+        def type
+          :key
+        end
+
+        def call(hash)
+          input = evaluator[hash]
+          result = rule.(input)
+
+          if result.success?
+            Result::SUCCESS
+          else
+            Result.new(false, path) { [type, [path, result.to_ast]] }
+          end
+        end
+
+        def [](hash)
+          rule[evaluator[hash]]
+        end
+
+        def ast(input = nil)
+          if input
+            [type, [path, rule.ast(evaluator[input])]]
+          else
+            [type, [path, rule.ast]]
+          end
+        end
+
+        def to_s
+          "#{type}[#{path}](#{rule})"
+        end
+      end
+    end
+  end
+end