design systems

import Foundation

public enum DesignSystem {
}

import UIKit

public extension DesignSystem {
    enum Color: Equatable, Hashable {
        case clear
        case primary(alpha: CGFloat = 1)
        case secondary(alpha: CGFloat = 1)
        case error(alpha: CGFloat = 1)

        public var value: UIColor {
            switch self {
            case .clear:                    return .clear
            case .primary(let alpha):       return UIColor(named: "primary")!.withAlphaComponent(alpha)
            case .secondary(let alpha):     return UIColor(named: "secondary")!.withAlphaComponent(alpha)
            case .error(let alpha):         return UIColor(named: "error")!.withAlphaComponent(alpha)
            }
        }
    }
}

import UIKit

public extension UIView {
    func setBackgroundColor(to color: DesignSystem.Color) {
        self.backgroundColor = color.value
    }

    func setTintColor(to color: DesignSystem.Color) {
        self.tintColor = color.value
    }

    func setBorderColor(to color: DesignSystem.Color) {
        self.layer.borderColor = color.value.cgColor
    }
}

import UIKit

public extension UILabel {
    func setTextColor(to color: DesignSystem.Color) {
        self.textColor = color.value
    }
}

import UIKit

public extension UIButton {
    func setTitleColor(to color: DesignSystem.Color?, for state: UIControl.State) {
        self.setTitleColor(color?.value, for: state)
    }
}

import XCTest
@testable import DesignSystem

class DesignSystemTests: XCTestCase {
    // MARK: - UIView
    
    func testViewSetBackgroundColor() {
        let color = DesignSystem.Color.primary()
        let view = UIView()
        
        view.setBackgroundColor(to: color)
        
        XCTAssertEqual(view.backgroundColor, color.value)
    }
    
    func testViewSetTintColor() {
        let alpha = CGFloat.random(in: 0...1)
        let color = DesignSystem.Color.secondary(alpha: alpha)
        let view = UIView()
        
        view.setTintColor(to: color)
        
        XCTAssertEqual(view.tintColor, color.value)
    }
    
    func testViewSetBorderColor() {
        let color = DesignSystem.Color.error()
        let view = UIView()
        
        view.setBorderColor(to: color)
        
        XCTAssertEqual(view.layer.borderColor, color.value.cgColor)
    }
    
    // MARK: - UILabel
    
    func testLabelSetTitleColor() {
            let alpha = CGFloat.random(in: 0...1)
            let color = DesignSystem.Color.primary(alpha: alpha)
            let label = UILabel()
            
            label.setTextColor(to: color)
            
            XCTAssertEqual(label.textColor, color.value)
        }
    
    // MARK: - UIButton
    
    func testButtonSetTitleColor() {
        let alpha = CGFloat.random(in: 0...1)
        let color = DesignSystem.Color.error(alpha: alpha)
        let button = UIButton()
        
        button.setTitleColor(to: color, for: .normal)
        
        XCTAssertEqual(button.titleColor(for: .normal), color.value)
    }
}

import UIKit

public extension DesignSystem {
    enum Typography: Equatable {
        case title1
        case title2
        case title3
        case body

        public var description: Description {
            switch self {
            case .title1: return .init(font: UIFont(name: "Roboto-Medium", size: 24)!, lineSpacing: 3)
            case .title2: return .init(font: UIFont(name: "Roboto-Medium", size: 20)!, lineSpacing: 2)
            case .title3: return .init(font: UIFont(name: "Roboto-Bold", size: 16)!, lineSpacing: 1)
            case .body:   return .init(font: UIFont(name: "Roboto-Regular", size: 13)!, lineSpacing: 0)
            }
        }

        public struct Description {
            public var font: UIFont
            public var lineSpacing: CGFloat
        }
    }
}

public extension UILabel {
    func setFont(from typography: DesignSystem.Typography) {
        self.font = typography.description.font
    }
}

public extension UIButton {
    func setFont(from typography: DesignSystem.Typography) {
        self.titleLabel?.font = typography.description.font
    }
}

import XCTest
@testable import DesignSystem

class DesignSystemTests: XCTestCase {
    // MARK: - UILabel
    func testLabelSetFont() {
        let typography = DesignSystem.Typography.title1
        let label = UILabel()
        
        label.setFont(from: typography)
        
        XCTAssertEqual(label.font, typography.description.font)
    }
    
    // MARK: - UIButton
    
    func testButtonSetFont() {
        let typography = DesignSystem.Typography.title2
        let button = UIButton()
        
        button.setFont(from: typography)
        
        XCTAssertEqual(button.titleLabel?.font, typography.description.font)
    }
}

import UIKit

public extension DesignSystem {
    enum Button: Equatable {
        public enum Size {
            case small
            case medium
            case large

            public var description: Description {
                switch self {
                case .small:    return .init(typography: .title2, contentEdgeInsets: .zero)
                case .medium:   return .init(typography: .title2, contentEdgeInsets: .init(top: 10, left: 20, bottom: 10, right: 20))
                case .large:    return .init(typography: .title2, contentEdgeInsets: .init(top: 15, left: 25, bottom: 15, right: 25))
                }
            }

            public struct Description {
                public let typography: Typography
                public var contentEdgeInsets: UIEdgeInsets
            }
        }

        public enum State: Equatable {
            case normal
            case disabled
        }

        public enum Style {
            case primary(state: State, size: Size)

            public var description: Description {
                switch self {
                case .primary(let state, let size):
                    switch state {
                    case .normal:   return .init(size: size, textColor: .primary(), backgroundColor: .clear)
                    case .disabled: return .init(size: size, textColor: .secondary(), backgroundColor: .clear)
                    }
                }
            }

            public struct Description {
                public var size: Button.Size
                public var textColor: Color
                public var backgroundColor: Color = .clear
            }
        }
    }
}

public extension UIButton {
    func setStyle(to style: DesignSystem.Button.Style) {
        let description = style.description

        setBackgroundColor(to: description.backgroundColor)
        setTitleColor(to: description.textColor, for: .normal)
        setFont(from: description.size.description.typography)
        contentEdgeInsets = description.size.description.contentEdgeInsets
    }
}

import XCTest
@testable import DesignSystem

class DesignSystemTests: XCTestCase {
    // MARK: - UIButton
    
    func testButtonSetStyle() {
        let style = DesignSystem.Button.Style.primary(state: .normal, size: .medium)
        let button = UIButton()
        
        button.setStyle(to: style)
        
        XCTAssertEqual(button.titleLabel?.font, style.description.size.description.typography.description.font)
        XCTAssertEqual(button.contentEdgeInsets, style.description.size.description.contentEdgeInsets)
        XCTAssertEqual(button.backgroundColor, style.description.backgroundColor.value)
        XCTAssertEqual(button.titleColor(for: .normal), style.description.textColor.value)
    }
}

import UIKit

public extension DesignSystem {
    enum Typography: Equatable {
        case title1
        case title2
        case title3
        case body
        case custom(description: Description)

        public var description: Description {
            
            switch self {
            case .title1:                   return .init(font: UIFont(name: "Roboto-Medium", size: 24)!, lineSpacing: 3)
            case .title2:                   return .init(font: UIFont(name: "Roboto-Medium", size: 20)!, lineSpacing: 2)
            case .title3:                   return .init(font: UIFont(name: "Roboto-Bold", size: 16)!, lineSpacing: 1)
            case .body:                     return .init(font: UIFont(name: "Roboto-Regular", size: 13)!, lineSpacing: 0)
            case .custom(let description):  return description
            }
        }

        public struct Description {
            public var font: UIFont
            public var lineSpacing: CGFloat = 0
        }
    }
}