Can't compile on macOS 11 (11.3 beta 20E5229a) using XCode 12.5 beta 3 (12E5244e) due to following error: 'Float16' is unavailable in macOS Not sure what the extent of this is or if it does build for other macOS versions? If not we can simply rewrite the swift version check as: #if swift(>=5.4) && !os(macOS)

The CocoaPods manager doesn't see the 2.0.6 fix because it is not specified in CodableWrappers.podspec

You can test the difference specifying

pod 'CodableWrappers', :git=>'https://github.com/aserdobintsev/CodableWrappers', :branch=>'fix/cocoapodsVersion'

vs

pod 'CodableWrappers',

Hey @GottaGetSwifty,

Using @Immutable with @EncodeNulls doesn’t work as expected.

struct TestModel: Encodable {
    @EncodeNulls var date1: Date?
    @Immutable @EncodeNulls var date2: Date?
}

 print(String(data: try! JSONEncoder().encode(TestModel(date1: nil, date2: nil)), encoding: .utf8))

// OUTPUT: "{\"date1\":null}"

I also can’t seem to get this snippet to compile (related?):

@Immutable @OptionalCoding<DateFormatterCoding<RFC3339DateCoder>> @EncodeNulls var myDate: Date?

Apple responded to my feedback with:

Float16 isn’t supported on Intel Macs, but should be available on Apple Silicon Macs.

Introduced these warnings for the test cases:

warning: conformance of 'Float16' to ‘Encodable' is only available in macOS 11.0 or newer warning: conformance of 'Float16' to ‘Decodable' is only available in macOS 11.0 or newer warning: conformance of 'Float16' to ‘Encodable' is only available in Mac Catalyst 14.0 or newer warning: conformance of 'Float16' to 'Decodable' is only available in Mac Catalyst 14.0 or newer

Fixes https://github.com/GottaGetSwifty/CodableWrappers/issues/13.

Note: you have write access to edit my branch.

NullEncoding.swift includes a specific override of encode for AnyNullEncoder (NullEncoding.swift) to bypass the default behaviour of OptionalEncodingWrapper which would otherwise skip the property when the wrappedValue is nil.

However, Immutable also overrides encoding of wrapped OptionalEncodingWrappers (ImmutableWrapper.swift) to check if the deeply nested wrappedValue is nil or not, which means the above AnyNullEncoder override is never called.

This PR adds an additional bypass for AnyNullEncoders wrapped in AnyImmutableWrapper.

Hi,

I'm looking for a way to map/decode json values to custom Enums.

For instance my API return status value which may be something like -1, 0 or 1 I also have an enum:

enum Status: Int {
    case deleted = -1
    case inactive = 0
    case active = 1
}

Can I map these together? I tried implementing a custom mapper from your example buy it doest seem to accept custom types, such as Status. I want to be able to do something like this:

return Status(rawValue: -1)

and get my custom type

normal case:

{
    "maintenance": true
}

{
    "maintenance": false
}

If there is no maintenance station then it will become empty string

{
    "maintenance": ""
}

i want to have nil if maintenance is empty string in json

struct Demo: Codable {
    var maintenance: Bool?
}

Is there a good way to do it?

struct WorkingModel: Codable {
  @FallbackDecoding<EmptyDouble>
  var duration: Double = 0
}

struct FailingModel: Codable {
  @Immutable @FallbackDecoding<EmptyDouble>
  var duration: Double = 0
}

let json = "{}"
let decoder = JSONDecoder()

do {
  _ = try decoder.decode(WorkingModel.self, from: json.data(using: .utf8).unsafelyUnwrapped) // Works
  _ = try decoder.decode(FailingModel.self, from: json.data(using: .utf8).unsafelyUnwrapped) // Throws an error about missing key
} catch {
  dump(error)
  fatalError()
}

Running the above code should produce an error about a missing key. Using breakpoints I was expecting ImmutableWrapper.swift:L41-L44 or ImmutableWrapper.swift:L64-L66 to be called. However, it didn’t appear that they were.

Hi,

What would be the simplest way to encode an optional as null if nil or use the default Codable encoding strategy if present ? I mean a generic way to do it on Codable to avoid writing static encoder for each of my Codable types.

so : struct some: Encodable { @?? let thisShouldBeEncodedAsNull: String? = nil let thisShouldNotBeEncodedAsNull: String? = nil }

would give in JSON: { "thisShouldBeEncodedAsNull": null }

Why does the code print "hi"?

https://github.com/GottaGetSwifty/CodableWrappers/blob/develop/Sources/CodableWrappers/OptionalWrappers.swift#L44

https://github.com/GottaGetSwifty/CodableWrappers/blob/develop/Sources/CodableWrappers/OptionalWrappers.swift#L98

The package build/test fails on linux with different errors for swift 5.2 and 5.6. I did my best to follow the travis docs, but I couldn't test that part myself. Package.resolved seems like a lite version of a lock file, so I added it following the conventions of other package managers.

https://github.com/GottaGetSwifty/CodableWrappers/blob/4eb46a4c656333e8514db8aad204445741de7d40/Sources/CodableWrappers/StaticCoders/DateCoding.swift#L60-L71 I was debugging an issue which was made a bit confusing because of throwing valueNotFound, would you like me to make a PR changing this to a dataCorrupted error?

It would match the behaviour of:

import Foundation

let string = """
{ "date": "ehrtrthrt" }
"""

struct Model: Codable {
  let date: Date
}

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601

do {
  let model = try decoder.decode(Model.self, from: Data(string.utf8))
} catch {
  if case DecodingError.dataCorrupted = error {
    print("DecodingError is dataCorrupted")
  } else {
    // not called
  }
}

Hi, I've been working on a similar set of features as this project, until I found this one, great work!

The one feature I'm missing is for a way to have a non optional field that contains a default value in case the key is not present in the input data. So far I was able to get to this solution, which works for my use case, and was wondering if it might be something that could be added to this project

What I came up with was this:

import Foundation

public protocol DefaultValue<Value> where Value: Codable {
  associatedtype Value

  static var defaultValue: Value { get }
}

@propertyWrapper
public struct DefaultCodable<D: DefaultValue>: Codable {
  private enum State<Value> {
    case uninitialized
    case initialized(Value)
  }

  private var innerValue: State<D.Value>

  public init(value: D.Value? = nil) {
    if let value {
      innerValue = .initialized(value)
    } else {
      innerValue = .uninitialized
    }
  }

  public var wrappedValue: D.Value {
    get {
      if case .initialized(let value) = innerValue {
        return value
      } else {
        return D.self.defaultValue
      }
    }
    set {
      innerValue = .initialized(newValue)
    }
  }

  fileprivate var isSet: Bool {
    if case .uninitialized = innerValue {
      return false
    } else {
      return true
    }
  }

  public func encode(to encoder: Encoder) throws {
    if case .initialized(let value) = innerValue {
      var container = encoder.singleValueContainer()
      try container.encode(value)
    }
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.singleValueContainer()
    self.innerValue = try .initialized(container.decode(D.Value.self))
  }
}

extension KeyedEncodingContainer {
  public mutating func encode<T>(
    _ value: DefaultCodable<T>,
    forKey key: KeyedEncodingContainer<K>.Key
  ) throws {
    if value.isSet {
      try encode(value.wrappedValue, forKey: key)
    }
  }
}

extension KeyedDecodingContainer {
  public func decode<T>(
    _ type: DefaultCodable<T>.Type,
    forKey key: Self.Key
  ) throws -> DefaultCodable<T> {
    if contains(key) {
      let value = try decode(T.Value.self, forKey: key)
      return DefaultCodable(value: value)
    } else {
      return DefaultCodable()
    }
  }
}

// Default Values

public enum DefaultBoolTrue: DefaultValue {
  public static var defaultValue = true
}

public enum DefaultBoolFalse: DefaultValue {
  public static var defaultValue = false
}

which can be used like this:

public enum DefaultNameUnknown: DefaultValue {
  public static var emptyDefault = "Unknown"
}

public struct UserInfo: Codable {
  @DefaultCodable<DefaultBoolFalse> public var admin: Bool
  @DefaultCodable<DefaultBoolTrue> public var isActive: Bool

  @DefaultCodable<DefaultNameUnknown> public var name: String

  public init() {}
}

And used like this:

public enum DefaultNameUnknown: DefaultValue {
  public static var defaultValue = "Unknown"
}

public struct UserInfo: Codable {
  @DefaultCodable<DefaultBoolFalse> public var admin: Bool
  @DefaultCodable<DefaultBoolTrue> public var isActive: Bool

  @DefaultCodable<DefaultNameUnknown> public var name: String

  public init() {}
}

which results in

let data = #"{}"#.data(using: .utf8)!

let decoder = JSONDecoder()
let user = try decoder.decode(UserInfo.self, from: data)
print(user.admin) // false
print(user.isActive) // true
print(user.name) // Unknown

This is using 5.7 syntax, but could probably be adapted. Also, there might be a better way to specify a default value other than types, but this worked for me well enough.

Is this something that you might consider adding to CodableWrappers?

https://github.com/GottaGetSwifty/CodableWrappers/blob/master/Sources/CodableWrappers/Core/OptionalWrappers.swift#L76

I think this public struct OptionalEncoding<CustomDecoderWrapper: StaticEncoderWrapper>: OptionalEncodable { should be public struct OptionalEncoding<CustomEncoderWrapper: StaticEncoderWrapper>: OptionalEncodable {

Hello, is it possible to combine the following two wrappers in some way?

public struct EmptyBoolTrue: FallbackValueProvider {
    public static var defaultValue: Bool { true }
}

@OptionalCoding<BoolAsIntCoding>
@FallbackEncoding<EmptyBoolTrue>
var autoRenewWarning: Bool?

The server sends 1 and 0 for booleans and I use Bool locally. What I would like to achieve is to set a default value of 1 or true whichever is possible if the key is missing or null but it seems the above two cannot be combined because one expects Int and the other Bool. How should I proceed regarding this, is there anything similar implemented that I can use as reference?

I want to write something like this:

@Immutable @EncodeNulls @OptionalEncoding<DateFormatterEncoding<RFC3339DateCoder>> var completedOn: Date?

However, currently that doesn’t work. I did try a few variations but from what I could tell we don’t have the functionality to do this yet.

@jayrhynas kindly helped me out and we were able to come up with:

struct Model: Codable {
  @Immutable @EncodeOptionalNulls @OptionalEncoding<DateFormatterEncoding<RFC3339DateCoder>> var completedOn: Date?
}

/// Encodes an optional nil value in a singleValueContainer using `encodeNil` rather than it being omitted.
typealias EncodeOptionalNulls<T: Encodable & OptionalEncodingWrapper> = EncodingUses<OptionalNullStaticEncoder<T>>

struct OptionalNullStaticEncoder<T: Encodable>: StaticEncoder, AnyNullEncoder where T: OptionalEncodingWrapper {
  static func encode(value: T, to encoder: Encoder) throws {
    if case Optional<Any>.none = value.wrappedValue as Any {
      var container = encoder.singleValueContainer()
      try container.encodeNil()
      return
    }
    try value.encode(to: encoder)
  }
}

struct RFC3339DateCoder: DateFormatterStaticCoder {
  static let dateFormatter = with(DateFormatter()) {
    $0.timeZone = TimeZone(secondsFromGMT: 0)
    $0.locale = Locale(identifier: "en_US_POSIX")
    $0.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
  }
}

I’m not sure if the above could be simplified or made so that an additional StaticEncoder struct is not needed?

Hey! It is not final version of intended PR, but I wanted to make sure that author is interested in such feature. Implemented @CurrentPathCoding wrapper allows this JSON structure:

{
    "title": "Cool title",
    "authorName": "John",
    "authorEmail": "[email protected]"
}

to be mapped to such model:

struct Author: Codable {
    var authorName: String
    var authorEmail: String
}

struct Article: Codable {
    var title: String
    @CurrentPathCoding
    var author: Author
}

If you can approve that such wrapper has the right to life and you would merge it, I'll add documentation and tests and then finalise the PR.