dry-logic 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95bd134452791d94fdaf05fc2afc746040800e47
-  data.tar.gz: c1a47707cec851ac223ba9a7ce5dcbe46d0f2e9e
+  metadata.gz: 0ea86d568127098e2777868066c2026dbc380eb9
+  data.tar.gz: 5553735b89ab2ef6a1c5bdd3f24874bab46c2581
 SHA512:
-  metadata.gz: b8d2c782c82ee06c6f434c3aa768c85fc6ba4d35ec2196d2e4318d8870ff84368284a6774ebe1ee6db82681cd8c5551be971d86e59a56251f6547750ed43f520
-  data.tar.gz: 03d4dad7d29603a97541db67089f27b3d44a36114592273e5e6d6a102785186021bdc3070da72a11d675a0e5b2d10b1e0b85ac287db24d59d1745e5250783d0c
+  metadata.gz: c943b1c67b55618b3e3fa1e982e371614a3e34c0ec2ca7457c775e755335a9579f52434d50545b411bf053f3c8e5a72209bdc86a58d7f13abef521df92b1fde5
+  data.tar.gz: 87598a0a72b1196d966464b1a731746922613fa8eb72cfa3d002ecfe3dee917502126bcfb2e506ae67c958335a6343b05db131e7012d1a0c64d74320d4e3d2d6

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# v0.3.0 2016-07-01
+
+### Added
+
+* `:type?` predicate imported from dry-types (solnic)
+* `Rule#curry` interface (solnic)
+
+### Changed
+
+* Predicates AST now includes information about args (names & possible values) (fran-worley + solnic)
+* Predicates raise errors when they are called with invalid arity (fran-worley + solnic)
+* Rules no longer evaluate input twice when building result objects (solnic)
+
+[Compare v0.2.3...v0.3.0](https://github.com/dryrb/dry-logic/compare/v0.2.3...v0.3.0)
+
 # v0.2.3 2016-05-11
 
 ### Added
@@ -11,7 +26,6 @@
 
 [Compare v0.2.2...v0.2.3](https://github.com/dryrb/dry-logic/compare/v0.2.2...v0.2.3)
 
-
 # v0.2.2 2016-03-30
 
 ### Added

data/README.md

@@ -28,20 +28,27 @@ require 'dry/logic/predicates'
 
 include Dry::Logic
 
-user_present = Rule::Key.new(Predicates[:key?], name: :user)
+user_present = Rule::Key.new(Predicates[:filled?], name: :user)
 
-has_min_age = Rule::Key.new(
-  Predicates[:key?]) & Rule::Value.new(:age, Predicates[:gt?].curry(18),
-  name: :age
-)
+has_min_age = Rule::Key.new(Predicates[:int?], name: [:user, :age])
+  & Rule::Key.new(Predicates[:gt?].curry(18), name: [:user, :age])
 
 user_rule = user_present & has_min_age
 
 user_rule.(user: { age: 19 })
-# #<Dry::Logic::Result::Value success?=true input=19 rule=#<Dry::Logic::Rule::Value name=:age predicate=#<Dry::Logic::Predicate id=:gt?>>>
+# #<Dry::Logic::Result::Named success?=true input={:user=>{:age=>19}} rule=#<Dry::Logic::Rule::Key predicate=#<Dry::Logic::Predicate id=:gt? args=[18, 19]> options={:evaluator=>#<Dry::Logic::Evaluator::Key path=[:user, :age]>, :name=>[:user, :age]}>>
 
 user_rule.(user: { age: 18 })
-# #<Dry::Logic::Result::Value success?=false input=18 rule=#<Dry::Logic::Rule::Value name=:age predicate=#<Dry::Logic::Predicate id=:gt?>>>
+# #<Dry::Logic::Result::Named success?=false input={:user=>{:age=>18}} rule=#<Dry::Logic::Rule::Key predicate=#<Dry::Logic::Predicate id=:gt? args=[18, 18]> options={:evaluator=>#<Dry::Logic::Evaluator::Key path=[:user, :age]>, :name=>[:user, :age]}>>
+
+user_rule.(user: { age: 'seventeen' }).inspect
+#<Dry::Logic::Result::Named success?=false input={:user=>{:age=>"seventeen"}} rule=#<Dry::Logic::Rule::Key predicate=#<Dry::Logic::Predicate id=:int? args=["seventeen"]> options={:evaluator=>#<Dry::Logic::Evaluator::Key path=[:user, :age]>, :name=>[:user, :age]}>>
+
+user_rule.(user: { }).inspect
+#<Dry::Logic::Result::Named success?=false input={:user=>{}} rule=#<Dry::Logic::Rule::Key predicate=#<Dry::Logic::Predicate id=:filled? args=[{}]> options={:evaluator=>#<Dry::Logic::Evaluator::Key path=[:user]>, :name=>:user}>>
+
+puts user_rule.({}).inspect
+#<Dry::Logic::Result::Named success?=false input={} rule=#<Dry::Logic::Rule::Key predicate=#<Dry::Logic::Predicate id=:filled? args=[nil]> options={:evaluator=>#<Dry::Logic::Evaluator::Key path=[:user]>, :name=>:user}>>
 ```
 
 ## License

data/examples/basic.rb

@@ -3,11 +3,17 @@ 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[:filled?], name: :user)
+has_min_age = Rule::Key.new(Predicates[:int?], name: [:user, :age]) & Rule::Key.new(Predicates[:gt?].curry(18), name: [:user, :age])
 
 user_rule = user_present & has_min_age
 
 puts user_rule.(user: { age: 19 }).inspect
 
 puts user_rule.(user: { age: 18 }).inspect
+
+puts user_rule.(user: { age: 'seventeen' }).inspect
+
+puts user_rule.(user: { }).inspect
+
+puts user_rule.({}).inspect

data/lib/dry/logic/predicate.rb

@@ -3,33 +3,98 @@ module Dry
     def self.Predicate(block)
       case block
       when Method then Predicate.new(block.name, &block)
+      when UnboundMethod then Predicate.new(block.name, fn: block)
       else raise ArgumentError, 'predicate needs an :id'
       end
     end
 
     class Predicate
+      Undefined = Class.new {
+        def inspect
+          "undefined"
+        end
+        alias_method :to_s, :inspect
+      }.new.freeze
+
       include Dry::Equalizer(:id, :args)
 
-      attr_reader :id, :args, :fn
+      attr_reader :id, :args, :fn, :arity
+
+      class Curried < Predicate
+        def call(*args)
+          all_args = @args + args
 
-      def initialize(id, *args, &block)
+          if all_args.size == arity
+            super(*args)
+          else
+            curry(*args)
+          end
+        end
+        alias_method :[], :call
+      end
+
+      def initialize(id, args: [], fn: nil, arity: nil, &block)
         @id = id
-        @fn = block
         @args = args
+        @fn = fn || block
+        @arity = arity || @fn.arity
       end
 
+      #as long as we keep track of the args, we don't actually need to curry the proc...
+      #if we never curry the proc then fn.arity & fn.parameters stay intact
+      def curry(*args)
+        if args.size > 0
+          all_args = @args + args
+          size = all_args.size
+
+          if size <= arity
+            Curried.new(id, args: all_args, fn: fn, arity: arity)
+          else
+            raise_arity_error(all_args.size)
+          end
+        else
+          self
+        end
+      end
+
+      # @api public
+      def bind(object)
+        self.class.new(id, *args, &fn.bind(object))
+      end
+
+      #enables a rule to call with its params & have them ignored if the
+      #predicate doesn't need them.
+      #if @args.size == arity then we should ignore called args
       def call(*args)
-        fn.(*args)
+        all_args = @args + args
+        size = all_args.size
+
+        if size == arity
+          fn.(*all_args)
+        else
+          raise_arity_error(size)
+        end
       end
+      alias_method :[], :call
 
-      def curry(*args)
-        self.class.new(id, *args, &fn.curry.(*args))
+      def parameters
+        fn.parameters
       end
 
       def to_ast
-        [:predicate, [id, args]]
+        [:predicate, [id, args_with_names]]
       end
       alias_method :to_a, :to_ast
+
+      private
+
+      def args_with_names
+        parameters.map(&:last).zip(args + Array.new(arity - args.size, Undefined))
+      end
+
+      def raise_arity_error(args_size)
+        raise ArgumentError, "wrong number of arguments (#{args_size} for #{arity})"
+      end
     end
   end
 end

data/lib/dry/logic/predicates.rb

@@ -15,6 +15,10 @@ module Dry
         other.import(self)
       end
 
+      predicate(:type?) do |type, input|
+        input.kind_of?(type)
+      end
+
       predicate(:none?) do |input|
         input.nil?
       end

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

@@ -3,7 +3,7 @@ module Dry
     class Result::Each < Result::Multi
       def to_ast
         failed_rules = failures.map { |idx, el| [:el, [idx, el.to_ast]] }
-        [:result, [rule.evaluate(input), [:each, failed_rules]]]
+        [:result, [input, [:each, failed_rules]]]
       end
 
       def success?

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

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

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

@@ -5,9 +5,13 @@ module Dry
         if response.respond_to?(:to_ast)
           response.to_ast
         else
-          [:result, [rule.evaluate(input), rule.to_ast]]
+          [:result, [input, rule.to_ast]]
         end
       end
+
+      def input
+        rule.input != Predicate::Undefined ? rule.input : super
+      end
     end
   end
 end

data/lib/dry/logic/rule.rb

@@ -7,6 +7,13 @@ module Dry
 
       attr_reader :options
 
+      def self.method_added(meth)
+        super
+        if meth == :call
+          alias_method :[], :call
+        end
+      end
+
       def initialize(predicate, options = {})
         @predicate = predicate
         @options = options
@@ -49,7 +56,11 @@ module Dry
       end
 
       def curry(*args)
-        self.class.new(predicate.curry(*args), options)
+        if arity > 0
+          new(predicate.curry(*args))
+        else
+          self
+        end
       end
 
       def each?

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

@@ -1,8 +1,8 @@
 module Dry
   module Logic
     class Rule::Attr < Rule::Key
-      def self.evaluator(options)
-        Evaluator::Attr.new(options.fetch(:name))
+      def self.evaluator(name)
+        Evaluator::Attr.new(name)
       end
 
       def type

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

@@ -21,7 +21,7 @@ module Dry
       def call(input)
         args = evaluator[input].reverse
         *head, tail = args
-        Logic.Result(predicate.curry(*head).(tail), head.size > 0 ? curry(*head) : self, input)
+        Logic.Result(predicate.curry(*head).(tail), curry(*args), input)
       end
 
       def evaluate(input)

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

@@ -10,6 +10,18 @@ module Dry
         @right = right
       end
 
+      def arity
+        -1
+      end
+
+      def input
+        Predicate::Undefined
+      end
+
+      def curry(*args)
+        self.class.new(left.curry(*args), right.curry(*args))
+      end
+
       def name
         :"#{left.name}_#{type}_#{right.name}"
       end
@@ -71,10 +83,6 @@ module Dry
         Logic.Result(left.(input).success? ^ right.(input).success?, self, input)
       end
 
-      def evaluate(input)
-        [left.evaluate(input), right.evaluate(input)]
-      end
-
       def type
         :xor
       end

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

@@ -7,11 +7,12 @@ module Dry
 
       def self.new(predicate, options)
         name = options.fetch(:name)
-        super(predicate, evaluator: evaluator(options), name: name)
+        eval = options.fetch(:evaluator, evaluator(name))
+        super(predicate, evaluator: eval, name: name)
       end
 
-      def self.evaluator(options)
-        Evaluator::Key.new(options.fetch(:name))
+      def self.evaluator(name)
+        Evaluator::Key.new(name)
       end
 
       def initialize(predicate, options)

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

@@ -7,10 +7,18 @@ module Dry
         :set
       end
 
+      def arity
+        -1
+      end
+
       def apply(input)
         rules.map { |rule| rule.(input) }
       end
 
+      def curry(*args)
+        new(rules.map { |r| r.curry(*args) })
+      end
+
       def at(*args)
         new(rules.values_at(*args))
       end

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

@@ -5,12 +5,35 @@ module Dry
         :val
       end
 
+      def nulary?
+        arity == 0
+      end
+
+      def arity
+        @arity ||= predicate.arity
+      end
+
+      def args
+        @args ||= predicate.args
+      end
+
+      def input
+        predicate.args.last
+      end
+
       def call(input)
-        Logic.Result(apply(input), self, input)
+        if nulary?
+          Logic.Result(predicate.(), self, input)
+        else
+          evaled = evaluate(input)
+          result = apply(evaled)
+          rule = result == true ? self : curry(evaled)
+          Logic.Result(result, rule, input)
+        end
       end
 
       def apply(input)
-        predicate.(evaluate(input))
+        predicate.(input)
       end
 
       def evaluate(input)

data/lib/dry/logic/rule_compiler.rb

@@ -50,8 +50,15 @@ module Dry
       end
 
       def visit_predicate(node)
-        name, args = node
-        predicates[name].curry(*args)
+        name, params = node
+        predicate = predicates[name]
+
+        if params.size > 1
+          args = params.map(&:last).reject { |val| val == Predicate::Undefined }
+          predicate.curry(*args)
+        else
+          predicate
+        end
       end
 
       def visit_and(node)

data/lib/dry/logic/version.rb

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

data/spec/shared/predicates.rb

@@ -30,8 +30,8 @@ RSpec.shared_examples 'a passing predicate' do
   let(:predicate) { Dry::Logic::Predicates[predicate_name] }
 
   it do
-    arguments_list.each do |(left, right)|
-      expect(predicate.call(left, right)).to be(true)
+    arguments_list.each do |args|
+      expect(predicate.call(*args)).to be(true)
     end
   end
 end
@@ -40,8 +40,8 @@ RSpec.shared_examples 'a failing predicate' do
   let(:predicate) { Dry::Logic::Predicates[predicate_name] }
 
   it do
-    arguments_list.each do |(left, right)|
-      expect(predicate.call(left, right)).to be(false)
+    arguments_list.each do |args|
+      expect(predicate.call(*args)).to be(false)
     end
   end
 end

data/spec/unit/predicate_spec.rb

@@ -1,6 +1,35 @@
 require 'dry/logic/predicate'
 
-RSpec.describe Dry::Logic::Predicate do
+RSpec.describe Predicate do
+  describe '.new' do
+    it 'can be initialized with empty args' do
+      predicate = Predicate.new(:id) { |v| v.is_a?(Integer) }
+
+      expect(predicate.to_ast).to eql([:predicate, [:id, [[:v, Predicate::Undefined]]]])
+    end
+
+    it 'can be initialized with args' do
+      predicate = Predicate.new(:id, args: [1]) { |v| v.is_a?(Integer) }
+
+      expect(predicate.to_ast).to eql([:predicate, [:id, [[:v, 1]]]])
+    end
+
+    it 'can be initialized with fn as the last arg' do
+      predicate = Predicate.new(:id, args: [1], fn: -> v { v.is_a?(Integer) })
+
+      expect(predicate.to_ast).to eql([:predicate, [:id, [[:v, 1]]]])
+    end
+  end
+
+  describe '#bind' do
+    it 'returns a predicate bound to a specific object' do
+      fn = String.instance_method(:empty?)
+
+      expect(Dry::Logic.Predicate(fn).bind("").()).to be(true)
+      expect(Dry::Logic.Predicate(fn).bind("foo").()).to be(false)
+    end
+  end
+
   describe '#call' do
     it 'returns result of the predicate function' do
       is_empty = Dry::Logic::Predicate.new(:is_empty) { |str| str.empty? }
@@ -9,6 +38,52 @@ RSpec.describe Dry::Logic::Predicate do
 
       expect(is_empty.('filled')).to be(false)
     end
+
+    it "raises argument error when incorrect number of args provided" do
+      min_age = Dry::Logic::Predicate.new(:min_age) { |age, input| input >= age }
+
+      expect { min_age.curry(10, 12, 14) }.to raise_error(ArgumentError)
+      expect { min_age.(18, 19, 20, 30) }.to raise_error(ArgumentError)
+      expect { min_age.curry(18).(19, 20) }.to raise_error(ArgumentError)
+    end
+
+    it "predicates should work without any args" do
+      is_empty = Dry::Logic::Predicate.new(:is_empty) { true }
+
+      expect(is_empty.()).to be(true)
+    end
+  end
+
+  describe '#arity' do
+    it 'returns arity of the predicate function' do
+      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
+
+      expect(is_equal.arity).to eql(2)
+    end
+  end
+
+  describe '#parameters' do
+    it 'returns arity of the predicate function' do
+      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
+
+      expect(is_equal.parameters).to eql([[:opt, :left], [:opt, :right]])
+    end
+  end
+
+  describe '#arity' do
+    it 'returns arity of the predicate function' do
+      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
+
+      expect(is_equal.arity).to eql(2)
+    end
+  end
+
+  describe '#parameters' do
+    it 'returns arity of the predicate function' do
+      is_equal = Dry::Logic::Predicate.new(:is_equal) { |left, right| left == right }
+
+      expect(is_equal.parameters).to eql([[:opt, :left], [:opt, :right]])
+    end
   end
 
   describe '#curry' do
@@ -23,5 +98,18 @@ RSpec.describe Dry::Logic::Predicate do
       expect(min_age_18.(19)).to be(true)
       expect(min_age_18.(17)).to be(false)
     end
+
+    it 'can curry again & again' do
+      min_age = Dry::Logic::Predicate.new(:min_age) { |age, input| input >= age }
+
+      min_age_18 = min_age.curry(18)
+
+      expect(min_age_18.args).to eql([18])
+
+      actual_age_19 = min_age_18.curry(19)
+
+      expect(actual_age_19.()).to be(true)
+      expect(actual_age_19.args).to eql([18,19])
+    end
   end
 end

data/spec/unit/predicates/array_spec.rb

@@ -0,0 +1,41 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#array?' do
+    let(:predicate_name) { :array? }
+
+    context 'when value is an array' do
+      let(:arguments_list) do
+        [
+          [ [] ],
+          [ ['other', 'array'] ],
+          [ [123, 'really', :blah] ],
+          [ Array.new ],
+          [ [nil] ],
+          [ [false] ],
+          [ [true] ]
+        ]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'when value is not an array' do
+      let(:arguments_list) do
+        [
+          [''],
+          [{}],
+          [nil],
+          [:symbol],
+          [String],
+          [1],
+          [1.0],
+          [true],
+          [Hash.new]
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/predicates/type_spec.rb

@@ -0,0 +1,35 @@
+require 'dry/logic/predicates'
+
+RSpec.describe Dry::Logic::Predicates do
+  describe '#type?' do
+    let(:predicate_name) { :type? }
+
+    context 'when value has a correct type' do
+      let(:arguments_list) do
+        [[TrueClass, true]]
+      end
+
+      it_behaves_like 'a passing predicate'
+    end
+
+    context 'with value is not true' do
+      let(:arguments_list) do
+        [
+          [TrueClass, false],
+          [TrueClass, ''],
+          [TrueClass, []],
+          [TrueClass, {}],
+          [TrueClass, nil],
+          [TrueClass, :symbol],
+          [TrueClass, String],
+          [TrueClass, 1],
+          [TrueClass, 0],
+          [TrueClass, 'true'],
+          [TrueClass, 'false']
+        ]
+      end
+
+      it_behaves_like 'a failing predicate'
+    end
+  end
+end

data/spec/unit/rule/check_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Rule::Check do
 
         expect(rule.(num: 1).to_ast).to eql(
           [:input, [:compare, [
-            :result, [1, [:check, [:compare, [:predicate, [:eql?, [1]]]]]]]]
+            :result, [1, [:check, [:compare, [:predicate, [:eql?, [[:left, 1], [:right, 1]]]]]]]]]
           ]
         )
       end
@@ -29,12 +29,13 @@ RSpec.describe Rule::Check do
         expect(rule.(nums: { left: 1, right: 2 })).to be_failure
       end
 
+      #check rules reverse the order of params to enable cases like `left.gt(right)` to work
       it 'curries args properly' do
         result = rule.(nums: { left: 1, right: 2 })
 
         expect(result.to_ast).to eql([
           :input, [:compare, [
-            :result, [1, [:check, [:compare, [:predicate, [:eql?, [2]]]]]]]
+            :result, [1, [:check, [:compare, [:predicate, [:eql?, [[:left, 2], [:right, 1]]]]]]]]
           ]
         ])
       end

data/spec/unit/rule/each_spec.rb

@@ -21,8 +21,8 @@ RSpec.describe Dry::Logic::Rule::Each do
       expect(address_rule.([nil, nil]).to_ast).to eql([
         :result, [[nil, nil], [
           :each, [
-            [:el, [0, [:result, [nil, [:val, [:predicate, [:str?, []]]]]]]],
-            [:el, [1, [:result, [nil, [:val, [:predicate, [:str?, []]]]]]]]
+            [:el, [0, [:result, [nil, [:val, [:predicate, [:str?, [[:input, nil]]]]]]]]],
+            [:el, [1, [:result, [nil, [:val, [:predicate, [:str?, [[:input, nil]]]]]]]]]
           ]
         ]]
       ])

data/spec/unit/rule/key_spec.rb

@@ -56,7 +56,7 @@ RSpec.describe Rule::Key do
             :address,
               [:result, [
                 { city: "NYC" },
-                [:set, [[:result, [{ city: 'NYC' }, [:val, [:predicate, [:key?, [:zipcode]]]]]]]]
+                [:set, [[:result, [{ city: 'NYC' }, [:val, [:predicate, [:key?, [[:name, :zipcode], [:input, {:city=>"NYC"}]]]]]]]]]
               ]]
             ]
         ])
@@ -93,8 +93,8 @@ RSpec.describe Rule::Key do
               :result, [
                 [1, '3', 3],
                 [:each, [
-                  [:el, [0, [:result, [1, [:val, [:predicate, [:str?, []]]]]]]],
-                  [:el, [2, [:result, [3, [:val, [:predicate, [:str?, []]]]]]]]
+                  [:el, [0, [:result, [1, [:val, [:predicate, [:str?, [[:input, 1]]]]]]]]],
+                  [:el, [2, [:result, [3, [:val, [:predicate, [:str?, [[:input, 3]]]]]]]]]
                 ]]
               ]
             ]

data/spec/unit/rule/set_spec.rb

@@ -21,8 +21,8 @@ RSpec.describe Dry::Logic::Rule::Set do
     it 'returns an array representation' do
       expect(rule.to_ast).to eql([
         :set, [
-          [:val, [:predicate, [:str?, []]]],
-          [:val, [:predicate, [:min_size?, [6]]]]
+          [:val, [:predicate, [:str?, [[:input, Predicate::Undefined]]]]],
+          [:val, [:predicate, [:min_size?, [[:num, 6], [:input, Predicate::Undefined]]]]]
         ]
       ])
     end

data/spec/unit/rule/value_spec.rb

@@ -15,11 +15,31 @@ RSpec.describe Dry::Logic::Rule::Value do
       expect(is_string.('1')).to be_success
     end
 
+    context 'with a composite rule' do
+      subject(:rule) { Dry::Logic::Rule::Value.new(is_nil | is_string) }
+
+      it 'returns a success for valid input' do
+        expect(rule.(nil)).to be_success
+        expect(rule.('foo')).to be_success
+      end
+
+      it 'returns a failure for invalid input' do
+        expect(rule.(312)).to be_failure
+      end
+
+      it 'returns a failure result with curried args' do
+        expect(rule.(312).to_ast).to eql(
+          [:result, [312, [:val, [:predicate, [:str?, [[:input, 312]]]]]]]
+        )
+      end
+    end
+
     context 'with a custom predicate' do
       subject(:rule) { Dry::Logic::Rule::Value.new(predicate) }
 
-      let(:response) { double(success?: true) }
-      let(:predicate) { -> input { Result.new(response, double, input) } }
+      let(:response) { double("response", success?: true) }
+      let(:predicate) { double("predicate", arity: 1, curry: curried, call: Result.new(response, double("rule"), test: true)) }
+      let(:curried) { double("curried", arity: 1, call: Result.new(response, double("rule"), test: true)) }
 
       let(:result) { rule.(test: true) }
 
@@ -39,6 +59,17 @@ RSpec.describe Dry::Logic::Rule::Value do
       it 'has no name by default' do
         expect(result.name).to be(nil)
       end
+
+      context "works with predicates.arity == 0" do
+        subject(:rule) { Dry::Logic::Rule::Value.new(predicate) }
+
+        let(:predicate) { Dry::Logic::Predicate.new(:without_args) { true } }
+        let(:result) { rule.('sutin') }
+
+        it "calls its predicate without any args" do
+          expect(result).to be_success
+        end
+      end
     end
   end
 

data/spec/unit/rule_compiler_spec.rb

@@ -25,7 +25,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   let(:each_rule) { Rule::Each.new(val_rule) }
 
   it 'compiles key rules' do
-    ast = [[:key, [:email, [:predicate, [:filled?, []]]]]]
+    ast = [[:key, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]
 
     rules = compiler.(ast)
 
@@ -33,7 +33,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles attr rules' do
-    ast = [[:attr, [:email, [:predicate, [:filled?, []]]]]]
+    ast = [[:attr, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]
 
     rules = compiler.(ast)
 
@@ -41,7 +41,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles check rules' do
-    ast = [[:check, [:email, [:predicate, [:filled?, []]]]]]
+    ast = [[:check, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]
 
     rules = compiler.(ast)
 
@@ -49,7 +49,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles attr rules' do
-    ast = [[:attr, [:email, [:predicate, [:attr?, predicate]]]]]
+    ast = [[:attr, [:email, [:predicate, [:attr?, [[:name, :email]]]]]]]
 
     rules = compiler.(ast)
 
@@ -57,7 +57,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles negated rules' do
-    ast = [[:not, [:key, [:email, [:predicate, [:filled?, []]]]]]]
+    ast = [[:not, [:key, [:email, [:predicate, [:filled?, [[:input, nil]]]]]]]]
 
     rules = compiler.(ast)
 
@@ -68,8 +68,8 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
     ast = [
       [
         :and, [
-          [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:predicate, [:filled?, []]]]
+          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, nil]]]]]],
+          [:val, [:predicate, [:filled?, [[:input, nil]]]]]
         ]
       ]
     ]
@@ -83,8 +83,8 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
     ast = [
       [
         :or, [
-          [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:predicate, [:filled?, []]]]
+          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, nil]]]]]],
+          [:val, [:predicate, [:filled?, [[:input, nil]]]]]
         ]
       ]
     ]
@@ -98,8 +98,8 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
     ast = [
       [
         :xor, [
-          [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:predicate, [:filled?, []]]]
+          [:key, [:email, [:predicate, [:key?, [[:name, :email], [:input, nil]]]]]],
+          [:val, [:predicate, [:filled?, [[:input, nil]]]]]
         ]
       ]
     ]
@@ -110,7 +110,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles set rules' do
-    ast = [[:set, [[:val, [:predicate, [:filled?, []]]]]]]
+    ast = [[:set, [[:val, [:predicate, [:filled?, [[:input, nil]]]]]]]]
 
     rules = compiler.(ast)
 
@@ -118,7 +118,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles each rules' do
-    ast = [[:each, [:val, [:predicate, [:filled?, []]]]]]
+    ast = [[:each, [:val, [:predicate, [:filled?, [[:input, nil]]]]]]]
 
     rules = compiler.(ast)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-logic
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-container
@@ -131,6 +131,7 @@ files:
 - spec/shared/predicates.rb
 - spec/spec_helper.rb
 - spec/unit/predicate_spec.rb
+- spec/unit/predicates/array_spec.rb
 - spec/unit/predicates/attr_spec.rb
 - spec/unit/predicates/bool_spec.rb
 - spec/unit/predicates/date_spec.rb
@@ -163,6 +164,7 @@ files:
 - spec/unit/predicates/str_spec.rb
 - spec/unit/predicates/time_spec.rb
 - spec/unit/predicates/true_spec.rb
+- spec/unit/predicates/type_spec.rb
 - spec/unit/rule/attr_spec.rb
 - spec/unit/rule/check_spec.rb
 - spec/unit/rule/conjunction_spec.rb
@@ -194,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Predicate logic with rule composition
@@ -202,6 +204,7 @@ test_files:
 - spec/shared/predicates.rb
 - spec/spec_helper.rb
 - spec/unit/predicate_spec.rb
+- spec/unit/predicates/array_spec.rb
 - spec/unit/predicates/attr_spec.rb
 - spec/unit/predicates/bool_spec.rb
 - spec/unit/predicates/date_spec.rb
@@ -234,6 +237,7 @@ test_files:
 - spec/unit/predicates/str_spec.rb
 - spec/unit/predicates/time_spec.rb
 - spec/unit/predicates/true_spec.rb
+- spec/unit/predicates/type_spec.rb
 - spec/unit/rule/attr_spec.rb
 - spec/unit/rule/check_spec.rb
 - spec/unit/rule/conjunction_spec.rb
@@ -245,3 +249,4 @@ test_files:
 - spec/unit/rule/set_spec.rb
 - spec/unit/rule/value_spec.rb
 - spec/unit/rule_compiler_spec.rb
+has_rdoc: