Hammock

Value Members

1. final def !=(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. final def ==(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

4. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

5. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

6. def deleteWithOpts(uri: Uri, opts: Opts): HttpRequestIO[HttpResponse]

   

   Create an DELETE request to the given uri and opts.

   Create an DELETE request to the given uri and opts.

   scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
   opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
   
   scala> Hammock.deleteWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts)
   res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

7. final def eq(arg0: AnyRef): Boolean

   

   Definition Classes

   AnyRef

8. def equals(arg0: Any): Boolean

   

   Definition Classes

   AnyRef → Any

9. def finalize(): Unit

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( classOf[java.lang.Throwable] )

10. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

11. def getWithOpts(uri: Uri, opts: Opts): HttpRequestIO[HttpResponse]

    

    Create an GET request to the given uri and opts.

    Create an GET request to the given uri and opts.

    scala> import hammock._, hammock.jvm.free.Interpreter, hammock.hi._, hammock.hi.dsl._, cats._, cats.implicits._, scala.util.Try
    import hammock._
    import hammock.jvm.free.Interpreter
    import hammock.hi._
    import hammock.hi.dsl._
    import cats._
    import cats.implicits._
    import scala.util.Try
    
    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> Hammock.getWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts)
    res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

12. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

13. def headWithOpts(uri: Uri, opts: Opts): HttpRequestIO[HttpResponse]

    

    Create an HEAD request to the given uri and opts.

    Create an HEAD request to the given uri and opts.

    scala> import hammock._, hammock.jvm.free.Interpreter, hammock.hi._, hammock.hi.dsl._, cats._, cats.implicits._, scala.util.Try
    import hammock._
    import hammock.jvm.free.Interpreter
    import hammock.hi._
    import hammock.hi.dsl._
    import cats._
    import cats.implicits._
    import scala.util.Try
    
    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> Hammock.headWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts)
    res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

14. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

15. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

16. final def notify(): Unit

    

    Definition Classes

    AnyRef

17. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

18. def optionsWithOpts(uri: Uri, opts: Opts): HttpRequestIO[HttpResponse]

    

    Create an OPTIONS request to the given uri and opts.

    Create an OPTIONS request to the given uri and opts.

    scala> import hammock._, hammock.jvm.free.Interpreter, hammock.hi._, hammock.hi.dsl._, cats._, cats.implicits._, scala.util.Try
    import hammock._
    import hammock.jvm.free.Interpreter
    import hammock.hi._
    import hammock.hi.dsl._
    import cats._
    import cats.implicits._
    import scala.util.Try
    
    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> Hammock.optionsWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts)
    res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

19. def postWithOpts[A](uri: Uri, opts: Opts, body: Option[A] = None)(implicit arg0: Codec[A]): HttpRequestIO[HttpResponse]

    

    Create an POST request to the given uri and opts.

    Create an POST request to the given uri and opts. It also has an optional body parameter that can be used.

    scala> import hammock._, hammock.jvm.free.Interpreter, hammock.hi._, hammock.hi.dsl._, cats._, cats.implicits._, scala.util.Try
    import hammock._
    import hammock.jvm.free.Interpreter
    import hammock.hi._
    import hammock.hi.dsl._
    import cats._
    import cats.implicits._
    import scala.util.Try
    
    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> implicit val stringCodec = new Codec[String] {
         |   def encode(s: String) = s
         |   def decode(s: String) = Right(s)
         | }
    stringCodec: hammock.Codec[String]{def decode(s: String): scala.util.Right[Nothing,String]} = $anon$1@1533f96a
    
    scala> Hammock.postWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts, Some("""{"body": true}"""))
    res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

20. def putWithOpts[A](uri: Uri, opts: Opts, body: Option[A] = None)(implicit arg0: Codec[A]): HttpRequestIO[HttpResponse]

    

    Create an PUT request to the given uri and opts.

    Create an PUT request to the given uri and opts. It also has an optional body parameter that can be used.

    scala> import hammock._, hammock.jvm.free.Interpreter, hammock.hi._, hammock.hi.dsl._, cats._, cats.implicits._, scala.util.Try
    import hammock._
    import hammock.jvm.free.Interpreter
    import hammock.hi._
    import hammock.hi.dsl._
    import cats._
    import cats.implicits._
    import scala.util.Try
    
    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> implicit val stringCodec = new Codec[String] {
         |   def encode(s: String) = s
         |   def decode(s: String) = Right(s)
         | }
    stringCodec: hammock.Codec[String]{def decode(s: String): scala.util.Right[Nothing,String]} = $anon$1@1533f96a
    
    scala> Hammock.putWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts, Some("""{"body": true}"""))
    res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

21. def request[A](method: Method, uri: Uri, headers: Map[String, String], body: Option[A])(implicit arg0: Codec[A]): HttpRequestIO[HttpResponse]

    

    Create an hammock.HttpRequestIO as well, but you can pass it a body when it exists an instance for the Codec typeclass for the given type A

22. def request(method: Method, uri: Uri, headers: Map[String, String]): HttpRequestIO[HttpResponse]

    

    Create an hammock.HttpRequestIO[HttpResponse] from the Method, Uri, and String] headers.

    Create an hammock.HttpRequestIO[HttpResponse] from the Method, Uri, and String] headers. It can be later executed via an interpreter.

23. final def synchronized[T0](arg0: ⇒ T0): T0

    

    Definition Classes

    AnyRef

24. def toString(): String

    

    Definition Classes

    AnyRef → Any

25. def traceWithOpts(uri: Uri, opts: Opts): HttpRequestIO[HttpResponse]

    

    Create an TRACE request to the given uri and opts.

    Create an TRACE request to the given uri and opts.

    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> Hammock.traceWithOpts(Uri.unsafeParse("http://httpbin.org/get"), opts)
    res1: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)

26. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

27. final def wait(arg0: Long, arg1: Int): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

28. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

29. def withOpts[A](method: Method, uri: Uri, opts: Opts, body: Option[A])(implicit arg0: Codec[A]): HttpRequestIO[HttpResponse]

    

    Variant of withOpts methods that also takes an optional body of a request.

    Variant of withOpts methods that also takes an optional body of a request. There should be a Codec instance for the body type for this to work.

    See also

    Hammock.withOpts

30. def withOpts(method: Method, uri: Uri, opts: Opts): HttpRequestIO[HttpResponse]

    

    Creates a HttpRequestIO[HttpResponse] value given a method, uri, and opts.

    Creates a HttpRequestIO[HttpResponse] value given a method, uri, and opts.

    Usage:

    scala> import hammock._, hammock.jvm.free.Interpreter, hammock.hi._, hammock.hi.dsl._, cats._, cats.implicits._, scala.util.Try
    import hammock._
    import hammock.jvm.free.Interpreter
    import hammock.hi._
    import hammock.hi.dsl._
    import cats._
    import cats.implicits._
    import scala.util.Try
    
    scala> val opts = (header("X-Test" -> "works!") &> auth(Auth.BasicAuth("user", "pass")) &> cookie(Cookie("key", "value")))(Opts.default)
    opts: hammock.hi.Opts = Opts(Some(BasicAuth(user,pass)),Map(X-Test -> works!),Some(List(Cookie(key,value,None,None,None,None,None,None,None,None))))
    
    scala> val response = Hammock.withOpts(Method.GET, Uri.unsafeParse("http://httpbin.org/get"), opts)
    response: hammock.free.algebra.HttpRequestIO[hammock.HttpResponse] = Free(...)