viktorklang

import scala.collection.mutable.ListBuffer
import akka.actor.{Actor,ActorRef}
import akka.actor.Actor._
import akka.routing.{ Listeners, Listen }

//Represents a domain event
trait Event

//A builder to create domain entities
trait EntityBuilder[Entity] {

eLod

for i in `git config -f .gitmodules --get-regexp path | cut -d" " -f2` ; do git submodule add $(git config -f .gitmodules --get submodule."$i".url) $i ; done

them0nk

#Model 

@user.should have(1).error_on(:username) # Checks whether there is an error in username 
@user.errors[:username].should include("can't be blank")  # check for the error message 

#Rendering
response.should render_template(:index)

#Redirecting 
response.should redirect_to(movies_path)

aloiscochard

package slick

/**
 * This is some code extracted from TimeOut codebase, demonstrating:
 * - Use of tag typed to avoid mixing session of different DB
 * - The use of the Reader Monad to compose Actions together and defer the choice of async/sync computation
 *
 * I remove the part where we can say if our operation are read only or not (to use different connection), in order to
 * make things easier.
 **/

ruescasd

// optionally filter on a column with a supplied predicate
case class MaybeFilter[X, Y](val query: scala.slick.lifted.Query[X, Y]) {
  def filter[T](data: Option[T])(f: T => X => scala.slick.lifted.Column[Boolean]) = {
    data.map(v => MaybeFilter(query.filter(f(v)))).getOrElse(this)
  }
}

// example use case
def find(id: Option[Int], createdMin: Option[Date], createdMax: Option[Date], modifiedMin: Option[Date], modifiedMax: Option[Date]) = {

markhibberd

package argonaut.example

import argonaut._, Argonaut._
import scalaz._, Scalaz._

object UnionExample extends {

  sealed trait Thing
  final case class One(n: String, i: Int) extends Thing
  final case class Two(n: String) extends Thing

justjoheinz

/**
 * Original source:
 * [[https://gist.github.com/oxbowlakes/970717]]
 * 
 * Modifications:
 *  - use scala 7.0.5
 *  - use toValidationNel
 *  - use sequenceU and traverseU instead of the lambda trick
 * 
 * Part Zero : 10:15 Saturday Night

joseraya

package com.agilogy.spray.cors

import spray.http.{HttpMethods, HttpMethod, HttpResponse, AllOrigins}
import spray.http.HttpHeaders._
import spray.http.HttpMethods._
import spray.routing._

// see also https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS
trait CORSSupport {
  this: HttpService =>

pchiusano

// WARNING! totally untested, I have only compiled the code! :)

package json

import collection.immutable.Map
import scalaz.{\/, MonadPlus}
import scalaz.\/._
import scalaz.std.vector._
import scalaz.std.map._
import scalaz.std.list._

leifwickland

// Suggested Wartremover errors to improve inference rules and avoid partial methods which throw
wartremoverErrors ++= Seq(
  Wart.Any,
  Wart.Any2StringAdd,
  Wart.EitherProjectionPartial,
  Wart.OptionPartial,
  Wart.Product,
  Wart.Serializable,
  Wart.ListOps,
  Wart.Nothing