Merge pull request adobe#26 from adobe/dev

Dev to main

.github/workflows/swift.yml

@@ -16,9 +16,20 @@ jobs:
 
     - name: Install swiftformat
       run: brew install swiftformat
+
+    - name: Install SwiftLint
+      run: brew install swiftlint
+
     - name: Linting
-      run: swiftformat --lint Sources
+      run: make lint; make check-format
+
     - name: Build
       run: swift build -v
+
     - name: Run tests
-      run: swift test -v      
+      run: swift test -v --enable-code-coverage  
+
+    - name: Upload Code Coverage 
+      run: make generate-lcov; bash <(curl -s https://codecov.io/bash)  
+
+

.swift-version

@@ -0,0 +1 @@
+5.0

.swiftlint.yml

@@ -1,3 +1,21 @@
 included: # paths to include during linting. `--path` is ignored if present.
   - Sources
-  - Tests
+
+line_length: 1000
+function_body_length: 500
+disabled_rules: # rule identifiers to exclude from running
+  - identifier_name
+  - force_cast
+  - todo
+  - multiple_closures_with_trailing_closure
+  - cyclomatic_complexity
+  - file_length
+  - unused_optional_binding
+  - implicit_getter
+  - shorthand_operator
+  - nesting
+  - switch_case_alignment
+  - orphaned_doc_comment
+  - type_name
+  - large_tuple
+  - trailing_comma

Makefile

@@ -0,0 +1,15 @@
+lint-autocorrect:
+	swiftlint autocorrect
+
+lint:
+	swiftlint lint
+
+check-format:
+	swiftformat --lint Sources
+
+format:
+	swiftformat .
+
+generate-lcov:
+	xcrun llvm-cov export -format="lcov" .build/debug/AEPRulesEnginePackageTests.xctest/Contents/MacOS/AEPRulesEnginePackageTests -instr-profile .build/debug/codecov/default.profdata > info.lcov
+

README.md

@@ -47,18 +47,22 @@ let rulesEngine = RulesEngine(evaluator: evaluator)
 
 ### Define Rules
 
-Any thing that conforms to the `Rule` protocol can be used as rule. The easiest way is to use the built-in `ConsequenceRule`.
-```
+Any thing that conforms to the `Rule` protocol can be used as rule. 
+``` Swift
+public class MobileRule: Rule {
+    init(condition: Evaluable) { self.condition = condition }
+    var condition: Evaluable
+}
 let condition = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc")
-let rule = ConsequenceRule(id: "sample-rule", condition: condition)
+let rule = MobileRule(condition: condition)
 rulesEngine.addRules(rules: [rule])
 ```
 However, a rule like this doesn't make much sense, without the ability to dynamically fetch a value it will always be true or false.
 
-```
+``` Swift
 let mustache = Operand<String>(mustache: "{{company}}")
 let condition = ComparisonExpression(lhs: mustache, operationName: "equals", rhs: "adobe")
-let rule = ConsequenceRule(id: "sample-rule", condition: condition)
+let rule = MobileRule(condition: condition)
 rulesEngine.addRules(rules: [rule])
 ```
 

Sources/AEPRulesEngine/ConditionEvaluator.swift

@@ -114,11 +114,6 @@ public extension ConditionEvaluator {
         addComparisonOperator(operation: "exists", type: Any?.self, closure: { lhs, _ in
             lhs != nil
         })
-
-//        self.addComparisonOperator(operation: "co", closure: { (lhs:Array<String>, rhs:String) in
-//            return lhs.contains(rhs)
-//        })
-//        self.addComparisonOperator(operation: "eq", type: AnyObject.self, closure: {$0.isEqual($1)})
     }
 
     private func addCaseInSensitiveOperators() {

Sources/AEPRulesEngine/Expression/Operand.swift

@@ -26,7 +26,7 @@ public enum Operand<T> {
             return value
         case let .token(token):
 
-            if let result = token.resolve(in: args[0]) {
+            if let result = token.resolve(in: args[0].transformer, data: args[0].data) {
                 return result as? T
             }
             return nil
@@ -57,15 +57,3 @@ extension Operand: CustomStringConvertible {
         }
     }
 }
-
-extension MustacheToken {
-    public func resolve(in context: Context) -> Any? {
-        switch self {
-        case let .function(name, innerToken):
-            let innerValue = innerToken.resolve(in: context)
-            return context.transformer.transform(name: name, parameter: innerValue ?? "")
-        case let .variable(path):
-            return context.data.get(key: path)
-        }
-    }
-}

Sources/AEPRulesEngine/Template/Segment.swift

@@ -31,5 +31,4 @@ public struct Segment {
     let type: Type
     let templateString: String
     let range: Range<String.Index>
-    var templateSubstring: String { String(templateString[range]) }
 }

Tests/AEPRulesEngineTests/UnitTests/ExpressionTests.swift

@@ -15,7 +15,7 @@ import XCTest
 
 @testable import AEPRulesEngine
 struct CustomOperand: Traversable {
-    func get(key:String) -> Any? {
+    func get(key: String) -> Any? {
         return key
     }
 }
@@ -47,6 +47,50 @@ class ExpressionTests: XCTestCase {
         XCTAssertTrue(result.value)
     }
 
+    func testOrSuccess() {
+        let evaluator = ConditionEvaluator(options: .defaultOptions)
+
+        let a = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc1")
+        let b = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc")
+        let c = LogicalExpression(operationName: "or", operands: a, b)
+        let result = c.evaluate(in: Context(data: [:], evaluator: evaluator, transformer: Transform()))
+        XCTAssertTrue(result.value)
+    }
+
+    func testOrFail() {
+        let evaluator = ConditionEvaluator(options: .defaultOptions)
+
+        let a = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc1")
+        let b = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc1")
+        let c = LogicalExpression(operationName: "or", operands: a, b)
+        let result = c.evaluate(in: Context(data: [:], evaluator: evaluator, transformer: Transform()))
+        XCTAssertTrue(!result.value)
+    }
+
+    func testUnknownOperation() {
+        let evaluator = ConditionEvaluator(options: .defaultOptions)
+
+        let a = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc1")
+        let b = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc1")
+        let c = LogicalExpression(operationName: "unkonwn", operands: a, b)
+        let result = c.evaluate(in: Context(data: [:], evaluator: evaluator, transformer: Transform()))
+        XCTAssertTrue(!result.value)
+    }
+
+    func testUnaryExpression() {
+        let evaluator = ConditionEvaluator(options: .defaultOptions)
+        evaluator.addUnaryOperator(operation: "isTrue") { (_: CustomOperand) -> Bool in
+            true
+        }
+
+        let mustache = Operand<CustomOperand>(mustache: "{{custom}}")
+        let a = UnaryExpression(lhs: mustache, operationName: "isTrue")
+        let b = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc")
+        let c = LogicalExpression(operationName: "and", operands: a, b)
+        let result = c.evaluate(in: Context(data: ["custom1": CustomOperand()], evaluator: evaluator, transformer: Transform()))
+        XCTAssertTrue(!result.value)
+    }
+
     func testMustache() {
         let evaluator = ConditionEvaluator(options: .defaultOptions)
         let mustache = Operand<String>(mustache: "{{key}}")
@@ -57,12 +101,22 @@ class ExpressionTests: XCTestCase {
         XCTAssertTrue(result.value)
     }
 
-    func testMustache_Nil() {
+    func testMustacheNotFound() {
         let evaluator = ConditionEvaluator(options: .defaultOptions)
         let mustache = Operand<String>(mustache: "{{key}}")
         let a = ComparisonExpression(lhs: mustache, operationName: "equals", rhs: "abc")
         let b = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc")
         let c = LogicalExpression(operationName: "and", operands: a, b)
+        let result = c.evaluate(in: Context(data: ["key1": "abc"], evaluator: evaluator, transformer: Transform()))
+        XCTAssertTrue(!result.value)
+    }
+
+    func testMustache_Nil() {
+        let evaluator = ConditionEvaluator(options: .defaultOptions)
+        let mustache = Operand<String>(mustache: "{{key}}")
+        let a = ComparisonExpression(lhs: mustache, operationName: "equals", rhs: "abc")
+        let b = ComparisonExpression(lhs: "abc", operationName: "equals", rhs: "abc")
+        let c = LogicalExpression(operationName: "and", operands: [a, b])
         let result = c.evaluate(in: Context(data: ["someelse": "abc"], evaluator: evaluator, transformer: Transform()))
         XCTAssertFalse(result.value)
     }
@@ -102,4 +156,14 @@ class ExpressionTests: XCTestCase {
         let result = c.evaluate(in: Context(data: ["custom": CustomOperand()], evaluator: evaluator, transformer: Transform()))
         XCTAssertTrue(result.value)
     }
+
+    func testComparisonExpressionWithDifferentTypes() {
+        let evaluator = ConditionEvaluator(options: .defaultOptions)
+        evaluator.addComparisonOperator(operation: "equals") { (_: String, _: Int) -> Bool in
+            true
+        }
+        let a = ComparisonExpression(lhs: "3", operationName: "equals", rhs: 3)
+        let result = a.evaluate(in: Context(data: [:], evaluator: evaluator, transformer: Transform()))
+        XCTAssertTrue(result.value)
+    }
 }

Tests/AEPRulesEngineTests/UnitTests/OperandTests.swift

@@ -0,0 +1,39 @@
+/*
+ Copyright 2020 Adobe. All rights reserved.
+ This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License. You may obtain a copy
+ of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software distributed under
+ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ OF ANY KIND, either express or implied. See the License for the specific language
+ governing permissions and limitations under the License.
+ */
+
+import Foundation
+import XCTest
+
+@testable import AEPRulesEngine
+
+class OperandTests: XCTestCase {
+
+    func testMustacheNoneValue() {
+        let mustache = Operand<String>(mustache: "")
+        XCTAssertEqual("<None>", String(describing: mustache))
+    }
+
+    func testDoubleValue(){
+        let operand = Operand(floatLiteral: 1.2)
+        XCTAssertEqual("<Value:1.2>", String(describing: operand))
+    }
+
+    func testBoolValue(){
+        let operand = Operand(booleanLiteral: true)
+        XCTAssertEqual("<Value:true>", String(describing: operand))
+    }
+
+    func testNilValue(){
+        let operand: Operand<String> = nil
+        XCTAssertEqual("<None>", String(describing: operand))
+    }
+}

Tests/AEPRulesEngineTests/UnitTests/ParserTests.swift

@@ -34,6 +34,12 @@ class ParserTests: XCTestCase {
         let result = template.render(data: ["test": "value"], transformers: Transform())
         XCTAssertEqual("sdfdfdvalueaaa", result)
     }
+
+    func testCustomizedTokenFormat() {
+        let template = Template(templateString: "sdfdfd[[test]]aaa", tagDelimiterPair: ("[[","]]"))
+        let result = template.render(data: ["test": "value"], transformers: Transform())
+        XCTAssertEqual("sdfdfdvalueaaa", result)
+    }
 
     func testTransform() {
         let template = Template(templateString: "sdfdfd{{dash(test)}}aaa")

Tests/AEPRulesEngineTests/UnitTests/RulesEngineLogLevelTests.swift

@@ -0,0 +1,30 @@
+/*
+ Copyright 2020 Adobe. All rights reserved.
+ This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License. You may obtain a copy
+ of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software distributed under
+ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ OF ANY KIND, either express or implied. See the License for the specific language
+ governing permissions and limitations under the License.
+ */
+
+@testable import AEPRulesEngine
+import XCTest
+
+class RulesEngineLogLevelTests: XCTestCase {
+
+    func testLogLevelComparison() {
+        XCTAssertTrue(RulesEngineLogLevel.error < RulesEngineLogLevel.warning)
+        XCTAssertTrue(RulesEngineLogLevel.warning < RulesEngineLogLevel.debug)
+        XCTAssertTrue(RulesEngineLogLevel.debug < RulesEngineLogLevel.trace)
+    }
+
+    func testLogLevelToString() {
+        XCTAssertEqual(RulesEngineLogLevel.error.toString(), "ERROR")
+        XCTAssertEqual(RulesEngineLogLevel.warning.toString(), "WARNING")
+        XCTAssertEqual(RulesEngineLogLevel.debug.toString(), "DEBUG")
+        XCTAssertEqual(RulesEngineLogLevel.trace.toString(), "TRACE")
+    }
+}