Main.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}

import qualified Data.Proxy as Proxy
import qualified Data.Text as Text
import qualified Lackey
import qualified Servant.API as Servant
import qualified Test.Hspec as Hspec

main :: IO ()
main =
  Hspec.hspec
    . Hspec.parallel
    . Hspec.describe "Lackey"
    . Hspec.describe "rubyForAPI"
    $ do
      Hspec.it "supports delete requests" $ do
        let api =
              Proxy.Proxy :: Proxy.Proxy (Servant.Delete '[Servant.JSON] ())
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "delete" "" "delete" "" "" False

      Hspec.it "supports get requests" $ do
        let api = Proxy.Proxy :: Proxy.Proxy (Servant.Get '[Servant.JSON] ())
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" "" "get" "" "" False

      Hspec.it "supports patch requests" $ do
        let api =
              Proxy.Proxy :: Proxy.Proxy (Servant.Patch '[Servant.JSON] ())
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "patch" "" "patch" "" "" False

      Hspec.it "supports post requests" $ do
        let api = Proxy.Proxy :: Proxy.Proxy (Servant.Post '[Servant.JSON] ())
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "post" "" "post" "" "" False

      Hspec.it "supports put requests" $ do
        let api = Proxy.Proxy :: Proxy.Proxy (Servant.Put '[Servant.JSON] ())
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "put" "" "put" "" "" False

      Hspec.it "supports alternatives" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.Get '[Servant.JSON] () Servant.:<|> Servant.Delete '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` Text.concat
            [ ruby "get" "" "get" "" "" False,
              Text.singleton ';',
              ruby "delete" "" "delete" "" "" False
            ]

      Hspec.it "supports captures" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.Capture "id" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get_by_id" ",id" "get" "#{id}" "" False

      Hspec.it "supports query flags" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryFlag "flag" Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby
            "get"
            ",flag: nil"
            "get"
            "?flag=#{flag}"
            ""
            False

      Hspec.it "supports query params" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryParam "param" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby
            "get"
            ",param: nil"
            "get"
            "?param=#{param}"
            ""
            False

      Hspec.it "supports multiple query params" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryParams "params" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby
            "get"
            ",params: nil"
            "get"
            "?params=#{params}"
            ""
            False

      Hspec.it "supports request bodies" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.ReqBody '[Servant.JSON] () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" ",body" "get" "" "" True

      Hspec.it "supports request headers" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.Header "cookie" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby
            "get"
            ",cookie: nil"
            "get"
            ""
            "\"cookie\"=>cookie"
            False

      Hspec.it "supports response headers" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  (Servant.Get '[Servant.JSON] (Servant.Headers '[] ()))
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" "" "get" "" "" False

      Hspec.it "puts the body param after captures" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.Capture "segment" () Servant.:> Servant.ReqBody '[Servant.JSON] () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby
            "get_by_segment"
            ",segment,body"
            "get"
            "#{segment}"
            ""
            True

      Hspec.it "puts the body param after query params" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryFlag "flag" Servant.:> Servant.ReqBody '[Servant.JSON] () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby
            "get"
            ",flag: nil,body"
            "get"
            "?flag=#{flag}"
            ""
            True

      Hspec.it "sanitizes path segments" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ("A!" Servant.:> Servant.Get '[Servant.JSON] ())
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get_A!" "" "get" "A!" "" False

      Hspec.it "sanitizes captures" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.Capture "A!" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get_by_A!" ",a_" "get" "#{a_}" "" False

      Hspec.it "sanitizes query flags" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryFlag "A!" Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" ",a_: nil" "get" "?A!=#{a_}" "" False

      Hspec.it "sanitizes query params" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryParam "A!" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" ",a_: nil" "get" "?A!=#{a_}" "" False

      Hspec.it "sanitizes multiple query params" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.QueryParams "A!" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" ",a_: nil" "get" "?A!=#{a_}" "" False

      Hspec.it "sanitizes headers" $ do
        let api =
              Proxy.Proxy ::
                Proxy.Proxy
                  ( Servant.Header "A!" () Servant.:> Servant.Get '[Servant.JSON] ()
                  )
        Lackey.rubyForAPI api
          `Hspec.shouldBe` ruby "get" ",a_: nil" "get" "" "\"A!\"=>a_" False

-- Since every generated function has the same structure, it can be abstracted
-- away behind this function.
ruby :: String -> String -> String -> String -> String -> Bool -> Text.Text
ruby name params method path headers body =
  Text.pack
    ( concat
        [ "def ",
          name,
          "(excon",
          params,
          ")",
          "excon.request(",
          ":method=>:",
          method,
          ",",
          ":path=>\"/",
          path,
          "\",",
          ":headers=>{",
          headers,
          "},",
          ":body=>",
          if body then "body" else "nil",
          ")",
          "end"
        ]
    )