https://github.com/sharplet/regex

A delightful and expressive regular expression type for Swift.
https://github.com/sharplet/regex

Last synced: 9 days ago
JSON representation

A delightful and expressive regular expression type for Swift.

• Host: GitHub
• URL: https://github.com/sharplet/regex
• Owner: sharplet
• License: mit
• Created: 2015-10-29T22:09:51.000Z (about 9 years ago)
• Default Branch: master
• Last Pushed: 2021-04-13T14:42:19.000Z (over 3 years ago)
• Last Synced: 2024-10-22T22:49:37.337Z (16 days ago)
• Language: Swift
• Homepage:
• Size: 8.25 MB
• Stars: 612
• Watchers: 6
• Forks: 48
• Open Issues: 6
• Metadata Files:
  • Readme: README.md
  • Contributing: CONTRIBUTING.md
  • License: LICENSE.txt

Awesome Lists containing this project

README

        
# Regex

Pattern match like a boss.

## Usage

Create:

```swift

// Use `Regex.init(_:)` to build a regex from a static pattern

let greeting = Regex("hello (world|universe)")

// Use `Regex.init(string:)` to construct a regex from dynamic data, and

// gracefully handle invalid input

var validations: [String: Regex]

for (name, pattern) in config.loadValidations() {

  do {

    validations[name] = try Regex(string: pattern)

  } catch {

    print("error building validation \(name): \(error)")

  }

}

```

Match:

```swift

if greeting.matches("hello universe!") {

  print("wow, you're friendly!")

}

```

_Pattern_ match:

```swift

switch someTextFromTheInternet {

case Regex("DROP DATABASE (.+)"):

  // TODO: patch security hole

default:

  break

}

```

Capture:

```swift

let greeting = Regex("hello (world|universe|swift)")

if let subject = greeting.firstMatch(in: "hello swift")?.captures[0] {

  print("ohai \(subject)")

}

```

Find and replace:

```swift

"hello world".replacingFirst(matching: "h(ello) (\\w+)", with: "H$1, $2!")

// "Hello, world!"

```

Accessing the last match:

```swift

switch text {

case Regex("hello (\\w+)"):

  if let friend = Regex.lastMatch?.captures[0] {

    print("lovely to meet you, \(friend)!")

  }

case Regex("goodbye (\\w+)"):

  if let traitor = Regex.lastMatch?.captures[0] {

    print("so sorry to see you go, \(traitor)!")

  }

default:

  break

}

```

Options:

```swift

let totallyUniqueExamples = Regex("^(hello|foo).*$", options: [.ignoreCase, .anchorsMatchLines])

let multilineText = "hello world\ngoodbye world\nFOOBAR\n"

let matchingLines = totallyUniqueExamples.allMatches(in: multilineText).map { $0.matchedString }

// ["hello world", "FOOBAR"]

```

Decode:

```swift

let json = """

  [

    {

      "name" : "greeting",

      "pattern" : "^(\\\\w+) world!$"

    }

  ]

  """.data(using: .utf8)!

struct Validation: Codable {

  var name: String

  var pattern: Regex

}

let decoder = JSONDecoder()

try decoder.decode(Validation.self, from: json)

// Validation(name: "greeting", pattern: /^(\w+) world!/)

```

Ranges:

```swift

let lyrics = """

  So it's gonna be forever

  Or it's gonna go down in flames

  """

let possibleEndings = Regex("it's gonna (.+)")

    .allMatches(in: lyrics)

    .flatMap { $0.captureRanges[0] }

    .map { lyrics[$0] }

// it's gonna: ["be forever", "go down in flames"]

```

## Installation

Regex supports Swift 4.2 and above, on all Swift platforms.

#### Swift Package Manager

Add a dependency to your `Package.swift`:

```swift

let package = Package(

  name: "MyPackage",

  dependencies: [

    // other dependencies...

    .package(url: "https://github.com/sharplet/Regex.git", from: "2.1.0"),

  ]

)

```

#### Carthage

Put this in your Cartfile:

```

github "sharplet/Regex" ~> 2.1

```

#### CocoaPods

Put this in your Podfile:

```ruby

pod "STRegex", "~> 2.1"

```

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).

## Development Setup

### Swift Package Manager

Build and run the tests:

```

swift test

# or just

rake test:package

```

If you're on a Mac, testing on Linux is supported via [Docker for Mac](https://www.docker.com/docker-mac).

Once Docker is set up, start a Linux shell:

```

rake docker

```

And run the tests via Swift Package Manager.

### Xcode

`xcpretty` is recommended, for prettifying test output:

```

gem install xcpretty

```

Then run the tests:

```

# one of

rake test:osx

rake test:ios

rake test:tvos

```

### Formatting & Linting

Regex uses [SwiftFormat](https://github.com/nicklockwood/SwiftFormat) to

maintain consistent code formatting.

Regex uses [SwiftLint](https://github.com/realm/SwiftLint) to validate code style.

SwiftLint is automatically run against pull requests using [Hound CI](https://houndci.com/).

When submitting a pull request, running these tools and addressing any issues

is much appreciated!

```

brew bundle

swiftformat .

swiftlint

```

## License

See [LICENSE.txt](LICENSE.txt).