dry-logic 0.3.0 → 0.4.0

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

@@ -0,0 +1,18 @@
+require 'dry/logic/operations/unary'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Negation < Unary
+        def type
+          :not
+        end
+
+        def call(input)
+          Result.new(!rule[input], id) { ast(input) }
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,35 @@
+require 'dry/logic/operations/abstract'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Set < Abstract
+        def type
+          :set
+        end
+
+        def call(input)
+          results = rules.map { |rule| rule.(input) }
+          success = results.all?(&:success?)
+
+          Result.new(success, id) do
+            [type, results.select(&:failure?).map { |failure| failure.to_ast }]
+          end
+        end
+
+        def [](input)
+          rules.map { |rule| rule[input] }.all?
+        end
+
+        def ast(input = Undefined)
+          [type, rules.map { |rule| rule.ast(input) }]
+        end
+
+        def to_s
+          "#{type}(#{rules.map(&:to_s).join(', ')})"
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+require 'dry/logic/operations/binary'
+require 'dry/logic/result'
+
+module Dry
+  module Logic
+    module Operations
+      class Xor < Binary
+        def type
+          :xor
+        end
+        alias_method :operator, :type
+
+        def call(input)
+          Result.new(self[input], id) { ast(input) }
+        end
+
+        def [](input)
+          left[input] ^ right[input]
+        end
+
+        def ast(input = Undefined)
+          [type, rules.map { |rule| rule.ast(input) }]
+        end
+      end
+    end
+  end
+end

data/lib/dry/logic/operators.rb

@@ -0,0 +1,25 @@
+module Dry
+  module Logic
+    module Operators
+      def and(other)
+        Operations::And.new(self, other)
+      end
+      alias & and
+
+      def or(other)
+        Operations::Or.new(self, other)
+      end
+      alias | or
+
+      def xor(other)
+        Operations::Xor.new(self, other)
+      end
+      alias ^ xor
+
+      def then(other)
+        Operations::Implication.new(self, other)
+      end
+      alias > then
+    end
+  end
+end

data/lib/dry/logic/predicates.rb

@@ -2,189 +2,196 @@ require 'bigdecimal'
 require 'bigdecimal/util'
 require 'date'
 
-require 'dry/logic/predicate_set'
-
 module Dry
   module Logic
     module Predicates
-      extend Logic::PredicateSet
-
-      def self.included(other)
-        super
-        other.extend(Logic::PredicateSet)
-        other.import(self)
-      end
+      module Methods
+        def [](name)
+          method(name)
+        end
 
-      predicate(:type?) do |type, input|
-        input.kind_of?(type)
-      end
+        def type?(type, input)
+          input.kind_of?(type)
+        end
 
-      predicate(:none?) do |input|
-        input.nil?
-      end
+        def none?(input)
+          input.nil?
+        end
 
-      predicate(:key?) do |name, input|
-        input.key?(name)
-      end
+        def key?(name, input)
+          input.key?(name)
+        end
 
-      predicate(:attr?) do |name, input|
-        input.respond_to?(name)
-      end
+        def attr?(name, input)
+          input.respond_to?(name)
+        end
 
-      predicate(:empty?) do |input|
-        case input
-        when String, Array, Hash then input.empty?
-        when nil then true
-        else
-          false
+        def empty?(input)
+          case input
+          when String, Array, Hash then input.empty?
+          when nil then true
+          else
+            false
+          end
         end
-      end
 
-      predicate(:filled?) do |input|
-        !self[:empty?].(input)
-      end
+        def filled?(input)
+          !self[:empty?].(input)
+        end
 
-      predicate(:bool?) do |input|
-        input.is_a?(TrueClass) || input.is_a?(FalseClass)
-      end
+        def bool?(input)
+          input.is_a?(TrueClass) || input.is_a?(FalseClass)
+        end
 
-      predicate(:date?) do |input|
-        input.is_a?(Date)
-      end
+        def date?(input)
+          input.is_a?(Date)
+        end
 
-      predicate(:date_time?) do |input|
-        input.is_a?(DateTime)
-      end
+        def date_time?(input)
+          input.is_a?(DateTime)
+        end
 
-      predicate(:time?) do |input|
-        input.is_a?(Time)
-      end
+        def time?(input)
+          input.is_a?(Time)
+        end
 
-      predicate(:number?) do |input|
-        begin
-          true if Float(input)
-        rescue ArgumentError, TypeError
-          false
+        def number?(input)
+          begin
+            true if Float(input)
+          rescue ArgumentError, TypeError
+            false
+          end
         end
-      end
 
-      predicate(:int?) do |input|
-        input.is_a?(Fixnum)
-      end
+        def int?(input)
+          input.is_a?(Fixnum)
+        end
 
-      predicate(:float?) do |input|
-        input.is_a?(Float)
-      end
+        def float?(input)
+          input.is_a?(Float)
+        end
 
-      predicate(:decimal?) do |input|
-        input.is_a?(BigDecimal)
-      end
+        def decimal?(input)
+          input.is_a?(BigDecimal)
+        end
 
-      predicate(:str?) do |input|
-        input.is_a?(String)
-      end
+        def str?(input)
+          input.is_a?(String)
+        end
 
-      predicate(:hash?) do |input|
-        input.is_a?(Hash)
-      end
+        def hash?(input)
+          input.is_a?(Hash)
+        end
 
-      predicate(:array?) do |input|
-        input.is_a?(Array)
-      end
+        def array?(input)
+          input.is_a?(Array)
+        end
 
-      predicate(:odd?) do |input|
-        input.odd?
-      end
+        def odd?(input)
+          input.odd?
+        end
 
-      predicate(:even?) do |input|
-        input.even?
-      end
+        def even?(input)
+          input.even?
+        end
 
-      predicate(:lt?) do |num, input|
-        input < num
-      end
+        def lt?(num, input)
+          input < num
+        end
 
-      predicate(:gt?) do |num, input|
-        input > num
-      end
+        def gt?(num, input)
+          input > num
+        end
 
-      predicate(:lteq?) do |num, input|
-        !self[:gt?].(num, input)
-      end
+        def lteq?(num, input)
+          !self[:gt?].(num, input)
+        end
 
-      predicate(:gteq?) do |num, input|
-        !self[:lt?].(num, input)
-      end
+        def gteq?(num, input)
+          !self[:lt?].(num, input)
+        end
 
-      predicate(:size?) do |size, input|
-        case size
-        when Fixnum then size == input.size
-        when Range, Array then size.include?(input.size)
-        else
-          raise ArgumentError, "+#{size}+ is not supported type for size? predicate"
+        def size?(size, input)
+          case size
+          when Fixnum then size == input.size
+          when Range, Array then size.include?(input.size)
+          else
+            raise ArgumentError, "+#{size}+ is not supported type for size? predicate."
+          end
         end
-      end
 
-      predicate(:min_size?) do |num, input|
-        input.size >= num
-      end
+        def min_size?(num, input)
+          input.size >= num
+        end
 
-      predicate(:max_size?) do |num, input|
-        input.size <= num
-      end
+        def max_size?(num, input)
+          input.size <= num
+        end
 
-      predicate(:inclusion?) do |list, input|
-        ::Kernel.warn 'inclusion is deprecated - use included_in instead.'
-        self[:included_in?].(list, input)
-      end
+        def inclusion?(list, input)
+          ::Kernel.warn 'inclusion is deprecated - use included_in instead.'
+          self[:included_in?].(list, input)
+        end
 
-      predicate(:exclusion?) do |list, input|
-        ::Kernel.warn 'exclusion is deprecated - use excluded_from instead.'
-        self[:excluded_from?].(list, input)
-      end
+        def exclusion?(list, input)
+          ::Kernel.warn 'exclusion is deprecated - use excluded_from instead.'
+          self[:excluded_from?].(list, input)
+        end
 
-      predicate(:included_in?) do |list, input|
-        list.include?(input)
-      end
+        def included_in?(list, input)
+          list.include?(input)
+        end
 
-      predicate(:excluded_from?) do |list, input|
-        !list.include?(input)
-      end
+        def excluded_from?(list, input)
+          !list.include?(input)
+        end
 
-      predicate(:includes?) do |value, input|
-        begin
-          if input.respond_to?(:include?)
-            input.include?(value)
-          else
+        def includes?(value, input)
+          begin
+            if input.respond_to?(:include?)
+              input.include?(value)
+            else
+              false
+            end
+          rescue TypeError
             false
           end
-        rescue TypeError
-          false
         end
-      end
 
-      predicate(:excludes?) do |value, input|
-        !self[:includes?].(value, input)
-      end
+        def excludes?(value, input)
+          !self[:includes?].(value, input)
+        end
 
-      predicate(:eql?) do |left, right|
-        left.eql?(right)
-      end
+        def eql?(left, right)
+          left.eql?(right)
+        end
 
-      predicate(:not_eql?) do |left, right|
-        !left.eql?(right)
-      end
+        def not_eql?(left, right)
+          !left.eql?(right)
+        end
 
-      predicate(:true?) do |value|
-        value === true
-      end
+        def true?(value)
+          value.equal?(true)
+        end
 
-      predicate(:false?) do |value|
-        value === false
+        def false?(value)
+          value.equal?(false)
+        end
+
+        def format?(regex, input)
+          !regex.match(input).nil?
+        end
+
+        def predicate(name, &block)
+          define_singleton_method(name, &block)
+        end
       end
 
-      predicate(:format?) do |regex, input|
-        !regex.match(input).nil?
+      extend Methods
+
+      def self.included(other)
+        super
+        other.extend(Methods)
       end
     end
   end