Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP

Loading…

Rename ComputeTransformRules->CanBind, #{computeTransform->apply} #1407

Closed
wants to merge 1 commit into from

3 participants

@nafg

Rename ComputeTransformRules to CanBind
Rename CTR#computeTransform(x, ns) to CTR#apply(x)(ns)

@nafg nafg was assigned
@buildhive

Lift Web Framework » framework #5 FAILURE
Looks like there's a problem with this pull request
(what's this?)

@nafg

Note that buildhive failed due to OOM, not anything wrong with the code. My own jenkins instance seems to be in the process of building it for 2.9.1 after having sucessfully tested it on 2.10 and 2.9.2.
Can someone tell me who set up buildhive? /cc @indrajitr

@nafg

My Jenkins says "Finished: SUCCESS"

@nafg

After running
LIFTSH_OPTS=-Xmx2g -XX:MaxPermSize=1536m ./liftsh +clean +test +publish-local

@fmpwizard
Owner

+1

@fmpwizard
Owner

rebasing to master in less than an hour

@fmpwizard
Owner

rebased to master

@fmpwizard fmpwizard closed this
@nafg
@nafg nafg removed their assignment
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
This page is out of date. Refresh to see the latest.
Showing with 77 additions and 81 deletions.
  1. +77 −81 core/util/src/main/scala/net/liftweb/util/CssSel.scala
View
158 core/util/src/main/scala/net/liftweb/util/CssSel.scala
@@ -724,86 +724,84 @@ final class CssJBridge {
}
-trait ComputeTransformRules[-T] {
- def name: String = "ComputeTransformRule"
- def computeTransform(it: => T, ns: NodeSeq): Seq[NodeSeq]
+trait CanBind[-T] {
+ def apply(it: => T)(ns: NodeSeq): Seq[NodeSeq]
}
-object ComputeTransformRules {
- implicit def stringTransform: ComputeTransformRules[String] = new ComputeTransformRules[String] {
- def computeTransform(str: => String, ns: NodeSeq): Seq[NodeSeq] = {
+object CanBind {
+ implicit def stringTransform: CanBind[String] = new CanBind[String] {
+ def apply(str: => String)(ns: NodeSeq): Seq[NodeSeq] = {
val s = str
List(if (null eq s) NodeSeq.Empty else Text(s))
}
}
- implicit def bindableTransform: ComputeTransformRules[Bindable] = new ComputeTransformRules[Bindable] {
- def computeTransform(str: => Bindable, ns: NodeSeq): Seq[NodeSeq] = List(str.asHtml)
+ implicit def bindableTransform: CanBind[Bindable] = new CanBind[Bindable] {
+ def apply(str: => Bindable)(ns: NodeSeq): Seq[NodeSeq] = List(str.asHtml)
}
- implicit def numberTransform[T <: java.lang.Number]: ComputeTransformRules[T] = new ComputeTransformRules[java.lang.Number] {
- def computeTransform(str: => java.lang.Number, ns: NodeSeq): Seq[NodeSeq] = {
+ implicit def numberTransform[T <: java.lang.Number]: CanBind[T] = new CanBind[java.lang.Number] {
+ def apply(str: => java.lang.Number)(ns: NodeSeq): Seq[NodeSeq] = {
val num = str
List(if (null eq num) NodeSeq.Empty else Text(num.toString))
}
}
- implicit def doubleTRansform: ComputeTransformRules[Double] = new ComputeTransformRules[Double] {
- def computeTransform(str: => Double, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
+ implicit def doubleTRansform: CanBind[Double] = new CanBind[Double] {
+ def apply(str: => Double)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
}
- implicit def jsCmdTransform: ComputeTransformRules[ToJsCmd] = new ComputeTransformRules[ToJsCmd] {
- def computeTransform(str: => ToJsCmd, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toJsCmd))
+ implicit def jsCmdTransform: CanBind[ToJsCmd] = new CanBind[ToJsCmd] {
+ def apply(str: => ToJsCmd)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toJsCmd))
}
- implicit def jsCmdPairTransform: ComputeTransformRules[(_, ToJsCmd)] = new ComputeTransformRules[(_, ToJsCmd)] {
- def computeTransform(str: => (_, ToJsCmd), ns: NodeSeq): Seq[NodeSeq] = List(Text(str._2.toJsCmd))
+ implicit def jsCmdPairTransform: CanBind[(_, ToJsCmd)] = new CanBind[(_, ToJsCmd)] {
+ def apply(str: => (_, ToJsCmd))(ns: NodeSeq): Seq[NodeSeq] = List(Text(str._2.toJsCmd))
}
- implicit def intTransform: ComputeTransformRules[Int] = new ComputeTransformRules[Int] {
- def computeTransform(str: => Int, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
+ implicit def intTransform: CanBind[Int] = new CanBind[Int] {
+ def apply(str: => Int)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
}
- implicit def stringPromoteTransform: ComputeTransformRules[StringPromotable] = new ComputeTransformRules[StringPromotable] {
- def computeTransform(str: => StringPromotable, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
+ implicit def stringPromoteTransform: CanBind[StringPromotable] = new CanBind[StringPromotable] {
+ def apply(str: => StringPromotable)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
}
- implicit def symbolTransform: ComputeTransformRules[Symbol] = new ComputeTransformRules[Symbol] {
- def computeTransform(str: => Symbol, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.name))
+ implicit def symbolTransform: CanBind[Symbol] = new CanBind[Symbol] {
+ def apply(str: => Symbol)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.name))
}
- implicit def longTransform: ComputeTransformRules[Long] = new ComputeTransformRules[Long] {
- def computeTransform(str: => Long, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
+ implicit def longTransform: CanBind[Long] = new CanBind[Long] {
+ def apply(str: => Long)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
}
- implicit def boolTransform: ComputeTransformRules[Boolean] = new ComputeTransformRules[Boolean] {
- def computeTransform(str: => Boolean, ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
+ implicit def boolTransform: CanBind[Boolean] = new CanBind[Boolean] {
+ def apply(str: => Boolean)(ns: NodeSeq): Seq[NodeSeq] = List(Text(str.toString))
}
-
- implicit def toNodeSeqTransform[T](implicit f: T => NodeSeq): ComputeTransformRules[T] = new ComputeTransformRules[T] {
- override def name: String = "def toNodeSeqTransform[T]"
- def computeTransform(param: => T, ns: NodeSeq): Seq[NodeSeq] = List(f(param))
+ class CanBindNodeSeqTransform[T](f: T => NodeSeq) extends CanBind[T] {
+ def apply(param: => T)(ns: NodeSeq): Seq[NodeSeq] = List(f(param))
}
+ implicit def toNodeSeqTransform[T](implicit f: T => NodeSeq): CanBind[T] = new CanBindNodeSeqTransform[T](f)
- implicit def nodeSeqFuncTransform[A](implicit view: A => NodeSeq => NodeSeq): ComputeTransformRules[A] = new ComputeTransformRules[A] {
- def computeTransform(func: =>A, ns: NodeSeq): Seq[NodeSeq] = List(view(func)(ns))
+ implicit def nodeSeqFuncTransform[A](implicit view: A => NodeSeq => NodeSeq): CanBind[A] = new CanBind[A] {
+ def apply(func: =>A)(ns: NodeSeq): Seq[NodeSeq] = List(view(func)(ns))
}
- implicit def nodeSeqSeqFuncTransform: ComputeTransformRules[NodeSeq => Seq[Node]] = new ComputeTransformRules[NodeSeq => Seq[Node]] {
- def computeTransform(func: => NodeSeq => Seq[Node], ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(List(func(ns)))
+ implicit def nodeSeqSeqFuncTransform: CanBind[NodeSeq => Seq[Node]] = new CanBind[NodeSeq => Seq[Node]] {
+ def apply(func: => NodeSeq => Seq[Node])(ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(List(func(ns)))
}
- implicit def nodeFuncTransform: ComputeTransformRules[NodeSeq => Node] = new ComputeTransformRules[NodeSeq => Node] {
- def computeTransform(func: => NodeSeq => Node, ns: NodeSeq): Seq[NodeSeq] = List(func(ns))
+ implicit def nodeFuncTransform: CanBind[NodeSeq => Node] = new CanBind[NodeSeq => Node] {
+ def apply(func: => NodeSeq => Node)(ns: NodeSeq): Seq[NodeSeq] = List(func(ns))
}
- implicit def iterableNodeTransform[NST](implicit f2: NST => NodeSeq): ComputeTransformRules[Iterable[NST]] =
- new ComputeTransformRules[Iterable[NST]] {
- def computeTransform(info: => Iterable[NST], ns: NodeSeq): Seq[NodeSeq] =
+ implicit def iterableNodeTransform[NST](implicit f2: NST => NodeSeq): CanBind[Iterable[NST]] =
+ new CanBind[Iterable[NST]] {
+ def apply(info: => Iterable[NST])(ns: NodeSeq): Seq[NodeSeq] =
{
val i = info
i match {
@@ -813,71 +811,69 @@ object ComputeTransformRules {
}
}
- implicit def boxNodeTransform[NST](implicit f2: NST => NodeSeq): ComputeTransformRules[Box[NST]] =
- new ComputeTransformRules[Box[NST]] {
- def computeTransform(info: => Box[NST], ns: NodeSeq): Seq[NodeSeq] = info.toList.map(f2)
+ implicit def boxNodeTransform[NST](implicit f2: NST => NodeSeq): CanBind[Box[NST]] =
+ new CanBind[Box[NST]] {
+ def apply(info: => Box[NST])(ns: NodeSeq): Seq[NodeSeq] = info.toList.map(f2)
}
- implicit def optionNodeTransform[NST](implicit f2: NST => NodeSeq): ComputeTransformRules[Option[NST]] =
- new ComputeTransformRules[Option[NST]] {
- def computeTransform(info: => Option[NST], ns: NodeSeq): Seq[NodeSeq] = info.toList.map(f2)
+ implicit def optionNodeTransform[NST](implicit f2: NST => NodeSeq): CanBind[Option[NST]] =
+ new CanBind[Option[NST]] {
+ def apply(info: => Option[NST])(ns: NodeSeq): Seq[NodeSeq] = info.toList.map(f2)
}
-
- implicit def iterableStringTransform[T[_]](implicit f: T[String] => Iterable[String]): ComputeTransformRules[T[String]] =
- new ComputeTransformRules[T[String]] {
- def computeTransform(info: => T[String], ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.map(a => Text(a))
+ implicit def iterableStringTransform[T[_]](implicit f: T[String] => Iterable[String]): CanBind[T[String]] =
+ new CanBind[T[String]] {
+ def apply(info: => T[String])(ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.map(a => Text(a))
}
- implicit def iterableNumberTransform[T[_], N <: java.lang.Number](implicit f: T[N] => Iterable[N]): ComputeTransformRules[T[N]] =
- new ComputeTransformRules[T[N]] {
- def computeTransform(info: => T[N], ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.flatMap(a =>
+ implicit def iterableNumberTransform[T[_], N <: java.lang.Number](implicit f: T[N] => Iterable[N]): CanBind[T[N]] =
+ new CanBind[T[N]] {
+ def apply(info: => T[N])(ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.flatMap(a =>
if (a eq null) Nil else List(Text(a.toString)))
}
- implicit def iterableDouble[T[Double]](implicit f: T[Double] => Iterable[Double]): ComputeTransformRules[T[Double]] =
- new ComputeTransformRules[T[Double]] {
- def computeTransform(info: => T[Double], ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.flatMap(a =>
+ implicit def iterableDouble[T[Double]](implicit f: T[Double] => Iterable[Double]): CanBind[T[Double]] =
+ new CanBind[T[Double]] {
+ def apply(info: => T[Double])(ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.flatMap(a =>
if (a equals null) Nil else List(Text(a.toString)))
}
- implicit def iterableBindableTransform[T[_]](implicit f: T[Bindable] => Iterable[Bindable]): ComputeTransformRules[T[Bindable]] =
- new ComputeTransformRules[T[Bindable]] {
- def computeTransform(info: => T[Bindable], ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(f(info).toSeq.map(_.asHtml))
+ implicit def iterableBindableTransform[T[_]](implicit f: T[Bindable] => Iterable[Bindable]): CanBind[T[Bindable]] =
+ new CanBind[T[Bindable]] {
+ def apply(info: => T[Bindable])(ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(f(info).toSeq.map(_.asHtml))
}
implicit def iterableStringPromotableTransform[T[_], PM](implicit f: T[PM] => Iterable[PM],
- prom: PM => StringPromotable):
- ComputeTransformRules[T[PM]] =
- new ComputeTransformRules[T[PM]] {
- def computeTransform(info: => T[PM], ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.map(a => Text(prom(a).toString))
+ prom: PM => StringPromotable): CanBind[T[PM]] =
+ new CanBind[T[PM]] {
+ def apply(info: => T[PM])(ns: NodeSeq): Seq[NodeSeq] = f(info).toSeq.map(a => Text(prom(a).toString))
}
- implicit def iterableNodeFuncTransform[T[_], F <: NodeSeq => NodeSeq](implicit f: T[F] => Iterable[F]): ComputeTransformRules[T[F]] =
- new ComputeTransformRules[T[F]] {
- def computeTransform(info: => T[F], ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(f(info).toSeq.map(_.apply(ns)))
+ implicit def iterableNodeFuncTransform[T[_], F <: NodeSeq => NodeSeq](implicit f: T[F] => Iterable[F]): CanBind[T[F]] =
+ new CanBind[T[F]] {
+ def apply(info: => T[F])(ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(f(info).toSeq.map(_.apply(ns)))
}
- implicit def funcIterableTransform[T[_], F <: NodeSeq](implicit f: T[F] => Iterable[F]): ComputeTransformRules[NodeSeq => T[F]] =
- new ComputeTransformRules[NodeSeq => T[F]] {
- def computeTransform(info: => NodeSeq => T[F], ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(f(info(ns)).toSeq)
+ implicit def funcIterableTransform[T[_], F <: NodeSeq](implicit f: T[F] => Iterable[F]): CanBind[NodeSeq => T[F]] =
+ new CanBind[NodeSeq => T[F]] {
+ def apply(info: => NodeSeq => T[F])(ns: NodeSeq): Seq[NodeSeq] = Helpers.ensureUniqueId(f(info(ns)).toSeq)
}
- implicit def stringFuncTransform: ComputeTransformRules[NodeSeq => String] =
- new ComputeTransformRules[NodeSeq => String] {
- def computeTransform(info: => NodeSeq => String, ns: NodeSeq): Seq[NodeSeq] = List(Text(info(ns)))
+ implicit def stringFuncTransform: CanBind[NodeSeq => String] =
+ new CanBind[NodeSeq => String] {
+ def apply(info: => NodeSeq => String)(ns: NodeSeq): Seq[NodeSeq] = List(Text(info(ns)))
}
- implicit def stringIterFuncTransform[T[_]](implicit f: T[String] => Iterable[String]): ComputeTransformRules[NodeSeq => T[String]] =
- new ComputeTransformRules[NodeSeq => T[String]] {
- def computeTransform(info: => NodeSeq => T[String], ns: NodeSeq): Seq[NodeSeq] = f(info(ns)).toSeq.map(Text(_))
+ implicit def stringIterFuncTransform[T[_]](implicit f: T[String] => Iterable[String]): CanBind[NodeSeq => T[String]] =
+ new CanBind[NodeSeq => T[String]] {
+ def apply(info: => NodeSeq => T[String])(ns: NodeSeq): Seq[NodeSeq] = f(info(ns)).toSeq.map(Text(_))
}
- implicit def iterableConstFuncTransform: ComputeTransformRules[IterableConst] =
- new ComputeTransformRules[IterableConst] {
- def computeTransform(info: => IterableConst, ns: NodeSeq): Seq[NodeSeq] = info.constList(ns)
+ implicit def iterableConstFuncTransform: CanBind[IterableConst] =
+ new CanBind[IterableConst] {
+ def apply(info: => IterableConst)(ns: NodeSeq): Seq[NodeSeq] = info.constList(ns)
}
}
@@ -896,15 +892,15 @@ final case class ToCssBindPromoter(stringSelector: Box[String], css: Box[CssSele
* @tparam T the type of it
* @return the function that will transform an incoming DOM based on the transform rules
*/
- def #>[T](it: => T)(implicit computer: ComputeTransformRules[T]): CssSel = {
+ def #>[T](it: => T)(implicit computer: CanBind[T]): CssSel = {
css match {
case Full(EnclosedSelector(a, b)) => null
(ToCssBindPromoter(stringSelector, Full(a))).#>(nsFunc(ns => {
ToCssBindPromoter(stringSelector, Full(b)).#>(it)(computer)(ns)
- })) // (ComputeTransformRules.nodeSeqFuncTransform)
+ })) // (CanBind.nodeSeqFuncTransform)
case _ =>
new CssBindImpl(stringSelector, css) {
- def calculate(in: NodeSeq): Seq[NodeSeq] = computer.computeTransform(it, in)
+ def calculate(in: NodeSeq): Seq[NodeSeq] = computer(it)(in)
}
}
}
@@ -917,5 +913,5 @@ final case class ToCssBindPromoter(stringSelector: Box[String], css: Box[CssSele
* @tparam T the type of it
* @return the function that will transform an incoming DOM based on the transform rules
*/
- def replaceWith[T](it: => T)(implicit computer: ComputeTransformRules[T]): CssSel = this.#>(it)(computer)
+ def replaceWith[T](it: => T)(implicit computer: CanBind[T]): CssSel = this.#>(it)(computer)
}
Something went wrong with that request. Please try again.