How do I find all the modifications of a given string using git

Luka Bratos — Sat, 18 Apr 2020 10:29:17 +0000

A few days ago I was reviewing some code. While looking at one class, one of the global variables caught my attention. I wanted to understand why it was to that class and who wrote it.

The first thing I did was to run git blame command. It gave me the context about the last modification and the developer who made it. Yet, sometimes seeing just the most recent change is not enough.

Luckily, there is a way to see the entire lifecycle of a variable changing through git history. You just need to dig deeper.

Behold the git pickaxe ⛏🪓 🦖🦴

Like an archaeologist, looking for an ancient civilization, we can use the (git) pickaxe!

I didn’t know about this until today, but looking at git’s documentation, I found this gem of a command, that lets you find all the commits contaning a modification of a given string:

git log -S isPizzaDelivered

Let’s say you’re looking for a flag isPizzaDelivered, you need to pass it as a -S¹ argument.

You might be familiar with git log which will return list of all the commits, but this uses the -S flag which does all the heavy lifting. That’s your pickaxe that lets you dig through the commits.

Since git version 1.7.4 you can also use the flag -G² which lets you regular expressions.

As a result you will receive a list of commits which include changes to the string that you’ve specified and that’s really useful to learn more about the context and lifecycle in which the variable was being used.

It’s always valuable to invest your time in the tools you use on a daily basis.

As my friend @zmarkan says, your tools do sometimes indeed give you superpowers.

How do you search through your git history? Do you have any tricks to share?
Let me know!

-S<string> ↩
-G<regex> ↩

How to save Swift Enum Types with Associated Values

Luka Bratos — Sun, 08 Sep 2019 15:00:16 +0000

In this blog post we will explore how to create enumerations with associated values, make them conform to the Codable protocol by implementing Decoder and Encoder, and persist them to the file.

Motivation

In one of the SDKs that I’ve been recently working on we wanted to provide functionality where we could persist all of the network operations to the persistent data store in case our customers device lost network connectivity.
We wanted to be able to retrieve operations later in time from the client in the same order that they’d been enqueued in, and execute every single one of them when the user’s device reconnects to the internet - we wanted to implement a queue. Because we have been using enum with associated values to describe operations in a type-safe way I’ve decided to explore further how could I implement all of the requirements.

Associated values

Associated values in Swift let us store additional data of any type to enum case values.

Lets say that we have encoded some operations related to the user profile update in an enum:

enum UserProfileOperations {
    case updateProfilePicture(URL)
    case updateDateOfBirth(Int)
}

Constants or variables of UserProfileOperations enumeration can either store a value of updateProfilePicture with an associated value of type URL or a value updateDateOfBirth with an associated value of type Int.

This example creates a new variable called profilePictureOperation and assigns it a value of UserProfileOperations.updateProfilePicture with associated value URL(string: "https://via.placeholder.com/150/1ee8a4"):

let profilePictureOperation = UserProfileOperations.updateProfilePicture(URL(string: "https://via.placeholder.com/150/1ee8a4")!)

Similar example for dateOfBirthOperation variable where we assign UNIX timestamp (associated value of type Int) to the value UserProfileOperations.updateDateOfBirth:

let dateOfBirthOperation = UserProfileOperations.updateDateOfBirth(1561825023)

Adding Codable conformance

Since Swift 4.1 cannot automatically synthesize conformance to the Codable if we’re using enum with one or more associated values we have to do that manually:

We will start by creating an extension of UserProfileOperations enum that conforms to the Codable protocol:

extension UserProfileOperations: Codable {
    ...
}

Next, we will define coding keys, which will be used as the authoritative list of properties that must be included when instances of a codable type are encoded or decoded:

extension UserProfileOperations: Codable {
    enum CodingKeys: CodingKey {
        case profilePictureURL
        case dobTimestamp
    }
}

If keys in our JSON payload differ from the ones that we have defined in CodingKeys we’ll receive an error.

Because Codable is a type alias for the Encodable and Decodable protocols we need to make sure that our enum conforms to both. Lets start with implementation of the required method for Decodable: init(from:):

extension UserProfileOperations: Codable {
    ...

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        // Decode the value of `profilePictureURL` from the decoder.
        if let profilePictureURL = try? container.decode(URL.self, forKey: .profilePictureURL) {
            self = .updateProfilePicture(profilePictureURL)
            return
        }
        if let dob = try? container.decode(Int.self, forKey: .dobTimestamp) {
            self = .updateDateOfBirth(dob)
            return
        }
        // If the keys used in serialized data format don't match with ones specified
        // in `CodingKeys`, throw an error.
        throw CodingError.message("Error: \(dump(container))")
    }
}

Lastly, we need to provide implementation for Encodable, which is method encode(to:):

extension UserProfileOperations: Codable {
    ...

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case .updateProfilePicture(let url):
            try container.encode(url, forKey: .profilePictureURL)
        case .updateDateOfBirth(let dob):
            try container.encode(dob, forKey: .dobTimestamp)
        }
    }
}

Encoding and Decoding

We can encode profilePictureOperation by using JSONEncoder:

let encoder = JSONEncoder()
let profilePictureOperation = UserProfileOperations.updateProfilePicture(URL(string: "https://via.placeholder.com/150/1ee8a4")!)
let data = try! encoder.encode(profilePictureOperation)
let jsonString = String(data: data, encoding: .utf8)!
print(jsonString) // {"profilePictureURL":"https:\/\/via.placeholder.com\/150\/1ee8a4"}

And do the reverse, by using JSONDecoder:

let decoder = JSONDecoder()
let profilePictureJSONString = """
{"profilePictureURL":"https://via.placeholder.com/150/1ee8a4"}
"""
let profilePictureOperation = try! decoder.decode(UserProfileOperations.self, from: profilePictureJSONString.data(using: .utf8)!)

Persisting values atomically to the file

Lets create a few instances of our UserProfileOperations enum and add them into array:

let johnProfilePictureURL = UserProfileOperations.updateProfilePicture(URL(string: "https://via.placeholder.com/150/197d29")!)
let johnDateOfBirthOperation = UserProfileOperations.updateDateOfBirth(1561825023)

let kateProfilePictureURL = UserProfileOperations.updateProfilePicture(URL(string: "https://via.placeholder.com/150/c70a4d")!)
let kateDateOfBirthOperation = UserProfileOperations.updateDateOfBirth(733622400)

let timProfilePictureURL = UserProfileOperations.updateProfilePicture(URL(string: "https://via.placeholder.com/150/56acb2")!)
let timDateOfBirthOperation = UserProfileOperations.updateDateOfBirth(586915200)

let operations = [johnProfilePictureURL, johnDateOfBirthOperation, kateProfilePictureURL, kateDateOfBirthOperation, timProfilePictureURL, timDateOfBirthOperation]

In the next step we will create a JSONEncoder and use it to encode our operations array into the data object which will contain encoded JSON data.

let jsonEncoder = JSONEncoder()
let data = jsonEncoder.encode(operations)

Finally, we can persist this information into the file:

let url = URL(fileURLWithPath: "operations")
data.write(to: url, options: .atomic)

Reading values from the file

let operationsData = try! Data(contentsOf: url)
let jsonDecoder = JSONDecoder()
let operationsArray = try! jsonDecoder.decode([UserProfileOperations].self, from: operationsData)

Conclusion

In this blog post we have looked into associated values and implemented required methods to conform to the Codable protocol. We have then encoded and decoded values by using JSONEncoder and JSONDecoder.
Finally, we have saved the data into the file so it can be retrieved and deserialized back when needed.

I hope you enjoyed this post. Questions? Feedback? Hit me up on Twitter!

You can download the Swift Playgrounds file here.

Forem: Luka Bratos