I found myself having to google this multiple times so I decide to write it here as a quick references for myself.

Git submodules is a way for you to keep a git repository as a subdirectory of another git repository. It’s useful when you want to incorporate and keep track of external code or framework that your project depends on. It’s like a poor man’s version of npm or cocoapods.

Anyway, to add a git submodules is very easy. It’s just simple a one liner. Eg:

git submodule add git@github.com:faizmokhtar/example-repo library/example-submodule

That’s it. But the steps to remove it are very tedious and it’s something that I always forgot how to. So here are the steps to completely remove it from your repository.

To Completely Remove Git Submodule

1. Open and edit the .gitmodules with your text editor.
2. Find and delete the relevant submodule lines:

   [submodule "library/example-submodule"]
       path = library/example-submodule
       url = git@github.com:faizmokhtar/example-repo.git

3. Open and edit .git/config file.
4. Find and delete the relevant submodule lines:

   [submodule "library/example-submodule"]
    url = git@github.com:faizmokhtar/example-repo.git

5. Delete the submodules.

   $~ rm -rf library/example-submodule

6. Delete the files in .git/modules

   $~ rm -rf .git/modules/example-submodule

7. Now, there should be some unstaged changes in your git staging area. Stage it and commit all the changes.

That should be it. Maybe you can turn this into a one liner bash script.

Until next time. ✌️

Cloud SQL Proxy is one of the ways to connect to your Cloud SQL instance. It’s useful if you want to securely connect to Cloud SQL from your local applications.

Here are the steps to setup Cloud SQL Proxy on your local machines:

1. Download and Setup Cloud SQL Proxy (macOS)

First of all you have to download it. I would recommend putting it at root (~/) folder.

$~ cd ~/
$~ curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.amd64
$~ chmod +x cloud_sql_proxy

2. Create a Google Service Account for the Proxy

A service account is a special type of Google account that belongs to your project. Instead of using your individual user’s credential, you can use service account to authenticate your application.

To set it up, follow these commands. You can replace "my-proxy-user" to your likings

$~ gcloud iam service-accounts create proxy-user --display-name "my-proxy-user"

Once you have created it, list it down to get the email of the service account.

$~ gcloud iam service-accounts list

Next, allow your service account to connect to the Cloud SQL proxy on your behalf. You can do this by giving Cloud SQL Client role to the service account.

Run the following commands. Replace [PROJECT_ID] and [SERVICE_ACCOUNT_EMAIL] with your own Google Project ID and the service account email that you got from the command before.

$~ gcloud projects add-iam-policy-binding [PROJECT_ID] --member \
serviceAccount:[SERVICE_ACCOUNT_EMAIL] --role roles/cloudsql.client

3. Create key.json

Next, generate a key.json for authentication to the service account. (I would recommend you to ignore this file in git)

$~ gcloud iam service-accounts keys create key.json --iam-account [SERVICE_ACCOUNT_EMAIL]

4. Start Cloud SQL Proxy

Finally to start the Cloud SQL Proxy, run the following commands. Replace the [INSTANCE_CONNECTION_NAME] with your own and the [PORT] based on the database you want to connect to.

$~ ./cloud_sql_proxy -instances=[INSTANCE_CONNECTION_NAME]=tcp:[PORT] -credential_file=key.json

If everything is working fine, you will get an output similar like this

2020/05/10 22:23:07 Listening on 127.0.0.1:5432 for [INSTANCE_CONNECTION_NAME]
2020/05/10 22:23:07 Ready for new connections

That’s pretty much it. You should be connected to your Cloud SQL from your local machine now.

Error Troubleshooting

If you happened to get following error:

listen tcp 127.0.0.1:5432: bind: address already in use

It’s likely you already have a local database instance running on your local machine that’s using the port 5432 (In this case it’s Postgresql). If this is the case, stop the running instance first.

Today I learned that you can actually create multiple Xcode screen previews in SwiftUI.

Assuming you have a SwiftUI View named ContentView. In the PreviewProvider, create a Group and init multiple ContentView() children inside of it. For example:

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        Group {
            ContentView()
                .previewDevice(PreviewDevice(rawValue: "iPhone 11"))
                .previewDisplayName("iPhone 11") // Optional
            ContentView()
                .previewDevice(PreviewDevice(rawValue: "iPhone 8"))
                .previewDisplayName("iPhone 8 Dark")
                .environment(\.colorScheme, .dark)
                .environment(\.sizeCategory, .accessibilityLarge)
            ContentView()
                .previewDevice(PreviewDevice(rawValue: "iPhone SE"))
                .previewDisplayName("iPhone SE")
        }

    }
}

This will display the View that you have created in 3 previews with the following order:

1. Display it in iPhone 11
2. Display it in iPhone 8 with dark mode enabled and large accessibility size font set
3. Display it in iPhone SE

Here’s how the above code will look like in action

This is going to be super useful when you want to quickly preview your View in different screen sizes, accessibility mode or color schemes. Neat huh?

References:

• Hacking With Swift - SwiftUI tips and tricks

Did you know that SwiftUI can be use in UIKit project? To use SwiftUI in UIKit project, you have to make use of UIHostingViewController. It is a UIViewController that basically “host” a SwiftUI view.

Assuming you have a SwiftUI View named SwiftUIView like so:

let swiftUIView = SwiftUIView()

Initializing it programmatically

To initialize it programmatically, set the SwiftUI View as the rootView of the UIHostingController.

let vc = UIHostingController(rootView: swiftUIView)
self.present(vc, animated: true, completion: nil)

Initializing it in Storyboard

Using it in Storyboard requires a little bit more work.

1. First, add a Hosting View Controller and create a segue to it

   

2. Then, create an IBSegueAction where you can init the UIHostingController like so

 @IBSegueAction func openSwiftUIView(_ coder: NSCoder) -> UIViewController? {
     return UIHostingController(coder: coder, rootView: swiftUIView))
 }

That’s it.

References:

1. Apple documentation on UIHostingController

Similar like Cocoapods or Carthage, you can use Swift Package Manager to manage the dependencies in your Cocoa project.

With the latest Xcode 11, there is now a native support for Swift Package Manager for you to use it directly in your project.

Adding a new package

To add a new package with Swift Package Manager is really easy. Go to the following Xcode’s menu:

File > Swift Packages > Add Package Dependency...

and add the package’s repository URL. That’s it.

For example, to add Alamofire library you just have to add https://github.com/Alamofire/Alamofire.git in the search field.

You then will have the option to configure the package based on the version, branch or even commit.

Once you have chosen the package target, you will noticed the newly added package at the bottom of Xcode’s Project Navigator. Now, you can import the package as usual.

Removing a package

To remove a package is easy too. Navigate to your project settings and you will noticed that there is a new section called Swift Packages. Navigate to it, click on your library and click on the minus button below to remove it.

Caveats

From my limited understanding of how it works, I was expecting Swift Package Manager to create a Package.swift file but instead it creates a references of the package in .xcodeproj file.

Based on my experience of how painful it is to solve a merge conflict in .xcodeproj file, this is definitely something that I probably would think twice before using it in a team project. Otherwise, using Swift Package Manager is really easy.

Hey, no rubygems dependencies is already a plus! 😉