dry-logic 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a6ff887f61b513496991a96d7903685886ab29dae71cb4f75185cd7866fd4b2
-  data.tar.gz: 9e063f346341b395ac21645f84319e619af19151e62bd97413badf246440d353
+  metadata.gz: cc0793c95681757b6d069c1d7c6bc59278457069edac35f329845dc283e69c22
+  data.tar.gz: e46cd2a8f4e03c78778f35e51a3c616a2dc32881eb703aa6b441da1d34603733
 SHA512:
-  metadata.gz: f643a0238e3b67c91c83af1e90cb4398279b4c01957ce663a5186ae8437a87e94c9d9cb2f7a2aabca1c7edb47be28a531317a044e58e270ffff59c44e6a9ccf5
-  data.tar.gz: 17b0ff20fc5c41258a537ad0c57e959cd3359765801261157772a62ee5d1ce525c15bca2ce92c8ee624b1fda67a5cf6cbf4228af552cf99efc8e8428026dbccb
+  metadata.gz: 732504942a364347befcdc7bee439777a0fd60b470b288cd793d9a21835ff13cc5399b2b6fd514ca0d586708fe044acd664dc2403b6a6a821851b4183533f494
+  data.tar.gz: 811ba73afd3bc3f0bb13511ca69fa6af54a24638a7dc02cbc867df7529a276ed7b559c4cae7863b8b21a529b2095f8bbfc33eb027ea6f80e1d29076656cf13de

data/.codeclimate.yml

@@ -1,23 +1,15 @@
-engines:
+version: "2"
+
+prepare:
+  fetch:
+  - url: "https://raw.githubusercontent.com/dry-rb/devtools/master/.rubocop.yml"
+    path: ".rubocop.yml"
+
+exclude_patterns:
+  - "benchmarks/"
+  - "examples/"
+  - "spec/"
+
+plugins:
   rubocop:
     enabled: true
-    checks:
-      Rubocop/Metrics/LineLength:
-        enabled: true
-        max: 100
-      Rubocop/Style/Documentation:
-        enabled: false
-      Rubocop/Lint/HandleExceptions:
-        enabled: true
-        exclude:
-          - rakelib/*.rake
-      Rubocop/Style/FileName:
-        enabled: true
-        exclude:
-          - 'lib/dry-logic.rb'
-ratings:
-  paths:
-    - lib/**/*.rb
-  exclude_paths:
-    - spec/**/*
-    - examples/**/*

data/.gitignore

@@ -3,5 +3,7 @@ coverage
 /.bundle
 vendor/bundle
 tmp/
+pkg/
 .idea/
 Gemfile.lock
+.rubocop.yml

data/.travis.yml

@@ -1,8 +1,6 @@
 language: ruby
 cache: bundler
-sudo: false
 bundler_args: --without benchmarks tools
-before_install: gem update --system
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
   - chmod +x ./cc-test-reporter
@@ -12,19 +10,22 @@ after_script:
 script:
   - bundle exec rake
 rvm:
-  - 2.6.0
-  - 2.5.3
-  - 2.4.5
-  - 2.3.8
-  - jruby-9.2.5.0
+  - 2.6.3
+  - 2.5.5
+  - 2.4.6
+  - jruby-9.2.7.0
+  - truffleruby
 env:
   global:
     - COVERAGE=true
+matrix:
+  allow_failures:
+    - rvm: truffleruby
 notifications:
   email: false
   webhooks:
     urls:
-      - https://webhooks.gitter.im/e/19098b4253a72c9796db
+      - https://dry-rb.zulipchat.com/api/v1/external/travis?api_key=SY8LLz6fShd4TJeLDXEdT0eBEgRqT2lv&stream=notifications&topic=ci
     on_success: change # options: [always|never|change] default: always
     on_failure: always # options: [always|never|change] default: always
     on_start: false # default: false

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+# v1.0.0 2019-04-23
+
+Version bump to 1.0.0
+
+[Compare v0.6.1...v1.0.0](https://github.com/dry-rb/dry-logic/compare/v0.6.1...v1.0.0)
+
+# v0.6.1 2019-04-18
+
+* Fix a regression in dry-validation 0.x for argument-less predicates (flash-gordon)
+
+[Compare v0.6.0...v0.6.1](https://github.com/dry-rb/dry-logic/compare/v0.6.0...v0.6.1)
+
+# v0.6.0 2019-04-04
+
+### Added
+
+* Generating hints can be disabled by building `Operations::And` with `hints: false` option set (solnic)
+
+### Changed
+
+* `Rule` construction has been optimized so that currying and application is multiple-times faster (flash-gordon)
+
+[Compare v0.5.0...v0.6.0](https://github.com/dry-rb/dry-logic/compare/v0.5.0...v0.6.0)
+
 # v0.5.0 2019-01-29
 
 ### Added

data/Gemfile

@@ -7,11 +7,7 @@ group :test do
 end
 
 group :tools do
-  gem 'rubocop'
-  gem 'byebug', platform: :mri
-
-  unless ENV['TRAVIS']
-    gem 'mutant', github: 'mbj/mutant'
-    gem 'mutant-rspec', github: 'mbj/mutant'
-  end
+  gem 'pry-byebug', platform: :mri
+  gem 'benchmark-ips', platform: :mri
+  gem 'hotch', platform: :mri
 end

data/README.md

@@ -1,10 +1,10 @@
 [gem]: https://rubygems.org/gems/dry-logic
 [travis]: https://travis-ci.org/dry-rb/dry-logic
 [codeclimate]: https://codeclimate.com/github/dry-rb/dry-logic
-[coveralls]: https://coveralls.io/r/dry-rb/dry-logic
+[chat]: https://dry-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-logic
 
-# dry-logic [![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dry-rb/chat)
+# dry-logic [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/dry-logic.svg)][gem]
 [![Build Status](https://travis-ci.org/dry-rb/dry-logic.svg?branch=master)][travis]
@@ -15,7 +15,7 @@
 Predicate logic and rule composition used by:
 
 * [dry-types](https://github.com/dry-rb/dry-types) for constrained types
-* [dry-validation](https://github.com/dry-rb/dry-validation) for composing validation rules
+* [dry-schema](https://github.com/dry-rb/dry-schema) and [dry-validation](https://github.com/dry-rb/dry-validation) for composing validation rules
 * your project...?
 
 ## Links

data/benchmarks/rule_application.rb

@@ -0,0 +1,28 @@
+require_relative 'setup'
+
+unless Dry::Logic::Rule.respond_to?(:build)
+  Dry::Logic::Rule.singleton_class.alias_method(:build, :new)
+end
+
+predicates = Dry::Logic::Predicates
+
+type_check = Dry::Logic::Rule.build(predicates[:type?]).curry(Integer)
+int_check = Dry::Logic::Rule.build(predicates[:int?])
+key_check = Dry::Logic::Rule.build(predicates[:key?]).curry(:user)
+with_user = { user: {} }
+without_user = {}
+
+comparison = Dry::Logic::Rule.build(predicates[:gteq?]).curry(18)
+
+Benchmark.ips do |x|
+  x.report("type check - success") { type_check.(0) }
+  x.report("type check - failure") { type_check.('0') }
+  x.report("int check - success") { int_check.(0) }
+  x.report("int check - failure") { int_check.('0') }
+  x.report("key check - success") { key_check.(with_user) }
+  x.report("key check - failure") { key_check.(without_user) }
+  x.report("comparison - success") { comparison.(20) }
+  x.report("comparison - failure") { comparison.(17) }
+
+  x.compare!
+end

data/benchmarks/setup.rb

@@ -0,0 +1,11 @@
+require 'benchmark/ips'
+require 'hotch'
+ENV['HOTCH_VIEWER'] ||= 'open'
+
+require 'dry/logic'
+require 'dry/logic/predicates'
+
+def profile(&block)
+  Hotch(filter: 'Dry', &block)
+end
+

data/dry-logic.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_runtime_dependency 'dry-core', '~> 0.2'
-  spec.add_runtime_dependency 'dry-container', '~> 0.2', '>= 0.2.6'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
 
   spec.add_development_dependency 'bundler'

data/examples/basic.rb

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

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

@@ -5,10 +5,17 @@ module Dry
   module Logic
     module Operations
       class And < Binary
+        attr_reader :hints
+
+        def initialize(*)
+          super
+          @hints = options.fetch(:hints, true)
+        end
+
         def type
           :and
         end
-        alias_method :operator, :type
+        alias operator type
 
         def call(input)
           left_result = left.(input)
@@ -22,7 +29,10 @@ module Dry
               Result.new(false, id) { right_result.ast(input) }
             end
           else
-            Result.new(false, id) { [type, [left_result.to_ast, [:hint, right.ast(input)]]] }
+            Result.new(false, id) do
+              left_ast = left_result.to_ast
+              hints ? [type, [left_ast, [:hint, right.ast(input)]]] : left_ast
+            end
           end
         end
 

data/lib/dry/logic/rule.rb

@@ -1,15 +1,17 @@
+require 'concurrent/map'
 require 'dry/core/constants'
 require 'dry/equalizer'
 require 'dry/logic/operations'
 require 'dry/logic/result'
+require 'dry/logic/rule/interface'
 
 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 +20,6 @@ module Dry
       include Dry::Equalizer(:predicate, :options)
       include Operators
 
-      DEFAULT_OPTIONS = { args: [].freeze }.freeze
-
       attr_reader :predicate
 
       attr_reader :options
@@ -28,10 +28,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,29 +60,15 @@ 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)
           )
@@ -77,7 +80,7 @@ module Dry
       end
 
       def with(new_opts)
-        self.class.new(predicate, options.merge(new_opts))
+        self.class.build(predicate, options.merge(new_opts))
       end
 
       def parameters

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

@@ -0,0 +1,144 @@
+module Dry
+  module Logic
+    class Rule
+      class Interface < ::Module
+        attr_reader :arity
+
+        attr_reader :curried
+
+        def initialize(arity, curried)
+          @arity = arity
+          @curried = curried
+
+          if !variable_arity? && curried > arity
+            raise ArgumentError, "wrong number of arguments (#{curried} for #{arity})"
+          end
+
+          define_constructor if curried?
+
+          if variable_arity?
+            define_splat_application
+          elsif constant?
+            define_constant_application
+          else
+            define_fixed_application
+          end
+        end
+
+        def constant?
+          arity.zero?
+        end
+
+        def variable_arity?
+          arity.equal?(-1)
+        end
+
+        def curried?
+          !curried.zero?
+        end
+
+        def unapplied
+          if variable_arity?
+            -1
+          else
+            arity - curried
+          end
+        end
+
+        def name
+          if constant?
+            'Constant'
+          else
+            arity_str = variable_arity? ? 'VariableArity' : "#{arity}Arity"
+            curried_str = curried? ? "#{curried}Curried" : EMPTY_STRING
+
+            "#{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(*)
+              super
+
+              #{assignment}
+            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_splat_application
+          application =
+            if curried?
+              "@predicate[#{curried_args.join(', ')}, *input]"
+            else
+              '@predicate[*input]'
+            end
+
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def call(*input)
+              if #{application}
+                Result::SUCCESS
+              else
+                Result.new(false, id) { ast(*input) }
+              end
+            end
+
+            def [](*input)
+              #{application}
+            end
+          RUBY
+        end
+
+        def define_fixed_application
+          parameters = unapplied_args.join(', ')
+          application = "@predicate[#{ (curried_args + unapplied_args).join(', ') }]"
+
+          module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def call(#{parameters})
+              if #{application}
+                Result::SUCCESS
+              else
+                Result.new(false, id) { ast(#{parameters}) }
+              end
+            end
+
+            def [](#{parameters})
+              #{application}
+            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

@@ -3,6 +3,10 @@ require 'dry/logic/rule'
 module Dry
   module Logic
     class Rule::Predicate < Rule
+      def self.specialize(arity, curried, base = Predicate)
+        super
+      end
+
       def type
         :predicate
       end

data/lib/dry/logic/rule_compiler.rb

@@ -52,7 +52,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,5 @@
 module Dry
   module Logic
-    VERSION = '0.5.0'.freeze
+    VERSION = '1.0.0'.freeze
   end
 end

data/spec/integration/result_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Result do
     end
 
     context 'with a predicate' do
-      let(:rule) { Rule::Predicate.new(gt?, args: [18]) }
+      let(:rule) { Rule::Predicate.build(gt?, args: [18]) }
       let(:input) { 17 }
       let(:output) { 'gt?(18, 17)' }
 
@@ -17,7 +17,7 @@ RSpec.describe Result do
     end
 
     context 'with AND operation' do
-      let(:rule) { Rule::Predicate.new(array?).and(Rule::Predicate.new(empty?)) }
+      let(:rule) { Rule::Predicate.build(array?).and(Rule::Predicate.build(empty?)) }
       let(:input) { '' }
       let(:output) { 'array?("") AND empty?("")' }
 
@@ -25,7 +25,7 @@ RSpec.describe Result do
     end
 
     context 'with OR operation' do
-      let(:rule) { Rule::Predicate.new(array?).or(Rule::Predicate.new(empty?)) }
+      let(:rule) { Rule::Predicate.build(array?).or(Rule::Predicate.build(empty?)) }
       let(:input) { 123 }
       let(:output) { 'array?(123) OR empty?(123)' }
 
@@ -33,7 +33,7 @@ RSpec.describe Result do
     end
 
     context 'with XOR operation' do
-      let(:rule) { Rule::Predicate.new(array?).xor(Rule::Predicate.new(empty?)) }
+      let(:rule) { Rule::Predicate.build(array?).xor(Rule::Predicate.build(empty?)) }
       let(:input) { [] }
       let(:output) { 'array?([]) XOR empty?([])' }
 
@@ -41,7 +41,7 @@ RSpec.describe Result do
     end
 
     context 'with THEN operation' do
-      let(:rule) { Rule::Predicate.new(array?).then(Rule::Predicate.new(empty?)) }
+      let(:rule) { Rule::Predicate.build(array?).then(Rule::Predicate.build(empty?)) }
       let(:input) { [1, 2, 3] }
       let(:output) { 'empty?([1, 2, 3])' }
 
@@ -49,7 +49,7 @@ RSpec.describe Result do
     end
 
     context 'with NOT operation' do
-      let(:rule) { Operations::Negation.new(Rule::Predicate.new(array?)) }
+      let(:rule) { Operations::Negation.new(Rule::Predicate.build(array?)) }
       let(:input) { 'foo' }
       let(:output) { 'not(array?("foo"))' }
 

data/spec/shared/rule.rb

@@ -1,11 +1,12 @@
 shared_examples_for Dry::Logic::Rule do
-  let(:predicate) { double(:predicate, arity: 2, name: predicate_name) }
+  let(:arity) { 2 }
+  let(:predicate) { double(:predicate, arity: arity, name: predicate_name) }
   let(:rule_type) { described_class }
   let(:predicate_name) { :good? }
 
   describe '#arity' do
     it 'returns its predicate arity' do
-      rule = rule_type.new(predicate)
+      rule = rule_type.build(predicate)
 
       expect(rule.arity).to be(2)
     end
@@ -13,15 +14,17 @@ shared_examples_for Dry::Logic::Rule do
 
   describe '#parameters' do
     it 'returns a list of args with their names' do
-      rule = rule_type.new(-> foo, bar { true }, args: [312])
+      rule = rule_type.build(-> foo, bar { true }, args: [312])
 
       expect(rule.parameters).to eql([[:req, :foo], [:req, :bar]])
     end
   end
 
   describe '#call' do
+    let(:arity) { 1 }
+
     it 'returns success for valid input' do
-      rule = rule_type.new(predicate)
+      rule = rule_type.build(predicate)
 
       expect(predicate).to receive(:[]).with(2).and_return(true)
 
@@ -29,7 +32,7 @@ shared_examples_for Dry::Logic::Rule do
     end
 
     it 'returns failure for invalid input' do
-      rule = rule_type.new(predicate)
+      rule = rule_type.build(predicate)
 
       expect(predicate).to receive(:[]).with(2).and_return(false)
 
@@ -38,8 +41,10 @@ shared_examples_for Dry::Logic::Rule do
   end
 
   describe '#[]' do
+    let(:arity) { 1 }
+
     it 'delegates to its predicate' do
-      rule = rule_type.new(predicate)
+      rule = rule_type.build(predicate)
 
       expect(predicate).to receive(:[]).with(2).and_return(true)
       expect(rule[2]).to be(true)
@@ -48,7 +53,7 @@ shared_examples_for Dry::Logic::Rule do
 
   describe '#curry' do
     it 'returns a curried rule' do
-      rule = rule_type.new(predicate).curry(3)
+      rule = rule_type.build(predicate).curry(3)
 
       expect(predicate).to receive(:[]).with(3, 2).and_return(true)
       expect(rule.args).to eql([3])
@@ -59,7 +64,7 @@ shared_examples_for Dry::Logic::Rule do
     it 'raises argument error when arity does not match' do
       expect(predicate).to receive(:arity).and_return(2)
 
-      expect { rule_type.new(predicate).curry(3, 2, 1) }.to raise_error(
+      expect { rule_type.build(predicate).curry(3, 2, 1) }.to raise_error(
         ArgumentError, 'wrong number of arguments (3 for 2)'
       )
     end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
 end
 
 begin
-  require 'byebug'
+  require 'pry-byebug'
 rescue LoadError; end
 
 require 'dry-logic'

data/spec/unit/operations/and_spec.rb

@@ -3,8 +3,8 @@ RSpec.describe Operations::And do
 
   include_context 'predicates'
 
-  let(:left) { Rule::Predicate.new(int?) }
-  let(:right) { Rule::Predicate.new(gt?).curry(18) }
+  let(:left) { Rule::Predicate.build(int?) }
+  let(:right) { Rule::Predicate.build(gt?).curry(18) }
 
   describe '#call' do
     it 'calls left and right' do
@@ -24,6 +24,10 @@ RSpec.describe Operations::And do
         [:and, [[:predicate, [:int?, [[:input, '18']]]], [:hint, [:predicate, [:gt?, [[:num, 18], [:input, '18']]]]]]]
       )
 
+      expect(operation.with(hints: false).('18').to_ast).to eql(
+        [:predicate, [:int?, [[:input, '18']]]]
+      )
+
       expect(operation.(18).to_ast).to eql(
         [:predicate, [:gt?, [[:num, 18], [:input, 18]]]]
       )
@@ -41,7 +45,7 @@ RSpec.describe Operations::And do
   end
 
   describe '#and' do
-    let(:other) { Rule::Predicate.new(lt?).curry(30) }
+    let(:other) { Rule::Predicate.build(lt?).curry(30) }
 
     it 'creates and with the other' do
       expect(operation.and(other).(31)).to be_failure
@@ -49,7 +53,7 @@ RSpec.describe Operations::And do
   end
 
   describe '#or' do
-    let(:other) { Rule::Predicate.new(lt?).curry(14) }
+    let(:other) { Rule::Predicate.build(lt?).curry(14) }
 
     it 'creates or with the other' do
       expect(operation.or(other).(13)).to be_success

data/spec/unit/operations/attr_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Operations::Attr do
-  subject(:operation) { Operations::Attr.new(Rule::Predicate.new(str?), name: :name) }
+  subject(:operation) { Operations::Attr.new(Rule::Predicate.build(str?), name: :name) }
 
   include_context 'predicates'
 
@@ -13,7 +13,7 @@ RSpec.describe Operations::Attr do
   end
 
   describe '#and' do
-    let(:other) { Operations::Attr.new(Rule::Predicate.new(min_size?).curry(3), name: :name) }
+    let(:other) { Operations::Attr.new(Rule::Predicate.build(min_size?).curry(3), name: :name) }
 
     it 'returns and where value is passed to the right' do
       present_and_string = operation.and(other)

data/spec/unit/operations/check_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Operations::Check do
   describe '#call' do
     context 'with 1-level nesting' do
       subject(:operation) do
-        Operations::Check.new(Rule::Predicate.new(eql?).curry(1), id: :compare, keys: [:num])
+        Operations::Check.new(Rule::Predicate.build(eql?).curry(1), id: :compare, keys: [:num])
       end
 
       it 'applies predicate to args extracted from the input' do
@@ -15,7 +15,7 @@ RSpec.describe Operations::Check do
 
     context 'with 2-levels nesting' do
       subject(:operation) do
-        Operations::Check.new(Rule::Predicate.new(eql?), id: :compare, keys: [[:nums, :left], [:nums, :right]])
+        Operations::Check.new(Rule::Predicate.build(eql?), id: :compare, keys: [[:nums, :left], [:nums, :right]])
       end
 
       it 'applies predicate to args extracted from the input' do
@@ -37,7 +37,7 @@ RSpec.describe Operations::Check do
 
   describe '#to_ast' do
     subject(:operation) do
-      Operations::Check.new(Rule::Predicate.new(str?), keys: [:email])
+      Operations::Check.new(Rule::Predicate.build(str?), keys: [:email])
     end
 
     it 'returns ast' do

data/spec/unit/operations/each_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe Operations::Each do
 
   include_context 'predicates'
 
-  let(:is_string) { Rule::Predicate.new(str?) }
+  let(:is_string) { Rule::Predicate.build(str?) }
 
   describe '#call' do
     it 'applies its rules to all elements in the input' do

data/spec/unit/operations/implication_spec.rb

@@ -3,8 +3,8 @@ RSpec.describe Operations::Implication do
 
   include_context 'predicates'
 
-  let(:left) { Rule::Predicate.new(int?) }
-  let(:right) { Rule::Predicate.new(gt?).curry(18) }
+  let(:left) { Rule::Predicate.build(int?) }
+  let(:right) { Rule::Predicate.build(gt?).curry(18) }
 
   describe '#call' do
     it 'calls left and right' do

data/spec/unit/operations/key_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Operations::Key do
   include_context 'predicates'
 
   let(:predicate) do
-    Rule::Predicate.new(key?).curry(:age)
+    Rule::Predicate.build(key?).curry(:age)
   end
 
   describe '#call' do
@@ -32,7 +32,7 @@ RSpec.describe Operations::Key do
       end
 
       let(:predicate) do
-        Operations::Set.new(Rule::Predicate.new(key?).curry(:city), Rule::Predicate.new(key?).curry(:zipcode))
+        Operations::Set.new(Rule::Predicate.build(key?).curry(:city), Rule::Predicate.build(key?).curry(:zipcode))
       end
 
       it 'applies set rule to the value that passes' do
@@ -60,7 +60,7 @@ RSpec.describe Operations::Key do
       end
 
       let(:predicate) do
-        Operations::Each.new(Rule::Predicate.new(str?))
+        Operations::Each.new(Rule::Predicate.build(str?))
       end
 
       it 'applies each rule to the value that passses' do
@@ -108,11 +108,11 @@ RSpec.describe Operations::Key do
 
   describe '#and' do
     subject(:operation) do
-      Operations::Key.new(Rule::Predicate.new(str?), name: [:user, :name])
+      Operations::Key.new(Rule::Predicate.build(str?), name: [:user, :name])
     end
 
     let(:other) do
-      Operations::Key.new(Rule::Predicate.new(filled?), name: [:user, :name])
+      Operations::Key.new(Rule::Predicate.build(filled?), name: [:user, :name])
     end
 
     it 'returns and rule where value is passed to the right' do

data/spec/unit/operations/negation_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe Operations::Negation do
 
   include_context 'predicates'
 
-  let(:is_int) { Rule::Predicate.new(int?) }
+  let(:is_int) { Rule::Predicate.build(int?) }
 
   describe '#call' do
     it 'negates its rule' do

data/spec/unit/operations/or_spec.rb

@@ -3,11 +3,11 @@ RSpec.describe Operations::Or do
 
   include_context 'predicates'
 
-  let(:left) { Rule::Predicate.new(nil?) }
-  let(:right) { Rule::Predicate.new(gt?).curry(18) }
+  let(:left) { Rule::Predicate.build(nil?) }
+  let(:right) { Rule::Predicate.build(gt?).curry(18) }
 
   let(:other) do
-    Rule::Predicate.new(int?) & Rule::Predicate.new(lt?).curry(14)
+    Rule::Predicate.build(int?) & Rule::Predicate.build(lt?).curry(14)
   end
 
   describe '#call' do

data/spec/unit/operations/set_spec.rb

@@ -3,8 +3,8 @@ RSpec.describe Operations::Set do
 
   include_context 'predicates'
 
-  let(:is_int) { Rule::Predicate.new(int?) }
-  let(:gt_18) { Rule::Predicate.new(gt?, args: [18]) }
+  let(:is_int) { Rule::Predicate.build(int?) }
+  let(:gt_18) { Rule::Predicate.build(gt?, args: [18]) }
 
   describe '#call' do
     it 'applies all its rules to the input' do

data/spec/unit/operations/xor_spec.rb

@@ -3,11 +3,11 @@ RSpec.describe Operations::Xor do
 
   include_context 'predicates'
 
-  let(:left) { Rule::Predicate.new(array?) }
-  let(:right) { Rule::Predicate.new(empty?) }
+  let(:left) { Rule::Predicate.build(array?) }
+  let(:right) { Rule::Predicate.build(empty?) }
 
   let(:other) do
-    Rule::Predicate.new(str?)
+    Rule::Predicate.build(str?)
   end
 
   describe '#call' do

data/spec/unit/rule/predicate_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Rule::Predicate do
-  subject(:rule) { Rule::Predicate.new(predicate) }
+  subject(:rule) { Rule::Predicate.build(predicate) }
 
   let(:predicate) { str? }
 
@@ -27,11 +27,11 @@ RSpec.describe Rule::Predicate do
     end
 
     context 'with a result' do
-      it 'returns success ast' do
-        expect(rule.('foo').to_ast).to eql([:predicate, [:str?, [[:input, 'foo']]]])
+      it 'returns success' do
+        expect(rule.('foo')).to be_success
       end
 
-      it 'returns ast' do
+      it 'returns failure ast' do
         expect(rule.(5).to_ast).to eql([:predicate, [:str?, [[:input, 5]]]])
       end
     end

data/spec/unit/rule_compiler_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
 
   let(:predicate) { double(:predicate, name: :test?, arity: 2).as_null_object }
 
-  let(:rule) { Rule::Predicate.new(predicate) }
+  let(:rule) { Rule::Predicate.build(predicate) }
   let(:key_op) { Operations::Key.new(rule, name: :email) }
   let(:attr_op) { Operations::Attr.new(rule, name: :email) }
   let(:check_op) { Operations::Check.new(rule, keys: [:email]) }

data/spec/unit/rule_spec.rb

@@ -1,11 +1,11 @@
 RSpec.describe Dry::Logic::Rule do
-  subject(:rule) { Rule.new(predicate, options) }
+  subject(:rule) { Rule.build(predicate, options) }
 
   let(:predicate) { -> { true } }
   let(:options) { {} }
 
   let(:schema) do
-    Class.new(BasicObject) do
+    Class.new do
       define_method(:class, Kernel.instance_method(:class))
 
       def method_missing(m, *)
@@ -34,29 +34,29 @@ RSpec.describe Dry::Logic::Rule do
 
   describe '.new' do
     it 'accepts an :id' do
-      expect(Rule.new(predicate, id: :check_num).id).to be(:check_num)
+      expect(Rule.build(predicate, id: :check_num).id).to be(:check_num)
     end
   end
 
   describe 'with a function returning truthy value' do
     it 'is successful for valid input' do
-      expect(Rule.new(-> val { val }).('true')).to be_success
+      expect(Rule.build(-> val { val }).('true')).to be_success
     end
 
     it 'is not successful for invalid input' do
-      expect(Rule.new(-> val { val }).(nil)).to be_failure
+      expect(Rule.build(-> val { val }).(nil)).to be_failure
     end
   end
 
   describe '#ast' do
     it 'returns predicate node with :id' do
-      expect(Rule.new(-> value { true }).with(id: :email?).ast('oops')).to eql(
+      expect(Rule.build(-> value { true }).with(id: :email?).ast('oops')).to eql(
         [:predicate, [:email?, [[:value, 'oops']]]]
       )
     end
 
     it 'returns predicate node with undefined args' do
-      expect(Rule.new(-> value { true }).with(id: :email?).ast).to eql(
+      expect(Rule.build(-> value { true }).with(id: :email?).ast).to eql(
         [:predicate, [:email?, [[:value, Undefined]]]]
       )
     end
@@ -120,7 +120,7 @@ RSpec.describe Dry::Logic::Rule do
 
   describe '#eval_args' do
     context 'with an unbound method' do
-      let(:options) { { args: [1, klass.instance_method(:num), :foo] } }
+      let(:options) { { args: [1, klass.instance_method(:num), :foo], arity: 3 } }
       let(:klass) { Class.new { def num; 7; end } }
       let(:object) { klass.new }
 
@@ -130,7 +130,7 @@ RSpec.describe Dry::Logic::Rule do
     end
 
     context 'with a schema instance' do
-      let(:options) { { args: [1, schema, :foo] } }
+      let(:options) { { args: [1, schema, :foo], arity: 3 } }
       let(:object) { Object.new }
 
       it 'returns a new with its predicate executed in the context of the provided object' do
@@ -138,4 +138,74 @@ RSpec.describe Dry::Logic::Rule do
       end
     end
   end
+
+  describe 'arity specialization' do
+    describe '0-arity rule' do
+      let(:options) { { args: [1], arity: 1 } }
+      let(:predicate) { :odd?.to_proc }
+
+      it 'generates interface with the right arity' do
+        expect(rule.method(:call).arity).to be_zero
+        expect(rule.method(:[]).arity).to be_zero
+        expect(rule[]).to be(true)
+        expect(rule.()).to be_success
+      end
+    end
+
+    describe '1-arity rule' do
+      let(:options) { { args: [1], arity: 2 } }
+      let(:predicate) { -> a, b { a + b } }
+
+      it 'generates interface with the right arity' do
+        expect(rule.method(:call).arity).to be(1)
+        expect(rule.method(:[]).arity).to be(1)
+        expect(rule[10]).to be(11)
+        expect(rule.(1)).to be_success
+      end
+    end
+
+    describe 'currying' do
+      let(:options) { { args: [], arity: 2 } }
+      let(:predicate) { -> a, b { a + b } }
+      let(:rule) { super().curry(1) }
+
+      it 'generates correct arity on currying' do
+        expect(rule.method(:call).arity).to be(1)
+        expect(rule.method(:[]).arity).to be(1)
+        expect(rule[10]).to be(11)
+        expect(rule.(1)).to be_success
+      end
+    end
+
+    describe 'arbitrary arity' do
+      let(:arity) { rand(20) }
+      let(:curried) { arity.zero? ? 0 : rand(arity) }
+
+      let(:options) { { args: [1] * curried, arity: arity } }
+      let(:predicate) { double(:predicate) }
+
+      it 'generates correct arity' do
+        expect(rule.method(:call).arity).to be(arity - curried)
+        expect(rule.method(:[]).arity).to be(arity - curried)
+      end
+    end
+
+    describe '-1 arity' do
+      let(:options) { { args: [], arity: -1 } }
+
+      it 'accepts variable number of arguments' do
+        expect(rule.method(:call).arity).to be(-1)
+        expect(rule.method(:[]).arity).to be(-1)
+      end
+    end
+
+    describe 'constants' do
+      let(:options) { { args: [], arity: 0 } }
+
+      fit 'accepts variable number of arguments' do
+        expect(rule.method(:call).arity).to be(-1)
+        expect(rule.method(:[]).arity).to be(-1)
+      end
+    end
+  end
 end

metadata

@@ -1,39 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: dry-logic
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-29 00:00:00.000000000 Z
+date: 2019-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: dry-core
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-container
+  name: dry-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -41,9 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.6
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
   requirement: !ruby/object:Gem::Requirement
@@ -110,8 +104,6 @@ files:
 - ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
-- ".rubocop.yml"
-- ".rubocop_todo.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
@@ -119,6 +111,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmarks/rule_application.rb
+- benchmarks/setup.rb
 - bin/console
 - dry-logic.gemspec
 - examples/basic.rb
@@ -144,6 +138,7 @@ files:
 - lib/dry/logic/predicates.rb
 - lib/dry/logic/result.rb
 - lib/dry/logic/rule.rb
+- lib/dry/logic/rule/interface.rb
 - lib/dry/logic/rule/predicate.rb
 - lib/dry/logic/rule_compiler.rb
 - lib/dry/logic/version.rb
@@ -221,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Predicate logic with rule composition

data/.rubocop.yml

@@ -1,16 +0,0 @@
-# Generated by `rubocop --auto-gen-config`
-inherit_from: .rubocop_todo.yml
-
-Metrics/LineLength:
-  Max: 100
-
-Style/Documentation:
-  Enabled: false
-
-Lint/HandleExceptions:
-  Exclude:
-    - rakelib/*.rake
-
-Style/FileName:
-  Exclude:
-    - lib/dry-logic.rb

data/.rubocop_todo.yml

@@ -1,7 +0,0 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2015-10-30 01:32:46 +0000 using RuboCop version 0.34.2.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.