Close Menu

sculptor

Introduction

Welcome to the documentation for Sculptor, a powerful open-source framework that facilitates the development of scalable and maintainable iOS applications. Whether you are an experienced developer or just getting started with iOS development, this documentation will provide you with a detailed guide on how to effectively utilize Sculptor in your projects.

Key Features

  • Modularity: Sculptor encourages modular architecture, making it easier to isolate and test individual components of your app.
  • Dependency Injection: The framework simplifies the management of dependencies and improves the testability and flexibility of your code.
  • Data Persistence: Sculptor provides a straightforward approach to handling data persistence, allowing you to easily integrate various storage solutions into your app.
  • Networking: It includes a robust networking layer that facilitates communication with RESTful APIs and supports asynchronous operations.
  • User Interface: Sculptor offers a powerful set of UI components and utilities for building intuitive interfaces that follow the best iOS design practices.
  • Logging and Debugging: The framework provides extensive logging capabilities and debugging tools to simplify troubleshooting in your app.

Getting Started

If you are new to Sculptor, this section will guide you through the installation and setup process, allowing you to quickly start integrating Sculptor into your iOS projects.

Installation

To install Sculptor, follow these steps:

  1. Open Terminal and navigate to your project’s directory.
  2. Run the command pod init to create a new Podfile for your project.
  3. Edit the Podfile and add the following line: pod 'sculptor'.
  4. Run the command pod install to install Sculptor and its dependencies.
  5. Open the newly created .xcworkspace file in Xcode.

Configuration

Once you have installed Sculptor, you need to configure it before you can start using it in your project. Follow these steps:

  1. Create a new Swift file called SculptorConfig.swift in your project.
  2. Import the Sculptor framework at the top of the file: import Sculptor.
  3. Add the following code to configure Sculptor:

“`swift
import Sculptor

class SculptorConfig {
static func configure() {
// Add your custom configuration here
ServiceLocator.shared.register(Service.self) { _ in
// Register your services here
return MyWebService()
}
}
}
“`

Usage

Now that you have Sculptor installed and configured, let’s explore how to effectively use it in your iOS projects.

Dependency Injection

Sculptor simplifies dependency injection in your app. You can declare your dependencies and resolve them when needed.

To get started, follow these steps:

  1. In your class, declare a property with the appropriate protocol type.
  2. Use the @Inject attribute to mark the property for injection.
  3. Let Sculptor resolve and inject the dependency automatically.

Here is an example:

“`swift
import Sculptor

class MyViewController: UIViewController {
@Inject private var myService: Service

// Your code here…
}
“`

Data Persistence

Sculptor provides a convenient way to handle data persistence in your app. It supports multiple storage solutions, such as Core Data and Realm.

To start using data persistence in your project, follow these steps:

  1. Create your model objects or entities.
  2. Implement the necessary protocols for each model.
  3. Use the provided persistence manager to perform CRUD operations on your models.

Here is an example:

“`swift
import Sculptor

struct NoteEntity: Entity {
var id: String
var title: String
var content: String

init(id: String, title: String, content: String) {
self.id = id
self.title = title
self.content = content
}
}

class NoteRepository: Repository {
typealias Entity = NoteEntity
…

// Your code here…
}

class MyDataManager {
private let noteRepository: NoteRepository

init() {
self.noteRepository = Sculptor.resolve()
}

// Your code here…
}
“`

API Networking

Sculptor comes with a powerful networking layer that simplifies communication with RESTful APIs.

To perform API requests and handle responses, follow these steps:

  1. Create a reference to the necessary API service.
  2. Make requests using the provided API service methods.
  3. Handle the received responses and perform necessary actions.

Here is an example:

“`swift
import Sculptor

class MyAPIService {
private let apiClient: APIClient

init(apiClient: APIClient) {
self.apiClient = apiClient
}

func getUserDetails(userId: String, completion: @escaping (Result) -> Void) {
let request = APIRequest(url: “/users/\(userId)”, method: .get)

apiClient.sendRequest(request) { result in
switch result {
case .success(let data):
let decoder = JSONDecoder()
do {
let user = try decoder.decode(User.self, from: data)
completion(.success(user))
} catch {
completion(.failure(error))
}
case .failure(let error):
completion(.failure(error))
}
}
}

// Your code here…
}
“`

User Interface Components

Sculptor provides a set of UI components and utilities to help you build compelling iOS interfaces.

Here are some of the UI components included in Sculptor:

  • Button
  • Label
  • TextField
  • ImageView
  • ActivityIndicator
  • …

You can easily create and customize these components using Sculptor’s provided APIs.

Debugging and Logging

Sculptor offers extensive logging capabilities and debugging tools to simplify troubleshooting in your app.

To enable logging in Sculptor, set the desired log level in your app’s configuration:

“`swift
import Sculptor

class SculptorConfig {
static func configure() {
SculptorLogger.logLevel = .debug

// Add your custom configuration and services here
}
}
“`

You can then use Sculptor’s logging methods to print useful information during the runtime of your app.

Conclusion

Congratulations! You have successfully explored the main features of Sculptor and learned how to integrate and utilize it in your iOS projects. By following the guidelines and examples provided in this documentation, you can create scalable, maintainable, and powerful iOS applications.