Swiftpack.co - nsagora/peppermint as Swift Package

Swiftpack.co is a collection of thousands of indexed Swift packages. Search packages.
nsagora/peppermint
Declarative data validation framework, written in Swift
.package(url: "https://github.com/nsagora/peppermint.git", from: "1.0.0")

Peppermint badge-version

badge-build-macos badge-build-linux badge-codecov badge-docs badge-license badge-twitter

  1. Introduction
  2. Requirements
  3. Installation
  4. Usage Examples
  5. Contribute
  6. Meta

Introduction

let constraint = TypeConstraint<Account, Account.Error> {
    KeyPathConstraint(\.username) {
        BlockConstraint {
            $0.count >= 5
        } errorBuilder: {
            .username
        }
    }
    KeyPathConstraint(\.password) {
        GroupConstraint(.all) {
            PredicateConstraint {
                CharacterSetPredicate(.lowercaseLetters, mode: .inclusive)
            } errorBuilder: {
                .password(.missingLowercase)
            }
            PredicateConstraint{
                CharacterSetPredicate(.uppercaseLetters, mode: .inclusive)
            } errorBuilder: {
                .password(.missingUppercase)
            }
            PredicateConstraint {
                CharacterSetPredicate(.decimalDigits, mode: .inclusive)
            } errorBuilder: {
                .password(.missingDigits)
            }
            PredicateConstraint {
                CharacterSetPredicate(CharacterSet(charactersIn: "!?@#$%^&*()|\\/<>,.~`_+-="), mode: .inclusive)
            } errorBuilder: {
                .password(.missingSpecialChars)
            }
            PredicateConstraint {
                LengthPredicate(min: 8)
            }  errorBuilder: {
                .password(.tooShort)
            }
        }
    }
    BlockConstraint {
        $0.password == $0.passwordConfirmation
    } errorBuilder: {
        .password(.confirmationMismatch)
    }
    KeyPathConstraint(\.email) {
        PredicateConstraint(EmailPredicate(), error: .email)
    }
    KeyPathConstraint(\.age) {
        PredicateConstraint(RangePredicate(min: 14), error: .underAge)
    }
    KeyPathConstraint(\.website) {
        OptionalConstraint {
            PredicateConstraint(URLPredicate(), error: .website)
        }
    }
}

let result = constarint.evaluate(with: account)
switch result {
case .success:
    handleSuccess()
case .failure(let summary):
    handleErrors(summary.errors)
}

Peppermint is a declarative and lightweight data validation framework.

At the core of it, there are 2 principles:

  • Empower composition.
  • Embrace standard library.

Every project is unique in it's own challenges and it's great when we can focus on solving them instead of spending our time on boilerplate tasks.

With this idea in mind, the framework follows the Protocol Oriented Programming paradigm and was designed from a small set of protocols and structures that can easily be composed to fit your project needs. Thus, you can think of Peppermint as an adjustable wrench more than a Swiss knife.

Since validation can take place at many levels, Peppermint is available on iOS, macOS, tvOS, watchOS and native Swift projects, such as server-side apps.

Requirements

  • Swift 4.2+
  • iOS 8.0+ / macOS 10.10+ / tvOS 9.0+ / watchOS 2.0+
  • Xcode 8.1+

Installation

Peppermint is available only through Swift Package Manager.

Swift Package Manager

You can add Peppermint to your project in Xcode by going to File > Swift Packages > Add Package Dependency.

Or, if you want to use it as a dependency to your own package, you can add it to your Package.swift file:

import PackageDescription

let package = Package(
    name: "YOUR_PROJECT_NAME",
    targets: [],
    dependencies: [
        .Package(url: "https://github.com/nsagora/peppermint", majorVersion: 1),
    ]
)

Usage example

For a comprehensive list of examples try out the Examples.playground:

  1. Download the repository locally on your machine
  2. Open the project in Xcode
  3. Select the Examples playground from the Project navigator

The Peppermint framework is compact and offers you the foundation you need to build data validation around your project needs. In addition, it includes a set of common validation predicates and constraints that most projects can benefit off.

Predicates

The Predicate represents the core protocol and has the role to evaluate if an input matches on a given validation condition.

At the core of Peppermint there are the following two predicates, which allows you to compose predicates specific to the project needs:

BlockPredicate
let predicate = BlockPredicate<String> { $0.characters.count > 2 }
predicate.evaluate(with: "a") // returns false
predicate.evaluate(with: "abc") // returns true
RegexPredicate
let predicate = RegexPredicate(expression: "^[a-z]$")
predicate.evaluate(with: "a") // returns true
predicate.evaluate(with: "5") // returns false
predicate.evaluate(with: "ab") // returns false

In addition, the framework offers a set of common validation predicates that your project can benefit of:

EmailPredicate
let predicate = EmailPredicate()
predicate.evaluate(with: "hello@") // returns false
predicate.evaluate(with: "hello@nsagora.com") // returns true
predicate.evaluate(with: "héllo@nsagora.com") // returns true
URLPredicate
let predicate = URLPredicate()
predicate.evaluate(with: "http://www.url.com") // returns true
predicate.evaluate(with: "http:\\www.url.com") // returns false
RangePredicate
let predicate = let range = RangePredicate(10...20)
predicate.evaluate(with: 15) // returns true
predicate.evaluate(with: 21) // returns false
LengthPredicate
let predicate = let range = LengthPredicate<String>(min: 5)
predicate.evaluate(with: "abcde")   // returns true
predicate.evaluate(with: "abcd")    // returns false

On top of that, developers can build more advanced or complex predicates by extending the Predicate protocol, and/ or by composing or decorating the existing predicates:

Custom Predicate
public struct CustomPredicate: Predicate {

    public typealias InputType = String

    private let custom: String

    public init(custom: String) {
        self.custom = custom
    }

    public func evaluate(with input: String) -> Bool {
        return input == custom
    }
}

let predicate = CustomPredicate(custom: "alphabet")
predicate.evaluate(with: "alp") // returns false
predicate.evaluate(with: "alpha") // returns false
predicate.evaluate(with: "alphabet") // returns true

Constraints

Predicate Constraint

A PredicateConstraint represents a data type that links a Predicate to an Error, in order to provide useful feedback for the end users.

PredicateConstraint
let predicate = BlockPredicate<String> { $0 == "Mr. Goodbytes" }
let constraint = PredicateConstraint<String, MyError>(predicate: predicate, error: .magicWord)

let result = constraint.evaluate(with: "please")
switch result {
case .valid:
    print("access granted...")
case .invalid(let summary):
    print("Ah Ah Ah! You didn't say the magic word!")
}  // prints "Ah Ah Ah! You didn't say the magic word!"
enum MyError: Error {
    case magicWord
}

Block Constraint

A BlockConstraint represents a data type that links a custom validation closure to an Error that describes why the evaluation has failed. It's a shortcut of a PredicateConstraint that is initialised with a BlockPredicate.

BlockConstraint
let constraint = BlockConstraint<Int, MyError> {
    $0 % 2 == 0
} errorBuilder: {
    .magicNumber
}

let anyConstraint = AnyConstraint(constraint)
anyConstraint.evaluate(with: 3)
enum Failure: MyError {
    case magicNumber
}

Group Constraint

A GroupConstraint represents a composition of constraints that allows the evaluation to be made on:

  • all constraints
  • or any of the constraints

To provide context, a GroupConstraint allows us to constraint a piece of data as being required and also as being a valid email.

GroupConstraintAn example of a registration form, whereby users are prompted to enter a strong password. This process typically entails some form of validation, but the logic itself is often unstructured and spread out through a view controller.

Peppermint seeks instead to consolidate, standardise, and make explicit the logic that is being used to validate user input. To this end, the below example demonstrates construction of a full GroupConstraint object that can be used to enforce requirements on the user's password data:

var passwordConstraint = GroupConstraint<String, Form.Password>(.all) {
    PredicateConstraint {
        CharacterSetPredicate(.lowercaseLetters, mode: .loose)
    } errorBuilder: {
        .missingLowercase
    }
    PredicateConstraint{
        CharacterSetPredicate(.uppercaseLetters, mode: .loose)
    } errorBuilder: {
        .missingUppercase
    }
    PredicateConstraint {
        CharacterSetPredicate(.decimalDigits, mode: .loose)
    } errorBuilder: {
        .missingDigits
    }
    PredicateConstraint {
        CharacterSetPredicate(CharacterSet(charactersIn: "!?@#$%^&*()|\\/<>,.~`_+-="), mode: .loose)
    } errorBuilder: {
        .missingSpecialChars
    }
    PredicateConstraint {
        LengthPredicate(min: 8)
    }  errorBuilder: {
        .minLength(8)
    }
}

let password = "3nGuard!"
let result = passwordConstraint.evaluate(with: password)

switch result {
case .success:
    print("Wow, that's a 💪 password!")
case .failure(let summary):
    print(summary.errors.map({$0.localizedDescription}))
} // prints "Wow, that's a 💪 password!"

From above, we see that once we've constructed the passwordConstraint, we're simply calling evaluate(with:) to get our evaluation Result. This contains a Summary that can be handled as we please.

Contribute

We would love you for the contribution to Peppermint, check the LICENSE file for more info.

Meta

This project is developed and maintained by the members of iOS NSAgora, the community of iOS Developers of Iași, Romania.

Distributed under the MIT license. See LICENSE for more information.

[https://github.com/nsagora/peppermint]

GitHub

link
Stars: 36
Last commit: 5 weeks ago

Ad: Job Offers

iOS Software Engineer @ Perry Street Software
Perry Street Software is Jack’d and SCRUFF. We are two of the world’s largest gay, bi, trans and queer social dating apps on iOS and Android. Our brands reach more than 20 million members worldwide so members can connect, meet and express themselves on a platform that prioritizes privacy and security. We invest heavily into SwiftUI and using Swift Packages to modularize the codebase.

Submit a free job ad (while I'm testing this). The analytics numbers for this website are here.

Release Notes

Release 1.0.0
14 weeks ago

Added:

  • Support for result builders
  • BlockConstraint constraint
  • OptionalConstraint constraint

Removed:

  • PairMatchingPredicate predicate
  • ConditionedConstraint constraint

Enhanced:

  • CompoundConstraint into GroupConstraint
  • Consistency between APIs
  • Documentation and usage examples

Swiftpack is being maintained by Petr Pavlik | @ptrpavlik | @swiftpackco | API | Analytics