DEV Community: Saeid Rezaei

Setting Up GitHub Actions for Continuous Integration

Saeid Rezaei — Sat, 21 Jun 2025 13:33:28 +0000

When working on a project, keeping your builds clean and your tests passing is key to a smooth development process. In this post, I'll guide you through setting up a GitHub Action workflow that automates building and testing your app every time you push changes to your repository.

Why GitHub Actions?

Continuous Integration (CI) is an essential part of modern app development. By integrating GitHub Actions into your workflow, you can ensure that every pull request and commit is automatically built and tested - catching issues early and boosting confidence in your codebase.

Getting Started

Before diving in, make sure you have:

A repository already set up on GitHub (in our case, SwiftUIDeepLinking).
Basic familiarity with GitHub Actions and YAML syntax.
Xcode is installed locally to verify that your project builds correctly.

Creating the Workflow File

GitHub Actions uses YAML files to define workflows. In your repository, create the following directory structure if it doesn't exist:

.github/
└── workflows/

Inside the workflows folder, create a file named ci.yml

Triggers: The on key specifies the events that will trigger the execution of your workflow. For a typical Swift project, you might want to trigger the CI process whenever code is pushed to the main branch or when a pull request is opened or updated targeting specific branches.

name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

Job Environment: This section defines one or more jobs that will be executed by the workflow. Each job has a unique identifier (e.g., build) and a more descriptive name that appears in the GitHub Actions UI (e.g., Build and Test). The runs-on key within a job definition specifies the type of virtual machine runner that will execute the job.

name: CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:
    name: Build and Test
    runs-on: macos-latest

Steps

Checkout Code: The workflow checks out your repository so that it can access your project files.

Set Up Xcode: Using the maxim-lobanov/setup-xcode action ensures that the correct version of Xcode is installed.

Build: This command cleans and builds your project. Adjust the -project and -scheme flags if your project structure differs.

name: CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:
    name: Build and Test
    runs-on: macos-latest

    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Set up Xcode
        uses: maxim-lobanov/setup-xcode@v1
        with:
          xcode-version: '16.2'
      - name: Build
        run: |
          xcodebuild clean build \
          -project Deep_Linking_with_TCA/DeepLinkTCA.xcodeproj \
          -scheme DeepLinkTCA \
          -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest'
          -skipPackagePluginValidation 
          -skipMacroValidation

Verifying Your Setup

Once you've committed the ci.yml file, navigate to the Actions tab in your GitHub repository. You should see your workflow listed and running on your next push or pull request. Any build or test errors will be displayed there, making it easier to catch issues early. Here is the link to the final ci.yml file.

Conclusion: Taking Your Swift CI/CD to the Next Level

Setting up a CI/CD pipeline for your Swift project using GitHub Actions offers numerous benefits, from improved code quality and reduced manual effort to faster feedback loops and accelerated development cycles. By automating the build and test processes, you can ensure that your codebase remains stable and reliable with every change.

Custom Text in SwiftUI

Saeid Rezaei — Mon, 12 Aug 2024 15:16:13 +0000

In this post, I’m going to talk about how to create custom Text in SwiftUI with ViewModifier.

The Text view in SwiftUI provides a convenient way to display and format text content in a clear and readable manner. But, as you develop more complex interfaces, you may find that you need to style your text in specific ways to meet the design requirements. In this case, you can use View Modifiers to add extra functionality and styling to the Text view.

The ViewModifier protocol in SwiftUI is a powerful tool that allows developers to modify the view in a more structured way. It provides an easy way to apply multiple modifiers to a single view and allows the developer to define custom modifiers that can be used across multiple views. This helps simplify and streamline the process of creating and maintaining complex user interfaces. The ViewModifier protocol also helps to create a more consistent look and feel across the user interface, and it can be used to create a wide range of custom user interface elements.

A View Modifier in SwiftUI is a type that conforms to the ViewModifier protocol. The protocol defines a single method named body that takes in a View and returns a modified version of that View. View Modifiers are applied to views by calling the modifier method on the view, passing in an instance of the View Modifier.

Here’s an example of how to create a View Modifier that adds an icon to the Text view:

struct IconText: ViewModifier {
    private var icon: Image

    init(icon: Image) {
        self.icon = icon
    }

    func body(content: Content) -> some View {
        HStack {
            icon
            content
        }
    }
}

We define a struct called IconText that conforms to the ViewModifier protocol. The body method takes in a Content view and returns a new view with an image on the left.

To use this View Modifier, you can simply call the modifier method on a Text view and pass in an instance of IconText:

Text("Icon button")
    .modifier(IconText(icon: Image(systemName: "play.fill")))

This will result in a Text with the text “Icon button” and a play icon on the left.

It’s worth noting that View Modifiers can be composed and applied to a view multiple times to achieve complex styling.

In conclusion, View Modifiers provide an elegant and reusable way to add functionality and styling to your SwiftUI views. They are a great tool for keeping your code clean and readable and are especially useful when you need to apply the same styling to multiple views. So, next time you’re developing a complex interface in SwiftUI, consider using View Modifiers to help simplify your code.

Reference Type and Value Type in Swift

Saeid Rezaei — Tue, 02 Apr 2024 15:38:49 +0000

In this post, I'm going to talk about one of the basic features of Swift, which exists in most programming languages.

Value type
Reference type

When working with variables in Swift, it's important to understand the difference between reference types and value types. In this story, we'll explore the key differences between the two and provide examples of when to use each type.

Reference types

such as classes, are variables that store a reference to an object in memory. When one variable is assigned to another variable, they both point to the same object in memory. Any changes made to the object will be reflected in both variables.

Value Types

on the other hand, are variables that store a copy of the object in memory. When one variable is assigned to another variable, they each get their own copy of the object. Any changes made to one variable will not affect the other variable.

Let's see an example for reference type:

final class User {
    var name: String
    init(name: String) {
        self.name = name
    }
}

var user1 = User(name: "Saeed")
var user2 = user1
user2.name = "David"

print(user1.name) // prints "David"
print(user2.name) // also prints "David"

In this example, we have a class called User with a property called name. We create two variables, user1 and user2, and assign user1 to user2. Since User is a reference type, both variables point to the same object in memory. When we change the name property of user2 to "David", the name property of user1 is also changed to "David".
Here's an example of a value type:

struct Location {
    var x: Int
    var y: Int
}

var location1 = Point(x: 0, y: 0)
var location2 = location1
location2.x = 5

print(location1.x) // prints 0
print(location2.x) // prints 5

In this example, we have a struct called Location with properties x and y. We create two variables, location1 and location2, and assign location1 to location2. Since Location is a value type, both variables have their own copy of the struct. When we change the x property of location2 to 5, the x property of location1 is not affected and remains 0.

In Swift, class is a reference type and struct is a value type.
It's important to understand the difference between reference types and value types and choose the appropriate type for your needs. Reference types are useful when you want multiple variables to refer to the same object in memory, while value types are useful when you want to maintain a separate copy of the object for each variable.
For example, If you ever programmed for UIKit you'll know that they use classes for views rather than structs. but SwiftUI uses struct, there are a couple of reasons for it which you can search and find out the benefits behind this decision.

Conclusion

Reference and Value types in Swift are two important concepts that every developer should be familiar with, they are the fundamental building blocks of the language, and using them correctly will make your code more efficient, readable and maintainable.

Reference Type and Value Type in Swift | by Saeid Rezaeisadrabadi | Towards Dev

When working with variables in Swift, it’s important to understand the difference between reference types and value types.

towardsdev.com