dry-logic 0.3.0 → 0.4.0

data/lib/dry/logic/result.rb

@@ -1,55 +1,98 @@
+require 'dry/core/constants'
+
 module Dry
   module Logic
-    def self.Result(response, rule, input)
-      Result[rule].new(response, rule, input)
-    end
-
     class Result
-      include Dry::Equalizer(:success?, :input, :rule)
+      include Core::Constants
 
-      attr_reader :input, :rule, :response, :success
+      SUCCESS = Class.new {
+        def success?
+          true
+        end
 
-      def self.[](type)
-        case type
-        when Rule::Each then Result::Each
-        when Rule::Set then Result::Set
-        when Rule::Key, Rule::Attr, Rule::Check then Result::Named
-        else Result::Value
+        def failure?
+          false
         end
+      }.new.freeze
+
+      attr_reader :success
+
+      attr_reader :id
+
+      attr_reader :serializer
+
+      def initialize(success, id = nil, &block)
+        @success = success
+        @id = id
+        @serializer = block
       end
 
-      def initialize(response, rule, input)
-        @response = response
-        @success = response.respond_to?(:success?) ? response.success? : response
-        @rule = rule
-        @input = input
+      def success?
+        success
       end
 
-      def [](name)
-        response[name] if response.respond_to?(:[])
+      def failure?
+        !success?
       end
 
-      def name
-        nil
+      def type
+        success? ? :success : :failure
       end
 
-      def negated
-        self.class.new(!success, rule, input)
+      def ast(input = Undefined)
+        serializer.(input)
       end
 
-      def success?
-        @success
+      def to_ast
+        if id
+          [type, [id, ast]]
+        else
+          ast
+        end
       end
 
-      def failure?
-        !success?
+      def to_s
+        visit(to_ast)
+      end
+
+      private
+
+      def visit(ast)
+        __send__(:"visit_#{ast[0]}", ast[1])
+      end
+
+      def visit_predicate(node)
+        name, args = node
+
+        if args.empty?
+          name.to_s
+        else
+          "#{name}(#{args.map(&:last).map(&:inspect).join(', ')})"
+        end
+      end
+
+      def visit_and(node)
+        left, right = node
+        "#{visit(left)} AND #{visit(right)}"
+      end
+
+      def visit_or(node)
+        left, right = node
+        "#{visit(left)} OR #{visit(right)}"
+      end
+
+      def visit_xor(node)
+        left, right = node
+        "#{visit(left)} XOR #{visit(right)}"
+      end
+
+      def visit_not(node)
+        "not(#{visit(node)})"
+      end
+
+      def visit_hint(node)
+        visit(node)
       end
     end
   end
 end
-
-require 'dry/logic/result/value'
-require 'dry/logic/result/named'
-require 'dry/logic/result/multi'
-require 'dry/logic/result/each'
-require 'dry/logic/result/set'

data/lib/dry/logic/rule.rb

@@ -1,82 +1,98 @@
+require 'dry/core/constants'
+require 'dry/equalizer'
+require 'dry/logic/operations'
+require 'dry/logic/result'
+
 module Dry
   module Logic
+    def self.Rule(*args, **options, &block)
+      if args.any?
+        Rule.new(*args, Rule::DEFAULT_OPTIONS.merge(options))
+      elsif block
+        Rule.new(block, Rule::DEFAULT_OPTIONS.merge(options))
+      end
+    end
+
     class Rule
+      include Core::Constants
       include Dry::Equalizer(:predicate, :options)
+      include Operators
+
+      DEFAULT_OPTIONS = { args: [].freeze }.freeze
 
       attr_reader :predicate
 
       attr_reader :options
 
-      def self.method_added(meth)
-        super
-        if meth == :call
-          alias_method :[], :call
-        end
-      end
+      attr_reader :args
+
+      attr_reader :arity
 
-      def initialize(predicate, options = {})
+      def initialize(predicate, options = DEFAULT_OPTIONS)
         @predicate = predicate
         @options = options
+        @args = options[:args]
+        @arity = options[:arity] || predicate.arity
       end
 
-      def predicate_id
-        predicate.id
+      def type
+        :rule
       end
 
-      def type
-        raise NotImplementedError
+      def id
+        options[:id]
+      end
+
+      def call(*input)
+        Result.new(self[*input], id) { ast(*input) }
       end
 
-      def and(other)
-        Conjunction.new(self, other)
+      def [](*input)
+        arity == 0 ? predicate.() : predicate[*args, *input]
       end
-      alias_method :&, :and
 
-      def or(other)
-        Disjunction.new(self, other)
+      def curry(*new_args)
+        all_args = args + new_args
+
+        if all_args.size > arity
+          raise ArgumentError, "wrong number of arguments (#{all_args.size} for #{arity})"
+        else
+          with(args: all_args)
+        end
       end
-      alias_method :|, :or
 
-      def xor(other)
-        ExclusiveDisjunction.new(self, other)
+      def bind(object)
+        if predicate.instance_of?(UnboundMethod)
+          self.class.new(predicate.bind(object), options)
+        else
+          self.class.new(
+            -> *args { object.instance_exec(*args, &predicate) },
+            options.merge(arity: arity, parameters: parameters)
+          )
+        end
       end
-      alias_method :^, :xor
 
-      def then(other)
-        Implication.new(self, other)
+      def eval_args(object)
+        with(args: args.map { |arg| arg.instance_of?(UnboundMethod) ? arg.bind(object).() : arg })
       end
-      alias_method :>, :then
 
-      def negation
-        Negation.new(self)
+      def with(new_opts)
+        self.class.new(predicate, options.merge(new_opts))
       end
 
-      def new(predicate)
-        self.class.new(predicate, options)
+      def parameters
+        options[:parameters] || predicate.parameters
       end
 
-      def curry(*args)
-        if arity > 0
-          new(predicate.curry(*args))
-        else
-          self
-        end
+      def ast(input = Undefined)
+        [:predicate, [id, args_with_names(input)]]
       end
 
-      def each?
-        predicate.is_a?(Rule::Each)
+      private
+
+      def args_with_names(*input)
+        parameters.map(&:last).zip(args + input)
       end
     end
   end
 end
-
-require 'dry/logic/rule/value'
-require 'dry/logic/rule/key'
-require 'dry/logic/rule/attr'
-require 'dry/logic/rule/each'
-require 'dry/logic/rule/set'
-require 'dry/logic/rule/composite'
-require 'dry/logic/rule/negation'
-require 'dry/logic/rule/check'
-
-require 'dry/logic/result'

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

@@ -0,0 +1,28 @@
+require 'dry/logic/rule'
+
+module Dry
+  module Logic
+    class Rule::Predicate < Rule
+      def type
+        :predicate
+      end
+
+      def name
+        predicate.name
+      end
+
+      def to_s
+        if args.size > 0
+          "#{name}(#{args.map(&:inspect).join(', ')})"
+        else
+          "#{name}"
+        end
+      end
+
+      def ast(input = Undefined)
+        [type, [name, args_with_names(input)]]
+      end
+      alias_method :to_ast, :ast
+    end
+  end
+end

data/lib/dry/logic/rule_compiler.rb

@@ -1,8 +1,11 @@
+require 'dry/core/constants'
 require 'dry/logic/rule'
 
 module Dry
   module Logic
     class RuleCompiler
+      include Core::Constants
+
       attr_reader :predicates
 
       def initialize(predicates)
@@ -19,42 +22,38 @@ module Dry
       end
 
       def visit_check(node)
-        name, predicate, keys = node
-        Rule::Check.new(visit(predicate), name: name, keys: keys || [name])
+        keys, predicate = node
+        Operations::Check.new(visit(predicate), keys: keys)
       end
 
       def visit_not(node)
-        visit(node).negation
+        Operations::Negation.new(visit(node))
       end
 
       def visit_key(node)
         name, predicate = node
-        Rule::Key.new(visit(predicate), name: name)
+        Operations::Key.new(visit(predicate), name: name)
       end
 
       def visit_attr(node)
         name, predicate = node
-        Rule::Attr.new(visit(predicate), name: name)
-      end
-
-      def visit_val(node)
-        Rule::Value.new(visit(node))
+        Operations::Attr.new(visit(predicate), name: name)
       end
 
       def visit_set(node)
-        Rule::Set.new(call(node))
+        Operations::Set.new(*call(node))
       end
 
       def visit_each(node)
-        Rule::Each.new(visit(node))
+        Operations::Each.new(visit(node))
       end
 
       def visit_predicate(node)
         name, params = node
-        predicate = predicates[name]
+        predicate = Rule::Predicate.new(predicates[name])
 
         if params.size > 1
-          args = params.map(&:last).reject { |val| val == Predicate::Undefined }
+          args = params.map(&:last).reject { |val| val == Undefined }
           predicate.curry(*args)
         else
           predicate
@@ -63,22 +62,22 @@ module Dry
 
       def visit_and(node)
         left, right = node
-        visit(left) & visit(right)
+        visit(left).and(visit(right))
       end
 
       def visit_or(node)
         left, right = node
-        visit(left) | visit(right)
+        visit(left).or(visit(right))
       end
 
       def visit_xor(node)
         left, right = node
-        visit(left) ^ visit(right)
+        visit(left).xor(visit(right))
       end
 
       def visit_implication(node)
         left, right = node
-        visit(left) > visit(right)
+        visit(left).then(visit(right))
       end
     end
   end

data/lib/dry/logic/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Logic
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/spec/integration/result_spec.rb

@@ -0,0 +1,59 @@
+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.new(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.new(array?).and(Rule::Predicate.new(empty?)) }
+      let(:input) { '' }
+      let(:output) { 'array?("") AND empty?("")' }
+
+      it_behaves_like 'string representation'
+    end
+
+    context 'with OR operation' do
+      let(:rule) { Rule::Predicate.new(array?).or(Rule::Predicate.new(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.new(array?).xor(Rule::Predicate.new(empty?)) }
+      let(:input) { [] }
+      let(:output) { 'array?([]) XOR empty?([])' }
+
+      it_behaves_like 'string representation'
+    end
+
+    context 'with THEN operation' do
+      let(:rule) { Rule::Predicate.new(array?).then(Rule::Predicate.new(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.new(array?)) }
+      let(:input) { 'foo' }
+      let(:output) { 'not(array?("foo"))' }
+
+      it_behaves_like 'string representation'
+    end
+  end
+end