Migrate enum possible values to metadata

Summary:
Before this change, possible values for an enumeration were embedded within the attribute value itself.

After this change, possible values are located within the attribute metadata.

Reviewed By: LukeDefeo

Differential Revision: D41337003

fbshipit-source-id: cef5654a679e9b961e82993abb201b518fcbcd00

android/plugins/litho/src/main/java/com/facebook/flipper/plugins/uidebugger/litho/descriptors/props/ComponentPropExtractor.kt

@@ -39,13 +39,6 @@ object ComponentPropExtractor {
       declaredField.isAccessible = true
 
       val name = declaredField.name
-
-      val metadata = MetadataRegister.get(component.simpleName, name)
-      val identifier =
-          metadata?.id
-              ?: MetadataRegister.registerDynamic(
-                  MetadataRegister.TYPE_ATTRIBUTE, component.simpleName, name)
-
       val declaredFieldAnnotation = declaredField.getAnnotation(Prop::class.java)
 
       // Only expose `@Prop` annotated fields for Spec components
@@ -64,10 +57,12 @@ object ComponentPropExtractor {
         val resType = declaredFieldAnnotation.resType
         if (resType == ResType.COLOR) {
           if (prop != null) {
+            val identifier = getMetadataId(component.simpleName, name)
             props[identifier] = InspectableValue.Color(Color.fromColor(prop as Int))
           }
           continue
         } else if (resType == ResType.DRAWABLE) {
+          val identifier = getMetadataId(component.simpleName, name)
           props[identifier] = fromDrawable(prop as Drawable?)
           continue
         }
@@ -77,18 +72,42 @@ object ComponentPropExtractor {
           EditorRegistry.read(declaredField.type, declaredField, component)
 
       if (editorValue != null) {
-        props[identifier] = toInspectable(name, editorValue)
+        addProp(props, component.simpleName, name, editorValue)
       }
     }
 
     return props
   }
 
-  private fun fromDrawable(d: Drawable?): Inspectable =
-      when (d) {
-        is ColorDrawable -> InspectableValue.Color(Color.fromColor(d.color))
-        else -> InspectableValue.Unknown(d.toString())
-      }
+  private fun getMetadataId(
+      namespace: String,
+      key: String,
+      mutable: Boolean = false,
+      possibleValues: Set<InspectableValue>? = emptySet()
+  ): MetadataId {
+    val metadata = MetadataRegister.get(namespace, key)
+    val identifier =
+        metadata?.id
+            ?: MetadataRegister.registerDynamic(
+                MetadataRegister.TYPE_ATTRIBUTE, namespace, key, mutable, possibleValues)
+    return identifier
+  }
+
+  private fun addProp(
+      props: MutableMap<MetadataId, Inspectable>,
+      namespace: String,
+      name: String,
+      value: EditorValue
+  ) {
+    var possibleValues: MutableSet<InspectableValue>? = null
+    if (value is EditorPick) {
+      possibleValues = mutableSetOf()
+      value.values.forEach { possibleValues.add(InspectableValue.Text(it)) }
+    }
+
+    val identifier = getMetadataId(namespace, name, false, possibleValues)
+    props[identifier] = toInspectable(name, value)
+  }
 
   private fun toInspectable(name: String, editorValue: EditorValue): Inspectable {
     return editorValue.`when`(
@@ -97,13 +116,16 @@ object ComponentPropExtractor {
 
             val fields = mutableMapOf<MetadataId, Inspectable>()
             shape.value.entries.forEach { entry ->
-              val metadata = MetadataRegister.get(name, entry.key)
-              val identifier =
-                  metadata?.id
-                      ?: MetadataRegister.registerDynamic(
-                          MetadataRegister.TYPE_LAYOUT, name, entry.key)
-
               val value = toInspectable(entry.key, entry.value)
+
+              val shapeEditorValue = entry.value
+              var possibleValues: MutableSet<InspectableValue>? = null
+              if (shapeEditorValue is EditorPick) {
+                possibleValues = mutableSetOf()
+                shapeEditorValue.values.forEach { possibleValues.add(InspectableValue.Text(it)) }
+              }
+
+              val identifier = getMetadataId(name, entry.key, false, possibleValues)
               fields[identifier] = value
             }
 
@@ -116,7 +138,7 @@ object ComponentPropExtractor {
           }
 
           override fun isPick(pick: EditorPick?): Inspectable =
-              InspectableValue.Enum(Enumeration(pick?.values ?: setOf(), pick?.selected))
+              InspectableValue.Enum(Enumeration(pick?.selected))
 
           override fun isNumber(number: EditorNumber): Inspectable =
               InspectableValue.Number(number.value)
@@ -130,4 +152,10 @@ object ComponentPropExtractor {
           override fun isBool(bool: EditorBool): Inspectable = InspectableValue.Boolean(bool.value)
         })
   }
+
+  private fun fromDrawable(d: Drawable?): Inspectable =
+      when (d) {
+        is ColorDrawable -> InspectableValue.Color(Color.fromColor(d.color))
+        else -> InspectableValue.Unknown(d.toString())
+      }
 }

android/plugins/litho/src/main/java/com/facebook/flipper/plugins/uidebugger/litho/descriptors/props/LayoutPropExtractor.kt

@@ -9,6 +9,7 @@ package com.facebook.flipper.plugins.uidebugger.litho.descriptors.props
 
 import android.graphics.drawable.ColorDrawable
 import android.graphics.drawable.Drawable
+import com.facebook.flipper.plugins.uidebugger.common.enumToInspectableSet
 import com.facebook.flipper.plugins.uidebugger.descriptors.MetadataRegister
 import com.facebook.flipper.plugins.uidebugger.model.*
 import com.facebook.litho.DebugComponent
@@ -23,19 +24,54 @@ object LayoutPropExtractor {
       MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "foreground")
 
   private val DirectionId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "direction")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "direction",
+          false,
+          enumToInspectableSet<YogaDirection>())
   private val FlexDirectionId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "flexDirection")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "flexDirection",
+          false,
+          enumToInspectableSet<YogaFlexDirection>())
   private val JustifyContentId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "justifyContent")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "justifyContent",
+          false,
+          enumToInspectableSet<YogaJustify>())
   private val AlignItemsId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "alignItems")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "alignItems",
+          false,
+          enumToInspectableSet<YogaAlign>())
   private val AlignSelfId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "alignSelf")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "alignSelf",
+          false,
+          enumToInspectableSet<YogaAlign>())
   private val AlignContentId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "alignContent")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "alignContent",
+          false,
+          enumToInspectableSet<YogaAlign>())
   private val PositionTypeId =
-      MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "positionType")
+      MetadataRegister.register(
+          MetadataRegister.TYPE_LAYOUT,
+          NAMESPACE,
+          "positionType",
+          false,
+          enumToInspectableSet<YogaPositionType>())
 
   private val FlexGrowId =
       MetadataRegister.register(MetadataRegister.TYPE_LAYOUT, NAMESPACE, "flexGrow")
@@ -94,22 +130,14 @@ object LayoutPropExtractor {
     layout.background?.let { drawable -> props[BackgroundId] = fromDrawable(drawable) }
     layout.foreground?.let { drawable -> props[ForegroundId] = fromDrawable(drawable) }
 
-    props[DirectionId] =
-        InspectableValue.Enum(Enumeration(enumToSet<YogaDirection>(), layout.layoutDirection.name))
+    props[DirectionId] = InspectableValue.Enum(Enumeration(layout.layoutDirection.name))
 
-    props[FlexDirectionId] =
-        InspectableValue.Enum(
-            Enumeration(enumToSet<YogaFlexDirection>(), layout.flexDirection.name))
-    props[JustifyContentId] =
-        InspectableValue.Enum(Enumeration(enumToSet<YogaJustify>(), layout.justifyContent.name))
-    props[AlignItemsId] =
-        InspectableValue.Enum(Enumeration(enumToSet<YogaAlign>(), layout.alignItems.name))
-    props[AlignSelfId] =
-        InspectableValue.Enum(Enumeration(enumToSet<YogaAlign>(), layout.alignSelf.name))
-    props[AlignContentId] =
-        InspectableValue.Enum(Enumeration(enumToSet<YogaAlign>(), layout.alignContent.name))
-    props[PositionTypeId] =
-        InspectableValue.Enum(Enumeration(enumToSet<YogaPositionType>(), layout.positionType.name))
+    props[FlexDirectionId] = InspectableValue.Enum(Enumeration(layout.flexDirection.name))
+    props[JustifyContentId] = InspectableValue.Enum(Enumeration(layout.justifyContent.name))
+    props[AlignItemsId] = InspectableValue.Enum(Enumeration(layout.alignItems.name))
+    props[AlignSelfId] = InspectableValue.Enum(Enumeration(layout.alignSelf.name))
+    props[AlignContentId] = InspectableValue.Enum(Enumeration(layout.alignContent.name))
+    props[PositionTypeId] = InspectableValue.Enum(Enumeration(layout.positionType.name))
 
     props[FlexGrowId] = InspectableValue.Text(layout.flexGrow.toString())
     props[FlexShrinkId] = InspectableValue.Text(layout.flexShrink.toString())
@@ -199,12 +227,4 @@ object LayoutPropExtractor {
         is ColorDrawable -> InspectableValue.Color(Color.fromColor(d.color))
         else -> InspectableValue.Unknown(d.toString())
       }
-
-  private inline fun <reified T : Enum<T>> enumerator(): Iterator<T> = enumValues<T>().iterator()
-  private inline fun <reified T : Enum<T>> enumToSet(): Set<String> {
-    val set = mutableSetOf<String>()
-    val values = enumerator<T>()
-    values.forEach { set.add(it.name) }
-    return set
-  }
 }