huntc

package controllers

import play.api._
import play.api.mvc._
import play.api.libs.json._

case class Itinerary(name: String)

object Itinerary {
  implicit val format = Json.format[Itinerary]

huntc

object JSHintPlugin extends NodeJsPlugin {

  object JshintKeys {

    val jshint = TaskKey[Unit]("jshint", "Perform JavaScript linting.")

    val jshintOptions = TaskKey[String]("jshint-options", "An array of jshint options to pass to the linter. This options are found via jshint-resolved-config. If there is no config then the options will be specified such that the JSHint defaults are used.")

    val config = SettingKey[Option[File]]("jshint-config", "The location of a JSHint configuration file.")
    val resolvedConfig = TaskKey[Option[File]]("jshint-resolved-config", "The actual location of a JSHint configuration file if present. If jshint-config is none then the task will seek a .jshintrc in the project folder. If that's not found then .jshintrc will be searched for in the user's home folder. This behaviour is consistent with other JSHint tooling.")

huntc

(function(sbt) {
  var playScala = require("playScala");
  
  var playKeys = playScala.keys;
  
  return sbt.project.in(sbt.cwd)
    .addPlugins(playScala);
    .addSettings({
      "name": "test-jshint",
      "version": "1.0-SNAPSHOT",

huntc

package com.typesafe.jse

import java.io.{IOException, OutputStream, InputStream}
import java.util.concurrent.locks.{Lock, ReentrantLock}
import java.util.concurrent.TimeUnit
import scala.concurrent.duration._

/**
 * Maintains a circular buffer where an output stream is used to push data into it, and an input stream is used to
 * pull data from it. The caller is expected to *always* close the input and output streams.

huntc

package com.typesafe.sbt.rr

import sbt._
import Keys._
import complete.DefaultParsers._
import com.typesafe.sbt.SbtNativePackager._
import NativePackagerKeys._
import sbt.complete.Parser

object Import {

huntc

case class StartBundle(bundleName: String, bundleSource: ActorRef, configName: String, configSource: Option[ActorRef])

huntc

package com.typesafe.reactiveruntime.resource

import akka.actor.{ActorRef, Props, Actor}
import akka.cluster.ClusterEvent.{MemberEvent, InitialStateAsEvents, MemberRemoved, MemberUp}
import akka.cluster.{Member, Cluster, UniqueAddress}
import akka.contrib.pattern.{DistributedPubSubMediator, DistributedPubSubExtension}
import com.typesafe.reactiveruntime.resource.ResourceProvider.Event.ResourceOffer
import com.typesafe.reactiveruntime.resource.ResourceProvider.RequestResources
import java.util.UUID
import scala.collection.immutable.HashSet

huntc

package com.typesafe.reactiveruntime.net

import akka.actor.{ActorRef, Actor}
import akka.http.Unmarshal
import akka.http.model.HttpMethods._
import akka.http.model.{ HttpEntity, HttpRequest, HttpResponse, MultipartFormData, StatusCodes }
import akka.http.unmarshalling.Unmarshalling
import akka.pattern.ask
import akka.stream.scaladsl.{ ImplicitFlowMaterializer, Flow }
import akka.util.{ Timeout, ByteString }

huntc

/**
 * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
 */

package akka.contrib.stream

import akka.actor.{ ActorRef, ActorRefFactory, FSM, Props }
import akka.pattern.ask
import akka.stream.actor.ActorSubscriberMessage.{ OnComplete, OnError, OnNext }
import akka.stream.actor.{ ActorSubscriber, RequestStrategy, ZeroRequestStrategy }

huntc

  def render(project: Project.Value, path: String) = EssentialAction { rh =>
    val futureAction = project match {
      case Project.ConductR =>
        conductrDocRenderer.actorRef
          .ask(DocRenderer.Render(path))(settings.doc.renderer.timeout)
          .map {
            case html: Html                 => Action(Ok(html))(rh)
            case action: Action[AnyContent] => action(rh)
            case DocRenderer.NotFound(p)    => Action(NotFound(s"Cannot find $p"))(rh)
            case DocRenderer.NotReady       => Action(ServiceUnavailable("Initializing documentation. Please try again in a minute."))(rh)