zio / zio-intellij Goto Github PK

// TODO add such places.

TBD

https://github.com/zio/zio-shield

Needs filtering out classes that are in the same package name, but are not tests.

IntelliJ doesn't have good extensibility for plugging in new test runner supports without hard work. The functionality of the test runner is now implemented as a separate project https://github.com/zio/zio-test-intellij, allowing the plugin to be completely decoupled for a specific ZIO version.

This means that the user must manually add

"zio.dev" %%% "zio-test-intellij" % zioVersion % test

to their build.sbt in order for the runner to exist on the classpath, and IntelliJ to use it.

Consider alternative ways, such as downloading a matching runner in the background (similar to how IntelliJ downloads scalafmt)

I see that there's a PR for idea 2020.1 support #32,
can we publish a new version to the marketplace?

Could be nice to suggest type aliases like if there is ZIO[Any, Nothing, A], suggest UIO[A].

x *> 
y *> 
z

to

for {
  _ <- x
  _ <- y
  r <- z
} yield r

Oftentimes a chain starts small, with one or two actions chained with *>. When such a chain grows larger it becomes more suitable to write it as a for-comprehension.

The testrunner library is used by the test runner. It needs to add the correct version to the classpath in order to run the tests.
Right now, it's just a duplicate project, with duplicated sources.
Ideally, they should share the sources and just use a different scala versions (and zio versions) to compile.

Any help is appreciated!

Given:

val a: Task[Option[Int]] = ZIO(Option(1))

it suggests ZIO.fromOption which is obviously wrong since the fromOption will return an IO[Unit,...] and initial code is IO[Throwable,...]

asError was deprecated in ZIO RC18 (zio/zio#2958)

See zio/zio#2049

clock.sleep(duration) *> io can be simplified to io.delay(duration)

Suggest using Task.fromFuture instead (pitfall no. 1 https://medium.com/wix-engineering/5-more-pitfalls-to-avoid-when-starting-to-work-with-zio-d0cdd44fa439)

The common pitfall we see is when ZIO is nested in other ZIO. And therefore is not executed.
This problem can have many forms. Thanks to developers and blogs this is already documented and has following forms:

• Case 1 (Writing two ZIO effects without mapping between them) in https://medium.com/wix-engineering/5-pitfalls-to-avoid-when-starting-to-work-with-zio-adefdc7d2d5c
• Case 5 (Using ZIO.Access instead of ZIO.AccessM) and a bit of case 3 in https://medium.com/wix-engineering/5-more-pitfalls-to-avoid-when-starting-to-work-with-zio-d0cdd44fa439

The idea would be to write an inspection that can recognize such lone ZIOs and at least warn about the issue.

Figure out versioning, etc.

The provideSomeLayer[R0] API was tricky for me to get until I peeked at the documentation -- where it states the type parameter is for the remainder. Perhaps IntelliJ could assist in figuring this out.

Sometimes the .unit suggestion is replacing too much code. Here's a minimal example:

UIO(println("a")) *> UIO(println("b")).unit

It gets replaced with:

UIO(println("a")).unit

This is with 2020.1.0.5.

There's a sbt-idea-plugin whose goal is to allow building and packaging IntelliJ plugins from sbt. It would be great to convert the current gradle build to this sbt one!

Bonus tip: https://medium.com/wix-engineering/5-more-pitfalls-to-avoid-when-starting-to-work-with-zio-d0cdd44fa439

ZIO guidelines suggest using zio-macros to generate helper methods for service mocking.
It would be great to add hints in Intellij Idea for the generated code.

zio-native types (like ZQuery, ZSink, etc) are supported. Consider supporting others, such as ZQuery from caliban.

When IntelliJ IDEA shorten command line arguments, it passes to ZTestRunner a file path in which actual command line arguments are stored.

Current implementation of argument parser does not handle this situation and fails to run test cases.

Example: caliban

src/test/scala/caliban/execution/ExecutionSpec.scala

running testM("fragment") runs both "fragment" and "inline fragment"

(this is most likely a bug in the args parsing in ZTestRunnerHost

IntelliJ will still sometimes show missing implicit hints for code that's compiling:

Perhaps it's possible to augment IntelliJ (using public API only!) to provide better hints for these implicits.

ZIO.collectAll(xs.map(f)) => ZIO.traverse(xs)(f)

In RC17 I was able to run the tests from within IntelliJ. I think in RC18 s.th. broke.

I get this error from the ZTestRunner.

Exception in thread "main" java.lang.NoSuchMethodError: zio.test.TestRunner.unsafeRun$default$2()Lzio/test/TestLogger;
	at zio.intellij.testsupport.runner.ZTestRunner$.run(ZTestRunner.scala:37)
	at zio.intellij.testsupport.runner.ZTestRunnerHost.main(ZTestRunnerHost.java:5)

As discussed with @adamgfraser in zio/zio#3014 it seems to be an issue with the IDEA plugin.

Pitfall no. 2 https://medium.com/wix-engineering/5-pitfalls-to-avoid-when-starting-to-work-with-zio-adefdc7d2d5c

This requires porting over massive amounts of base test fixtures from the scala plugin, because they are currently not published in the jar.

.flatMap(a => f(a).as(a)) => .tap(f)
.flatMap(a => b.as(a)) => .tap(_ => b)

Similarly, tapError and tapBoth.

When using the module pattern (described here: https://zio.dev/docs/howto/howto_use_module_pattern) one can use the @accessible annotation from zio-macros to generate helper methods to access services.

Right now intellij is unable to pick up the macro expansion, so going with this recommended approach leaves you with red underlines and no code completion.

It is possible to "fake" macro expansion in intellij by injecting synthetic members with a plugin: https://blog.jetbrains.com/scala/2015/10/14/intellij-api-to-build-scala-macros-support/

I am working to test out adding support for @accessible. Once this is done it would be worth considering adding the other annotations the same way.

At some point this plugin should be published to the IntelliJ plugin repository.

Instructions can be found here: https://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/publishing_plugin.html

I'm assuming this is something @hmemcpy will want to do himself, but if not let me know and I can.

.map(a).mapError(b) => .bimap(b, a)
.mapError(a).map(b) => .bimap(a, b)

if (a) b else IO.unit) => IO.when(a)(b)

Example

def list: List[Int] = ???
def toZio: Int => UIO[Int] = ???

for {
  _ <- if (true) ZIO.foreach_(list)(toZio) else ZIO.unit
} yield ???

Plugin correctly suggests using the .when method, but incorrectly transforms for comprehension into

for {
  _ <- ZIO.foreach_(ZIO.foreach_(list)(toZio)).when(true)
} yield ???

putStrLn("...")
ZIO.success(42)

Should detect putStrLn as unused, and offer to either add *> or at least a warning.

IO.succeed(None) => IO.none
IO.succeed(Some(a)) => IO.some(a)

i.e.

trait S {
  def foo: ZIO[Nothing, Nothing, Unit]
                 ^
                 |--------- most certainly a mistake
}

Provide an indication about code that's explicitly being forked. Display trace information when available (debugging)

.map(_ => a) => .as(a)
.mapError(_ => a) => .asError(a)

Need to figure out how to do it... @alexvanolst

java.lang.UnsupportedClassVersionError: zio/intellij/testsupport/runner/ZTestRunnerHost has been compiled by a more recent version of the Java Runtime (class file version 55.0), this version of the Java Runtime only recognizes class file versions up to 52.0

The test runner was compiled against JDK11... I guess java doesn't like it.

sigh 😕