What's Changed

• Added InvalidTypeError
• Removed force unwraps for throwing
• Changed JSON to a struct and removed conformance to Cacheable

Full Changelog: https://github.com/0xOpenBytes/c/compare/2.0.0...3.0.0

c

Micro Composition

What is c?

c is a simple composition framework. You have the ability to create transformations that are either unidirectional or bidirectional. There is also a cache that values can be set and resolved.

Where can c be used?

c can be used anywhere to create transformations or interact with the cache.

Examples

BiDirectionalTransformation of String and Int

let transformer = c.transformer(
    from: { string in Int(string) },
    to: { int in "\(String(describing: int))" }
)

let string = transformer.to(3)
let int = transformer.from("3")

try t.assert(transformer.to(int), isEqualTo: string)

Cache

let cache = c.Cache()

cache.set(value: Double.pi, forKey: "🥧")

let pi: Double = cache.get("🥧") ?? 0

try t.assert(pi, isEqualTo: .pi)

let resolvedValue: Double = try cache.resolve("🥧")

try t.assert(resolvedValue, isEqualTo: .pi)
                    
cache.remove("🥧")

let nilValue: Double? = cache.get("🥧")

try t.assert(isNil: nilValue)

KeyedCache

enum CacheKey: Hashable { ... }

let cache = c.KeyedCache<CacheKey>()

cache.set(value: Double.pi, forKey: CacheKey.piKey)

let pi: Double = cache.get(.piKey) ?? 0

try t.assert(pi, isEqualTo: .pi)

let resolvedValue: Double = try cache.resolve(.piKey)

try t.assert(resolvedValue, isEqualTo: .pi)
                    
cache.remove(.piKey)

let nilValue: Double? = cache.get(.piKey)

try t.assert(isNil: nilValue)

JSON

enum MockJSONKey: String, Hashable {
    case name, number, bool, invalid_key
}

struct MockJSON: Codable {
    var name: String
    var number: Int
    var bool: Bool
}

let jsonData: Data = try! JSONEncoder().encode(MockJSON(name: "Twitch", number: 5, bool: false))

let json: c.JSON<MockJSONKey> = .init(data: jsonData)

XCTAssertEqual(try! json.resolve(.name), "Twitch")
XCTAssertEqual(try! json.resolve(.number), 5)
XCTAssertEqual(try! json.resolve(.bool), false)

let invalid_key: Bool? = json.get(.invalid_key)

XCTAssertNil(json.get(.invalid_key))
XCTAssertNil(invalid_key)

json.set(value: "Leif", forKey: .name)

XCTAssertEqual(try! json.resolve(.name), "Leif")

Global Cache

let someCache: Cache = ...

// Set the value of a Cache with any hashable key
c.set(value: someCache, forKey: "someCache")

// Get an optional Cache using any hashable key
let anotherCache: Cache? = c.get(0)

// Require that a Cache exist using a `.get` with a force unwrap
let requiredCache: Cache = try c.resolve(0)

let keyedCache: KeyedCache<String> = try c.resolve(...)

Changes: https://github.com/0xOpenBytes/c/commit/1a211c68ce509f77f789440ba008e7ad2898dac1

What's Changed

• Support sub JSON Arrays by @0xLeif in https://github.com/0xOpenBytes/c/pull/6

Full Changelog: https://github.com/0xOpenBytes/c/compare/1.1.1...1.2.0

Fixed

• Access type for MissingRequiredKeysError init

Added

• contains: Checks if the given key has a value or not
• require: Checks to make sure the cache has the required keys, otherwise it will throw an error
• valuesInCache: Returns a Dictionary containing only the key value pairs where the value is the same type as the generic type Value

What's Changed

• Develop by @0xLeif in https://github.com/0xOpenBytes/c/pull/5

Full Changelog: https://github.com/0xOpenBytes/c/compare/1.1.0...1.1.1

Added

• contains: Checks if the given key has a value or not
• require: Checks to make sure the cache has the required keys, otherwise it will throw an error
• valuesInCache: Returns a Dictionary containing only the key value pairs where the value is the same type as the generic type Value

What's Changed

• Develop by @0xLeif in https://github.com/0xOpenBytes/c/pull/5

Full Changelog: https://github.com/0xOpenBytes/c/compare/1.0.1...1.1.0

Full Changelog: https://github.com/0xOpenBytes/c/compare/1.0.0...1.0.1

c

Micro Composition

What is c?

c is a simple composition framework. You have the ability to create transformations that are either unidirectional or bidirectional. There is also a cache that values can be set and resolved.

Where can c be used?

c can be used anywhere to create transformations or interact with the cache.

Examples

BiDirectionalTransformation of String and Int

let transformer = c.transformer(
    from: { string in Int(string) },
    to: { int in "\(String(describing: int))" }
)

let string = transformer.to(3)
let int = transformer.from("3")

try t.assert(transformer.to(int), isEqualTo: string)

Cache

let cache = c.Cache()

cache.set(value: Double.pi, forKey: "🥧")

let pi: Double = cache.get("🥧") ?? 0

try t.assert(pi, isEqualTo: .pi)

let resolvedValue: Double = cache.resolve("🥧")

try t.assert(resolvedValue, isEqualTo: .pi)
                    
cache.remove("🥧")

let nilValue: Double? = cache.get("🥧")

try t.assert(isNil: nilValue)

KeyedCache

enum CacheKey: Hashable { ... }

let cache = c.KeyedCache<CacheKey>()

cache.set(value: Double.pi, forKey: CacheKey.piKey)

let pi: Double = cache.get(.piKey) ?? 0

try t.assert(pi, isEqualTo: .pi)

let resolvedValue: Double = cache.resolve(.piKey)

try t.assert(resolvedValue, isEqualTo: .pi)
                    
cache.remove(.piKey)

let nilValue: Double? = cache.get(.piKey)

try t.assert(isNil: nilValue)

JSON

enum MockJSONKey: String, Hashable {
    case name, number, bool, invalid_key
}

struct MockJSON: Codable {
    var name: String
    var number: Int
    var bool: Bool
}

let jsonData: Data = try! JSONEncoder().encode(MockJSON(name: "Twitch", number: 5, bool: false))

let json: c.JSON<MockJSONKey> = .init(data: jsonData)

XCTAssertEqual(json.resolve(.name), "Twitch")
XCTAssertEqual(json.resolve(.number), 5)
XCTAssertEqual(json.resolve(.bool), false)

let invalid_key: Bool? = json.get(.invalid_key)

XCTAssertNil(json.get(.invalid_key))
XCTAssertNil(invalid_key)

json.set(value: "Leif", forKey: .name)

XCTAssertEqual(json.resolve(.name), "Leif"

Global Cache

let someCache: Cache = ...

// Set the value of a Cache with any hashable key
c.set(value: someCache, forKey: "someCache")

// Get an optional Cache using any hashable key
let anotherCache: Cache? = c.get(0)

// Require that a Cache exist using a `.get` with a force unwrap
let requiredCache: Cache = c.resolve(0)

let keyedCache: KeyedCache<String> = c.resolve(...)

Full Changelog: https://github.com/0xOpenBytes/c/compare/0.4.0...1.0.0

What's Changed

• Feature/json by @0xLeif in https://github.com/0xOpenBytes/c/pull/4

Full Changelog: https://github.com/0xOpenBytes/c/compare/0.3.0...0.4.0

What's Changed

• Feature/keyed cache by @0xLeif in https://github.com/0xOpenBytes/c/pull/3

Full Changelog: https://github.com/0xOpenBytes/c/compare/0.2.0...0.3.0

What's Changed

• Cache Update by @0xLeif in https://github.com/0xOpenBytes/c/pull/2

Full Changelog: https://github.com/0xOpenBytes/c/compare/0.1.0...0.2.0

c

Micro Composition

What is c?

c is a simple composition framework. You have the ability to create transformations that are either unidirectional or bidirectional. There is also a cache that values can be set and resolved.

Where can c be used?

c can be used anywhere to create transformations or interact with the cache.

Examples

BiDirectionalTransformation of String and Int

let transformer = c.transformer(
    from: { string in Int(string) },
    to: { int in "\(String(describing: int))" }
)

let string = transformer.to(3)
let int = transformer.from("3")

try t.assert(transformer.to(int), isEqualTo: string)

Cache

c.set(value: Double.pi, forKey: "🥧")

let pi: Double = c.get("🥧") ?? 0

try t.assert(pi, isEqualTo: .pi)

let resolvedValue: Double = c.resolve("🥧")

try t.assert(resolvedValue, isEqualTo: .pi)