Commit ⋅ scalalandio/chimney

Showing 1 of 2 files from the diff.

...nd/chimney/internal/macros/TransformerMacros.scala changed.

Other files ignored by Codecov

...src/test/scala/io/scalaland/chimney/DslFSpec.scala has changed.

@@ -75,9 +75,8 @@

Loading

    val To = weakTypeOf[To]

    val srcName = freshTermName(From)
    val srcPrefixTree = Ident(TermName(srcName.decodedName.toString))

    expandTransformerTree(srcPrefixTree, config)(From, To) match {
    genTransformerTree(srcName, config)(From, To) match {

      case Right(transformerTree) =>
        config.wrapperType match {

@@ -113,12 +112,25 @@

Loading

    }
  }

  def genTransformerTree(
      srcName: TermName,
      config: TransformerConfig
  )(From: Type, To: Type): Either[Seq[DerivationError], Tree] = {
    val srcPrefixTree = Ident(TermName(srcName.decodedName.toString))

    resolveTransformerBody(srcPrefixTree, config)(From, To).map {
      case TransformerBodyTree(tree, false) if config.wrapperType.isDefined =>
        q"${config.wrapperSupportInstance}.pure[$To]($tree)"
      case TransformerBodyTree(tree, _) => tree
    }
  }

  def expandTransformerTree(
      srcPrefixTree: Tree,
      config: TransformerConfig
  )(From: Type, To: Type): Either[Seq[DerivationError], Tree] = {

    resolveImplicitTransformer(srcPrefixTree, config)(From, To)
    resolveImplicitTransformer(config)(From, To)
      .map(localImplicitTree => Right(localImplicitTree.callTransform(srcPrefixTree)))
      .getOrElse {
        deriveTransformerTree(srcPrefixTree, config)(From, To)

@@ -732,44 +744,44 @@

Loading

      srcPrefixTree: Tree,
      config: TransformerConfig
  )(From: Type, To: Type): Either[Seq[DerivationError], TransformerBodyTree] = {
    resolveTransformerBody(srcPrefixTree, config.rec)(From, To)
  }

    val recConfig = config.rec
    val recConfigNoWrapper = recConfig.copy(wrapperType = None)

  def resolveTransformerBody(
      srcPrefixTree: Tree,
      config: TransformerConfig
  )(From: Type, To: Type): Either[Seq[DerivationError], TransformerBodyTree] = {
    if (config.wrapperType.isDefined) {
      val implicitTransformerF = resolveImplicitTransformer(srcPrefixTree, recConfig)(From, To)
      val implicitTransformer = resolveImplicitTransformer(srcPrefixTree, recConfigNoWrapper)(From, To)
      val implicitTransformerF = resolveImplicitTransformer(config)(From, To)
      val implicitTransformer = findLocalImplicitTransformer(From, To, None)

      (implicitTransformerF, implicitTransformer) match {
        case (Some(localImplicitTreeF), Some(localImplicitTree)) =>
          c.abort(
            c.enclosingPosition,
            s"""Ambiguous implicits while resolving Chimney recursive transformation:
              |
              |TransformerF[${config.wrapperType.get}, $From, $To]: $localImplicitTreeF
              |Transformer[$From, $To]: $localImplicitTree
              |
              |Please eliminate ambiguity from implicit scope or use withFieldComputed/withFieldComputedF to decide which one should be used
              |""".stripMargin
               |
               |TransformerF[${config.wrapperType.get}, $From, $To]: $localImplicitTreeF
               |Transformer[$From, $To]: $localImplicitTree
               |
               |Please eliminate ambiguity from implicit scope or use withFieldComputed/withFieldComputedF to decide which one should be used
               |""".stripMargin
          )
        case (Some(localImplicitTreeF), None) =>
          Right(TransformerBodyTree(localImplicitTreeF.callTransform(srcPrefixTree), isWrapped = true))
        case (None, Some(localImplicitTree)) =>
          Right(TransformerBodyTree(localImplicitTree.callTransform(srcPrefixTree), isWrapped = false))
        case (None, None) =>
          deriveTransformerTree(srcPrefixTree, recConfig)(From, To)
          deriveTransformerTree(srcPrefixTree, config)(From, To)
            .map(tree => TransformerBodyTree(tree, isWrapped = true))
      }
    } else {
      expandTransformerTree(srcPrefixTree, recConfig)(From, To)
      expandTransformerTree(srcPrefixTree, config)(From, To)
        .map(tree => TransformerBodyTree(tree, isWrapped = false))
    }
  }

  def resolveImplicitTransformer(
      srcPrefixTree: Tree,
      config: TransformerConfig
  )(From: Type, To: Type): Option[Tree] = {
  def resolveImplicitTransformer(config: TransformerConfig)(From: Type, To: Type): Option[Tree] = {
    if (config.definitionScope.contains((From, To))) {
      None
    } else {

Files		•	•	•	Coverage
chimney/src/main/scala/io/scalaland/chimney	674	671	0	3	99.55%
Project Totals (25 files)	674	671	0	3	99.55%

View CI Build Download

No yaml found.

Create your codecov.yml to customize your Codecov experience

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

75	75		val To = weakTypeOf[To]
76	76
77	77		val srcName = freshTermName(From)
78		-	val srcPrefixTree = Ident(TermName(srcName.decodedName.toString))
79	78
80		-	expandTransformerTree(srcPrefixTree, config)(From, To) match {
	79	+	genTransformerTree(srcName, config)(From, To) match {
81	80
82	81		case Right(transformerTree) =>
83	82		config.wrapperType match {

113	112		}
114	113		}
115	114
	115	+	def genTransformerTree(
	116	+	srcName: TermName,
	117	+	config: TransformerConfig
	118	+	)(From: Type, To: Type): Either[Seq[DerivationError], Tree] = {
	119	+	val srcPrefixTree = Ident(TermName(srcName.decodedName.toString))
	120	+
	121	+	resolveTransformerBody(srcPrefixTree, config)(From, To).map {
	122	+	case TransformerBodyTree(tree, false) if config.wrapperType.isDefined =>
	123	+	q"${config.wrapperSupportInstance}.pure[$To]($tree)"
	124	+	case TransformerBodyTree(tree, _) => tree
	125	+	}
	126	+	}
	127	+
116	128		def expandTransformerTree(
117	129		srcPrefixTree: Tree,
118	130		config: TransformerConfig
119	131		)(From: Type, To: Type): Either[Seq[DerivationError], Tree] = {
120	132
121		-	resolveImplicitTransformer(srcPrefixTree, config)(From, To)
	133	+	resolveImplicitTransformer(config)(From, To)
122	134		.map(localImplicitTree => Right(localImplicitTree.callTransform(srcPrefixTree)))
123	135		.getOrElse {
124	136		deriveTransformerTree(srcPrefixTree, config)(From, To)

732	744		srcPrefixTree: Tree,
733	745		config: TransformerConfig
734	746		)(From: Type, To: Type): Either[Seq[DerivationError], TransformerBodyTree] = {
	747	+	resolveTransformerBody(srcPrefixTree, config.rec)(From, To)
	748	+	}
735	749
736		-	val recConfig = config.rec
737		-	val recConfigNoWrapper = recConfig.copy(wrapperType = None)
738		-
	750	+	def resolveTransformerBody(
	751	+	srcPrefixTree: Tree,
	752	+	config: TransformerConfig
	753	+	)(From: Type, To: Type): Either[Seq[DerivationError], TransformerBodyTree] = {
739	754		if (config.wrapperType.isDefined) {
740		-	val implicitTransformerF = resolveImplicitTransformer(srcPrefixTree, recConfig)(From, To)
741		-	val implicitTransformer = resolveImplicitTransformer(srcPrefixTree, recConfigNoWrapper)(From, To)
	755	+	val implicitTransformerF = resolveImplicitTransformer(config)(From, To)
	756	+	val implicitTransformer = findLocalImplicitTransformer(From, To, None)
742	757
743	758		(implicitTransformerF, implicitTransformer) match {
744	759		case (Some(localImplicitTreeF), Some(localImplicitTree)) =>
745	760		c.abort(
746	761		c.enclosingPosition,
747	762		s"""Ambiguous implicits while resolving Chimney recursive transformation:
748		-	\|
749		-	\|TransformerF[${config.wrapperType.get}, $From, $To]: $localImplicitTreeF
750		-	\|Transformer[$From, $To]: $localImplicitTree
751		-	\|
752		-	\|Please eliminate ambiguity from implicit scope or use withFieldComputed/withFieldComputedF to decide which one should be used
753		-	\|""".stripMargin
	763	+	\|
	764	+	\|TransformerF[${config.wrapperType.get}, $From, $To]: $localImplicitTreeF
	765	+	\|Transformer[$From, $To]: $localImplicitTree
	766	+	\|
	767	+	\|Please eliminate ambiguity from implicit scope or use withFieldComputed/withFieldComputedF to decide which one should be used
	768	+	\|""".stripMargin
754	769		)
755	770		case (Some(localImplicitTreeF), None) =>
756	771		Right(TransformerBodyTree(localImplicitTreeF.callTransform(srcPrefixTree), isWrapped = true))
757	772		case (None, Some(localImplicitTree)) =>
758	773		Right(TransformerBodyTree(localImplicitTree.callTransform(srcPrefixTree), isWrapped = false))
759	774		case (None, None) =>
760		-	deriveTransformerTree(srcPrefixTree, recConfig)(From, To)
	775	+	deriveTransformerTree(srcPrefixTree, config)(From, To)
761	776		.map(tree => TransformerBodyTree(tree, isWrapped = true))
762	777		}
763	778		} else {
764		-	expandTransformerTree(srcPrefixTree, recConfig)(From, To)
	779	+	expandTransformerTree(srcPrefixTree, config)(From, To)
765	780		.map(tree => TransformerBodyTree(tree, isWrapped = false))
766	781		}
767	782		}
768	783
769		-	def resolveImplicitTransformer(
770		-	srcPrefixTree: Tree,
771		-	config: TransformerConfig
772		-	)(From: Type, To: Type): Option[Tree] = {
	784	+	def resolveImplicitTransformer(config: TransformerConfig)(From: Type, To: Type): Option[Tree] = {
773	785		if (config.definitionScope.contains((From, To))) {
774	786		None
775	787		} else {

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits