[Deprecated] A shiny JSON parsing library in Swift :sparkles: Loved by many from 2015-2021

Overview

Gloss

🚨 Deprecation Notice 🚨

Gloss has been deprecated in favor of Swift's Codable framework.

The existing Gloss source is not going away, however updates will only be made to support migration to Codable. Read the MIGRATION GUIDE now to get started.

If you do not yet have any Gloss models in your project yet are considering it for JSON parsing, turn around now! Select Swift's Codable framework instead.

I understand, I'm Using Gloss Anyway

Swift version CocoaPods Carthage compatible SPM CocoaPods Build Status

See the former README.md on instructions for using Gloss pre-Codable migration.

Credits

Gloss was created by Harlan Kellaway

Thank you to all contributors and the Swift community for 5 years of Gloss! 💖

License License

See the LICENSE file for more info.

Codable Migration Quick Reference

The following is a reference for what your Gloss models and call-sites should look like after preparing to migrate to Codable.

See the MIGRATION GUIDE for more detail.

Version

Use version 3.2.0 or higher to take advantage of migration helpers.

Deserialization

Given a Gloss model that conforms to JSONDecodable, add conformance to Decodable. A model that looks like this:

import Gloss

struct MyModel: JSONDecodable {
    let id: Int?
    
    init?(json: JSON) {
        self.id = "id" <~~ json
    }
}

adds

extension MyModel: Decodable {

    init(from decoder: Swift.Decoder) throws {
        // Proper Decodable definition or throw GlossError.decodableMigrationUnimplemented
        // Remove this method if Codable can synthesize decoding for you
    }

}

Initializing a Model from JSON

Where initializing that model currently looks like:

let myModel = MyModel(json: someJSON)

it becomes:

let myModel: MyModel = .from(decodableJSON: someJSON)

Serialization

Given a Gloss model that conforms to JSONEncodable, add conformance to Encodable. A model that looks like this:

import Gloss

struct MyModel: JSONEncodable {
    let id: Int?
    
    func toJSON() -> JSON? {
        return jsonify(["id" ~~> self.id])
    }
}

adds

extension MyModel: Encodable {

    func encode(to encoder: Swift.Encoder) throws {
        // Proper Encodable defintion or throw GlossError.encodableMigrationUnimplemented
        // Remove this method if Codable can synthesize encoding for you
    }

}

Translating Model Objects to JSON

Where translating to JSON currently looks like this:

let json: JSON? = myModel.toJSON()

it becomes:

let json: JSON? = myModel.toEncodableJSON()

JSON Arrays

Similar usage applies to arrays of Decodable and Encodable models, with from(decodableJSONArray:) and toEncodableJSONArray() respectively.

Configuring JSONDecoder and JSONEncoder

If your Codable definitions are sound but you're encountering Codable errors, make sure your JSONDecoder or JSONEncoder instances are configured properly and pass them at call-sites:

let mySharedJSONDecoder: JSONDecoder = ...
let myModel: MyModel = .from(decodableJSON: someJSON, jsonDecoder: mySharedJSONDecoder)
let mySharedJSONEncoder: JSONEncoder = ...
let json: JSON? = myModel.toEncodableJSON(jsonEncoder: mySharedJSONEncoder)

Using Data Instead of JSON to Create Models

In the places where you've come to rely on Gloss's JSON type, you'll eventually need to pass Data, as that is what Codable uses. To get a jump using decode(:), one option is use the same method Gloss uses to do Data transformation:

import Gloss

let sharedGlossSerializer: GlossJSONSerializer = ...
let json: JSON = ...
if let data: Data? = sharedGlossSerializer.data(from: json, options: nil) {
    let myModel: MyModel = try? myJSONDecoder.decode(MyModel.self, from : data)
    ...
}

Take the opportunity with this migration to pare your models down to the slim amount of code Codable needs to work its magic and detangle your networking code from the details of JSON serialization. Future you will be grateful! 🔮

EOF

Comments
  • Issue when using nested keypaths when compiling with optimization + Swift 2.2

    Issue when using nested keypaths when compiling with optimization + Swift 2.2

    With Swift 2.2, I've run into an issue when decoding deep json using the dot syntax. The decoding crashes with the error:

    Gloss was compiled with optimization - stepping may behave oddly; variables may not be available.
    (lldb) 
    

    The following test case fails with the above error:

    import XCTest
    import Gloss
    
    class GlossTestTests: XCTestCase {
    
        func testExample() {
            let json = [
                "foo":["bar":"woo"]
            ]
            let woo = FooBar(json: json)?.woo ?? "none"
            print(woo)
        }
    
    }
    
    class FooBar: Decodable {
        let woo: String?
    
        required init?(json: JSON) {
            self.woo = "foo.bar" <~~ json
        }
    }
    
    

    I'm not sure if I'm missing something, but everything seemed ok with Swift 2.1.

    bug help wanted 
    opened by stuartervine 23
  • Swift 4 - Decodable/Encodable protocols

    Swift 4 - Decodable/Encodable protocols

    New Swift 4 will include a new encoding/decoding protocols (https://github.com/apple/swift-evolution/blob/master/proposals/0166-swift-archival-serialization.md)

    Since Gloss is sharing the same namespace for protocols Decodable/Encodable, I suggest we change the name of the protocols, so Gloss can be a separate library to the new solution proposed by the Swift language team.

    @hkellaway - thoughts?

    swift 5 
    opened by ferusinfo 21
  • Initial Linux support

    Initial Linux support

    The third time's lucky? Hopefully...

    This have been tried to build on Ubuntu 16.10 with Swift versions: 3.0.1 3.0.2 DEVELOPMENT SNAPSHOT 2016-12-14

    and successfully passed all tests.

    enhancement linux 
    opened by rbukovansky 16
  • Add valueForKeyPathCoding

    Add valueForKeyPathCoding

    I have not tested this much but this will allow us to use keyPaths when needed.

    struct Person: Glossy {
    
        let id: String?
        let name: String?
    
        // MARK: - Deserialization
    
        init?(json: JSON) {
            self.id = "args.id" <~~ json
            self.name = "args.name" <~~ json
        }
    
        // MARK: - Serialization
    
        func toJSON() -> JSON? {
            return jsonify([
                "args.id" ~~> self.id,
                "args.login" ~~> self.name
                ])
        }
    
    }
    
    enhancement 
    opened by rahul0x24 13
  • enumArrayForKey should not be exclusive to the enum type

    enumArrayForKey should not be exclusive to the enum type

    Enum arrays (Decoder.decode(enumArrayForKey:)) forces you to have all values in the array the same type of the enum, e.g

    enum Color {
      case blue
      case red
    }
    
    enum Element {
      case fire
      case wind
    }
    
    //JSON
    "color_elements": {
      "blue",
      "fire",
      "red",
      'wind'
    }
    

    If I apply:

    self.colors = Decoder.decode(enumArrayForKey: "color_elements")(json) ?? []

    I would expect to have an array back with only the colors, but I'm getting back an empty array because there is a different type within the color_elements object

    question 
    opened by ed-mejia 12
  • Implementing Gloss protocol requires a class to be declared final

    Implementing Gloss protocol requires a class to be declared final

    this takes away any possibility of inheritance for similar classes e.g. Product and ProductDetail.

    Since Product will have to be declared final, ProductDetail would end up replicating all the fields of Product.

    I have no idea on how to fix it, or if it is even possible. I couldn't find a similar ticket in the closed issues so putting it on the radar.

    @hkellaway your thoughts please.

    help wanted 
    opened by ishaq 12
  • Reintroduce Nested Keypaths

    Reintroduce Nested Keypaths

    Hey @hkellaway :) After your recent changes regarding deprecating nested keypaths in Gloss (https://github.com/hkellaway/Gloss/issues/135), we faced a huge problem - we have A LOT of models using that feature, and we could:

    • ditch the Gloss completely (while we admire it a lot ) ❌
    • switch to ObjectMapper (or any other library supporting the feature) ❌
    • or just simply fix the issue ✌️

    I am happy to say that after few days of sorting that all out, my pull request is reintroducing the nested keypaths. It supports Swift 3.0 directly and does not need to disable swift optimizations. I've also reintroduced and modified tests that you've previously had for the feature.

    For those who are interested what was wrong - for Encoder it seems that when you put a lot of hard-logic code into Dictionary extension, the compiler is acting weird. I am also passing the sub-dictionaries by reference, so it does not create a new copy. For Decoder, I've rewritten the function to find the element by the keypath so it uses a recursive function to traverse the tree.

    For those who are interested, there is also a fixes_for_nested branch in my fork for Swift 2.3: https://github.com/ferusinfo/Gloss/tree/fixes_for_nested

    I hope we can discuss the changes and merge it - so we can keep using the Gloss as our favorite JSON parsing library.

    enhancement 
    opened by ferusinfo 10
  • CocoaPods cleanup, Carthage compatibility

    CocoaPods cleanup, Carthage compatibility

    Removed the Example pods from source control. Also the Example schemes has been un-shared, since it created issues in Carthage. The git ignore file has been extended with CocoaPods, Carthage and Xcode 7 exclusions.

    enhancement 
    opened by bojan 10
  • [GLOSS] Value found for key

    [GLOSS] Value found for key "image" but decoding failed.

    Does anyone know what this means? receiving this error in xcode log after upgrading to swift3 and xcode 8.3 :/

    Any help would be most certainly appreciated as I cannot run my app at the moment

    Thanks

    question 
    opened by 1lyyfe 9
  • fails to build on linux swift 3.0 preview 4

    fails to build on linux swift 3.0 preview 4

    I know it's probably not you favorite platform, but I'd love to use it in a server on linux. There are some errors building though:

    ~/Gloss$ swift build
    Compile Swift Module 'Gloss' (6 sources)
    /home/ubuntu/Gloss/Sources/Gloss.swift:78:35: error: argument labels '(identifier:)' do not match any available overloads
        dateFormatterISO8601.locale = Locale(identifier: "en_US_POSIX")
                                      ^     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /home/ubuntu/Gloss/Sources/Gloss.swift:78:35: note: overloads for 'Locale' exist with these partially matching parameter lists: (localeIdentifier: String), (coder: NSCoder)
        dateFormatterISO8601.locale = Locale(identifier: "en_US_POSIX")
                                      ^
    /home/ubuntu/Gloss/Sources/Gloss.swift:82:43: error: type 'String' has no member 'gregorian'
        var gregorian = Calendar(identifier: .gregorian)
                                              ^~~~~~~~~
    /home/ubuntu/Gloss/Sources/Decoder.swift:461:37: error: value of type 'String' has no member 'addingPercentEncoding'
                    let encodedString = urlString.addingPercentEncoding(withAllowedCharacters: NSCharacterSet.urlQueryAllowed) {
                                        ^~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~
    Foundation.String:286:16: note: did you mean 'removingPercentEncoding'?
        public var removingPercentEncoding: String? { get }
                   ^
    /home/ubuntu/Gloss/Sources/Encoder.swift:84:45: error: value of type 'String' does not conform to expected dictionary value type 'AnyObject'
                    return [key : dateFormatter.string(from: date)]
                                  ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:112:31: error: value of type '[String]' does not conform to expected dictionary value type 'AnyObject'
                    return [key : dateStrings]
                                  ^~~~~~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:153:31: error: value of type 'JSON' (aka 'Dictionary<String, AnyObject>') does not conform to expected dictionary value type 'AnyObject'
                    return [key : json]
                                  ^~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:180:31: error: value of type '[JSON]' does not conform to expected dictionary value type 'AnyObject'
                    return [key : encodedArray]
                                  ^~~~~~~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:210:27: error: value of type '[String : JSON]' does not conform to expected dictionary value type 'AnyObject'
                return [key : encoded]
                              ^~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:239:27: error: value of type '[String : [JSON]]' does not conform to expected dictionary value type 'AnyObject'
                return [key : encoded]
                              ^~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:320:31: error: value of type '[NSNumber]' does not conform to expected dictionary value type 'AnyObject'
                    return [key : numbers]
                                  ^~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:360:19: error: value of type '[NSNumber]' does not conform to expected dictionary value type 'AnyObject'
                                    return [key : numbers]
                                                  ^~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:400:31: error: value of type '[NSNumber]' does not conform to expected dictionary value type 'AnyObject'
                    return [key : numbers]
                                  ^~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:440:19: error: value of type '[NSNumber]' does not conform to expected dictionary value type 'AnyObject'
                                    return [key : numbers]
                                                  ^~~~~~~
    /home/ubuntu/Gloss/Sources/Encoder.swift:459:31: error: value of type 'String' does not conform to expected dictionary value type 'AnyObject'
                    return [key : absoluteURLString]
                                  ^~~~~~~~~~~~~~~~~
    <unknown>:0: error: build had 1 command failures
    error: exit(1): /home/ubuntu/swift-3.0-PREVIEW-4-ubuntu14.04/usr/bin/swift-build-tool -f /home/ubuntu/Gloss/.build/debug.yaml
    

    (that was in the swift_3.0 branch, I'll see what I can fix and make a PR)

    help wanted 
    opened by chad3814 9
  • Replace force unwrapping with failable initializer

    Replace force unwrapping with failable initializer

    Better supporting the unhappy path of failure by producing a nil model object instead of a non-nil model object with all of its fields set to nil. This also allows for non-optional model fields without the risk of runtime errors.

    opened by morganchen12 9
Releases(final)
  • final(Feb 8, 2021)

  • 3.2.1(Sep 1, 2020)

  • 3.2.0(Aug 31, 2020)

    Adds:

    • #363 Helper methods for migrating to Codable

    🚨 Deprecation Notice 🚨

    Gloss has been deprecated in favor of Swift's Codable. See README for info.

    Source code(tar.gz)
    Source code(zip)
  • 3.1.1(Aug 29, 2020)

  • 3.1.0(Oct 15, 2019)

  • 3.0.0(Jul 22, 2019)

  • 2.1.1(Apr 2, 2019)

  • 2.1.0(Nov 30, 2018)

  • 2.0.1(Jun 4, 2018)

    Updates:

    • #319 fixes Carthage builds failing for non-iOS targets (thanks @subtranix)
    • Experimental Linux support is officially dropped (see #322)
    Source code(tar.gz)
    Source code(zip)
  • 2.0.0(Dec 6, 2017)

  • 2.0.0-beta.2(Nov 4, 2017)

  • 2.0.0-beta.1(Sep 27, 2017)

  • 1.2.4(Mar 30, 2017)

  • 1.2.3(Mar 30, 2017)

  • 1.2.2(Mar 28, 2017)

  • 1.2.1(Feb 12, 2017)

  • 1.2.0(Jan 16, 2017)

    Updates:

    • #243 Adds support for Decimal types (thanks @gerbiljames)
    • #256 Adds the ability to create models from Data (thanks @kampro)
    • #257 Fixes issues decoding URLs caused by escaping (thanks for the suggestion @ryanschneider)
    Source code(tar.gz)
    Source code(zip)
  • 1.1.1(Nov 27, 2016)

    Updates:

    • #228 Updated tests to be run using swift test when loading as a Swift Package (thanks @ejmartin504)
    • #233 Nested UUID values not being decoded properly (thanks @ryanschneider)
    Source code(tar.gz)
    Source code(zip)
  • 1.1.0(Oct 26, 2016)

    Updates:

    • #225 reintroduced the nested keypaths feature 🎉 (thanks @ferusinfo)
    • #226 added support for UUID types (thanks @Hiiragisan09)

    Upgrade Notes

    The nested keypaths feature that was removed in version 0.8.0 and 1.0.0 has been reintroduced this version.

    Source code(tar.gz)
    Source code(zip)
  • 1.0.0(Sep 20, 2016)

    Updates:

    • #212 updated the JSON typealias to use Any instead of AnyObject (thanks for the suggestion @gerbiljames)
    • #214 updated to Swift 3.0
    • #216 updated syntax to better align with Swift 3.0

    Upgrade Notes

    The "nested keypaths" feature was removed version 0.8.0 (see Issue #135). However, it was reintroduced in version 1.1.0.

    Source code(tar.gz)
    Source code(zip)
  • 0.8.0(Sep 20, 2016)

    Updates:

    • #189 updated array decoding to be more consistent (thanks for the suggestion @htinlinn)
    • #209 updated for Swift 2.3
    • #210 removed the "nested keypaths" feature

    Upgrade Notes

    The "nested keypaths" feature was removed version 0.8.0 (see Issue #135). However, it was reintroduced in version 1.1.0.

    Source code(tar.gz)
    Source code(zip)
  • deprecation-nested-keypaths(Sep 20, 2016)

    The "nested keypaths" feature was removed in version 0.8.0 and 1.0.0, but was reintroduced in version 1.1.0. This tag represents the point in development at which this feature was removed.

    Source code(tar.gz)
    Source code(zip)
  • 0.7.4(Jul 14, 2016)

    Updates:

    • #168 added de/encoding for UInt32, UInt32 arrays, UInt64, and UInt64 arrays (thanks @4ch7ung)
    • #178 made syntax Swift 2.3 compatible (thanks for the suggestion @coverback)
    • #180 fixed occasional Carthage build failures (thanks @AndrewSB)
    • Created swift_2.3 and swift_3.0 branches
    Source code(tar.gz)
    Source code(zip)
  • 0.7.3(May 6, 2016)

    Updates:

    • #148 added de/encoding for dictionaries with arrays of De/Encodable models
    • #150 fixed access modifier inconsistencies
    • #154 added de/encoding for Int32 and Int64
    Source code(tar.gz)
    Source code(zip)
  • 0.7.2(Apr 16, 2016)

    Updates:

    • #126 fixed an issue with encoding Encodable dictionaries that resulted in top-level translation being lost (thanks @dwb357)
    • #129 fixed date parsing failure if non-Gregorian calendar set on device (thanks @fabb)
    • #135 fixed incorrect decoding of for nested keypaths in Release builds using Swift 2.2 (thanks @tholo and for the suggestion @stuartervine)
    • #138 fixed usage of lazy NSDateFormatter for ISO 8601 dates
    Source code(tar.gz)
    Source code(zip)
  • 0.7.1(Feb 21, 2016)

  • 0.7.0(Feb 20, 2016)

    Updates:

    • #98 added the ability to retrieve nested values via a period-delimited key (thanks @RahulKatariya )
    • #100 added the ability to de/encode dictionaries with de/encodable values (thanks @dwb357)
    • #103 fixed not being able to subclass Gloss models (thanks @bachino90)
    • #111 updated ISO 8601 date formatter to be lazily instantiated (thanks for the suggestion @GUL-)
    • #116 and #117 updated how JSON/model arrays are created (thanks @RahulKatariya)
    • #119 added sanitization to strings used to decode NSURLs (thanks @ejmartin504)
    Source code(tar.gz)
    Source code(zip)
  • 0.6.2(Dec 24, 2015)

    Updates:

    • #88 added a tvOS target (thanks @jkandzi)
    • #92 added support for Swift Package Manager
    • #93 added support for watchOS (thanks for the suggestion @micpringle)
    Source code(tar.gz)
    Source code(zip)
  • 0.6.1(Nov 21, 2015)

    Updates:

    • #81 fixed URL arrays not being decoded automatically (thanks for the suggestion @ishaq)
    • #84 fixed date arrays not being decoded or encoded automatically
    • #86 fixed empty JSON arrays being encoded as nil
    Source code(tar.gz)
    Source code(zip)
  • 0.6.0(Oct 25, 2015)

    Updates:

    • #71 fixed arrays with incomplete JSON models being encoded as nil (thanks for the suggestion @nuudles)
    • #73 added the ability to decode from JSON arrays and encode to JSON arrays
    • #76 added Mac OS X support (thanks for the suggestion @CodeEagle)
    Source code(tar.gz)
    Source code(zip)
Owner
Harlan Kellaway
Sr. Eng Mngr @mavenclinic 🏥 // Editor & Video Instructor @raywenderlich 📱 //// Previously @parsleyhealth @prolificinteractive
Harlan Kellaway
Swift-json - High-performance json parsing in swift

json 0.1.4 swift-json is a pure-Swift JSON parsing library designed for high-per

kelvin 43 Dec 15, 2022
Ss-json - High-performance json parsing in swift

json 0.1.1 swift-json is a pure-Swift JSON parsing library designed for high-per

kelvin 43 Dec 15, 2022
Developed with use Swift language. As a third party library used SDWebImage. JSON parsing using URLSession with TMDB API. This app provide by the Core Data structure.

Capstone Project ?? About Developed with use Swift language. As a third party library used SDWebImage. JSON parsing using URLSession with TMDB API. Ad

Ensar Batuhan Unverdi 9 Aug 22, 2022
Freddy - A reusable framework for parsing JSON in Swift.

Why Freddy? Parsing JSON elegantly and safely can be hard, but Freddy is here to help. Freddy is a reusable framework for parsing JSON in Swift. It ha

Big Nerd Ranch 1.1k Jan 1, 2023
Precise JSON decimal parsing for Swift 🧮

PreciseDecimal Introduction Swift has long suffered a problem with its Decimal type: unapparent loss of precision. This happens with all common ways o

David Roman 22 Dec 15, 2022
Networking, JSON Parsing, APIs and Core Location

Clima Our Goal It’s time to take our app development skills to the next level. We’re going to introduce you to the wonderful world of Application Prog

Dessana Caldeira M. Santos 1 Nov 25, 2021
📱 A comprehensive test task for creating an autolayout interface, requesting an API and JSON parsing from Effective Mobile.

ECOMMERCE A comprehensive test task for creating an autolayout interface, requesting an API and JSON parsing from Effective Mobile. ??‍?? Design ✨ Fea

Daniel Tvorun 4 Nov 21, 2022
JSEN (JSON Swift Enum Notation) is a lightweight enum representation of a JSON, written in Swift.

JSEN /ˈdʒeɪsən/ JAY-sən JSEN (JSON Swift Enum Notation) is a lightweight enum representation of a JSON, written in Swift. A JSON, as defined in the EC

Roger Oba 8 Nov 22, 2022
JSON-Practice - JSON Practice With Swift

JSON Practice Vista creada con: Programmatic + AutoLayout Breve explicación de l

Vanesa Giselle Korbenfeld 0 Oct 29, 2021
Swift parser for JSON Feed — a new format similar to RSS and Atom but in JSON.

JSONFeed Swift parser for JSON Feed — a new format similar to RSS and Atom but in JSON. For more information about this new feed format visit: https:/

Toto Tvalavadze 31 Nov 22, 2021
JSONNeverDie - Auto reflection tool from JSON to Model, user friendly JSON encoder / decoder, aims to never die

JSONNeverDie is an auto reflection tool from JSON to Model, a user friendly JSON encoder / decoder, aims to never die. Also JSONNeverDie is a very important part of Pitaya.

John Lui 454 Oct 30, 2022
A lightweight CSS parser for parsing and creating CSS stylesheets

SwiftCSSParser A lightweight CSS parser for Swift that uses cssparser (cpp) under the hood. Basic usage Here's a simple code snippet to get you starte

null 9 Jul 20, 2022
Himotoki (紐解き) is a type-safe JSON decoding library written purely in Swift.

Himotoki Himotoki (紐解き) is a type-safe JSON decoding library written purely in Swift. This library is highly inspired by the popular Swift JSON parsin

IKEDA Sho 799 Dec 6, 2022
Swift library for JSON-RPC

JSONRPC There are already a bunch of packages out there for doing JSON-RPC in Swift. This one is just very simple and makes no assumptions about the t

Chime 16 Dec 30, 2022
A type-safe JSON-RPC 2.0 library purely written in Swift

JSONRPCKit JSONRPCKit is a type-safe JSON-RPC 2.0 library purely written in Swift. // Generating request JSON let batchFactory = BatchFactory(version:

Shinichiro Oba 178 Mar 18, 2022
A JSON deserialization library for Swift

Mapper Mapper is a simple Swift library to convert JSON to strongly typed objects. One advantage to Mapper over some other libraries is you can have i

Lyft 1.2k Dec 29, 2022
Argo is a library that lets you extract models from JSON or similar structures in a way that's concise, type-safe, and easy to extend

Argo is a library that lets you extract models from JSON or similar structures in a way that's concise, type-safe, and easy to extend. Using Argo

thoughtbot, inc. 3.5k Dec 20, 2022
Library of Swiftui Views conforming to Codable, meaning we can produce JSON driven UI!

CodableView Library of Swiftui Views conforming to Codable, meaning we can produce JSON driven UI! Adding a CodableView Type Create View that conforms

Daniel Bolella 3 Apr 2, 2022
🧱 A JSON decoding/encoding library that handles optimistically or strictly.

Do you need to handle the root cause of failure in decoding JSON? We often process the value as a default value if it could not be decoded from JSON.

Muukii 252 Oct 28, 2022