From e72bc821a85dff16d4a96d49f755c9ef0be835d3 Mon Sep 17 00:00:00 2001 From: Jakob Odersky Date: Thu, 1 Apr 2021 13:50:56 +0200 Subject: [PATCH] 0.2.12 --- build.sc | 6 ++-- readme.md | 99 ++++++++++++++++++++++++++++++------------------------- 2 files changed, 57 insertions(+), 48 deletions(-) diff --git a/build.sc b/build.sc index 57fc900..99759c5 100644 --- a/build.sc +++ b/build.sc @@ -4,7 +4,7 @@ import de.tobiasroeser.mill.vcs.version.VcsVersion val dottyVersions = sys.props.get("dottyVersion").toList -val scalaVersions = "2.11.12" :: "2.12.13" :: "2.13.4" :: "3.0.0-RC1" :: dottyVersions +val scalaVersions = "2.11.12" :: "2.12.13" :: "2.13.4" :: "3.0.0-RC2" :: dottyVersions val scala2Versions = scalaVersions.filter(_.startsWith("2.")) val scalaJSVersions = for { @@ -39,7 +39,7 @@ trait FansiModule extends PublishModule { } trait FansiMainModule extends CrossScalaModule { def millSourcePath = super.millSourcePath / offset - def ivyDeps = Agg(ivy"com.lihaoyi::sourcecode::0.2.4") + def ivyDeps = Agg(ivy"com.lihaoyi::sourcecode::0.2.5") def offset: os.RelPath = os.rel def sources = T.sources( super.sources() @@ -56,7 +56,7 @@ trait FansiMainModule extends CrossScalaModule { trait FansiTestModule extends ScalaModule with TestModule { def crossScalaVersion: String def testFrameworks = Seq("utest.runner.Framework") - def ivyDeps = Agg(ivy"com.lihaoyi::utest::0.7.7") + def ivyDeps = Agg(ivy"com.lihaoyi::utest::0.7.8") def offset: os.RelPath = os.rel def millSourcePath = super.millSourcePath / os.up diff --git a/readme.md b/readme.md index 871b77c..7d6f62c 100644 --- a/readme.md +++ b/readme.md @@ -15,10 +15,10 @@ Fansi 0.2.10 [![Gitter Chat]][gitter-url] [![Build Status]][travis-url] [![Patre "com.lihaoyi" %%% "fansi" % "0.2.10" // Scala.js or Scala-Native ``` -Fansi is a Scala library to make it easy to deal with fancy colored Ansi +Fansi is a Scala library to make it easy to deal with fancy colored Ansi strings within your command-line programs. -While "normal" use of Ansi escapes with `java.lang.String`, you find yourself +While "normal" use of Ansi escapes with `java.lang.String`, you find yourself concatenating colors: ```scala @@ -37,35 +37,35 @@ this approach. For example, val colored: String = Console.RED + "Hello World Ansi!" + Console.RESET // How to efficiently get the length of this string on-screen? We could try -// using regexes to remove and Ansi codes, but that's slow and inefficient. +// using regexes to remove and Ansi codes, but that's slow and inefficient. // And it's easy to accidentally call `colored.length` and get a invalid length -val length = ??? +val length = ??? -// How to make the word `World` blue, while preserving the coloring of the -// `Ansi!` text after? What if the string came from somewhere else and you +// How to make the word `World` blue, while preserving the coloring of the +// `Ansi!` text after? What if the string came from somewhere else and you // don't know what color that text was originally? -val blueWorld = ??? +val blueWorld = ??? // What if I want to underline "World" instead of changing it's color, while // still preserving the original color? val underlinedWorld = ??? -// What if I want to apply underlines to "World" and the two characters on +// What if I want to apply underlines to "World" and the two characters on // either side, after I had already turned "World" blue? val underlinedBlue = ??? ``` While simple to describe, these tasks are all error-prone and difficult to -do using normal `java.lang.String`s containing Ansi color codes. This is +do using normal `java.lang.String`s containing Ansi color codes. This is especially so if, unlike the toy example above, `colored` is coming from some -other part of your program and you're not sure what or how-many Ansi color -codes it already contains. +other part of your program and you're not sure what or how-many Ansi color +codes it already contains. With Fansi, doing all these tasks is simple, error-proof and efficient: ```scala val colored: fansi.Str = fansi.Color.Red("Hello World Ansi!") -// Or fansi.Str("Hello World Ansi!").overlay(fansi.Color.Red) +// Or fansi.Str("Hello World Ansi!").overlay(fansi.Color.Red) val length = colored.length // Fast and returns the non-colored length of string @@ -113,15 +113,15 @@ too much and stomp over colors that already exist: ![StringError](docs/StringError.png) `fansi.Str` allows you to perform these tasks safely and easily: - + ![FansiRocks](docs/FansiRocks.png) Fansi is also very efficient: `fansi.Str` uses just 3x as much memory as `java.lang.String` to hold all the additional formatting information. -Its operations are probably about the same factor slower, as they are all -implemented using fast `arraycopy`s and while-loops similar to -`java.lang.String`. That means that - unlike fiddling with Ansi-codes using -regexes - you generally do not need to worry about performance when dealing with +Its operations are probably about the same factor slower, as they are all +implemented using fast `arraycopy`s and while-loops similar to +`java.lang.String`. That means that - unlike fiddling with Ansi-codes using +regexes - you generally do not need to worry about performance when dealing with `fansi.Str`s. Just treat them as you would `java.lang.String`s: splitting them, `substring`ing them, and applying or removing colors or other styles at-will. @@ -144,27 +144,27 @@ The main operations you need to know are: ![fansi.Str](docs/Str.png) -- `fansi.Attr`s are the individual modifications you can make to an - `fansi.Str`'s formatting. Examples are: +- `fansi.Attr`s are the individual modifications you can make to an + `fansi.Str`'s formatting. Examples are: - `fansi.Bold.{On, Off}` - `fansi.Reversed.{On, Off}` - - `fansi.Underlined.{On, Off}` - - `fansi.Color.*` - - `fansi.Back.*` + - `fansi.Underlined.{On, Off}` + - `fansi.Color.*` + - `fansi.Back.*` - `fansi.Attr.Reset` - + ![fansi.Attr](docs/Attr.png) -- `fansi.Attrs` represents a group of zero or more `fansi.Attr`s. - These that can be passed around together, combined via `++` or applied - to `fansi.Str`s all at once. Any individual `fansi.Attr` can be used - when `fansi.Attrs` is required, as can `fansi.Attrs.empty`. +- `fansi.Attrs` represents a group of zero or more `fansi.Attr`s. + These that can be passed around together, combined via `++` or applied + to `fansi.Str`s all at once. Any individual `fansi.Attr` can be used + when `fansi.Attrs` is required, as can `fansi.Attrs.empty`. ![fansi.Attrs](docs/Attrs.png) -- Using any of the `fansi.Attr` or `fansi.Attrs` mentioned above, e.g. - `fansi.Color.Red`, using `fansi.Color.Red("hello world ansi!")` to create a - `fansi.Str` with that text and color, or +- Using any of the `fansi.Attr` or `fansi.Attrs` mentioned above, e.g. + `fansi.Color.Red`, using `fansi.Color.Red("hello world ansi!")` to create a + `fansi.Str` with that text and color, or `fansi.Str("hello world ansi!").overlay(fansi.Color.Blue, 6, 11)` - `.render` to convert a `fansi.Str` back into a `java.lang.String` with all @@ -187,32 +187,32 @@ If you want to dig into deeper, there are a few more APIs you can use: - `fansi.Str.join(args: fansi.Str*)` to conveniently join together multiple - `fansi.Str`s all at once, more efficient than `++` for large numbers of + `fansi.Str`s all at once, more efficient than `++` for large numbers of inputs -- `getColors`/`getColor` and `getChars`/`getChar` methods on `fansi.Str` to +- `getColors`/`getColor` and `getChars`/`getChar` methods on `fansi.Str` to extract the raw data for your own use -- `fansi.Str.fromArrays` to piece it back together +- `fansi.Str.fromArrays` to piece it back together -This allows you to perform fast, mutable array operations on the -color/character arrays if you know what you're doing and want to perform -operations that are inconvenient or slow to do through `fansi.Str`'s immutable -API. For example, if you want to do a bunch of work with colored strings and -then at-the-end render everything to HTML, you can manually walk over the +This allows you to perform fast, mutable array operations on the +color/character arrays if you know what you're doing and want to perform +operations that are inconvenient or slow to do through `fansi.Str`'s immutable +API. For example, if you want to do a bunch of work with colored strings and +then at-the-end render everything to HTML, you can manually walk over the color/character arrays yourself and decide where to print HTML tags to give the text colors. `fansi.Str` currently has a relatively skeletal API: it is slightly smaller -than what `java.lang.String` has, and definitely much less than what is +than what `java.lang.String` has, and definitely much less than what is available on `scala.RichString`'s extension methods. Feel free to implement your own custom operations using `fromArrays` if you can't find what you want on `fansi.Str`, or send a patch if you think it's arguably general enough to be included in Fansi itself. -- `fansi.Attrs.emitAnsiCodes` Lets you manually emit the different +- `fansi.Attrs.emitAnsiCodes` Lets you manually emit the different `java.lang.String`s that correspond to changes in color in an Ansi string. -For example, if you want to emit the Ansi codes that correspond to the -transition from "No Color" to "Red", you can use +For example, if you want to emit the Ansi codes that correspond to the +transition from "No Color" to "Red", you can use ```scala fansi.Attrs.emitAnsiCodes(0, fansi.Color.Red.applyMask) // "\u001b[31m" @@ -235,7 +235,7 @@ You can also pass in an `errorMode` when parsing a string via `ansi.Str(...)` to tell Fansi how to behave if it finds Ansi escapes it can't handle. You have the options: -- `fansi.ErrorMode.Throw` is the default, to throw an exception and fail the +- `fansi.ErrorMode.Throw` is the default, to throw an exception and fail the parse if it sees an Ansi escape it does not recognize. - `fansi.ErrorMode.Sanitize` to remove the escape character but leave the remnants of the escape-sequence in the result that people can see @@ -250,6 +250,15 @@ Scaladoc Changelog --------- +### 0.2.12 + +- Support for Scala 3.0.0-RC2 + +### 0.2.11 + +- Support for Scala 3.0.0-RC1 +- Support for ScalaJS on Scala 3 + ### 0.2.10 - Support for Scala Native 0.4 @@ -300,9 +309,9 @@ Changelog ### 0.1.2 -- Removed infinite-loop if parsing strings with Ansi escapes that are not +- Removed infinite-loop if parsing strings with Ansi escapes that are not recognized by Fansi -- Added `fansi.ErrorMode` parameter, to control behavior when un-recognized +- Added `fansi.ErrorMode` parameter, to control behavior when un-recognized Ansi escapes are found. ### 0.1.1