name:                ghcjs-websockets
version:             0.2.0.0
synopsis:            GHCJS interface for the Javascript Websocket API
description:         'ghcjs-websockets' aims to provide an clean,
                     idiomatic Haskell interface abstracting over the
                     Javascript Websockets API, targeting 'ghcjs' for
                     receiving serialized tagged and untagged data.
                     .
                     The interface abstracts websockets as raw data streams
                     and is designed to allow multiple styles of usage; in
                     particular, is adapted for 'io-stream'-style usage and
                     'distributed-process'-style usage.  It is designed to fit
                     in unintrusively in larger frameworks, and adaptable for
                     other interfaces (like 'pipes').
                     .
                     This library provides both /tagged/ and /untagged/
                     communication channels, using 'tagged-binary'
                     <http://hackage.haskell.org/package/tagged-binary>.
                     .
                     * /Untagged/ channels will throw away incoming binary
                     data of unexpected type.
                     .
                     * /Tagged/ channels will queue up binary data of
                     unexpected type to be accessed later when data of that
                     type is requested.
                     .
                     Tagged channels mimic the behavior of Cloud Haskell
                     <http://www.haskell.org/haskellwiki/Cloud_Haskell> and
                     'distributed-process'
                     <http://hackage.haskell.org/package/distributed-process>,
                     with their dynamic communication channels.  You can use
                     the same channel to send in polymorphic, typed data and
                     deal with it at the time you wish.
                     .
                     Some examples:
                     .
                     * 'io-stream'-style usage.
                     .
                     > -- Echoes input from the server.
                     > main :: IO ()
                     > main = do
                     >     c <- openConnection "ws://server-url.com"
                     >     forever $ do
                     >         d <- withConn c expectText
                     >         putStrLn d
                     >         withConn c (sendText d)
                     >     closeConnection c
                     .
                     * Commands involving connections can be sequenced with a
                     monadic interface
                     .
                     > -- Echoes input from the server.
                     > main :: IO ()
                     > main = withUrl "ws://server-url.com" . forever $ do
                     >     d <- expectText
                     >     liftIO $ putStrLn d
                     >     sendText d
                     .
                     * Wait for incoming data only decodable as a desired
                     type, and skip over undecodable data.
                     .
                     > -- Keep on printing all `Just` values, and stop at the
                     > -- first `Nothing`.
                     > whileJust :: ConnectionProcess ()
                     > whileJust = do
                     >     d <- expect
                     >     case d of
                     >       Just d' -> do
                     >           liftIO $ putStrLn d'
                     >           whileJust
                     >       Nothing ->
                     >           return ()
                     .
                     * Typed dynamic communication channels with
                     'tagged-binary'
                     <http://hackage.haskell.org/package/tagged-binary>;
                     channels looking for a specific type skip over input of
                     the wrong type, and channels looking for the other type
                     can pick them up later or in parallel.
                     .
                     > -- Server emits `Int`s or `String`s randomly; launch
                     > -- two parallel threads to catch the data as it comes
                     > -- in, one watching for `Int`s and one watching for
                     > -- `String`s.
                     > main :: IO ()
                     > main = do
                     >    c <- openTaggedConnection "ws://server-url.com"
                     >    t1 <- forkIO . withConn c . forever $ do
                     >        n <- expectTagged
                     >        replicateM n . liftIO . putStrLn $ "got a number! " ++ show n
                     >    t2 <- forkIO . withConn c . forever $ do
                     >        s <- expectTagged
                     >        liftIO $ putStrN s
                     >    await t1
                     >    await t2
                     >    closeConnection c
                     .
                     See the 'JavaScript.WebSockets' module for a more
                     detailed introduction.
                     .
                     There is still some functionality left to be desired;
                     feel free to open a ticket and send in suggestions or
                     bugs, and all pull requests are welcomed!
homepage:            http://github.com/mstksg/ghcjs-websockets
license:             MIT
license-file:        LICENSE
author:              Justin Le <justin@jle.im>
maintainer:          Justin Le <justin@jle.im>
copyright:           Copyright (c) Justin Le 2014
category:            Web
build-type:          Simple
-- extra-source-files:  
cabal-version:       >=1.10

source-repository head
  type:     git
  location: https://github.com/mstksg/tagged-binary

library
  exposed-modules:     JavaScript.WebSockets
  -- ghcjs-options: -O2
  -- other-modules:       
  -- other-extensions:    
  ghc-options:       -Wall
  build-depends:     base ==4.7.*,
                     ghcjs-base,
                     transformers,
                     tagged-binary,
                     binary,
                     spoon,
                     containers,
                     bytestring,
                     text
  -- hs-source-dirs:      
  default-language:    Haskell2010

executable ghcjs-websockets-test
  main-is: Test/Tests.hs
  ghc-options:       -O2
  default-language:  Haskell2010
  build-depends:     base ==4.7.*,
                     spoon,
                     binary,
                     bytestring,
                     tagged-binary,
                     containers,
                     ghcjs-base,
                     transformers,
                     text