dry-logic 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d99c501f48f756fd19ec5f5c3da47041b704e97a
-  data.tar.gz: a8dd4c89cd7674a65b69a6d441091ba73b514bbc
+  metadata.gz: 556cffe1d07e756e85274f2af98b8d97245e4420
+  data.tar.gz: 86695fbdf83593baedb7dd73483c30f41f671280
 SHA512:
-  metadata.gz: 68a19a8f78af8a329e47e8b089fef34fb2b9dbdd686840568b328fe755b65f9fbd7e7d9b6324aa78d68d7bba56c61f5c1a97fa51a9f7d89d39e3cc91e7c64503
-  data.tar.gz: e5b68c7f5599a244f9918c5d2bc67b282983dc1e48cbd2deaaeabf55670dbbe5b05a27b5f5d9ce6655cf0de6f202eab50a08cb323e37e535aa0d80951ac60a31
+  metadata.gz: 05b63d57cfacd055926b256752698078dbca63afcf8bb03aff563cbecff5247e9dc66e999bad29cecc1fc5f37a15a5c6c76525cb1e6654f1c4915777825d5fa3
+  data.tar.gz: f1a65826b7049c3c5b0083b4c72feda8e911915898ff03a4d9acc5b4d6908954d9105edd36f611e535e0e0320b1f906f9ae658659a062b48ee18b564e1ab0abb

data/Gemfile

@@ -3,7 +3,6 @@ source 'https://rubygems.org'
 gemspec
 
 group :tools do
-  gem 'rubocop'
   gem 'guard'
   gem 'guard-rspec'
   gem 'guard-rubocop'

data/README.md

@@ -28,8 +28,12 @@ require 'dry/logic/predicates'
 
 include Dry::Logic
 
-user_present = Rule::Key.new(:user, Predicates[:key?])
-has_min_age = Rule::Key.new(:age, Predicates[:key?]) & Rule::Value.new(:age, Predicates[:gt?].curry(18))
+user_present = Rule::Key.new(Predicates[:key?], name: :user)
+
+has_min_age = Rule::Key.new(
+  Predicates[:key?]) & Rule::Value.new(:age, Predicates[:gt?].curry(18),
+  name: :age
+)
 
 user_rule = user_present & has_min_age
 

data/lib/dry/logic/evaluator.rb

@@ -0,0 +1,46 @@
+module Dry
+  module Logic
+    class Evaluator
+      include Dry::Equalizer(:path)
+
+      attr_reader :path
+
+      class Set
+        include Dry::Equalizer(:evaluators)
+
+        attr_reader :evaluators
+
+        def self.new(paths)
+          super(paths.map { |path| Evaluator::Key.new(path) })
+        end
+
+        def initialize(evaluators)
+          @evaluators = evaluators
+        end
+
+        def call(input)
+          evaluators.map { |evaluator| evaluator[input] }
+        end
+        alias_method :[], :call
+      end
+
+      class Key < Evaluator
+        def call(input)
+          path.reduce(input) { |a, e| a[e] }
+        end
+        alias_method :[], :call
+      end
+
+      class Attr < Evaluator
+        def call(input)
+          path.reduce(input) { |a, e| a.public_send(e) }
+        end
+        alias_method :[], :call
+      end
+
+      def initialize(path)
+        @path = Array(path)
+      end
+    end
+  end
+end

data/lib/dry/logic/predicate.rb

@@ -8,7 +8,7 @@ module Dry
     end
 
     class Predicate
-      include Dry::Equalizer(:id)
+      include Dry::Equalizer(:id, :args)
 
       attr_reader :id, :args, :fn
 
@@ -26,10 +26,10 @@ module Dry
         self.class.new(id, *args, &fn.curry.(*args))
       end
 
-      def to_ary
+      def to_ast
         [:predicate, [id, args]]
       end
-      alias_method :to_a, :to_ary
+      alias_method :to_a, :to_ast
     end
   end
 end

data/lib/dry/logic/result.rb

@@ -1,155 +1,55 @@
 module Dry
   module Logic
-    def self.Result(input, value, rule)
-      case value
-      when Result
-        value.class.new(value.input, value.success?, rule)
-      when Array
-        Result::Set.new(input, value, rule)
-      else
-        Result::Value.new(input, value, rule)
-      end
+    def self.Result(response, rule, input)
+      Result[rule].new(response, rule, input)
     end
 
     class Result
       include Dry::Equalizer(:success?, :input, :rule)
 
-      attr_reader :input, :value, :rule, :name
-
-      class Result::Set < Result
-        def success?
-          value.all?(&:success?)
-        end
-
-        def to_ary
-          indices = value.map { |v| v.failure? ? value.index(v) : nil }.compact
-          [:input, [name, input, value.values_at(*indices).map(&:to_ary)]]
-        end
-      end
-
-      class Result::Value < Result
-        def to_ary
-          [:input, [name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
-      end
-
-      class Result::LazyValue < Result
-        def to_ary
-          [:input, [rule.name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
+      attr_reader :input, :rule, :response, :success
 
-        def input
-          success? ? rule.evaluate_input(@input) : @input
+      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
         end
       end
 
-      class Result::Wrapped < Result::Value
-        def to_ary
-          [:input, [rule.name, rule.evaluate_input(input), [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
-
-        def wrapped?
-          true
-        end
-      end
-
-      class Result::Verified < Result
-        attr_reader :predicate_id
-
-        def initialize(result, predicate_id)
-          @input = result.input
-          @value = result.value
-          @rule = result.rule
-          @name = result.name
-          @predicate_id = predicate_id
-        end
-
-        def call(*)
-          Logic.Result(input, success?, rule)
-        end
-
-        def to_ary
-          [:input, [name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
-
-        def success?
-          rule.predicate_id == predicate_id
-        end
-      end
-
-      def initialize(input, value, rule)
-        @input = input
-        @value = value
+      def initialize(response, rule, input)
+        @response = response
+        @success = response.respond_to?(:success?) ? response.success? : response
         @rule = rule
-        @name = rule.name
+        @input = input
       end
 
-      def call(*)
-        self
+      def [](name)
+        response[name] if response.respond_to?(:[])
       end
 
-      def curry(predicate_id = nil)
-        if predicate_id
-          Result::Verified.new(self, predicate_id)
-        else
-          self
-        end
+      def name
+        nil
       end
 
       def negated
-        self.class.new(input, !value, rule)
-      end
-
-      def then(other)
-        if success?
-          other.(input)
-        else
-          Logic.Result(input, true, rule)
-        end
-      end
-
-      def and(other)
-        if success?
-          other.(input)
-        else
-          self
-        end
-      end
-
-      def or(other)
-        if success?
-          self
-        else
-          other.(input)
-        end
-      end
-
-      def xor(other)
-        other_result = other.(input)
-        value = success? ^ other_result.success?
-
-        if other_result.wrapped?
-          Result::Wrapped.new(input, value, rule)
-        else
-          Logic.Result(other_result.input, value, rule)
-        end
+        self.class.new(!success, rule, input)
       end
 
       def success?
-        @value
+        @success
       end
 
       def failure?
-        ! success?
-      end
-
-      def wrapped?
-        false
+        !success?
       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/result/each.rb

@@ -0,0 +1,10 @@
+module Dry
+  module Logic
+    class Result::Each < Result::Multi
+      def to_ast
+        failed_rules = failures.map { |el| [:el, [success.index(el), el.to_ast]] }
+        [:result, [rule.evaluate(input), [:each, failed_rules]]]
+      end
+    end
+  end
+end

data/lib/dry/logic/result/multi.rb

@@ -0,0 +1,14 @@
+module Dry
+  module Logic
+    class Result::Multi < Result
+      def success?
+        success.all?(&:success?)
+      end
+
+      def failures
+        indices = success.map { |v| v.failure? ? success.index(v) : nil }.compact
+        success.values_at(*indices)
+      end
+    end
+  end
+end

data/lib/dry/logic/result/named.rb

@@ -0,0 +1,17 @@
+module Dry
+  module Logic
+    class Result::Named < Result::Value
+      def name
+        rule.name
+      end
+
+      def to_ast
+        if response.respond_to?(:to_ast) && !response.is_a?(Result)
+          response.to_ast
+        else
+          [:input, [rule.name, super]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Dry
+  module Logic
+    class Result::Set < Result::Multi
+      def to_ast
+        failed_rules = failures.map { |el| el.to_ast }
+        [:result, [rule.evaluate(input), [:set, failed_rules]]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Dry
+  module Logic
+    class Result::Value < Result
+      def to_ast
+        if response.respond_to?(:to_ast)
+          response.to_ast
+        else
+          [:result, [rule.evaluate(input), rule.to_ast]]
+        end
+      end
+    end
+  end
+end

data/lib/dry/logic/rule.rb

@@ -1,31 +1,15 @@
 module Dry
   module Logic
     class Rule
-      include Dry::Equalizer(:name, :predicate)
+      include Dry::Equalizer(:predicate, :options)
 
-      attr_reader :name, :predicate
+      attr_reader :predicate
 
-      class Negation < Rule
-        include Dry::Equalizer(:rule)
+      attr_reader :options
 
-        attr_reader :rule
-
-        def initialize(rule)
-          @rule = rule
-        end
-
-        def call(*args)
-          rule.(*args).negated
-        end
-
-        def to_ary
-          [:not, rule.to_ary]
-        end
-      end
-
-      def initialize(name, predicate)
-        @name = name
+      def initialize(predicate, options = {})
         @predicate = predicate
+        @options = options
       end
 
       def predicate_id
@@ -33,18 +17,9 @@ module Dry
       end
 
       def type
-        :rule
-      end
-
-      def call(*args)
-        Logic.Result(args, predicate.call, self)
+        raise NotImplementedError
       end
 
-      def to_ary
-        [type, [name, predicate.to_ary]]
-      end
-      alias_method :to_a, :to_ary
-
       def and(other)
         Conjunction.new(self, other)
       end
@@ -70,24 +45,27 @@ module Dry
       end
 
       def new(predicate)
-        self.class.new(name, predicate)
+        self.class.new(predicate, options)
       end
 
       def curry(*args)
-        self.class.new(name, predicate.curry(*args))
+        self.class.new(predicate.curry(*args), options)
+      end
+
+      def each?
+        predicate.is_a?(Rule::Each)
       end
     end
   end
 end
 
+require 'dry/logic/rule/value'
 require 'dry/logic/rule/key'
 require 'dry/logic/rule/attr'
-require 'dry/logic/rule/value'
 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/rule/result'
-require 'dry/logic/rule/group'
 
 require 'dry/logic/result'