Given a trait that has abstract members.

trait Foo {
  val myValue: String
  var myVariable: Long
  def myMethod0(): Option[Double]
  def myMethod2(p0: Int, p1: Int): Int
  def myCurriedMethod(seq: Seq[Int])(mapper: Int => String): Seq[String]

  // Methods without pararmeters is disabled for now, due to https://github.com/scala/bug/issues/10647
  // def myByNameMethod: Option[Int]
}

When creating a factory for the trait.

val factory = Factory[Foo]

Then the newInstance method of the factory should accept named arguments according to abstract members.

val createdFromNamedArguments: Foo = factory.newInstance(
  myValue = "string value",
  myVariable = 42L,
  myMethod0 = () => Some(0.5),
  myMethod2 = _ + _,
  myCurriedMethod = seq => mapper => seq.map(mapper)
)
createdFromNamedArguments.myValue should be("string value")
createdFromNamedArguments.myVariable should be(42L)

createdFromNamedArguments.myMethod0() should be(Some(0.5))
createdFromNamedArguments.myMethod0() shouldNot be theSameInstanceAs createdFromNamedArguments.myMethod0()

createdFromNamedArguments.myMethod2(1000, 24) should be(1024)

createdFromNamedArguments.myCurriedMethod(Seq(2, 3, 4))(_.toString) should be(Seq("2", "3", "4"))

When using unnamed parameters, the parameters should be passed in alphabetical order

val createdFromUnnamedArguments: Foo = factory.newInstance(
  seq => mapper => seq.map(mapper), // myCurriedMethod
  () => Some(0.5),                  // myMethod0
  _ + _,                            // myMethod2
  "string value",                   // myValue
  42L                               // myVariable
)

Given two traits that have no abstract member.

trait Foo
trait Bar

When creating a factory for mix-in type of the two types.

val factory = Factory[Foo with Bar]

Then the newInstance method of the factory should accept no parameters.

val fooBar: Foo with Bar = factory.newInstance()
fooBar should be(a[Foo])
fooBar should be(a[Bar])

Given a trait that contains an abstract method annotated as @inject.

import com.thoughtworks.feature.Factory.inject
trait Foo[A] {
  @inject def orderingA: Ordering[A]
}

When creating a factory for the trait

val factory = Factory[Foo[Int]]

Then the @inject method will be replaced to an implicit value.

val foo = factory.newInstance()
foo.orderingA should be(implicitly[Ordering[Int]])

It will not compile if no implicit value found. For example, Foo[Symbol] requires an implicit value of type Ordering[Symbol], which is not availble.

"Factory[Foo[Symbol]]" shouldNot compile

If the trait does not contain abstract methods other than @inject methods, then the factory type class is a Factory.Factory0, which can be summoned by Predef.implicitly,

val nullaryFactory = implicitly[Factory.Factory0[Foo[Int]]]

and newInstance method is available on the Factory.Factory0 as well.

nullaryFactory.newInstance().orderingA should be(implicitly[Ordering[Int]])