dry-logic 0.5.0 → 1.5.0

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

@@ -1,6 +1,4 @@
-require 'dry/logic/operations/unary'
-require 'dry/logic/evaluator'
-require 'dry/logic/result'
+# frozen_string_literal: true
 
 module Dry
   module Logic
@@ -10,13 +8,13 @@ module Dry
 
         attr_reader :path
 
-        def self.new(rules, options)
+        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))
+            super(rules, **options, evaluator: eval, path: name)
           end
         end
 

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

@@ -1,5 +1,4 @@
-require 'dry/logic/operations/unary'
-require 'dry/logic/result'
+# frozen_string_literal: true
 
 module Dry
   module Logic

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

@@ -1,5 +1,4 @@
-require 'dry/logic/operations/binary'
-require 'dry/logic/result'
+# frozen_string_literal: true
 
 module Dry
   module Logic

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

@@ -1,5 +1,4 @@
-require 'dry/logic/operations/abstract'
-require 'dry/logic/result'
+# frozen_string_literal: true
 
 module Dry
   module Logic
@@ -14,7 +13,7 @@ module Dry
           success = results.all?(&:success?)
 
           Result.new(success, id) do
-            [type, results.select(&:failure?).map { |failure| failure.to_ast }]
+            [type, results.select(&:failure?).map(&:to_ast)]
           end
         end
 
@@ -27,7 +26,7 @@ module Dry
         end
 
         def to_s
-          "#{type}(#{rules.map(&:to_s).join(', ')})"
+          "#{type}(#{rules.map(&:to_s).join(", ")})"
         end
       end
     end

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

@@ -1,4 +1,4 @@
-require 'dry/logic/operations/abstract'
+# frozen_string_literal: true
 
 module Dry
   module Logic

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

@@ -1,5 +1,4 @@
-require 'dry/logic/operations/binary'
-require 'dry/logic/result'
+# frozen_string_literal: true
 
 module Dry
   module Logic

data/lib/dry/logic/operators.rb

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

data/lib/dry/logic/predicates.rb

@@ -1,17 +1,40 @@
-require 'bigdecimal'
-require 'bigdecimal/util'
-require 'date'
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+require "bigdecimal"
+require "bigdecimal/util"
+require "date"
 
 module Dry
   module Logic
     module Predicates
+      include Dry::Core::Constants
+
+      # rubocop:disable Metrics/ModuleLength
       module Methods
+        def self.uuid_format(version)
+          ::Regexp.new(<<~FORMAT.chomp, ::Regexp::IGNORECASE)
+            \\A[0-9A-F]{8}-[0-9A-F]{4}-#{version}[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}\\z
+          FORMAT
+        end
+
+        UUIDv1 = uuid_format(1)
+
+        UUIDv2 = uuid_format(2)
+
+        UUIDv3 = uuid_format(3)
+
+        UUIDv4 = uuid_format(4)
+
+        UUIDv5 = uuid_format(5)
+
         def [](name)
           method(name)
         end
 
         def type?(type, input)
-          input.kind_of?(type)
+          input.is_a?(type)
         end
 
         def nil?(input)
@@ -57,11 +80,9 @@ module Dry
         end
 
         def number?(input)
-          begin
-            true if Float(input)
-          rescue ArgumentError, TypeError
-            false
-          end
+          true if Float(input)
+        rescue ArgumentError, TypeError
+          false
         end
 
         def int?(input)
@@ -114,7 +135,7 @@ module Dry
 
         def size?(size, input)
           case size
-          when Integer then size == input.size
+          when Integer then size.equal?(input.size)
           when Range, Array then size.include?(input.size)
           else
             raise ArgumentError, "+#{size}+ is not supported type for size? predicate."
@@ -129,13 +150,30 @@ module Dry
           input.size <= num
         end
 
+        def bytesize?(size, input)
+          case size
+          when Integer then size.equal?(input.bytesize)
+          when Range, Array then size.include?(input.bytesize)
+          else
+            raise ArgumentError, "+#{size}+ is not supported type for bytesize? predicate."
+          end
+        end
+
+        def min_bytesize?(num, input)
+          input.bytesize >= num
+        end
+
+        def max_bytesize?(num, input)
+          input.bytesize <= num
+        end
+
         def inclusion?(list, input)
-          ::Kernel.warn 'inclusion is deprecated - use included_in instead.'
+          deprecated(:inclusion?, :included_in?)
           included_in?(list, input)
         end
 
         def exclusion?(list, input)
-          ::Kernel.warn 'exclusion is deprecated - use excluded_from instead.'
+          deprecated(:exclusion?, :excluded_from?)
           excluded_from?(list, input)
         end
 
@@ -148,22 +186,23 @@ module Dry
         end
 
         def includes?(value, input)
-          begin
-            if input.respond_to?(:include?)
-              input.include?(value)
-            else
-              false
-            end
-          rescue TypeError
+          if input.respond_to?(:include?)
+            input.include?(value)
+          else
             false
           end
+        rescue TypeError
+          false
         end
 
         def excludes?(value, input)
           !includes?(value, input)
         end
 
-        def eql?(left, right)
+        # This overrides Object#eql? so we need to make it compatible
+        def eql?(left, right = Undefined)
+          return super(left) if right.equal?(Undefined)
+
           left.eql?(right)
         end
 
@@ -183,23 +222,65 @@ module Dry
           value.equal?(false)
         end
 
-        if RUBY_VERSION < '2.4'
-          def format?(regex, input)
-            !regex.match(input).nil?
-          end
-        else
-          def format?(regex, input)
-            regex.match?(input)
-          end
+        def format?(regex, input)
+          !input.nil? && regex.match?(input)
         end
 
         def case?(pattern, input)
+          # rubocop:disable Style/CaseEquality
           pattern === input
+          # rubocop:enable Style/CaseEquality
+        end
+
+        def uuid_v1?(input)
+          format?(UUIDv1, input)
+        end
+
+        def uuid_v2?(input)
+          format?(UUIDv2, input)
+        end
+
+        def uuid_v3?(input)
+          format?(UUIDv3, input)
+        end
+
+        def uuid_v4?(input)
+          format?(UUIDv4, input)
+        end
+
+        def uuid_v5?(input)
+          format?(UUIDv5, input)
+        end
+
+        def uri?(schemes, input)
+          uri_format = URI::DEFAULT_PARSER.make_regexp(schemes)
+          format?(uri_format, input)
+        end
+
+        def uri_rfc3986?(input)
+          format?(URI::RFC3986_Parser::RFC3986_URI, input)
+        end
+
+        # This overrides Object#respond_to? so we need to make it compatible
+        def respond_to?(method, input = Undefined)
+          return super if input.equal?(Undefined)
+
+          input.respond_to?(method)
         end
 
         def predicate(name, &block)
           define_singleton_method(name, &block)
         end
+
+        def deprecated(name, in_favor_of)
+          Core::Deprecations.warn(
+            "#{name} predicate is deprecated and will " \
+            "be removed in the next major version\n" \
+            "Please use #{in_favor_of} predicate instead",
+            tag: "dry-logic",
+            uplevel: 3
+          )
+        end
       end
 
       extend Methods
@@ -209,5 +290,6 @@ module Dry
         other.extend(Methods)
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/dry/logic/result.rb

@@ -1,10 +1,8 @@
-require 'dry/core/constants'
+# frozen_string_literal: true
 
 module Dry
   module Logic
     class Result
-      include Core::Constants
-
       SUCCESS = Class.new {
         def success?
           true
@@ -67,7 +65,7 @@ module Dry
         if args.empty?
           name.to_s
         else
-          "#{name}(#{args.map(&:last).map(&:inspect).join(', ')})"
+          "#{name}(#{args.map(&:last).map(&:inspect).join(", ")})"
         end
       end
 

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Dry
+  module Logic
+    class Rule
+      class Interface < ::Module
+        SPLAT = ["*rest"].freeze
+
+        attr_reader :arity
+
+        attr_reader :curried
+
+        def initialize(arity, curried)
+          super()
+
+          @arity = arity
+          @curried = curried
+
+          if !variable_arity? && curried > arity
+            raise ArgumentError, "wrong number of arguments (#{curried} for #{arity})"
+          end
+
+          define_constructor if curried?
+
+          if constant?
+            define_constant_application
+          else
+            define_application
+          end
+        end
+
+        def constant?
+          arity.zero?
+        end
+
+        def variable_arity?
+          arity.negative?
+        end
+
+        def curried?
+          !curried.zero?
+        end
+
+        def unapplied
+          if variable_arity?
+            unapplied = arity.abs - 1 - curried
+
+            if unapplied.negative?
+              0
+            else
+              unapplied
+            end
+          else
+            arity - curried
+          end
+        end
+
+        def name
+          if constant?
+            "Constant"
+          else
+            arity_str =
+              if variable_arity?
+                "Variable#{arity.abs - 1}Arity"
+              else
+                "#{arity}Arity"
+              end
+
+            curried_str =
+              if curried?
+                "#{curried}Curried"
+              else
+                EMPTY_STRING
+              end
+
+            "#{arity_str}#{curried_str}"
+          end
+        end
+
+        def define_constructor
+          assignment =
+            if curried.equal?(1)
+              "@arg0 = @args[0]"
+            else
+              "#{curried_args.join(", ")} = @args"
+            end
+
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def initialize(*)  # def initialize(*)
+              super            #   super
+                               #
+              #{assignment}    #   @arg0 = @args[0]
+            end                # end
+          RUBY
+        end
+
+        def define_constant_application
+          module_exec do
+            def call(*)
+              if @predicate[]
+                Result::SUCCESS
+              else
+                Result.new(false, id) { ast }
+              end
+            end
+
+            def [](*)
+              @predicate[]
+            end
+          end
+        end
+
+        def define_application
+          splat = variable_arity? ? SPLAT : EMPTY_ARRAY
+          parameters = (unapplied_args + splat).join(", ")
+          application = "@predicate[#{(curried_args + unapplied_args + splat).join(", ")}]"
+
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def call(#{parameters})                                         # def call(input0, input1, *rest)
+              if #{application}                                             #   if @predicate[@arg0, @arg1, input0, input1, *rest]
+                Result::SUCCESS                               #     ::Dry::Logic::Result::Success
+              else                                                          #   else
+                Result.new(false, id) { ast(#{parameters}) }  #     ::Dry::Logic::Result.new(false, id) { ast(input0, input1, *rest) }
+              end                                                           #   end
+            end                                                             # end
+                                                                            #
+            def [](#{parameters})                                           # def [](@arg0, @arg1, input0, input1, *rest)
+              #{application}                                                #   @predicate[@arg0, @arg1, input0, input1, *rest]
+            end                                                             # end
+          RUBY
+        end
+
+        def curried_args
+          @curried_args ||= ::Array.new(curried) { |i| "@arg#{i}" }
+        end
+
+        def unapplied_args
+          @unapplied_args ||= ::Array.new(unapplied) { |i| "input#{i}" }
+        end
+      end
+    end
+  end
+end

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

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

data/lib/dry/logic/rule.rb

@@ -1,15 +1,14 @@
-require 'dry/core/constants'
-require 'dry/equalizer'
-require 'dry/logic/operations'
-require 'dry/logic/result'
+# frozen_string_literal: true
+
+require "concurrent/map"
 
 module Dry
   module Logic
     def self.Rule(*args, **options, &block)
       if args.any?
-        Rule.new(*args, Rule::DEFAULT_OPTIONS.merge(options))
+        Rule.build(*args, **options)
       elsif block
-        Rule.new(block, Rule::DEFAULT_OPTIONS.merge(options))
+        Rule.build(block, **options)
       end
     end
 
@@ -18,8 +17,6 @@ module Dry
       include Dry::Equalizer(:predicate, :options)
       include Operators
 
-      DEFAULT_OPTIONS = { args: [].freeze }.freeze
-
       attr_reader :predicate
 
       attr_reader :options
@@ -28,10 +25,27 @@ module Dry
 
       attr_reader :arity
 
-      def initialize(predicate, options = DEFAULT_OPTIONS)
+      def self.interfaces
+        @interfaces ||= ::Concurrent::Map.new
+      end
+
+      def self.specialize(arity, curried, base = Rule)
+        base.interfaces.fetch_or_store([arity, curried]) do
+          interface = Interface.new(arity, curried)
+          klass = Class.new(base) { include interface }
+          base.const_set("#{base.name.split("::").last}#{interface.name}", klass)
+          klass
+        end
+      end
+
+      def self.build(predicate, args: EMPTY_ARRAY, arity: predicate.arity, **options)
+        specialize(arity, args.size).new(predicate, {args: args, arity: arity, **options})
+      end
+
+      def initialize(predicate, options = EMPTY_HASH)
         @predicate = predicate
         @options = options
-        @args = options[:args]
+        @args = options[:args] || EMPTY_ARRAY
         @arity = options[:arity] || predicate.arity
       end
 
@@ -43,41 +57,27 @@ module Dry
         options[:id]
       end
 
-      def call(*input)
-        Result.new(self[*input], id) { ast(*input) }
-      end
-
-      def [](*input)
-        arity == 0 ? predicate.() : predicate[*args, *input]
-      end
-
       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
+        with(args: args + new_args)
       end
 
       def bind(object)
-        if UnboundMethod === predicate
-          self.class.new(predicate.bind(object), options)
+        if predicate.respond_to?(:bind)
+          self.class.build(predicate.bind(object), **options)
         else
-          self.class.new(
+          self.class.build(
             -> *args { object.instance_exec(*args, &predicate) },
-            options.merge(arity: arity, parameters: parameters)
+            **options, arity: arity, parameters: parameters
           )
         end
       end
 
       def eval_args(object)
-        with(args: args.map { |arg| UnboundMethod === arg ? arg.bind(object).() : arg })
+        with(args: args.map { |arg| arg.is_a?(UnboundMethod) ? arg.bind(object).() : arg })
       end
 
       def with(new_opts)
-        self.class.new(predicate, options.merge(new_opts))
+        self.class.build(predicate, **options, **new_opts)
       end
 
       def parameters

data/lib/dry/logic/rule_compiler.rb

@@ -1,13 +1,8 @@
-require 'dry/core/constants'
-
-require 'dry/logic/rule'
-require 'dry/logic/rule/predicate'
+# frozen_string_literal: true
 
 module Dry
   module Logic
     class RuleCompiler
-      include Core::Constants
-
       attr_reader :predicates
 
       def initialize(predicates)
@@ -52,7 +47,7 @@ module Dry
 
       def visit_predicate(node)
         name, params = node
-        predicate = Rule::Predicate.new(predicates[name])
+        predicate = Rule::Predicate.build(predicates[name])
 
         if params.size > 1
           args = params.map(&:last).reject { |val| val == Undefined }

data/lib/dry/logic/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Dry
   module Logic
-    VERSION = '0.5.0'.freeze
+    VERSION = "1.5.0"
   end
 end