Francis De Brabandere francisdb

If your csv doesn't contain escaped newlines then it is pretty easy to do a progressive parsing without putting the whole file into memory. The iteratee library comes with a method search inside play.api.libs.iteratee.Parsing :

def search (needle: Array[Byte]): Enumeratee[Array[Byte], MatchInfo[Array[Byte]]]

which will partition your stream into Matched[Array[Byte]] and Unmatched[Array[Byte]]

Then you can combine a first iteratee that takes a header and another that will fold into the umatched results. This should look like the following code:

// break at each match and concat unmatches and drop the last received element (the match)

	#!/bin/sh
	# simple script for turning a jar with a Main-Class
	# into a stand alone executable
	# cat [your jar file] >> [this file]
	# then chmod +x [this file]
	# you can now exec [this file]
	commandToRun="$(printf "%q " "$@")"
	if test "$commandToRun" = "'' "; then
	eval "exec java -Xmx1G -jar $0"
	else

	package controllers

	import play.api._
	import play.api.mvc._

	import com.novus.salat._
	import com.novus.salat.global._
	import com.novus.salat.dao._

	import util._

	#!/bin/bash
	#
	# Install Postgres 9.1, PostGIS and create PostGIS template on a clean Ubuntu 11.10 Oneiric Ocelot box
	# http://wildfish.com

	# add the ubuntu gis ppa
	sudo apt-get -y install python-software-properties
	sudo add-apt-repository ppa:ubuntugis/ubuntugis-unstable
	sudo apt-get update

	function sendError(message, url, lineNum) {
	var i;

	// First check the URL and line number of the error
	url = url \|\| window.location.href;
	lineNum = lineNum \|\| 'None';

	// If the error is from these 3rd party script URLs, we ignore
	// We could also just ignore errors from all scripts that aren't our own
	var scriptURLs = [

	# Upstart script for a play application that binds to an unprivileged user.
	# put this into a file like /etc/init/play.conf
	#
	# This could be the foundation for pushing play apps to the server using something like git-deploy
	# By calling service play stop in the restart command and play-start in the restart command.
	#
	# Usage:
	# start play
	# stop play
	# restart play

	def Secured[A](username: String, password: String)(action: Action[A]) = Action(action.parser) { request =>
	request.headers.get("Authorization").flatMap { authorization =>
	authorization.split(" ").drop(1).headOption.filter { encoded =>
	new String(org.apache.commons.codec.binary.Base64.decodeBase64(encoded.getBytes)).split(":").toList match {
	case u :: p :: Nil if u == username && password == p => true
	case _ => false
	}
	}.map(_ => action(request))
	}.getOrElse {
	Unauthorized.withHeaders("WWW-Authenticate" -> """Basic realm="Secured"""")

	import java.util.Date
	import play.test._

	import org.scalatest._
	import org.scalatest.matchers._

	class UnitTests extends UnitFlatSpec with ShouldMatchers with BeforeAndAfterEach {

	import models._
	import play.db.anorm._

	case class ValidationPromised[E, A](promised: Promise[Validation[E, A]]) {
	def map[B](f: A => B): ValidationPromised[E, B] =
	ValidationPromised(promised map { valid =>
	valid.fold(
	fail => KO(fail),
	suc => OK(f(suc))
	)
	})

	def flatMap[B](f: A => ValidationPromised[E, B]): ValidationPromised[E, B] =

	package util.logging;

	import ch.qos.logback.classic.spi.ILoggingEvent;
	import ch.qos.logback.core.UnsynchronizedAppenderBase;
	import play.libs.F;

	import java.util.Collections;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.atomic.AtomicInteger;