Tagless final refactor (#344)

* initial refactoring from free monad to tagless final

* Added Algebras

* Refactored HttpClient, temporarily bypassing HttpRequestBuilderExtension, added runtime implicits, added User alg interpretation

* moving /free/domain to /taglessFinal/domain

* Adding interpreters for algebras. Interpreters target the /api classes

* reformatted/linted, remove ADTs from algebras, added more implicit runtime instnaces

* updated algebra signatures to match existing api, removed accessToken as default param, added headers as default param

*  Modified intepreters to fit new algebra definitions and take accessToken as a default parameter

* removing free monad implementation

* updating GHWorkflow and Github

* for Rafa review

* pre merge

* Updated F type constraint F[_]: Applicative -> F[_]: ConcurrentEffect

* For Rafa comment, progress on replacing scalaj-http with http4s

* For Rafa review and refactor

* applied some refactoring to have clean layers

* Adding toFutue and toId syntax for IO[A]

* removing unit tests associated with deleted classes

* For Rafa Review, unit tests

* updating unit tests for interpreters

* unit test linting

* refactoring integration test to match new api usage

* updating unit and integration test base spec

* linting and updating scala version 2.13 and blaze client

* fixing TestData for integration test

* Updateding FakeResponses for Decoder testing

* fix integration test, pull GITHUB4S_ACCESS_TOKEN from sys env

* upgrades some models

* Revert "upgrades some models"

This reverts commit 4771d05

* fixes the unit tests

* removes commented import

* fixes the decoders issue for the new http client

* proves the organization's members with the proper token

* enables commented suites

* ignores temporally a test because we are getting permission issues

* Updating documentation, initial draft

* Update contributing.md

* fixing github doc links

* cleaning interpreter imports, retarget issue for testing (123 -> 17)

* remove old api tests

* remove mock-server dependency, change http4s version

* switching to compile-only check in documentation. mdoc:silent -> mdoc:compile-only

* Address Ben F. PR comments

* Address Lawrence's PR comments

* Address Anna M. PR Comments

* Address Ana G. PR comments

* Address Juan Pedro PR comments

* test remove label

Co-authored-by: Rafa Paradela <rafa.p@47deg.com>

Author: bond15

build.sbt

@@ -21,17 +21,12 @@ lazy val github4s =
     )
     .settings(coreDeps: _*)
 
-lazy val catsEffect =
-  (project in file("cats-effect"))
-    .settings(moduleName := "github4s-cats-effect")
-    .settings(catsEffectDependencies: _*)
-    .dependsOn(github4s)
 
 /////////////////////
 //// ALL MODULES ////
 /////////////////////
 
-lazy val allModules: Seq[ProjectReference] = Seq(github4s, catsEffect)
+lazy val allModules: Seq[ProjectReference] = Seq(github4s)
 
 lazy val allModulesDeps: Seq[ClasspathDependency] =
   allModules.map(ClasspathDependency(_, None))

cats-effect/src/main/scala/github4s/cats/effect/implicits.scala

@@ -15,20 +15,23 @@ with Github4s, you can interact with:
   - [List stargazers](#list-stargazers)
   - [List starred repositories](#list-starred-repositories)
 
-The following examples assume the following imports and token:
+The following examples use `cats.effect.IO` and assume the following imports and token:
 
 ```scala mdoc:silent
 import github4s.Github
-import github4s.Github._
-import github4s.implicits._
+import github4s.GithubIOSyntax._
+import cats.effect.IO
+import scala.concurrent.ExecutionContext.Implicits.global
 
+implicit val IOContextShift = IO.contextShift(global)
 val accessToken = sys.env.get("GITHUB4S_ACCESS_TOKEN")
 ```
 
-They also make use of `cats.Id`, but any type container implementing `MonadError[M, Throwable]` will do.
 
-Support for `cats.Id`, `cats.Eval`, and `Future` are
-provided out of the box when importing `github4s.implicits._`.
+They also make use of `cats.Id`, but any type container `F` implementing `ConcurrentEffect` will do.
+
+LiftIO syntax for `cats.Id` and `Future` are provided in `GithubIOSyntax`.
+
 
 ## Notifications
 
@@ -44,9 +47,9 @@ You can subscribe or unsubscribe using `setThreadSub`; it takes as arguments:
 - `subscribed`: Determines if notifications should be received from this thread.
 - `ignored`: Determines if all notifications should be blocked from this thread.
 
-```scala
-val threadSub = Github(accessToken).activities.setThreadSub(5, true, false)
-threadSub.exec[cats.Id]() match {
+```scala mdoc:compile-only
+val threadSub = Github[IO](accessToken).activities.setThreadSub(5, true, false)
+threadSub.unsafeRunSync match {
   case Left(e) => println(s"Something went wrong: ${e.getMessage}")
   case Right(r) => println(r.result)
 }
@@ -68,9 +71,9 @@ You can list the users starring a specific repository with `listStargazers`; it
 
 To list the stargazers of 47deg/github4s:
 
-```scala mdoc:silent
-val listStargazers = Github(accessToken).activities.listStargazers("47deg", "github4s", true)
-listStargazers.exec[cats.Id]() match {
+```scala mdoc:compile-only
+val listStargazers = Github[IO](accessToken).activities.listStargazers("47deg", "github4s", true)
+listStargazers.unsafeRunSync match {
   case Left(e) => println(s"Something went wrong: ${e.getMessage}")
   case Right(r) => println(r.result)
 }
@@ -95,9 +98,9 @@ the repo was last pushed to), optional.
 
 To list the starred repositories for user `rafaparadela`:
 
-```scala mdoc:silent
-val listStarredRepositories = Github(accessToken).activities.listStarredRepositories("rafaparadela", true)
-listStarredRepositories.exec[cats.Id]() match {
+```scala mdoc:compile-only
+val listStarredRepositories = Github[IO](accessToken).activities.listStarredRepositories("rafaparadela", true)
+listStarredRepositories.unsafeRunSync match {
   case Left(e) => println(s"Something went wrong: ${e.getMessage}")
   case Right(r) => println(r.result)
 }
@@ -112,4 +115,4 @@ As you can see, a few features of the activity endpoint are missing.
 
 As a result, if you'd like to see a feature supported, feel free to create an issue and/or a pull request!
 
-[activity-scala]: https://github.com/47deg/github4s/blob/master/github4s/shared/src/main/scala/github4s/free/domain/Activity.scala
+[activity-scala]: https://github.com/47deg/github4s/blob/master/github4s/src/main/scala/github4s/domain/Activity.scala

cats-effect/src/test/scala/github4s/cats/effect/CatsEffectSpec.scala

@@ -17,9 +17,15 @@ The following examples assume the following imports:
 
 ```scala mdoc:silent
 import github4s.Github
-import github4s.Github._
-import github4s.implicits._
+import github4s.GithubIOSyntax._
+import cats.effect.IO
+import scala.concurrent.ExecutionContext.Implicits.global
+
+implicit val IOContextShift = IO.contextShift(global)
 ```
+They also make use of `cats.Id`, but any type container `F` implementing `ConcurrentEffect` will do.
+
+LiftIO syntax for `cats.Id` and `Future` are provided in `GithubIOSyntax`.
 
 **NOTE**: In the examples you will see `Github(None)`
 because if you are authenticating for the first time you don't have any access token yet.
@@ -36,15 +42,15 @@ You can create a new authorization token using `newAuth`; it takes as arguments:
 - `client_id`: the 20 character OAuth app client key for which to create the token.
 - `client_secret`: the 40 character OAuth app client secret for which to create the token.
 
-```scala
-val newAuth = Github(None).auth.newAuth(
+```scala mdoc:compile-only
+val newAuth = Github[IO](None).auth.newAuth(
   "rafaparadela",
   "invalidPassword",
   List("public_repo"),
   "New access token",
   "e8e39175648c9db8c280",
   "1234567890")
-newAuth.exec[cats.Id]() match {
+newAuth.unsafeRunSync match {
   case Left(e) => println(s"Something went wrong: ${e.getMessage}")
   case Right(r) => println(r.result)
 }
@@ -65,12 +71,12 @@ You can authorize a url using `authorizeUrl`; it takes as arguments:
 - `redirect_uri`: the URL in your app where users will be sent to after authorization.
 - `scopes`: attached to the token, for more information see [the scopes doc](https://developer.github.com/v3/oauth/#scopes).
 
-```scala
-val authorizeUrl = Github(None).auth.authorizeUrl(
+```scala mdoc:compile-only
+val authorizeUrl = Github[IO](None).auth.authorizeUrl(
   "e8e39175648c9db8c280",
   "http://localhost:9000/_oauth-callback",
   List("public_repo"))
-authorizeUrl.exec[cats.Id]() match {
+authorizeUrl.unsafeRunSync match {
   case Left(e) => println(s"Something went wrong: ${e.getMessage}")
   case Right(r) => println(r.result)
 }
@@ -93,14 +99,14 @@ You can get an access token using `getAccessToken`; it takes as arguments:
 - `redirect_uri`: the URL in your app where users will be sent after authorization.
 - `state`: the unguessable random string you optionally provided in [Create a new authorization token](#create-a-new-authorization-token).
 
-```scala mdoc:silent
-val getAccessToken = Github(None).auth.getAccessToken(
+```scala mdoc:compile-only
+val getAccessToken = Github[IO](None).auth.getAccessToken(
   "e8e39175648c9db8c280",
   "1234567890",
   "code",
   "http://localhost:9000/_oauth-callback",
   "status")
-getAccessToken.exec[cats.Id]() match {
+getAccessToken.unsafeRunSync match {
   case Left(e) => println(s"Something went wrong: ${e.getMessage}")
   case Right(r) => println(r.result)
 }
@@ -114,4 +120,4 @@ As you can see, a few features of the authorization endpoint are missing.
 
 As a result, if you'd like to see a feature supported, feel free to create an issue and/or a pull request!
 
-[auth-scala]: https://github.com/47deg/github4s/blob/master/github4s/shared/src/main/scala/github4s/free/domain/Authorization.scala
+[auth-scala]: https://github.com/47deg/github4s/blob/master/github4s/src/main/scala/github4s/domain/Authorization.scala