dry-logic 0.1.4 → 0.2.0

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

@@ -1,21 +1,13 @@
 module Dry
   module Logic
-    class Rule::Attr < Rule
-      def self.new(name, predicate)
-        super(name, predicate.curry(name))
+    class Rule::Attr < Rule::Key
+      def self.evaluator(options)
+        Evaluator::Attr.new(options.fetch(:name))
       end
 
       def type
         :attr
       end
-
-      def evaluate_input(input)
-        input.public_send(name)
-      end
-
-      def call(input)
-        Logic::Result::LazyValue.new(input, predicate.(input), self)
-      end
     end
   end
 end

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

@@ -1,39 +1,40 @@
+require 'dry/logic/evaluator'
+
 module Dry
   module Logic
-    class Rule::Check < Rule
-      attr_reader :keys
+    class Rule::Check < Rule::Value
+      attr_reader :name, :evaluator
+
+      def self.new(predicate, options)
+        keys = options.fetch(:keys)
+        evaluator = Evaluator::Set.new(keys)
 
-      class Unary < Rule::Check
-        def evaluate_input(*)
-          predicate.input
-        end
+        super(predicate, options.merge(evaluator: evaluator))
       end
 
-      class Binary < Rule::Check
-        def evaluate_input(result)
-          keys.map do |key|
-            if key.is_a?(Hash)
-              parent, child = key.to_a.flatten
-              result[parent].input[child]
-            else
-              result[key].input
-            end
-          end
-        end
+      def initialize(predicate, options)
+        super
+        @name = options.fetch(:name)
+        @evaluator = options[:evaluator]
       end
 
-      def initialize(name, predicate, keys)
-        super(name, predicate)
-        @keys = keys
+      def call(input)
+        args = evaluator[input].reverse
+        *head, tail = args
+        Logic.Result(predicate.curry(*head).(tail), head.size > 0 ? curry(*head) : self, input)
       end
 
-      def call(result)
-        Logic.Result(evaluate_input(result), predicate.(result), self)
+      def evaluate(input)
+        evaluator[input].first
       end
 
       def type
         :check
       end
+
+      def to_ast
+        [type, [name, predicate.to_ast]]
+      end
     end
   end
 end

data/lib/dry/logic/rule/composite.rb

@@ -3,7 +3,7 @@ module Dry
     class Rule::Composite < Rule
       include Dry::Equalizer(:left, :right)
 
-      attr_reader :name, :left, :right
+      attr_reader :left, :right
 
       def initialize(left, right)
         @left = left
@@ -14,15 +14,19 @@ module Dry
         :"#{left.name}_#{type}_#{right.name}"
       end
 
-      def to_ary
-        [type, [left.to_ary, right.to_ary]]
+      def to_ast
+        [type, [left.to_ast, right.to_ast]]
       end
-      alias_method :to_a, :to_ary
+      alias_method :to_a, :to_ast
     end
 
     class Rule::Implication < Rule::Composite
-      def call(*args)
-        left.(*args).then(right)
+      def call(input)
+        if left.(input).success?
+          right.(input)
+        else
+          Logic.Result(true, left, input)
+        end
       end
 
       def type
@@ -31,8 +35,14 @@ module Dry
     end
 
     class Rule::Conjunction < Rule::Composite
-      def call(*args)
-        left.(*args).and(right)
+      def call(input)
+        result = left.(input)
+
+        if result.success?
+          right.(input)
+        else
+          result
+        end
       end
 
       def type
@@ -41,8 +51,14 @@ module Dry
     end
 
     class Rule::Disjunction < Rule::Composite
-      def call(*args)
-        left.(*args).or(right)
+      def call(input)
+        result = left.(input)
+
+        if result.success?
+          result
+        else
+          right.(input)
+        end
       end
 
       def type
@@ -51,8 +67,12 @@ module Dry
     end
 
     class Rule::ExclusiveDisjunction < Rule::Composite
-      def call(*args)
-        left.(*args).xor(right)
+      def call(input)
+        Logic.Result(left.(input).success? ^ right.(input).success?, self, input)
+      end
+
+      def evaluate(input)
+        [left.evaluate(input), right.evaluate(input)]
       end
 
       def type

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

@@ -1,8 +1,8 @@
 module Dry
   module Logic
-    class Rule::Each < Rule
-      def call(input)
-        Logic.Result(input, input.map { |element| predicate.(element) }, self)
+    class Rule::Each < Rule::Value
+      def apply(input)
+        input.map { |element| predicate.(element) }
       end
 
       def type

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

@@ -1,16 +1,35 @@
+require 'dry/logic/evaluator'
+
 module Dry
   module Logic
-    class Rule::Key < Rule
-      def self.new(name, predicate)
-        super(name, predicate.curry(name))
+    class Rule::Key < Rule::Value
+      attr_reader :name, :evaluator
+
+      def self.new(predicate, options)
+        name = options.fetch(:name)
+        super(predicate, evaluator: evaluator(options), name: name)
+      end
+
+      def self.evaluator(options)
+        Evaluator::Key.new(options.fetch(:name))
+      end
+
+      def initialize(predicate, options)
+        super
+        @name = options[:name]
+        @evaluator = options[:evaluator]
+      end
+
+      def evaluate(input)
+        evaluator[input]
       end
 
       def type
         :key
       end
 
-      def call(input)
-        Logic.Result(input[name], predicate.(input), self)
+      def to_ast
+        [type, [name, predicate.to_ast]]
       end
     end
   end

data/lib/dry/logic/rule/negation.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Logic
+    class Rule
+      class Negation < Rule::Value
+        def type
+          :not
+        end
+
+        def call(input)
+          predicate.(input).negated
+        end
+      end
+    end
+  end
+end

data/lib/dry/logic/rule/set.rb

@@ -1,22 +1,23 @@
 module Dry
   module Logic
-    class Rule::Set < Rule
-      def call(input)
-        Logic.Result(input, predicate.map { |rule| rule.(input) }, self)
-      end
+    class Rule::Set < Rule::Value
+      alias_method :rules, :predicate
 
       def type
         :set
       end
 
+      def apply(input)
+        rules.map { |rule| rule.(input) }
+      end
+
       def at(*args)
-        self.class.new(name, predicate.values_at(*args))
+        new(rules.values_at(*args))
       end
 
-      def to_ary
-        [type, [name, predicate.map(&:to_ary)]]
+      def to_ast
+        [type, rules.map { |rule| rule.to_ast }]
       end
-      alias_method :to_a, :to_ary
     end
   end
 end

data/lib/dry/logic/rule/value.rb

@@ -1,12 +1,24 @@
 module Dry
   module Logic
     class Rule::Value < Rule
+      def type
+        :val
+      end
+
       def call(input)
-        Logic.Result(input, predicate.(input), self)
+        Logic.Result(apply(input), self, input)
       end
 
-      def type
-        :val
+      def apply(input)
+        predicate.(evaluate(input))
+      end
+
+      def evaluate(input)
+        input
+      end
+
+      def to_ast
+        [type, predicate.to_ast]
       end
     end
   end

data/lib/dry/logic/rule_compiler.rb

@@ -10,7 +10,7 @@ module Dry
       end
 
       def call(ast)
-        ast.to_ary.map { |node| visit(node) }
+        ast.map { |node| visit(node) }
       end
 
       def visit(node)
@@ -20,26 +20,7 @@ module Dry
 
       def visit_check(node)
         name, predicate, keys = node
-        check_keys = keys ? keys : [name]
-        klass = check_keys.size == 1 ? Rule::Check::Unary : Rule::Check::Binary
-        klass.new(name, visit(predicate), check_keys)
-      end
-
-      def visit_res(node)
-        name, predicate = node
-        Rule::Result.new(name, visit(predicate))
-      end
-
-      def visit_args(nodes)
-        nodes.map { |node| visit(node) }
-      end
-
-      def visit_res_arg(name)
-        predicates[name].input
-      end
-
-      def visit_arg(value)
-        value
+        Rule::Check.new(visit(predicate), name: name, keys: keys || [name])
       end
 
       def visit_not(node)
@@ -48,37 +29,29 @@ module Dry
 
       def visit_key(node)
         name, predicate = node
-        Rule::Key.new(name, visit(predicate))
+        Rule::Key.new(visit(predicate), name: name)
       end
 
       def visit_attr(node)
         name, predicate = node
-        Rule::Attr.new(name, visit(predicate))
+        Rule::Attr.new(visit(predicate), name: name)
       end
 
       def visit_val(node)
-        name, predicate = node
-        Rule::Value.new(name, visit(predicate))
+        Rule::Value.new(visit(node))
       end
 
       def visit_set(node)
-        name, rules = node
-        Rule::Set.new(name, call(rules))
+        Rule::Set.new(call(node))
       end
 
       def visit_each(node)
-        name, rule = node
-        Rule::Each.new(name, visit(rule))
+        Rule::Each.new(visit(node))
       end
 
       def visit_predicate(node)
         name, args = node
-
-        if args[0] == :args
-          predicates[name].curry(*visit(args))
-        else
-          predicates[name].curry(*args)
-        end
+        predicates[name].curry(*args)
       end
 
       def visit_and(node)
@@ -100,11 +73,6 @@ module Dry
         left, right = node
         visit(left) > visit(right)
       end
-
-      def visit_group(node)
-        identifier, predicate = node
-        Rule::Group.new(identifier, visit(predicate))
-      end
     end
   end
 end

data/lib/dry/logic/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Logic
-    VERSION = '0.1.4'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/spec/shared/predicates.rb

@@ -5,6 +5,8 @@ RSpec.shared_examples 'predicates' do
 
   let(:str?) { Dry::Logic::Predicates[:str?] }
 
+  let(:true?) { Dry::Logic::Predicates[:true?] }
+
   let(:hash?) { Dry::Logic::Predicates[:hash?] }
 
   let(:int?) { Dry::Logic::Predicates[:int?] }

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ begin
 rescue LoadError; end
 
 require 'dry-logic'
+require 'pathname'
 
 SPEC_ROOT = Pathname(__dir__)
 

data/spec/unit/rule/attr_spec.rb

@@ -5,24 +5,24 @@ RSpec.describe Dry::Logic::Rule::Attr do
 
   let(:model) { Struct.new(:name) }
 
-  subject(:rule) { described_class.new(:name, attr?) }
+  subject(:rule) { described_class.new(str?, name: :name) }
 
   describe '#call' do
     it 'applies predicate to the value' do
-      expect(rule.(model.new(name: 'Jane'))).to be_success
-      expect(rule.(nil)).to be_failure
+      expect(rule.(model.new('Jane'))).to be_success
+      expect(rule.(model.new(nil))).to be_failure
     end
   end
 
   describe '#and' do
-    let(:other) { Dry::Logic::Rule::Value.new(:name, str?) }
+    let(:other) { Dry::Logic::Rule::Attr.new(min_size?.curry(3), name: :name) }
 
     it 'returns conjunction rule where value is passed to the right' do
       present_and_string = rule.and(other)
 
       expect(present_and_string.(model.new('Jane'))).to be_success
 
-      expect(present_and_string.(nil)).to be_failure
+      expect(present_and_string.(model.new('Ja'))).to be_failure
       expect(present_and_string.(model.new(1))).to be_failure
     end
   end