dry-logic 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9042bd42bf10c567eb88dc6e830ebface1daf974
-  data.tar.gz: dc92016f7c8a14ddd0db49f33d0818130cc9cada
+  metadata.gz: 42c06d53e8a80811c9bb63f5bc9538c87d9de6a6
+  data.tar.gz: 24d21638462c0dc1ce8cf1c685df35133d8d4c06
 SHA512:
-  metadata.gz: 049784897429ec2b7064da4217cd508d6557bdf4a3c9208e716a608d43c03b9f449a782cef01df03a1786ecb11216f2208ed576eaf1ef8ff93cd92a66ce347af
-  data.tar.gz: 64b6dbcd4d3e5b9e06f6b50fb1c1bfd6bd7b856d01b67f2357e46f93a0f716f600bce868b0aec0bd83d9a0e5a8141583aaf18a01a5a119766044f792c93a7467
+  metadata.gz: 6e554a728aa438a6293611ef53f7ac404932114a4ec91acee86295808d0ed39ce92e9e5afa2d1bdd5e1892bdddb949a3b6cb78b8bf61017457738e1ba4374465
+  data.tar.gz: d7294c09046932acc67f0778dacfa9f3e86d6bb3d37b864fb10e7e52c0630fff9a9e2095f287704c5ca7cdd636c05856b281a453ac09af334941954d2a5f0c43

data/CHANGELOG.md

@@ -1,9 +1,16 @@
+# v0.1.2 2016-01-19
+
+### Fixed
+
+* `xor` returns wrapped results when used against another result-rule (solnic)
+
 # v0.1.1 2016-01-18
 
 ### Added
 
 * `Rule::Attr` which can be applied to a data object with attr readers (SunnyMagadan)
 * `Rule::Result` which can be applied to a result object (solnic)
+* `true?` and `false?` predicates (solnic)
 
 [Compare v0.1.0...v0.1.1](https://github.com/dryrb/dry-logic/compare/v0.1.0...v0.1.1)
 

data/lib/dry/logic/result.rb

@@ -2,9 +2,12 @@ module Dry
   module Logic
     def self.Result(input, value, rule)
       case value
-      when Result then value.class.new(value.input, value.success?, rule)
-      when Array then Result::Set.new(input, value, rule)
-      else Result::Value.new(input, value, rule)
+      when Result
+        value.class.new(value.input, value.success?, rule)
+      when Array
+        Result::Set.new(input, value, rule)
+      else
+        Result::Value.new(input, value, rule)
       end
     end
 
@@ -72,6 +75,10 @@ module Dry
           [:input, [name, nil, [rule.to_ary]]]
         end
         alias_method :to_a, :to_ary
+
+        def wrapped?
+          true
+        end
       end
 
       def initialize(input, value, rule)
@@ -122,7 +129,14 @@ module Dry
       end
 
       def xor(other)
-        Logic.Result(input, success? ^ other.(input).success?, rule)
+        other_result = other.(input)
+        value = success? ^ other_result.success?
+
+        if other_result.wrapped?
+          Result::Wrapped.new(input, value, rule)
+        else
+          Logic.Result(other_result.input, value, rule)
+        end
       end
 
       def success?
@@ -132,6 +146,10 @@ module Dry
       def failure?
         ! success?
       end
+
+      def wrapped?
+        false
+      end
     end
   end
 end

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

@@ -3,9 +3,13 @@ module Dry
     class Rule::Result < Rule
       def call(input)
         result = input[name]
-        return result unless result.success?
         result_input = result.input
-        Result::Wrapped.new(input, predicate.(result_input), self)
+
+        if result.success?
+          Result::Wrapped.new(input, predicate.(result_input), self)
+        else
+          result
+        end
       end
 
       def type

data/lib/dry/logic/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Logic
-    VERSION = '0.1.1'.freeze
+    VERSION = '0.1.2'.freeze
   end
 end

data/spec/unit/rule/result_spec.rb

@@ -7,6 +7,7 @@ RSpec.describe Dry::Logic::Rule::Result do
 
   let(:is_str) { Dry::Logic::Rule::Value.new(:name, str?) }
   let(:is_jane) { Dry::Logic::Rule::Result.new(:name, eql?.curry('jane')) }
+  let(:is_john) { Dry::Logic::Rule::Result.new(:name, eql?.curry('john')) }
 
   describe '#call' do
     it 'returns result of a predicate' do
@@ -15,19 +16,76 @@ RSpec.describe Dry::Logic::Rule::Result do
       expect(rule.(name: is_str.(nil))).to be_failure
     end
 
-    it 'evaluates input for the ast' do
+    it 'evaluates successful input for the ast' do
       expect(rule.(name: is_str.('jane')).to_ary).to eql([
         :input, [
           :name, nil, [[:res, [:name, [:predicate, [:min_size?, [4]]]]]]
         ]
       ])
     end
+
+    it 'evaluates failed input for the ast' do
+      expect(rule.(name: is_str.(:john)).to_ary).to eql([
+        :input, [
+          :name, :john, [[:val, [:name, [:predicate, [:str?, []]]]]]
+        ]
+      ])
+    end
   end
 
   describe '#and' do
+    let(:conjunction) { rule.and(is_jane) }
+
     it 'returns result of a conjunction' do
-      expect(rule.and(is_jane).(name: is_str.('jane'))).to be_success
-      expect(rule.and(is_jane).(name: is_str.('john'))).to be_failure
+      expect(conjunction.(name: is_str.('jane'))).to be_success
+      expect(conjunction.(name: is_str.('john'))).to be_failure
+    end
+
+    it 'evaluates input for the ast' do
+      expect(conjunction.(name: is_str.('john')).to_ary).to eql([
+        :input, [
+          :name, nil, [[:res, [:name, [:predicate, [:eql?, ["jane"]]]]]]
+        ]
+      ])
+    end
+  end
+
+  describe '#xor' do
+    let(:xor) { rule.xor(is_john) }
+
+    it 'returns result of an exclusive disjunction' do
+      expect(xor.(name: is_str.('jane'))).to be_success
+      expect(xor.(name: is_str.('john'))).to be_failure
+    end
+
+    it 'evaluates input for the ast' do
+      result = xor.(name: is_str.('john'))
+
+      expect(result.to_ary).to eql([
+        :input, [
+          :name, nil, [[:res, [:name, [:predicate, [:min_size?, [4]]]]]]
+        ]
+      ])
+    end
+  end
+
+  describe '#then' do
+    let(:implication) { rule.then(is_jane) }
+
+    it 'returns result of an exclusive disjunction' do
+      expect(implication.(name: is_str.('jane'))).to be_success
+      expect(implication.(name: is_str.(nil))).to be_success
+      expect(implication.(name: is_str.('john'))).to be_failure
+    end
+
+    it 'evaluates input for the ast' do
+      result = implication.(name: is_str.('john'))
+
+      expect(result.to_ary).to eql([
+        :input, [
+          :name, nil, [[:res, [:name, [:predicate, [:eql?, ['jane']]]]]]
+        ]
+      ])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-logic
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-18 00:00:00.000000000 Z
+date: 2016-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-container