Merge branch 'master' into tutorial

Conflicts:
	geoscript/build.sbt
	geoscript/src/test/scala/GeoHashTest.scala
	geoscript/src/test/scala/UsageTests.scala
	geoscript/src/test/scala/org/geoscript/geometry/SerializationSpec.scala
	geoscript/src/test/scala/org/geoscript/workspaces/MemorySpec.scala
	project/Build.scala

Author: dwins

dummy/build.sbt

@@ -7,8 +7,9 @@ libraryDependencies <++= gtVersion { v =>
   )
 }
 
-libraryDependencies +=
-  "org.specs2" %% "specs2" % "1.7.1" % "test"
+libraryDependencies ++= Seq(
+  "org.scala-tools.testing" %% "scalacheck" % "1.9" % "test",
+  "org.scalatest" %% "scalatest" % "1.8" % "test")
 
 initialCommands += """
 import org.{ geotools => gt }

geocss/build.sbt

@@ -5,16 +5,7 @@
 import org.geotools.styling.Style;
 
 public final class CSS2SLD {
-    static abstract class Converter {
-        public abstract Style convert(Reader input);
-        public abstract Style convert(Reader input, URL baseURL);
-    }
-
-    protected static Converter impl;
-
-    static {
-        impl = new Impl();
-    }
+    protected static final Converter impl = new Converter();
 
     private CSS2SLD() throws Exception {
         throw new Exception("You shouldn't be instantiating this class");

geocss/src/main/java/org/geoscript/geocss/CSS2SLD.java renamed to geocss/src/main/java/org/geoscript/geocss/compat/CSS2SLD.java

@@ -298,7 +298,7 @@ object CssOps {
     def unapply(value: Value): Option[String] = value match {
       case Function("rgb", Seq(Literal(r), Literal(g), Literal(b))) =>
         val channels = Seq(r, g, b)
-        val hex = "#%2x%2x%2x"
+        val hex = "#%02x%02x%02x"
         def validInt(x: String) =
           try { x.toInt; true } catch { case _ => false }
 

geocss/src/main/scala/org/geoscript/geocss/CssOps.scala

@@ -541,6 +541,9 @@ class Translator(val baseURL: Option[java.net.URL]) {
     Seq(polySyms, lineSyms, pointSyms, textSyms).flatten
   }
 
+  type StyleSheet = Seq[Rule]
+  type ZIndex = Double
+
   /**
    * Convert a list of tokens (as generated by CssParser.parse) into a GeoTools
    * Style object.  This works by creating individual rules for every possible
@@ -550,91 +553,111 @@ class Translator(val baseURL: Option[java.net.URL]) {
    * @see org.geotools.styling.SLDTransformer if you want to serialize the
    *   resultant Style object to an XML file
    */
-  def css2sld(styleSheet: Seq[Rule]): gt.Style = {
-    val sld = styles.createStyle
-
-    val rules = stableSort(styleSheet, Specificity.order _).reverse
-
-    def extractTypeName(rule: Rule): Option[String] =
-      flatten(And(rule.selectors)).collect { 
-        case Typename(typename) => typename 
-      } headOption
-
-    def extractScaleRanges(rule: Rule): Seq[Pair[Option[Double], Option[Double]]] = {
-      val scales = 
-        flatten(And(rule.selectors))
-          .collect { 
-            case PseudoSelector("scale", _, d) => d.toDouble
-            case Not(PseudoSelector("scale", _, d)) => d.toDouble
-          }
-          .sorted
-          .distinct
-      
-      val limits = None +: (scales map (Some(_))) :+ None
-      limits zip limits.tail
-    }
+  def css2sld(s: StyleSheet): gt.Style = {
+    val sorted: StyleSheet = sort(s)
+    val byType: Seq[(Option[String], StyleSheet)] = splitOnType(sorted)
+    val resolved: Seq[(Option[String], StyleSheet)] =
+      for ((t, rs) <- byType) yield (t, cascading2exclusive(rs))
+    val withSymbolizers: Seq[(Option[String], Seq[(ZIndex, Rule, Seq[Symbolizer])])] =
+      for ((t, rs) <- resolved) yield (t, interpret(rs))
+    val gtRules: Seq[(Option[String], Seq[Seq[gt.Rule]])] =
+      for ((t, rs) <- withSymbolizers) yield (t, createSLDRuleLayers(rs))
+    val featureTypeStyles: Seq[gt.FeatureTypeStyle] =
+      gtRules.flatMap(createFeatureTypeStyles)
+    createStyle(featureTypeStyles)
+  }
+
+  def sort(s: StyleSheet): StyleSheet =
+    stableSort(s, (x: Rule, y: Rule) => Specificity.order(y, x))
+
+  def splitOnType(s: StyleSheet): Seq[(Option[String], StyleSheet)] = {
+    def isForTypename(t: Option[String])(r: Rule): Boolean =
+      t.forall(name => reduce(allOf(Typename(name) +: r.selectors)) != Exclude)
 
-    def isForTypename(typename: Option[String])(rule: Rule): Boolean =
-      typename map { t => 
-        reduce(allOf(Typename(t) +: rule.selectors)) != Exclude
-      } getOrElse true
+    def extractTypename(r: Rule): Option[String] = 
+      flatten(And(r.selectors)).collectFirst { case Typename(t) => t }
 
-    def stripTypenames(rule: Rule): Rule =
-      rule.copy(selectors = rule.selectors map {
+    def stripTypenames(r: Rule): Rule = {
+      val selectors0 = r.selectors.map {
         case Typename(_) => Accept
         case selector => selector
-      })
-
-    val typenames = (rules map extractTypeName) distinct
-
-    val styleRules = 
-      for (name <- typenames) yield (name, rules filter isForTypename(name) map stripTypenames)
-
-    for ((typename, overlays) <- styleRules) {
-      val zGroups: Seq[Seq[(Double, Rule, Seq[gt.Symbolizer])]] = 
-        for (rule <- cascading2exclusive(overlays)) yield
-          for ((z, syms) <- groupByZ(symbolize(rule))) yield
-            (z, rule, syms)
-
-      for ((_, group) <- flattenByZ(zGroups.flatten)) {
-        val fts = styles.createFeatureTypeStyle
-        typename.foreach { t => fts.featureTypeNames.add(new NameImpl(t)) }
-        for ((rule, syms) <- group if !syms.isEmpty) {
-          val sldRule = styles.createRule()
-          val ranges = extractScaleRanges(rule)
-
-          for (range @ (min, max) <- ranges) {
-            val minSelector = min.map(x => PseudoSelector("scale", ">", x.toString))
-            val maxSelector = max.map(x => PseudoSelector("scale", "<", x.toString))
-            val restricted = 
-              reduce(allOf(rule.selectors ++ minSelector ++ maxSelector))
-
-            if (restricted != Exclude) {
-              val sldRule = styles.createRule()
-
-              for (m <- min) sldRule.setMinScaleDenominator(m)
-              for (m <- max) sldRule.setMaxScaleDenominator(m)
-              for (title <- rule.description.title)
-                sldRule.getDescription().setTitle(title)
-              for (abstrakt <- rule.description.abstrakt)
-                sldRule.getDescription().setAbstract(abstrakt)
-
-              val filter = realize(restricted)
-
-              for (f <- filter)
-                sldRule.setFilter(f)
-              for (sym <- syms)
-                sldRule.symbolizers.add(sym)
-
-              fts.rules.add(sldRule)
-            }
-          }
-        }
-        sld.featureTypeStyles.add(fts)
       }
+
+      r.copy(selectors = selectors0)
     }
 
-    return sld 
+    val typenames = (s map extractTypename).distinct
+
+    for (t <- typenames)
+    yield (t, s.filter(isForTypename(t)).map(stripTypenames))
+  }
+
+  def extractScaleRanges(rule: Rule): Seq[Pair[Option[Double], Option[Double]]] = {
+    val scales = 
+      flatten(And(rule.selectors))
+        .collect { 
+          case PseudoSelector("scale", _, d) => d.toDouble
+          case Not(PseudoSelector("scale", _, d)) => d.toDouble
+        }
+        .sorted
+        .distinct
+
+    val limits = None +: (scales map (Some(_))) :+ None
+    limits zip limits.tail
+  }
+
+  def interpret(s: StyleSheet): Seq[(ZIndex, Rule, Seq[Symbolizer])] = 
+    for {
+      r <- cascading2exclusive(s)
+      (z, syms) <- groupByZ(symbolize(r))
+    } yield (z, r, syms)
+
+  def createSLDRuleLayers(rs: Seq[(ZIndex, Rule, Seq[Symbolizer])]): Seq[Seq[gt.Rule]] =
+    for ((_, group) <- flattenByZ(rs)) yield createSLDRuleLayer(group)
+
+  def createSLDRuleLayer(group: Seq[(Rule, Seq[Symbolizer])]): Seq[gt.Rule] =
+    for {
+      (rule, syms) <- group if syms.nonEmpty
+      range @ (min, max) <- extractScaleRanges(rule)
+      minSelector = min.map(x => PseudoSelector("scale", ">", x.toString))
+      maxSelector = max.map(x => PseudoSelector("scale", "<", x.toString))
+      filter = reduce(allOf(rule.selectors ++ minSelector ++ maxSelector))
+      if (filter != Exclude)
+    } yield createSLDRule(min, max, realize(filter), rule.description.title, rule.description.abstrakt, syms)
+
+  def createSLDRule(
+    min: Option[Double],
+    max: Option[Double],
+    filter: Option[org.opengis.filter.Filter],
+    title: Option[String],
+    `abstract`: Option[String],
+    symbolizers: Seq[gt.Symbolizer]): gt.Rule =
+  {
+    val rule = styles.createRule()
+    min.foreach { rule.setMinScaleDenominator }
+    max.foreach { rule.setMaxScaleDenominator }
+    filter.foreach { rule.setFilter }
+    title.foreach { t => rule.getDescription().setTitle(t) }
+    `abstract`.foreach { a => rule.getDescription().setAbstract(a) }
+    symbolizers.foreach { rule.symbolizers.add }
+    rule
+  }
+
+  def createFeatureTypeStyles(spec: (Option[String], Seq[Seq[gt.Rule]])): Seq[gt.FeatureTypeStyle] =
+    spec._2.map { createFeatureTypeStyle(spec._1, _) }
+
+  def createFeatureTypeStyle(spec: (Option[String], Seq[gt.Rule])): gt.FeatureTypeStyle = {
+    val (typename, rules) = spec
+    val ftStyle = styles.createFeatureTypeStyle()
+    typename.foreach { t => ftStyle.featureTypeNames().add(new NameImpl(t)) }
+    rules.foreach { ftStyle.rules.add }
+    ftStyle
+  }
+
+  def createStyle(fts: Seq[gt.FeatureTypeStyle]): gt.Style = {
+    val style = styles.createStyle()
+    fts.foreach { style.featureTypeStyles.add }
+    style
   }
 
   private def flattenByZ[R, S](zGroups: Seq[(Double, R, Seq[S])])

geocss/src/main/scala/org/geoscript/geocss/Translator.scala

@@ -4,14 +4,14 @@ import org.geotools.styling.Style
 import sys.error
 
 package compat {
-  class Impl extends CSS2SLD.Converter {
-    override def convert(input: java.io.Reader): Style =
+  class Converter protected[compat]() {
+    def convert(input: java.io.Reader): Style =
       CssParser.parse(input) match {
         case CssParser.Success(style, _) => (new Translator).css2sld(style)
         case (ns: CssParser.NoSuccess) => error(ns.toString)
       }
 
-    override def convert(input: java.io.Reader, baseURL: java.net.URL): Style =
+    def convert(input: java.io.Reader, baseURL: java.net.URL): Style =
       CssParser.parse(input) match {
         case CssParser.Success(style, _) => (new Translator(Some(baseURL))).css2sld(style)
         case (ns: CssParser.NoSuccess) => error(ns.toString)

geocss/src/main/scala/org/geoscript/geocss/compat/Impl.scala

@@ -43,15 +43,15 @@ object Interval {
   : Interval[T] =
     (a, b) match {
       case (`empty`, _) | (_, `empty`) => Empty
-      case (a: NonEmpty[T], b: NonEmpty[T]) => 
+      case (NonEmpty(aMin, aMax), NonEmpty(bMin, bMax)) => 
         val min = 
-          (for (x <- a.min; y <- b.min) yield join(evidence.gt _)(x, y)) orElse
-          a.min orElse
-          b.min
+          (for (x <- aMin; y <- bMin) yield join(evidence.gt _)(x, y)) orElse
+          aMin orElse
+          bMin
         val max =
-          (for (x <- a.max; y <- b.max) yield join(evidence.lt _)(x, y)) orElse
-          a.max orElse
-          b.max
+          (for (x <- aMax; y <- bMax) yield join(evidence.lt _)(x, y)) orElse
+          aMax orElse
+          bMax
         val emptyOpt =
           for (mn <- min; mx <- max) yield
             (mn, mx) match {