DEV Community: Juan Dorado

I-VIPER | Xcode Template

Juan Dorado — Sat, 12 Sep 2020 01:56:05 +0000

This template is one I have named I-VIPER, and you could also see it such as:

JAVAT: Just another VIPER architecture template

This architecture was created from the union of different resources, but, I think the most involved resource comes from The.Swift.Dev.

You can see through his page a lot of VIPER related articles.

The Ultimate VIPER Architecture tutorial

I don't want to dig deeper in what VIPER is, there is a lot of great resources around internet that have well-explanations of it.

But basically it is an architecture that helps to decouple layers and see our features as modules, instead of Controllers.

Remember there is no a final rule!, this is just a guideline that you could adapt it to your needs.

So let's give a short summary

I recommend you to take a look to The.Swift.Dev article, this is going to be a short summary of it.

VIPER architecture is one of the most popular architectures to write scalable and maintainable software.

Some people like it, some other don't, anyway, it will depend on each developer/team.

VIPER architecture is conformed through these layers.

View

The View usually is mostly conformed by UIViewController (or related) subclasses.

The idea is to don't have any business logic in here, it is in charge to just present and catch events.

Interactor

The Interactor's job is to retrieving data from the model layer, this can prepare and transform the data that you get from a database or a service.

DataBases and Services are not part of VIPER so they are treated as separate components, the best practice is to use DI (Dependency Injection) to handle this.

Presenter

The Presenter is responsible to format the data that is going to be displayed, also because it is connected to the View it also works as an event handler.

It is the CORE of VIPER because it connects with the Interactor and the Router.

Entity

The Entity is a plain model class mostly used by the Interactor, basically your model.

Router

This is the navigation logic, it also prepares the view.

Another good practice in Router is to use a Builder to decouple responsibilities to the router, use the builder to build your view and router just to navigate.

Now! How to use these templates?

Installation

The installation of these templates is really easy, you just need to use your terminal and locate yourself to the folder that you download from I-VIPER | fdorado985 | GitHub

The main image at the top is also a link to this repository.

A quick shortcut is to just type cd (change directory) command on your terminal and a space (don't forget the space), drag and drop your I-VIPER folder and press enter.

Then just run this command

make install_templates

Once installed, you can use them in your project.

How to use

You just need to create a New File and look for Module in the I-VIPER section you installed before

Give the module name, and which subclass do you want to use from the three available in there.

And if you want or not to create an entity for your module.

Quick Fix

Unfortunately the module created is added as reference folders (or virtual folders)

As a quick fix for this, you can just remove the reference and add it from your finder, be sure you have the creation by folder groups and copy if need it options checked.

And there you go! you will be more productive without being repeating a lot of boilerplate code!.

And repeating what I said, this is a guideline, even you can use it and adapt it to your needs, if you want to improve this template feel free to pull-requested and we'll see the improvement!.

Thanks for the reading and 👩‍💻 happy coding! 👨‍💻

Property Wrappers

Juan Dorado — Thu, 20 Aug 2020 20:55:30 +0000

If you have work with SwiftUI, you may see these couple of properties that begin with @State.

Well, this works as a property wrapper!.

Let's dive in, to get involved with this kind of properties we must know about value semantics.

Value Semantics

When your type supports value semantics, it means that you are watching that variable specifically, it guarantees the independence of variables.

These are related to value types (ex. structs).

Reference types and Value types differ in their assignment behavior, with reference we are pointing to the same reference, hash, address, unlike value we are just creating a new copy of our instance.

Reference Type

class ReferencePerson {

  var name: String

  init(name: String) {
    self.name = name
  }
}

var referencePerson1 = ReferencePerson(name: "Juan")
var referencePerson2 = referencePerson1

referencePerson2.name = "Ethan"

referencePerson1.name // output: "Ethan"
referencePerson2.name // output: "Ethan"

Value Type

struct ValuePerson {

  var name: String
}

var valuePerson1 = ValuePerson(name: "Juan")
var valuePerson2 = valuePerson1

valuePerson2.name = "Ethan"

valuePerson1.name // output: "Juan"
valuePerson2.name // output: "Ethan"

Value Types containing Reference Types

We could combine these two types on one, so we would expect that if we are containing a reference inside a value type, the assignment should be copy.

Let's take an example.

class Person {

  var name: String

  init(name: String) {
    self.name = name
  }
}

struct Dog {

  var name: String
  var owner: Person
}

Let's use these two classes, as you can see Dog is of type struct and Person is of type class.

var husky = Dog(name: "Jay-Jay", owner: Person(name: "Mike"))
var pug = husky

pug.owner.name = "Michell"

husky.owner.name // output: "Michell"
pug.owner.name // output: "Michell"

Oh-oh!, what happened? - Well, although we are creating a copy, our Person is pointing to the same reference.

But we have a solution to solve this, so here is where we meet Copy-on-write!

Copy-on-write

With copy-on-write we can validate what we really need to have value semantics, at the example above, the owner's name.

So, let's modify our Dog class.

struct Dog {

  var name: String

  private var owner: Person = Person()

  var ownerName: String {
    get { owner.name }
    set { owner = Person(name: newValue) }
  }

  init(name: String, ownerName: String) {
    self.name = name
    self.ownerName = ownerName
  }
}

Take a look at this.

private var owner: Person = Person()

  var ownerName: String {
    get { owner.name }
    set { owner = Person(name: newValue) }
  }

This is the magic of copy on write, now if we try to instantiate our values.

var husky = Dog(name: "Jay-Jay", ownerName: "Mike")
var pug = husky

pug.ownerName = "Michell"

husky.ownerName // output: "Mike"
pug.ownerName // output: "Michell"

The idea is as simple as just create a new backup and drop the old one, but there is something more to help with performance.

Of course there is much more under the hood about using Copy-on-write than just create a backup and drop the old one.

What if we are not referencing nothing more? - For the example before, if we just have the husky instance doesn't make sense to be creating new instances each time we change the value, for that part we have isKnownUniquelyReferenced(_ object:) this is a generic function that checks if our instance is unique or it has other references, so let's change our set from our ownerName property like this.

var ownerName: String {
    get { owner.name }
    set {
      if isKnownUniquelyReferenced(&owner) {
        owner.name = ownerName
      } else {
        owner = Person(name: newValue)
      }
    }
}

Property Wrappers - in action

Now, you could be thinking, ok... now I know some about Value Semantics, about copy-on-write, what about Property wrappers?.

To introduce these properties let's create our Property Wrapper of the magic code of copy-on-write.

@propertyWrapper
struct CopyOnWriteOwnerName {

  private var person: Person

  var wrappedValue: String {
    get { person.name }
    set {
      if isKnownUniquelyReferenced(&person) {
        person.name = newValue
      } else {
        person = Person(name: newValue)
      }
    }
  }

  init(wrappedValue: String) {
    self.person = Person(name: wrappedValue)
  }
}

Do you see that is the same code? - Well, now that we have encapsulated our copy-on-write code, let's use it, thanks to @propertyWrapper

We can use it inside our Dog struct, like this.

struct Dog {

  var name: String
  @CopyOnWriteOwnerName var ownerName: String
}

And now! our code was encapsulated, it is now short, and much easier to understand!.

Do you get now what property wrapper is?

👨‍💻 Happy coding devs! 👨‍💻

Keypaths

Juan Dorado — Sat, 15 Aug 2020 23:54:35 +0000

Have you ever listen the keypath keyword? - No

If you have used SwiftUI you may be familiar with List using identifiers just like this... List(data, id: \.id) { ... } on this code \.id is the keypath.

In short words keypaths are store references to your properties

What amazing thing huh?! 😁

Much easier to explain this using our handy dandy?... (📣 notebook!) - sorry, no!, example! (Bad joke from Blue's clues in case you didn't get it).

Let's use this simple classes to work with.

class BasicInfo {

  let name: String
  var quickSlots: (up: String?, left: String?, right: String?, down: String?)

  init(name: String, quickSlots: (up: String?, left: String?, right: String?, down: String?)) {
    self.name = name
    self.quickSlots = quickSlots
  }
}

class Jill {

  var basicInfo: BasicInfo
  var isInfected = false

  init(name: String) {
    self.basicInfo = BasicInfo(name: name, quickSlots: (up: "G19 Handgun", left: nil, right: "Survival Knife", down: nil))
  }
}

So in here we just have a simple class that have some basic info, later a Jill(Resident Evil character) class that depends from BasicInfo.

We are not going to dive deep on this class because it is not what we are talking about.

To get access to properties we can use dot-notation.

let jill = Jill(name: "Jill Valentine")
jill.isInfected // <= false

We can just get the same result using keypaths

// 1
let isInfected = \Jill.isInfected

// 2
let isJillInfected = jill[keypath: isInfected]

We just need a backslash then the path to reference, our class and the property we want to reference, look that I am using the class itself and not the instance.
Using keypath's subscript we can get the value of the property that we are referencing to.

But... our property doesn't need to be directly on our class, it can be from several levels deep

Take a look at this.

let characterName = \Jill.basicInfo.name
let jillName = jill[keyPath: characterName]

As you can see we are now trying to access the name from the basicInfo property, and the access, it is just the same way.

Additional to deep levels, guess what? - We can use it with tuples.

A tuple is just a set of variables composed in one.

let upSlot = \Jill.basicInfo.quickSlots.up
let jillUpSlot = jill[keyPath: upSlot]

And there you go, the same result we were expecting!

Also, we don't need to create the full path at first, we can have a base keypath and just append another to it.

// 1
let basicInfoPath = \Jill.basicInfo

// 2
let rightSlotPath = basicInfoPath.appending(path: \.quickSlots.right)

// 3
let jillRightSlot = jill[keyPath: rightSlotPath]

We have our base keypath that references the basicInfo property
We ju.st append the new route using the root (\) and moving deeper, in this case our right property inside our tuple.
We use our keypath such as before.

Until know we have been using this feature to read values, but... we can set values to it!.

// 1
let leftSlotPath = \Jill.basicInfo.quickSlots.left

// 2
jill[keyPath: leftSlotPath] = "M3 Shotgun"

We create the reference to our property, such as before.
Let's suppose we got a new gun and it automatically is assigned to our left side, and this is as simple as just assign it.

There is one more feature we can take approach of... Dynamic Member Lookup.

I have a post related to this topic using subscripts, it is a 3 minutes approximately lecture.

Subscripts: Dynamic Member Lookup

Juan Dorado ・ Aug 8 '20 ・ 3 min read

#swift #dynamic #member #lookup

In short words, using Dynamic Member Lookup we can make Swift a dynamic language related to Phyton or PHP.

@dynamicMemberLookup
class Carlos {

  var basicInfo: BasicInfo

  init(name: String) {
    self.basicInfo = BasicInfo(name: name, quickSlots: (up: "Assault Rifle", left: "G18 Handgun", right: "Survival Knife", down: nil))
  }

  subscript(dynamicMember keyPath: KeyPath<BasicInfo, String>) -> String {
    return basicInfo[keyPath: keyPath]
  }
}

I recommend you to take a look to the previous post about Dynamic Member Lookup, where I explain a little bit more how this works.

let carlos = Carlos(name: "Carlos Oliveira")
carlos.name

Finally we just need to access to the dynamic property we want to, we doesn't need to create our keypath.

And with this you got some more knowledge and learn a new skill to add it to your list!.

Happy coding 👨‍💻!

Subscripts: Dynamic Member Lookup

Juan Dorado — Sat, 08 Aug 2020 05:06:23 +0000

Previously I have about subscripts, a really basic post to get involved with subscripts.

Subscripts

Juan Dorado ・ Aug 6 '20 ・ 2 min read

#swift #subscript #basics

And a second one to see related to their parameters and static ones.

Subscripts: Parameters & Static

Juan Dorado ・ Aug 6 '20 ・ 2 min read

#swift #subscript #parameter #static

Now, let's see another topic related to them... Dynamic Member Lookup.

First of all, what comes in your mind when you hear about Swift language?

If you think about safety we are just right now on the same path.

One of the greatest features in Swift is that it is a safety language.

Unlike Python or PHP. But hey!, I'm not saying they are not safe, I'm just saying they are relaxed on that aspect.

But don't misunderstand me, everybody can write bad code on any language, it is that we just need to think much more on what we are doing on the code.

Just try to run "Hey Swift" + 5.3 on a playground in Xcode... that's right! it is going to complain as soon as it tries to compile it. (Of course it make sense because how are you going to sum a String with a Double).

Now, it was too much talk!... what is this for? - Answer this is as easy that just say provide arbitrary dot-syntax to your type.

You could be thinking, but Swift already provides dot-syntax - That's true, let's dive in on our example.

Example

struct Character {

  let name: String
  let costume: Costume

  enum Costume: String {
    case `default`
    case stars
    case re3Style
  }
}

We have our struct, and if we create an instance of our struct, we can get the properties using dot-syntax right?.

let jill = Character(name: "Jill Valentine", costume: .re3Style)

jill.name
jill.costume

Let's extend our struct with another property.

struct Character {

  // ...

  let quickSlots: [QuickSlot: String]

  enum QuickSlot {
    case up
    case left
    case right
    case down
  }

  // ...
}

The quick slots in the game will be the shortcuts to access to equipment from our items.

Now we will set this in our initializer

let jill = Character(..., quickSlots: [.up: "Beretta 92FS", .right: "M26 Hand Grenade"])

If we plan to access to the quick slot with the key up, we will need to do something like this.

jill.quickSlots[.up] // Beretta 92FS
jill.quickSlots[.down] // nil

But if I would like to access to them with something like this...

jill.up
jill.down

Here comes the Dynamic Member Lookup

First we need to add this core attributed @dynamicMemberLookup, and to make it work this needs the required subscript method subscript(dynamicMember:)

So our struct will look like this.

@dynamicMemberLookup
struct Character {

  let name: String
  let costume: Costume
  var quickSlots: [QuickSlot: String]

  enum Costume: String {
    case `default`
    case stars
    case re3Style
  }

  enum QuickSlot: String {
    case up
    case left
    case right
    case down
  }

  subscript(dynamicMember key: String) -> String? {
    guard let quickSlotKey = QuickSlot(rawValue: key) else { return nil }
    return quickSlots[quickSlotKey, default: "No Item"]
  }
}

I use : String on the QuickSlot enum to be easier to access by its rawValue

Now if we try to use our previous dot-syntax call we get this.

jill.up // Beretta 92FS
jill.down // No Item

Although this seems great, be careful because you can use whatever dot-syntax variable, even if this doesn't exist.

jill.asdfsdfsdf // nil

dynamicMemberLookup is evaluated at runtime not at compile time.

You can use dynamicMemberLookup for your own purposes but the main one is to interact with codes like Python.

Also as quick tip:

You can inherit dynamicMemberLookup from your base class to your children.

You can use class subscripts that works such as static subscripts

These can be used with keypath (but that will be a topic for other day).

I think this subscript posts work for you!.
It is just practice, so practice, practice, practice.

Happy coding 👨‍💻!

Subscripts: Parameters & Static

Juan Dorado — Thu, 06 Aug 2020 19:00:46 +0000

I previously wrote a post talking about the basics and how to create a subscript for your own classes, structs...

Subscripts

Juan Dorado ・ Aug 6 '20 ・ 2 min read

#swift #subscript #basics

I didn't want to extend that post too much, and I just wanted to keep it simple, with that basic example.

Now for this, let's see what else we can do using subscripts.

Subscript parameters

As you could see, the subscript signature looks just like a function, on the parameters I wrote

subscript(key: String) -> String? { ... }

And I just used my subscript like this...

jill["costume"]

But following the function rules, I should be used it like this...

jill[key: "costume"]

because I didn't add an underscore before my parameter, and functions use the parameter as parameter name when we skip it.

Well guess what? - This are subscripts not functions, this rule doesn't apply, but...

WE CAN ADD PARAMETER NAMES

and for that the rule is the same, as simple as just add the parameter name before the parameter.

  subscript(key key: String) -> String? {
    // ...
  }

Although we could use whatever name we want, c'mon, help other developers giving good names to them.

This is not a key, it is a property of our struct, using property as the name sounds much better don't you think?

  subscript(parameter key: String) -> String? {
    // ...
  }

Now, our subscript will be called like this.

jill[parameter: "costume"]

But there is much more with this, Xcode is so intelligent that will be able to detect all this issues.

In case you try to access to your subscript without your parameter name, Xcode will complain

Also if you start writing inside your brackets or simply using the shortcut CTRL + Space you will see autocompletion.

Static Subscripts

Now! another thing such as functions these can be static as well.

Let's see what we care about... example!

class Service {

  static subscript(key: String) -> String {
    switch key {
    case "production":
      return "https://a-production-url.com"
    case "stage":
      return "https://a-stage-url.com"
    case "development":
      return "https://a-development-url.com"
    default:
      return "No URL!"
    }
  }
}

And we don't need an instance to use our subscript, just call it directly...

Service["production"] // "https://a-production-url.com"
Service["stage"] // "https://a-stage-url.com"
Service["development"] // "https://a-development-url.com"
Service["custom"] // "No URL!"

Nice right?

There is one more topic related I would like to cover about subscripts.

I'll try it later on and HAPPY CODING!

Subscripts

Juan Dorado — Thu, 06 Aug 2020 06:34:33 +0000

Subscripts?, have you ever listened about this?, probably yes, if not, believe me, you have used them.

I'll make this post really basic to get involved with this.

If you are reading this, you are interested on iOS development or just Swift stuffs.

What are subscripts?, when I said that you have used them, it is because they are on Arrays, Dictionaries, Sets.

At the time we do something like this

var characters = ["Jill", "Claire", "Carlos", "Leon", "Ada"]

characters[0] // <- Here we are using our subscript

I'm a Resident Evil fan in case it wasn't clear 😁

Just think of subscripts as overloading the [] operator, it is an easy way to be familiar with them, and they are useful to create shortcuts for accessing elements.

This can be used on collections, enumerations, structures and classes

How to use subscripts

The subscript syntax is really easy, it is just like this.

subscript(parameters) -> ReturnType {
  get { ... }
  set(newValue) { ... }
}

The nice part is that you may be related with this syntax, it looks like a function's signature combined with computed properties.

Let's make a list of the stuffs you CAN and you CAN'T do

You CAN use variadic parameters.
You CAN'T use inout parameters.
You CAN'T use default parameters.
You CAN'T throw errors.
You CAN make it read-only, making the set optional.
You CAN omit newValue

Now let's do the funny part! the example!

Example

Just because of my love for Resident Evil games, let's create a Character class to be related with games!

struct Character {

  let name: String
  let costume: Costume

  enum Costume: String {
    case `default`
    case stars
    case re3Style
  }
}

let jill = Character(name: "Jill Valentine", costume: .re3Style)

Now, let's try to get the name of our character object, of course we could just do it like with dot-notation but c'mon, this is a subscript post, so we want to read it like this jill["costume"]

If we try to use that line we will receive a very beautiful error! 🤯.

"Value of type 'Character' has no subscripts"

Now, let's fix it extending our struct in order to add our subscript

extension Character {

  subscript(key: String) -> String? {
    switch key {
    case "name":
      return name
    case "costume":
      return costume.rawValue
    default:
      return nil
    }
  }
}

Now, with this code we can call our line again

jill["costume"] // <- Now we got "re3Style"

There you go! You have created your own custom subscript!, of course this is not all, but I want to keep this post as simple as I can, so later on, I'll create more about subscripts

DEV Community: Juan Dorado

I-VIPER | Xcode Template

View

Interactor

Presenter

Entity

Router

Installation

How to use

Quick Fix

Property Wrappers

Value Semantics

Reference Type

Value Type

Value Types containing Reference Types

Copy-on-write

Property Wrappers - in action

Keypaths

Subscripts: Dynamic Member Lookup

Juan Dorado ・ Aug 8 '20 ・ 3 min read

Subscripts: Dynamic Member Lookup

Subscripts

Juan Dorado ・ Aug 6 '20 ・ 2 min read

Subscripts: Parameters & Static

Juan Dorado ・ Aug 6 '20 ・ 2 min read

Example

Subscripts: Parameters & Static

Subscripts

Juan Dorado ・ Aug 6 '20 ・ 2 min read

Subscript parameters

Static Subscripts

Subscripts

How to use subscripts

Example

Wanna go further?

Subscripts: Parameters & Static

Juan Dorado ・ Aug 6 '20 ・ 2 min read

Subscripts: Dynamic Member Lookup

Juan Dorado ・ Aug 8 '20 ・ 3 min read