The default values of method arguments require to use the method owner instance (#339)

Author: xerial

airframe-codec/.jvm/src/test/scala/wvlet/airframe/codec/ObjectCodecTest.scala

@@ -50,7 +50,7 @@ class ObjectCodecTest extends CodecSpec {
     h.getLastValue shouldBe v
   }
 
-  "populate the default value when missing" in {
+  "populate the default value when missing" taggedAs ("default-arg") in {
     val packer = MessagePack.newBufferPacker
     packer.packMapHeader(1)
     packer.packString("i")

airframe-codec/src/main/scala/wvlet/airframe/codec/ObjectCodec.scala

@@ -19,56 +19,19 @@ import wvlet.airframe.surface._
 
 import scala.util.{Failure, Success, Try}
 
-object ParamListCodec extends LogSupport {
-  val defaultEmptyParamBinder = { p: Parameter =>
-    Zero.zeroOf(p.surface)
-  }
-
-  /**
-    * Access the default value of a method argument, through the owner object.
-    *
-    * {{{
-    * public class wvlet.airframe.opts.LauncherTest$MyCommand {
-    *   public void hello(int, java.lang.String);
-    *      descriptor: (ILjava/lang/String;)V
-    *   public int hello$default$1();
-    *      descriptor: ()I
-    * }
-    * }}}
-    *
-    * @param methodOwner
-    * @return
-    */
-  def resolveMethodArgDefaultFromOwnerObject(methodOwner: Any) = { p: Parameter =>
-    p match {
-      case m: MethodParameter =>
-        try {
-          val methodName = "%s$default$%d".format(m.method.name, p.index + 1)
-          val dm         = methodOwner.getClass.getMethod(methodName)
-          dm.invoke(methodOwner)
-        } catch {
-          case e: Throwable =>
-            Zero.zeroOf(p.surface)
-        }
-      case ohter =>
-        Zero.zeroOf(p.surface)
-    }
-  }
-}
-
 /**
   * A generic codec for parameter lists:
   * - array form: [v1, v2, ...]
   * - map form: {k1:v1, k2:v2, ..}
   * @param name
   * @param params
   * @param paramCodec
-  * @param emptyParamBinder
+  * @param methodOwner
   */
 class ParamListCodec(name: String,
                      params: IndexedSeq[Parameter],
                      paramCodec: Seq[MessageCodec[_]],
-                     emptyParamBinder: Parameter => Any = ParamListCodec.defaultEmptyParamBinder)
+                     methodOwner: Option[Any] = None)
     extends MessageCodec[Seq[Any]]
     with LogSupport {
   private lazy val codecTable =
@@ -105,6 +68,21 @@ class ParamListCodec(name: String,
     }
   }
 
+  private def getParamDefaultValue(p: Parameter): Any = {
+    p match {
+      case m: MethodParameter =>
+        methodOwner
+          .flatMap { owner =>
+            // If the method owner instance is provided, we can resolve method arg default values
+            m.getMethodArgDefaultValue(owner)
+          }
+          .orElse(p.getDefaultValue)
+          .getOrElse(Zero.zeroOf(p.surface))
+      case other =>
+        p.getDefaultValue.getOrElse(Zero.zeroOf(p.surface))
+    }
+  }
+
   override def unpack(u: Unpacker, v: MessageHolder): Unit = {
     val numParams = params.length
 
@@ -118,7 +96,7 @@ class ParamListCodec(name: String,
           paramCodec(index).unpack(u, v)
           val arg = if (v.isNull) {
             trace(v.getError)
-            p.getDefaultValue.getOrElse(Zero.zeroOf(p.surface))
+            getParamDefaultValue(p)
           } else {
             v.getLastValue
           }
@@ -128,7 +106,8 @@ class ParamListCodec(name: String,
         // Populate args with the default or zero value
         while (index < numParams) {
           val p = params(index)
-          b += p.getDefaultValue.getOrElse(emptyParamBinder(p))
+          val v = getParamDefaultValue(p)
+          b += v
           index += 1
         }
         // Ignore additional args
@@ -165,13 +144,11 @@ class ParamListCodec(name: String,
         val args = for (i <- 0 until numParams) yield {
           val p         = params(i)
           val paramName = CName.toCanonicalName(p.name)
-          map.get(paramName) match {
-            case Some(x) =>
-              x
-            case None =>
-              p.getDefaultValue.getOrElse(emptyParamBinder(p))
-          }
+          map
+            .get(paramName)
+            .getOrElse(getParamDefaultValue(p))
         }
+        trace(s"map:${map.mkString(",")}, args:${args.mkString(", ")}")
         v.setObject(args)
       case other =>
         u.skipValue

airframe-launcher/src/main/scala/wvlet/airframe/launcher/Launcher.scala

@@ -373,13 +373,14 @@ class CommandLauncher(private[launcher] val launcherInfo: LauncherInfo,
               methodSurface.name,
               methodSurface.args.toIndexedSeq,
               paramCodecs,
-              // We need to supply default values by using the parent object
-              ParamListCodec.resolveMethodArgDefaultFromOwnerObject(parentObj)
+              // We need to supply method owner object to resolve function arg values
+              methodOwner = Some(parentObj)
             )
 
             val msgpack = result.parseTree.toMsgPack
             methodArgCodec
               .unpackMsgPack(msgpack).map { args =>
+                trace(s"calling method ${methodSurface} with args: ${args.mkString(", ")}")
                 val methodResult = methodSurface.call(parentObj, args: _*)
                 LauncherResult(stack, Some(methodResult))
               }

airframe-launcher/src/test/scala/wvlet/airframe/launcher/ArgProcessorTest.scala

@@ -15,6 +15,7 @@ package wvlet.airframe.launcher
 import wvlet.airframe.AirframeSpec
 import wvlet.airframe.launcher.LauncherTest.capture
 import wvlet.log.LogSupport
+import wvlet.log.io.IOUtil
 
 object ArgProcessorTest {
 
@@ -56,6 +57,17 @@ object ArgProcessorTest {
     Launcher
       .of[Cmd]
       .add(subCommandModule, name = "sub", description = "sub command")
+
+  class FunctionArg(
+      @option(prefix = "-e", description = "Environment")
+      env: String = "default-env")
+      extends LogSupport {
+
+    @command(description = "Start a proxy server")
+    def proxy(
+        @option(prefix = "-p,--port", description = "port number")
+        port: Int = IOUtil.randomPort) = {}
+  }
 }
 
 class ArgProcessorTest extends AirframeSpec {
@@ -119,4 +131,7 @@ class ArgProcessorTest extends AirframeSpec {
     c3 should include("nested2")
   }
 
+  "should support function arg" taggedAs ("farg") in {
+    Launcher.of[FunctionArg].execute("proxy")
+  }
 }

airframe-surface/jvm/src/main/scala/wvlet/airframe/surface/reflect/ReflectMethodSurface.scala

@@ -36,9 +36,12 @@ case class ReflectMethodSurface(mod: Int, owner: Surface, name: String, returnTy
   override def call(obj: Any, x: Any*): Any = method match {
     case Some(m) =>
       if (x == null || x.isEmpty) {
+        trace(s"Calling method ${name}")
         m.invoke(obj)
       } else {
-        m.invoke(obj, x.map(_.asInstanceOf[AnyRef]): _*)
+        val args = x.map(_.asInstanceOf[AnyRef])
+        trace(s"Calling method ${name} with args: ${args.mkString(", ")}")
+        m.invoke(obj, args: _*)
       }
     case None => null
   }

airframe-surface/jvm/src/main/scala/wvlet/airframe/surface/reflect/RuntimeMethodParameter.scala

@@ -13,13 +13,11 @@
  */
 package wvlet.airframe.surface.reflect
 
-import wvlet.airframe.surface.{MethodParameter, MethodRef, Parameter, Surface}
 import java.{lang => jl}
 
+import wvlet.airframe.surface.{MethodParameter, MethodRef, Surface}
 import wvlet.log.LogSupport
 
-import scala.util.Try
-
 /**
   * MethodParameter implementation using reflection for accessing parameter values
   */
@@ -65,4 +63,15 @@ case class RuntimeMethodParameter(
       }
     }
   }
+
+  override def getMethodArgDefaultValue(methodOwner: Any): Option[Any] = {
+    try {
+      val methodName = "%s$default$%d".format(method.name, index + 1)
+      val dm         = methodOwner.getClass.getMethod(methodName)
+      Some(dm.invoke(methodOwner))
+    } catch {
+      case e: Throwable =>
+        None
+    }
+  }
 }

airframe-surface/shared/src/main/scala/wvlet/airframe/surface/Surface.scala

@@ -81,6 +81,7 @@ case class MethodRef(owner: Class[_], name: String, paramTypes: Seq[Class[_]], i
 
 trait MethodParameter extends Parameter {
   def method: MethodRef
+  def getMethodArgDefaultValue(methodOwner: Any): Option[Any] = getDefaultValue
 }
 
 trait MethodSurface extends ParameterBase {