expo-modules-core 0.4.8 → 0.5.0

package/ios/Swift/Views/ConcreteViewProp.swift

@@ -1,30 +1,57 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
 import UIKit
 
 /**
  Specialized class for the view prop. Specifies the prop name and its setter.
  */
-public class ConcreteViewProp<ViewType: UIView, PropType>: AnyViewProp {
+public final class ConcreteViewProp<ViewType: UIView, PropType: AnyArgument>: AnyViewProp {
   public typealias SetterType = (ViewType, PropType) -> Void
 
+  /**
+   Name of the view prop that JavaScript refers to.
+   */
   public let name: String
 
-  let setter: SetterType
+  /**
+   An argument type wrapper for the prop's value type.
+   */
+  private let propType: AnyArgumentType
+
+  /**
+   Closure to call to set the actual property on the given view.
+   */
+  private let setter: SetterType
 
-  init(_ name: String, _ setter: @escaping SetterType) {
+  internal init(name: String, propType: AnyArgumentType, setter: @escaping SetterType) {
     self.name = name
+    self.propType = propType
     self.setter = setter
   }
 
-  public func set(value: Any?, onView view: UIView) {
-    // Method's signature must be type-erased for `AnyViewProp` protocol,
-    // so we have to get UIView and cast it to the generic type.
-    // TODO: (@tsapeta) Throw an error instead of crashing the app.
+  /**
+   Function that sets the underlying prop value for given view.
+   */
+  public func set(value: Any, onView view: UIView) throws {
+    // Method's signature must be type-erased to conform to `AnyViewProp` protocol.
+    // Given view must be castable to the generic `ViewType` type.
     guard let view = view as? ViewType else {
-      fatalError("Given view must subclass UIView")
+      throw IncompatibleViewError(propName: name, viewType: ViewType.self)
     }
-    guard let value = value as? PropType else {
-      fatalError("Given value `\(String(describing: value))` cannot be casted to `\(String(describing: PropType.self))`")
+    guard let value = try propType.cast(value) as? PropType else {
+      throw Conversions.CastingError<PropType>(value: value)
     }
     setter(view, value)
   }
 }
+
+/**
+ An error that is thrown when the view passed to prop's setter doesn't match the type in setter's definition.
+ */
+internal struct IncompatibleViewError: CodedError {
+  let propName: String
+  let viewType: UIView.Type
+  var description: String {
+    "Tried to set prop `\(propName)` on the view that isn't `\(viewType)`"
+  }
+}

package/ios/Swift/Views/ViewModuleWrapper.swift

@@ -16,7 +16,7 @@ protocol DynamicModuleWrapperProtocol {
  We're generating its subclasses in runtime as a workaround.
  */
 @objc
-public class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtocol {
+public final class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtocol {
   /**
    A reference to the module holder that stores the module definition.
    Enforced unwrapping is required since it can be set right after the object is initialized.
@@ -100,14 +100,19 @@ public class ViewModuleWrapper: RCTViewManager, DynamicModuleWrapperProtocol {
    The setter for `proxiedProperties` prop. In Objective-C style, this function is generated by `RCT_CUSTOM_VIEW_PROPERTY` macro.
    */
   @objc
-  public func set_proxiedProperties(_ json: Any?, forView view: UIView, withDefaultView defaultView: UIView) {
-    guard let json = json as? [String: Any?],
+  public func set_proxiedProperties(_ json: Any, forView view: UIView, withDefaultView defaultView: UIView) {
+    guard let json = json as? [String: Any],
           let props = wrappedModuleHolder.definition.viewManager?.propsDict() else {
       return
     }
     for (key, value) in json {
       if let prop = props[key] {
-        prop.set(value: value, onView: view)
+        let value = Conversions.fromNSObject(value)
+
+        // TODO: @tsapeta: Figure out better way to rethrow errors from here.
+        // Adding `throws` keyword to the function results in different
+        // method signature in Objective-C. Maybe just call `RCTLogError`?
+        try? prop.set(value: value, onView: view)
       }
     }
   }

package/ios/Swift.h

@@ -0,0 +1,9 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+// When `use_frameworks!` is used, the generated Swift header is inside ExpoModulesCore module.
+// Otherwise, it's available only locally with double-quoted imports.
+#if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)
+#import <ExpoModulesCore/ExpoModulesCore-Swift.h>
+#else
+#import "ExpoModulesCore-Swift.h"
+#endif

package/ios/Tests/ArgumentTypeSpec.swift

@@ -0,0 +1,145 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import Quick
+import Nimble
+
+@testable import ExpoModulesCore
+
+class ArgumentTypeSpec: QuickSpec {
+  override func spec() {
+
+    it("casts primitives") {
+      let type = ArgumentType(Int.self)
+      let value = 123
+      let anyValue = value as Any
+
+      expect(try type.cast(anyValue)).to(be(value))
+    }
+
+    it("casts optional types") {
+      let type = ArgumentType(Double?.self)
+      let value: Double? = nil
+      let anyValue = value as Any
+      let result = try type.cast(anyValue)
+
+      expect(result).to(beAKindOf(Double?.self))
+
+      // Since this `nil` is in fact of non-optional `Any` type, under the hood it's described as `Optional` enum.
+      // Simply checking `result == nil` does NOT work here, see `Optional.isNil` extension implementation.
+      expect(Optional.isNil(result)) == true
+    }
+
+    it("throws null cast error") {
+      let type = ArgumentType(Double.self) // non-optional (!)
+      let value: Double? = nil
+      let anyValue = value as Any
+
+      expect { try type.cast(anyValue) }.to(throwError(errorType: Conversions.NullCastError<Double>.self))
+    }
+
+    it("casts arrays") {
+      let type = ArgumentType([Double].self)
+      let value = 9.9
+      let anyValue = [value] as [Any]
+      let result = try type.cast(anyValue) as! [Any]
+
+      expect(result).to(beAKindOf([Double].self))
+      expect((result as! [Double]).first) == value
+    }
+
+    it("casts convertibles") {
+      let type = ArgumentType(ConvertibleTestStruct.self)
+      let value = "expo is the best"
+      let result = try type.cast(value)
+
+      expect(result).to(beAKindOf(ConvertibleTestStruct.self))
+      expect((result as! ConvertibleTestStruct).value) == value
+    }
+
+    it("casts array of convertibles") {
+      let type = ArgumentType([ConvertibleTestStruct].self)
+      let value = ["expo is the best"]
+      let result = try type.cast(value)
+
+      expect(result).to(beAKindOf([ConvertibleTestStruct].self))
+      expect((result as! [ConvertibleTestStruct]).first!.value) == value.first
+    }
+
+    it("casts array of array of convertibles") {
+      let type = ArgumentType([[ConvertibleTestStruct]].self)
+      let value = [["expo is the best"]]
+      let result = try type.cast(value)
+
+      expect(result).to(beAKindOf([[ConvertibleTestStruct]].self))
+      expect((result as! [[ConvertibleTestStruct]]).first!.first!.value) == value.first!.first
+    }
+
+    describe("EnumArgumentType") {
+      it("casts from String") {
+        let type = ArgumentType(StringTestEnum.self)
+        let input = "expo"
+        let output = try type.cast(input)
+
+        expect(output).to(beAKindOf(StringTestEnum.self))
+        expect(output as? StringTestEnum) == StringTestEnum.expo
+        expect(output as? StringTestEnum) == StringTestEnum(rawValue: input)
+        expect((output as! StringTestEnum).rawValue) == input
+        expect((output as! EnumArgument).anyRawValue).to(beAKindOf(String.self))
+      }
+
+      it("casts from Int") {
+        let type = ArgumentType(IntTestEnum.self)
+        let input: Int = -1
+        let output = try type.cast(input)
+
+        expect(output).to(beAKindOf(IntTestEnum.self))
+        expect(output as? IntTestEnum) == IntTestEnum.negative
+        expect(output as? IntTestEnum) == IntTestEnum(rawValue: input)
+        expect((output as! IntTestEnum).rawValue) == input
+        expect((output as! EnumArgument).anyRawValue).to(beAKindOf(Int.self))
+      }
+
+      it("throws casting error") {
+        let type = ArgumentType(IntTestEnum.self)
+
+        // "841" is not a raw value of any `IntTestEnum` case
+        expect { try type.cast("string instead of int") }.to(throwError {
+          expect($0).to(beAKindOf(EnumCastingError.self))
+        })
+      }
+
+      it("throws no such value error") {
+        let type = ArgumentType(IntTestEnum.self)
+
+        // "841" is not a raw value of any `IntTestEnum` case
+        expect { try type.cast(841) }.to(throwError {
+          expect($0).to(beAKindOf(EnumNoSuchValueError.self))
+        })
+      }
+
+      it("gets a list of all raw values") {
+        expect(StringTestEnum.allRawValues as? [String]) == ["hello", "expo"]
+        expect(IntTestEnum.allRawValues as? [Int]) == [-1, 1]
+      }
+    }
+  }
+}
+
+struct ConvertibleTestStruct: ConvertibleArgument {
+  let value: String
+
+  static func convert(from value: Any?) throws -> ConvertibleTestStruct {
+    guard let str = value as? String else { fatalError() }
+    return ConvertibleTestStruct(value: str)
+  }
+}
+
+enum StringTestEnum: String, EnumArgument {
+  case hello
+  case expo
+}
+
+enum IntTestEnum: Int, EnumArgument {
+  case negative = -1
+  case positive = 1
+}

package/ios/Tests/ConvertiblesSpec.swift

@@ -0,0 +1,231 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import CoreGraphics
+import Quick
+import Nimble
+
+@testable import ExpoModulesCore
+
+class ConvertiblesSpec: QuickSpec {
+  override func spec() {
+    describe("CGPoint") {
+      let x = -8.3
+      let y = 4.6
+
+      it("converts from array of doubles") {
+        let point = try CGPoint.convert(from: [x, y])
+
+        expect(point.x) == x
+        expect(point.y) == y
+      }
+
+      it("converts from dict") {
+        let point = try CGPoint.convert(from: ["x": x, "y": y])
+
+        expect(point.x) == x
+        expect(point.y) == y
+      }
+
+      it("throws when array size is unexpected") { // different than two
+        expect { try CGPoint.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
+        expect { try CGPoint.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
+        expect { try CGPoint.convert(from: [x, y, x]) }.to(throwError(errorType: Conversions.ConvertingError<CGPoint>.self))
+      }
+
+      it("throws when dict is missing some keys") {
+        expect { try CGPoint.convert(from: ["test": x]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["x", "y"]).description
+        })
+      }
+
+      it("throws when dict has uncastable keys") {
+        expect { try CGPoint.convert(from: ["x": x, "y": "string"]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["y"]).description
+        })
+      }
+    }
+
+    describe("CGSize") {
+      let width = 52.8
+      let height = 81.7
+
+      it("converts from array of doubles") {
+        let size = try CGSize.convert(from: [width, height])
+
+        expect(size.width) == width
+        expect(size.height) == height
+      }
+
+      it("converts from dict") {
+        let size = try CGSize.convert(from: ["width": width, "height": height])
+
+        expect(size.width) == width
+        expect(size.height) == height
+      }
+
+      it("throws when array size is unexpected") { // different than two
+        expect { try CGSize.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
+        expect { try CGSize.convert(from: [width]) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
+        expect { try CGSize.convert(from: [width, height, width]) }.to(throwError(errorType: Conversions.ConvertingError<CGSize>.self))
+      }
+
+      it("throws when dict is missing some keys") {
+        expect { try CGSize.convert(from: ["width": width]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["height"]).description
+        })
+      }
+
+      it("throws when dict has uncastable keys") {
+        expect { try CGSize.convert(from: ["width": "test", "height": height]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["width"]).description
+        })
+      }
+    }
+
+    describe("CGVector") {
+      let dx = 11.6
+      let dy = -4.0
+
+      it("converts from array of doubles") {
+        let vector = try CGVector.convert(from: [dx, dy])
+
+        expect(vector.dx) == dx
+        expect(vector.dy) == dy
+      }
+
+      it("converts from dict") {
+        let vector = try CGVector.convert(from: ["dx": dx, "dy": dy])
+
+        expect(vector.dx) == dx
+        expect(vector.dy) == dy
+      }
+
+      it("throws when array size is unexpected") { // different than two
+        expect { try CGVector.convert(from: []) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
+        expect { try CGVector.convert(from: [dx]) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
+        expect { try CGVector.convert(from: [dx, dy, dx]) }.to(throwError(errorType: Conversions.ConvertingError<CGVector>.self))
+      }
+
+      it("throws when dict is missing some keys") {
+        expect { try CGVector.convert(from: ["dx": dx]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["dy"]).description
+        })
+      }
+
+      it("throws when dict has uncastable keys") {
+        expect { try CGVector.convert(from: ["dx": "dx", "dy": dy]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["dx"]).description
+        })
+      }
+    }
+
+    describe("CGRect") {
+      let x = -8.3
+      let y = 4.6
+      let width = 52.8
+      let height = 81.7
+
+      it("converts from array of doubles") {
+        let rect = try CGRect.convert(from: [x, y, width, height])
+
+        expect(rect.origin.x) == x
+        expect(rect.origin.y) == y
+        expect(rect.width) == width
+        expect(rect.height) == height
+      }
+
+      it("converts from dict") {
+        let rect = try CGRect.convert(from: ["x": x, "y": y, "width": width, "height": height])
+
+        expect(rect.origin.x) == x
+        expect(rect.origin.y) == y
+        expect(rect.width) == width
+        expect(rect.height) == height
+      }
+
+      it("throws when array size is unexpected") { // different than four
+        expect { try CGRect.convert(from: [x]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
+        expect { try CGRect.convert(from: [x, y]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
+        expect { try CGRect.convert(from: [x, y, width, height, y]) }.to(throwError(errorType: Conversions.ConvertingError<CGRect>.self))
+      }
+
+      it("throws when dict is missing some keys") {
+        expect { try CGRect.convert(from: ["x": x]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.MissingKeysError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.MissingKeysError<Double>(keys: ["y", "width", "height"]).description
+        })
+      }
+
+      it("throws when dict has uncastable keys") {
+        expect { try CGRect.convert(from: ["x": x, "y": nil, "width": width, "height": "\(height)"]) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.CastingValuesError<Double>.self))
+          expect(($0 as! CodedError).description) == Conversions.CastingValuesError<Double>(keys: ["y", "height"]).description
+        })
+      }
+    }
+
+    describe("UIColor/CGColor") {
+      func testColorComponents(_ color: CGColor, _ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat) {
+        expect(color.components?[0]) == red   / 255.0
+        expect(color.components?[1]) == green / 255.0
+        expect(color.components?[2]) == blue  / 255.0
+        expect(color.components?[3]) == alpha / 255.0
+      }
+      func testInvalidHexColor(_ hex: String) {
+        expect { try CGColor.convert(from: hex) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.InvalidHexColorError.self))
+          expect(($0 as! CodedError).description) == Conversions.InvalidHexColorError(hex: hex).description
+        })
+      }
+
+      it("converts from ARGB int") {
+        // NOTE: int representation has alpha channel at the beginning
+        let color = try CGColor.convert(from: 0x5147AC7F)
+        testColorComponents(color, 0x47, 0xAC, 0x7F, 0x51)
+      }
+
+      it("converts from RGBA hex string") {
+        let color = try CGColor.convert(from: "47AC7F51")
+        testColorComponents(color, 0x47, 0xAC, 0x7F, 0x51)
+      }
+
+      it("converts from #RGBA hex string") {
+        let color = try CGColor.convert(from: " #47AC7F51")
+        testColorComponents(color, 0x47, 0xAC, 0x7F, 0x51)
+      }
+
+      it("converts from 3-character shorthand hex string") {
+        let color = try CGColor.convert(from: "C2B ")
+        testColorComponents(color, 0xCC, 0x22, 0xBB, 0xFF)
+      }
+
+      it("converts from 4-character shorthand hex string") {
+        let color = try CGColor.convert(from: " #9EA5 ")
+        testColorComponents(color, 0x99, 0xEE, 0xAA, 0x55)
+      }
+
+      it("throws when hex string is invalid") {
+        testInvalidHexColor("")
+        testInvalidHexColor("#21")
+        testInvalidHexColor("ABCDEFGH")
+        testInvalidHexColor("1122334455")
+        testInvalidHexColor("XYZ")
+        testInvalidHexColor("!@#$%")
+      }
+
+      it("throws when int overflows") {
+        let hex = 0xBBAA88FF2
+        expect { try CGColor.convert(from: hex) }.to(throwError {
+          expect($0).to(beAKindOf(Conversions.HexColorOverflowError.self))
+          expect(($0 as! CodedError).description) == Conversions.HexColorOverflowError(hex: UInt64(hex)).description
+        })
+      }
+    }
+  }
+}