Andrey Stolyarov

Мой workflow работы с claude

Sun, 06 Jul 2025 00:00:00 +0000

Copy-Paste workflow для работы с Claude и кодом проекта

Мой workflow для взаимодействия с Claude при разработке: два скрипта на Scala, которые позволяют быстро передавать контекст проекта в Claude и получать обратно готовый код.

Идея

copy.scala - собирает весь проект в один файл для Claude

paste.scala - восстанавливает файлы из ответа Claude прямо в проект

Workflow

Подготовка контекста для Claude

 scala-cli copy.scala -- . output.txt

Получаем файл output.txt со всем кодом проекта:

// file: src/main/scala/Main.scala
object Main:
  def main(args: Array[String]): Unit =
  println("Hello!")
   
// file: build.sbt
name := "my-project"
scalaVersion := "3.6.4"

Работа с Claude

Вставляем output.txt в Project knowledge проекта claude.
Настройка промпта для Claude

Важно добавить промпт в claude проект Set project instructions:

При показе полных файлов из репозитория добавляй первой строкой комментарий // file: $path

claude будет отвечать в нужном формате
Применение изменений

Копируем ответ Claude в буфер обмена и выполняем:
```
clippaste | scala-cli run paste.scala
```
Необходимые директории создаются автоматически
```
Created file: src/main/scala/Main.scala
Created file: build.sbt
```
Готово! Все изменения применены к проекту.

copy.scala

//> using scala "3.6.4-RC1"
//> using jvm "17"
//> using dep "org.eclipse.jgit:org.eclipse.jgit:7.1.0.202411261347-r"
//> using dep "org.slf4j:slf4j-simple:2.0.17"

import java.io.File
import java.io.PrintWriter
import java.nio.charset.*
import java.nio.file.*
import org.eclipse.jgit.ignore.FastIgnoreRule
import scala.jdk.CollectionConverters.*
import scala.util.Failure
import scala.util.Success
import scala.util.Try
import scala.util.Using

object Copy:
  type PathPredicate = Path => Boolean

  enum RuleType:
    case Include, Exclude

  case class FilterRule(ruleType: RuleType, predicate: PathPredicate)
  case class ReplacementRule(from: String, to: String)

  object PathFilters:
    def containsInPath(substring: String): PathPredicate =
      p => p.toString.toLowerCase.contains(substring.toLowerCase)

    def hasFileName(name: String): PathPredicate =
      p => p.getFileName.toString.equalsIgnoreCase(name)

    def hasExtension(ext: String): PathPredicate =
      p => p.toString.toLowerCase.endsWith(ext.toLowerCase)

    def hasAnyExtension(extensions: Set[String]): PathPredicate =
      p => {
        val lcPath = p.toString.toLowerCase
        extensions.exists(ext => lcPath.endsWith(ext))
      }

    def keepOnlyExtensions(extensions: Set[String]): FilterRule =
      exclude(not(hasAnyExtension(extensions)))

    def or(predicates: PathPredicate*): PathPredicate =
      p => predicates.exists(pred => pred(p))

    def and(predicates: PathPredicate*): PathPredicate =
      p => predicates.forall(pred => pred(p))

    def not(predicate: PathPredicate): PathPredicate =
      p => !predicate(p)

    def include(predicate: PathPredicate): FilterRule =
      FilterRule(RuleType.Include, predicate)

    def exclude(predicate: PathPredicate): FilterRule =
      FilterRule(RuleType.Exclude, predicate)

  def applyReplacements(
    text: String,
    replacements: List[ReplacementRule]
  ): String =
    replacements.foldLeft(text) { (acc, rule) =>
      acc.replace(rule.from, rule.to)
    }

  def loadGitignoreRules(basePath: String): List[FastIgnoreRule] =
    val gitignorePath = Paths.get(basePath, ".gitignore")
    if Files.exists(gitignorePath) then
      Files
        .readAllLines(gitignorePath)
        .asScala
        .filterNot(_.trim.isEmpty)
        .filterNot(_.startsWith("#"))
        .map(pattern => new FastIgnoreRule(pattern))
        .toList
    else List.empty

  def shouldIgnore(path: String, rules: List[FastIgnoreRule]): Boolean =
    path.contains("/.git/") ||
      path.startsWith(".git/") ||
      rules.exists(_.isMatch(path, false))

  def shouldIncludePath(path: Path, filterRules: List[FilterRule]): Boolean =
    if filterRules.isEmpty then return false

    var include = false
    for rule <- filterRules do
      if rule.predicate(path) then include = rule.ruleType == RuleType.Include

    include

  def findFiles(
    basePath: String,
    gitRules: List[FastIgnoreRule],
    filterRules: List[FilterRule]
  ): List[Path] =
    val basePathObj = Paths.get(basePath)

    Files
      .walk(basePathObj)
      .iterator
      .asScala
      .filter(Files.isRegularFile(_))
      .filter(p => shouldIncludePath(p, filterRules))
      .filterNot(p =>
        val relativePath = basePathObj.relativize(p).toString
        shouldIgnore(relativePath, gitRules)
      )
      .toList
      .sortBy(_.toString)

  def readFile(path: Path): String =
    val encodings = List(
      StandardCharsets.UTF_8,
      StandardCharsets.ISO_8859_1,
      Charset.forName("windows-1251")
    )

    def tryRead(encoding: Charset): Try[String] =
      Try(Files.readString(path, encoding))

    encodings
      .foldLeft[Option[String]](None) { (result, encoding) =>
        result.orElse {
          tryRead(encoding) match
            case Success(content) => Some(content)
            case Failure(_)       => None
        }
      }
      .getOrElse {
        System.err.println(
          s"Warning: Could not read file ${path.toString}. Skipping."
        )
        s"// Could not read file due to encoding issues"
      }

  def generateText(
    basePath: String,
    filterRules: List[FilterRule],
    replacements: List[ReplacementRule] = List.empty
  ): String =
    val gitRules = loadGitignoreRules(basePath)
    val files = findFiles(basePath, gitRules, filterRules)

    println(s"Selected ${files.size} files for processing:")
    files.foreach(f => println(s"- ${f.toString.replace(basePath + "/", "")}"))

    val fileContents = files
      .map { path =>
        val relativePath = path.toString.replace(basePath + "/", "")
        val processedPath = applyReplacements(relativePath, replacements)
        val rawContent = readFile(path)
        val processedContent = applyReplacements(rawContent, replacements)

        s"// file: $processedPath\n$processedContent"
      }
      .mkString("\n\n")

    fileContents

  @main def run(args: String*): Unit =
    println(s"args = ${args}")
    val basePath = args.headOption.getOrElse(".")
    val output = args.lift(1).getOrElse("project-knowledge.txt")

    println(s"Generating project knowledge from $basePath to $output")

    import PathFilters.*
    import RuleType.*

    val replacements = List[ReplacementRule](
      ReplacementRule("myprojectname", "example"),
      ReplacementRule("com.mycompany", "com.example"),
      ReplacementRule("MyProjectName", "ExampleProject")
    )

    val filterRules = List[FilterRule](
      include(p => true),
      exclude(hasFileName("copy.scala")),
      exclude(hasFileName("paste.scala")),
      include(containsInPath("shared/shared")),
      keepOnlyExtensions(Set(".scala", ".sbt", ".css", ".md", ".cfg", ".yml", ".j2")),
    )

    val buildFilesRules = List[FilterRule](
      include(p => true),
      keepOnlyExtensions(Set(".sbt")),
      include(and(hasFileName("build.properties"), containsInPath("project")))
    )

    val text = generateText(basePath, filterRules, replacements)

    Using(new PrintWriter(output)) { writer =>
      writer.write(text)
    }.get

    println(s"Project knowledge generated successfully to $output")

Возможности copy.scala

Фильтрация файлов - исключаем тесты, build артефакты
Замена конфиденциальных данных - автоматически меняем название проекта, секретные ключи, пароли
Учет .gitignore - не включаем игнорируемые файлы

val replacements = List(
  ReplacementRule("mycompany", "example"),
  ReplacementRule("secret-key", "demo-key")
)

val filterRules = List(
  exclude(containsInPath("target")),
  exclude(containsInPath("src/test")),
  keepOnlyExtensions(Set(".scala", ".sbt", ".md"))
)

paste.scala

#!/usr/bin/env scala-cli

//> using scala "3.6.4"

import java.nio.file.Files
import java.nio.file.Paths
import java.nio.file.StandardOpenOption
import scala.collection.mutable.StringBuilder
import scala.io.StdIn

object Paste {
  case class ReplacementRule(from: String, to: String)

  private val FilePathPatterns = List(
    "//file:",
    "// file:",
    "//Файл:",
    "// Файл:",
    "-- file:",
    "-- Файл:",
    "# file:",
    "# Файл:",
    "<!-- file:",
    "<!-- Файл:",
    "/* file:",
    "/* Файл:"
  )

  def extractFilePath(line: String): Option[String] = {
    val trimmed = line.trim

    FilePathPatterns
      .find(pattern => trimmed.startsWith(pattern))
      .map { pattern =>
        val afterPattern = trimmed.substring(pattern.length)
        val cleanPath = if (pattern.startsWith("<!--")) {
          afterPattern.replaceAll("\\s*-->\\s*$", "")
        } else if (pattern.startsWith("/*")) {
           afterPattern.replaceAll("\\s*\\*/\\s*$", "")
        } else {
          afterPattern
        }
        cleanPath.trim
      }
  }

  def applyReplacements(
    text: String,
    replacements: List[ReplacementRule]
  ): String =
    replacements.foldLeft(text) { (acc, rule) =>
      acc.replace(rule.from, rule.to)
    }

  def writeFile(
    path: String,
    content: StringBuilder,
    replacements: List[ReplacementRule]
  ): Unit = {
    val processedPath = applyReplacements(path, replacements)
    val processedContent = applyReplacements(content.toString, replacements)

    val p = Paths.get(processedPath)

    Option(p.getParent).foreach(Files.createDirectories(_))

    Files.write(
      p,
      processedContent.getBytes,
      StandardOpenOption.CREATE,
      StandardOpenOption.TRUNCATE_EXISTING
    )
    println(s"Created file: $processedPath")
  }

  def main(args: Array[String]): Unit = {
    val replacements = List[ReplacementRule](
      ReplacementRule("myprojectname", "example"),
      ReplacementRule("com.mycompany", "com.example"),
      ReplacementRule("com/mycompany", "com/example"),
      ReplacementRule("MyProjectName", "ExampleProject")
    )

    var currentFilePath: Option[String] = None
    var currentContent = new StringBuilder

    var line = StdIn.readLine()
    while (line != null) {
      val filePath = extractFilePath(line)

      if (filePath.isDefined) {
        if (currentFilePath.isDefined) {
          writeFile(currentFilePath.get, currentContent, replacements)
          currentContent = new StringBuilder
        }

        currentFilePath = filePath
      } else if (currentFilePath.isDefined) {
        if (currentContent.nonEmpty) {
          currentContent.append("\n")
        }
        currentContent.append(line)
      }

      line = StdIn.readLine()
    }

    if (currentFilePath.isDefined) {
      writeFile(currentFilePath.get, currentContent, replacements)
    }
  }
}

Предупреждение

paste.scala перезаписывает существующие файлы. Перед выполнением следует делать commit.

log4cats. Почему нужно использовать LoggerFactory

Thu, 06 Mar 2025 00:00:00 +0000

Правильный подход к организации логирования с log4cats

При использовании log4cats велик соблазн передавать везде неявно Logger, в этом посте хочу показать как это сделать правильно.

Неправильный подход: Logger

Рассмотрим сначала распространенную, но не рекомендуемую практику — создание одного общего логгера и его передачу в компоненты приложения:

#!/usr/bin/env -S scala-cli shebang
//> using scala 2.13.12
//> using dep org.typelevel::log4cats-core:2.7.0
//> using dep org.typelevel::log4cats-slf4j:2.7.0
//> using dep ch.qos.logback:logback-classic:1.5.17

import cats.effect._
import org.typelevel.log4cats._
import org.typelevel.log4cats.slf4j.Slf4jFactory
import cats.syntax.all._

object LoggerExample extends IOApp.Simple {
  implicit val logging: LoggerFactory[IO] = Slf4jFactory.create[IO]

  class Service[F[_]: Async: Logger] {
    def doSomething(value: String): F[Unit] = 
      Logger[F].info(s"Service processing: $value")
  }

  class Application[F[_]: Async](implicit L: LoggerFactory[F]) {
    private val logger = L.getLogger
    
    implicit private val loggerInstance: Logger[F] = logger

    def run: F[Unit] = for {
      _ <- logger.info("Application starting")
      service = new Service[F]
      _ <- service.doSomething("test")
      _ <- logger.info("Application finished")
    } yield ()
  }

  def run: IO[Unit] = new Application[IO].run
}

Проблема данного подхода

Потеря информации о происхождении логов: все логи имеют одинаковый источник (LoggingExample.Application), что затрудняет отладку:

   [INFO] LoggingExample.Application - Application starting
   [INFO] LoggingExample.Application - Service processing: test  // Источник лога не Service
   [INFO] LoggingExample.Application - Application finished

Правильный подход: LoggerFactory в каждом классе

Более корректный подход — использование LoggerFactory для создания отдельных логгеров в каждом компоненте:

#!/usr/bin/env -S scala-cli shebang
//> using scala 2.13.12
//> using dep org.typelevel::log4cats-core:2.7.0
//> using dep org.typelevel::log4cats-slf4j:2.7.0
//> using dep ch.qos.logback:logback-classic:1.5.17

import cats.effect._
import org.typelevel.log4cats._
import org.typelevel.log4cats.slf4j.Slf4jFactory
import cats.syntax.all._

object LoggerFactoryExample extends IOApp.Simple {
  implicit val logging: LoggerFactory[IO] = Slf4jFactory.create[IO]

  class Service[F[_]: Async](implicit L: LoggerFactory[F]) {
    private val logger = L.getLogger
    
    def doSomething(value: String): F[Unit] = 
      logger.info(s"Service processing: $value")
  }

  class Application[F[_]: Async](implicit L: LoggerFactory[F]) {
    private val logger = L.getLogger

    def run: F[Unit] = for {
      _ <- logger.info("Application starting")
      service = new Service[F]
      _ <- service.doSomething("test")
      _ <- logger.info("Application finished")
    } yield ()
  }

  def run: IO[Unit] = new Application[IO].run
}

Результат логирования:

[INFO] LoggingExample.Application - Application starting
[INFO] LoggingExample.Service - Service processing: test  // Источник лога правильный
[INFO] LoggingExample.Application - Application finished

Выводы

Использование LoggerFactory в каждом классе предпочтительнее по следующим причинам:

Точное указание источника логов: легко определить, какой компонент создал лог-запись
Гибкость конфигурирования: возможность настройки различных уровней логирования для отдельных компонентов

TodoApp. scala-cli + http4s

Sat, 27 Jan 2024 00:00:00 +0000

Представленный код - это сниппет TODO-приложения. Он написан для Scala CLI, включает все необходимые зависимости и готов к запуску как есть. В коде используются HTTP4S и Circe. Сниппет демонстрирует создание простого REST API для управления задачами: добавление, просмотр и удаление задач.

Код http4s-сервера для TODO-сервиса

#!/usr/bin/env scala-cli

//> using scala "2.12"
//> using dep "org.http4s::http4s-ember-server:1.0.0-M30"
//> using dep "org.http4s::http4s-dsl:1.0.0-M30"
//> using dep "org.typelevel::log4cats-slf4j:2.6.0"
//> using dep "ch.qos.logback:logback-classic:1.4.14"
//> using dep "io.circe::circe-generic:0.14.1"
//> using dep "org.http4s::http4s-circe:1.0.0-M30"

import cats.effect._
import org.http4s._
import org.http4s.dsl.io._
import cats.syntax.all._
import com.comcast.ip4s._
import org.http4s.ember.server._
import org.http4s.implicits._
import org.http4s.server.Router
import org.typelevel.log4cats.LoggerFactory
import org.typelevel.log4cats.slf4j.Slf4jFactory
import scala.concurrent.duration._
import org.http4s.server.Server
import io.circe.generic.auto._
import org.http4s.circe._


class TodoList(ref: Ref[IO, List[TodoApp.TodoItem]]) {
  import TodoApp._
  private var nextId = 1

  def addTask(task: String): IO[TodoItem] = {
    val newItem = TodoItem(nextId, task)
    nextId += 1
    ref.update(newItem :: _) *> IO.pure(newItem)
  }

  def getAllTasks: IO[TodoListResponse] = ref.get.map(TodoListResponse)

  def removeTask(id: Int): IO[Option[TodoItem]] = {
    ref.modify { todos =>
      val (remaining, removed) = todos.partition(_.id != id)
      (remaining, removed.headOption)
    }
  }
}

object TodoApp extends IOApp.Simple {

  import org.http4s.circe.CirceEntityCodec._
  
  case class TodoItem(id: Int, task: String)
  case class CreateTodoItem(task: String)
  case class TodoListResponse(todos: List[TodoItem])

  val todoList: IO[TodoList] =
    Ref.of[IO, List[TodoItem]](List.empty).map(new TodoList(_))

  val server: IO[Resource[IO, Server]] = todoList.map { list =>
    val todoService = HttpRoutes.of[IO] {
      case req @ POST -> Root / "todo" =>
        for {
          createItem <- req.as[CreateTodoItem]
          item <- list.addTask(createItem.task)
          resp <- Ok(item)
        } yield resp

      case GET -> Root / "todo" =>
        list.getAllTasks.flatMap(Ok(_))

      case DELETE -> Root / "todo" / IntVar(id) =>
        list.removeTask(id).flatMap {
          case Some(item) => Ok(item)
          case None       => NotFound()
        }
    }

    val httpApp = Router("/" -> todoService).orNotFound
    EmberServerBuilder
      .default[IO]
      .withHost(ipv4"0.0.0.0")
      .withPort(port"8080")
      .withHttpApp(httpApp)
      .build
  }

  override def run: IO[Unit] =
    server.flatMap(_.use(_ => IO.never))
}

Запросы к сервису (curl)

Для тестирования приложения можно воспользоваться следующими запросами:

Добавление задачи в список TODO:

 curl -X POST -H "Content-Type: application/json" -d '{"task":"Новая задача"}' http://localhost:8080/todo

Получение списка всех задач:
```
 curl -X GET http://localhost:8080/todo
```

Удаление задачи из списка:

 curl -X DELETE http://localhost:8080/todo/{id}

Клиент http4s-blaze-client

#!/usr/bin/env scala-cli

//> using scala "2.12"
//> using lib "org.http4s::http4s-blaze-client:1.0.0-M30"
//> using lib "org.http4s::http4s-circe:1.0.0-M30"
//> using lib "io.circe::circe-generic:0.14.1"
//> using lib "org.typelevel::cats-effect:3.5.3"
//> using dep "ch.qos.logback:logback-classic:1.4.14"

import cats.effect._
import org.http4s._
import org.http4s.client._
import org.http4s.client.blaze._
import org.http4s.circe._
import org.http4s.client.dsl.io._
import io.circe.generic.auto._
import io.circe.syntax._


object TodoClientApp extends IOApp.Simple {

   case class CreateTodoItem(task: String)
   case class TodoItem(id: Int, task: String)
   case class TodoListResponse(todos: List[TodoItem])

   implicit val todoItemDecoder: EntityDecoder[IO, TodoItem] =
      jsonOf[IO, TodoItem]
   implicit val todoListDecoder: EntityDecoder[IO, TodoListResponse] =
      jsonOf[IO, TodoListResponse]
   implicit val createTodoItemEncoder: EntityEncoder[IO, CreateTodoItem] =
      jsonEncoderOf[CreateTodoItem]

   def run(): IO[Unit] = {
      val uri = Uri.uri("http://localhost:8080/todo")

      val clientResource = BlazeClientBuilder[IO].resource

      clientResource.use { client =>
         for {
            postResp <- client.expect[TodoItem](
               Request[IO](Method.POST, uri)
                       .withEntity(CreateTodoItem("buy milk").asJson)
            )
            _ <- IO(println(s"New todo: ${postResp.asJson}"))
            
            getResp <- client.expect[TodoListResponse](uri)
            _ <- IO(println(s"List todoes: ${getResp.asJson}"))

            deleteResp <- client.expect[TodoItem](
               Request[IO](Method.DELETE, uri / postResp.id.toString)
            )
            _ <- IO(println(s"Deleted todo: ${deleteResp.asJson}"))
         } yield ()
      }
   }
}

Заключение

В этой статье я представил сниппеты для сервера и клиента, использующих HTTP4S, а также CURL-запросы для взаимодействия с сервером

Несколько аккаунтов github на одном компьютере

Sat, 11 Feb 2023 00:00:00 +0000

Статья про настройку ssh ключей для работы с разных GitHub аккаунтов на одном компьютере (macOs) Подобных статей в интеренте и без меня достаточно. Основная часть везде одинакова, но есть особенности моего исползования.

Дисклеймер

Аккаунт с именем account2 существует на гитхабе, это не мой. Я его просто для примера использую.

macOs

Некоторые части этой статьи специфичны для macOs. Например, параметр --apple-use-keychain в ssh-add.

Отключить автоматические name & email при коммитах

Не рекомендую использовать глобальные переменные git при работе с несколькими аккаунтами. Очень легко ошибиться и закоммитить с неправильным именем/мэйлом. Удалить глобальные переменные и запретить генерировать следующими командами:

git config --global --unset-all user.name
git config --global --unset-all user.email
git config --global user.useConfigOnly true

user.useConfigOnly - отключает автоматическую генерацию name, email для git пользователя
–unset-all удаляет параметры из глобальной конфигурации

Создать отдельный аккаунт на гитхабе

На один gmail можно создать больше одного аккаунта. Например, для мэйла example@gmail.com можно указать example+account2@gmail.com. Письмо с подтверждением придёт на основной ящик.

Создание ssh ключа

cd ~/.ssh
ssh-keygen -t ed25519 -C "example+account2@gmail.com" -f account2

-f путь, по которому будет сохранен приватный ключ. Публичный будет создан рядом с расширением .pub

ПАРОЛЬ СТАВИМ СЛОЖНЫЙ. НЕ ОСТАВЛЯЕМ КЛЮЧ БЕЗ ПАРОЛЯ. Пароль сохранится в keychain, его не придётся вводить каждый раз заново.

Редактируем конфиг ssh

Добавляем аккаунт в конфиг

~/.ssh/config

Host github-account2
    HostName github.com
    User git
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/id_ed25519_account2

Добавляем ПУБЛИЧНЫЙ ssh ключ на GitHub

Копируем в буфер обмена публичный ключ:

pbcopy < ~/.ssh/id_ed25519_account2.pub

Добавляем ключ на GitHub:

Settings > SSH and GPG keys > New SSH Key

После добавления, публичный ключ окажется в открытом доступе по ссылке:

https://github.com/{username}.keys

ssh-add

Добавляем ключ в keychain, вводим пароль. Это нужно, что бы не вводить пароль каждый раз.

ssh-add --apple-use-keychain ~/.ssh/id_ed25519_account2

git clone

Дойдя до этой части статьи, уже можно клонировать репозиторий, используя ssh ключ.

git clone git@github-account2:account2/test.git

Хост в урле соответствует параметру Host из ssh конфига (про него выше).

git clone https -> ssh

Для удобства, можно настроить автоматическое переписывание https урла на ssh

~/.gitconfig

[url "ssh://git@account2/account2"]
   insteadOf = https://github.com/account2

С такой настройкой https://github.com/account2/test.git перепишется на git@github-account2:account2/test.git

Можно будет копировать https ссылки в ui гитхаба, а клонироваться они будут по ssh. Это избавит от ручного написания урла с кастомным хостом.

Устанавливаем user.name и user.email на все проекты пользователя

Воспользуемся фичей гита Conditional includes, появившейся в git 2.13

Добавляем:

~/.gitconfig

[includeIf "gitdir:~/ghq/github.com/account2/"]
    path = ~/.gitconfig-account2

~/.gitconfig-account2

[user]
    name = Your Username
    email = YourEmail@example.com

Для каждого нового пользователя - свой файлик с конфигом и строка includeIf в .gitconfig

ghq

ghq - Утилита для клонирования репозиториев в правильное место на диске

ghq get https://github.com/account2/test.git

Результатом выполнения команды будет склонированный репозиторий в директорию ~/ghq/github.com/account2/test

После настройки переписывания урла из https в ssh - работает автоматически.

Почему работает:

Утилита берет url, который ей передали и на основе него формирует локальный путь к репозиторию
Запускает процесс git clone с https урлом
git смотрит в файл .gitconfig видит там замену https на ssh
репозиторий клонируется с помощью ssh, но в локальную директорию, как будто это https репозиторий

Поиск задач в jira с помощью Chrome Site Search

Sat, 11 Feb 2023 00:00:00 +0000

В браузерах на базе Chromium есть возможность добавить поиск по любому сайту. Достаточным условием является возможность указать поисковую строку в URL. В этой статье я покажу, как искать задачи в jira таким способом. Более продвинутый поиск можно сделать через скрипты Raycast. Например, для поиска на сайте https://mvnrepository.com/ можно задать алиас mvn и искать сразу из поисковой строки браузера. (в строке поиска пишем mvn TAB запрос)

Как добавить сайт в Chrome Site Search

В google-chrome открываем настроики:

Settings - Search Engine - Manage search engines and site search - Site Search - Add

Для примера с mvn repository вводим следующее:

Search engine: mvnrepository
Shortcut: mvn
URL with %s in place of query: https://mvnrepository.com/search?q=%s

Site Search для JIRA

Поисковая строка для JIRA выглядит сложнее чем для других сайтов. Написать её руками и не ошибиться - дело не простое. Воспользуюсь скриптом. Буду искать issue в проекте zookeeper.

from urllib.parse import urlencode

base_url = 'https://issues.apache.org/jira'
project = 'ZOOKEEPER'

issuekey = '%s'
terms = [
    f'issuekey={project}-REPLACE',
    f'issue in linkedIssues({project}-REPLACE)',
    f'text ~ "{project}-REPLACE"',
    f'issueFunction in linkedIssuesOfAll("issuekey={project}-REPLACE")'
]
jql = ' or '.join(terms)
query_string = urlencode({'jql': jql})  
url = f'{base_url}/browse/{project}-REPLACE/?' + query_string  
url_with_placeholder = url.replace('REPLACE', issuekey)  
print(url_with_placeholder)

Скрипт создаст следующую строку:

https://issues.apache.org/jira/browse/ZOOKEEPER-%s/?jql=issuekey%3DZOOKEEPER-%s+or+issue+in+linkedIssues%28ZOOKEEPER-%s%29+or+comment+~+%22ZOOKEEPER-%s%22+or+text+~+%22ZOOKEEPER-%s%22+or+issueFunction+in+linkedIssuesOfAll%28%22issuekey%3DZOOKEEPER-%s%22%29

Меняем base_url и project и получаем строку для своей jira. В скрипт можно легко добавить свои критерии поиска или убрать лишние.

issuekey поиск по номеру задачи
issue in linkedIssues задачи, которые ссылаются на искомую задачу
text есть упоминание номера задачи в разделах: Summary, Description, Environment, Comments
issueFunction in linkedIssuesOfAll - задачи, на которые ссылается искомая задача (Как issue in linkedIssues, но в обратную сторону)

Добавляем в chrome и пользуемся

Моя шпаргалка по ffmpeg

Tue, 14 Jun 2022 00:00:00 +0000

ffmpeg - набор библиотек для обработки аудио и видео. Шпаргалка содержит примеры консольных команд и примеры кода с использованием python библиотеки ffmpeg-python

Аргументы

-map_metadata 0 переносит “известные” метаданные, такие как create date. Кастомные теги не переносятся (Location, Android Version, Android Capture Fps итд)
-movflags use_metadata_tags Перенос кастомных ключей метаданных

Конкатенация видео

Создать файл join.txt

file 1.mp4
file 2.mp4
file 3.mp4

ffmpeg -f concat -safe 0 -i join.txt -c copy joined.mp4

При конкатенации возникают предупреждения вида: [mp4 @ 0x7ff9f8436380] Non-monotonous DTS in output stream 0:0; previous: 4399686, current: 4399684; changing to 4399687. This may result in incorrect timestamps in the output file.

На стековерфлоу есть вариант исправления, но он перекодирует видео.

Поворот видео

Поворот без перекодировки видео. Сохраняет информацию о повороте в метаданные.

ffmpeg -ss 00:01:00 -to 00:02:00 -i in.mp4 -map_metadata 0 -movflags use_metadata_tags -c copy out.mp4

Разрезать видео (python)

import os

import ffmpeg

inputfile = 'video.mp4'
fragments = [
    ('00:05', '00:10'),
    ('00:15', '00:20'),
]
for i, (start, end) in enumerate(fragments):
    filename, file_extension = os.path.splitext(inputfile)
    newfilename = f'{filename}_cut{i + 1}{file_extension}'
    stream = ffmpeg.input(inputfile, ss=start, to=end)
    stream = ffmpeg.output(
        stream,
        newfilename,
        codec='copy',
        movflags='use_metadata_tags',
        map_metadata='0'
    )
    print(stream.get_args())
    if not os.path.exists(newfilename):
        stream.run()
    else:
        print(f'skip {newfilename}')

Извлечь аудио:

без перекодировки:

ffmpeg -i video.mp4 -vn -acodec copy audio.m4a

преобразовать в mp3:

ffmpeg -i video.mp4 -f mp3 -ab 192000 -vn audio.mp3

Самоподписанный сертификат

Sat, 26 Mar 2022 00:00:00 +0000

Инструкция по созданию сертификата SSL(TLS) консольной утилитой openssl.

Создание центра сертификации (CA – Certificate Authority)

Создание ключа:

openssl genrsa -aes256 -out CA.key 4096

-out CA.key - корневой ключ.
-aes256 - установка пароля на ключ. Рекомендуется устанавливать

Создание сертификата:

openssl req -x509 -new -nodes -key CA.key -sha256 -days 18250 -out CA.pem

Вводим пароль от корневого ключа. Нужно заполнить поле Common Name (eg, fully qualified host name), остальное - опционально.

CA.pem - корневой сертификат
-x509 - output a x509 structure instead of a cert. req
-new - new request.
-nodes - don’t encrypt the output key
-key file - use the private key contained in file
-days - number of days a certificate generated by -x509 is valid for. (18250 дней == 50 лет)

Установка сертификата в систему

macos добавление сертификата в keychain:

sudo security add-trusted-cert -d -r trustRoot -k "/Library/Keychains/System.keychain" CA.pem

macos удаление сертификата из keychain:

sudo security remove-trusted-cert -d CA.pem

ubuntu:

sudo apt-get update
sudo apt-get install -y ca-certificates
openssl x509 -outform der -in CA.pem -out CA.crt
sudo cp CA.crt /usr/local/share/ca-certificates
sudo update-ca-certificates

Создание серверного ключа

export DOMAIN=domain.example.com
openssl genrsa -out "$DOMAIN.key" 2048

-aes256 - установка пароля на ключ. В примере этот параметр упущен. Если поставить пароль, его придётся вводить при старте приложения (или прописывать в конфигах путь к файлу с паролем).

Создание серверного сертификата

Установим переменную DOMAIN. Должен соответствовать вашему домену

export DOMAIN=domain.example.com

Переменная DOMAIN используется в дальнейших командах.

openssl req -new -key "$DOMAIN.key" -out "$DOMAIN.csr" -subj "/CN=$DOMAIN"

-subj - Избавляет от интерактивного ввода информации о домене. Можно упустить этот аргумент

cat > "$DOMAIN.ext" << EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names

[alt_names]
DNS.1 = ${DOMAIN}
EOF

openssl x509 -req -in "$DOMAIN.csr" -CA CA.pem -CAkey CA.key -CAcreateserial -out "$DOMAIN.crt" -days 397 -sha256 -extfile "$DOMAIN.ext"

-req - input is a certificate request, sign and output.
-in arg - input file - default stdin
-CA arg - set the CA certificate, must be PEM format.
-extfile - configuration file with X509V3 extensions to add
-CAkey arg - set the CA key, must be PEM format
-CAcreateserial - create serial number file if it does not exist
-out arg - output file - default stdout
-days arg - How long till expiry of a signed certificate - def 30 days
-extfile - configuration file with X509V3 extensions to add

Сетап макбука

Fri, 10 Dec 2021 00:00:00 +0000

Установка обновлений

Apple menu () > About This Mac > Software Update.

Шифрование диска FileVault

Security & privacy -> FileVault
Click the lock to make changes
Turn On FileVault

Установка Homebrew

https://brew.sh

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Отключение Google Analytics. Зачем Homebrew аналитика

brew analytics off

yadm

grep -q zshrc_local ~/.zshrc || mv ~/.zshrc{,_legacy}
brew install yadm
yadm clone https://github.com/d10xa/dotfiles.git
yadm bootstrap

Клавиатура

System Settings -> Keyboard -> Keyboard Shortcuts -> Function Keys

Use F1, F2, etc. keys as standard function keys

⚠️ Modifier Keys нужно настраивать для внешних клавиатур отдельно.

Keyboard -> Keyboard Shortcuts -> Modifier Keys

Keyboard -> Shortcuts -> Spotlight

Убрать галки:

show spotlight search

show finder search window

Keyboard -> Text (На более свежих macOs: Text Input -> Edit…)

Убрать галки:

Correct spelling automatically

Capitalise words automatically

Add full stop with double-space

(Если есть Touch Bar) Touch Bar typing suggestions

Use smart quotes and dashes

Keyboard -> Shortcuts -> Input Sources

Select the previous input source

Select next source in Input menu ⌘Space

Trackpad

Silent clicking

Point & Click -> Tracking speed -> 6/10

Turn display off

System Settings -> Lock Screen -> Turn display off on power adapter when inactive: for 30 minutes

System Settings -> Battery -> Options… -> Wake for network access -> Never

Убрать громкий звук при старте

System Settings -> Sound ->

Play sound on startup

Lock gesture

System Settings -> Lock Screen -> Start Screen Saver when inactive -> For 30 minutes

System Settings -> Desktop & Dock -> Hot Corners… -> Start Screen Saver

System Settings -> Require password after screen saver begins or display is turned off -> [Immediately]

Screenshots

mkdir ~/Documents/Screenshots
defaults write com.apple.screencapture location "$HOME/Documents/Screenshots"

App Store

Установить:

Blackmagic Disk Speed Test 4+

Finder

Добавить в боковую панель (Favourites):

~
~/ghq/
~/ghq/github.com/

jetbrains-toolbox

mkdir "${HOME}/bin"
echo "${HOME}/bin" # Вывод этой команды скопировать

jetbrains-toolbox -> Settinmgs -> Shell scripts location: вставить сюда

Дописать в ~/.zshrc

export PATH="$PATH:${HOME}/bin"

В idea установить плагины:

Scala
String Manipulation

Settings -> Tools -> Terminal -> Configure terminal keybindings -> Plugins -> Terminal -> Switch Focus To Editor убрать шорткат для Escape через контекстное меню

iterm

https://iterm2.com/documentation-shell-integration.html

Iterm2 -> Install Shell Integration

Prefs -> General -> Closing

Confirm Quit iTerm2

Dock

System Settings -> Dock & Menu Bar

Automatically hide and show the Dock

always open with

На файле с нужным расширением открыть контекстное меню
Get Info
Open with: выбрать приложение
Change All…

Изменение применится ко всем файлам такого формата

Форматы, для которых следует изменить open with приложение:

.mp4 -> vlc

Тесты с временной директорией

Sun, 29 Aug 2021 00:00:00 +0000

Если ваш код работает с файлами, для его тестирования нужны временные директории. Директории нужно создавать, наполнять тестовым содержимым и удалять после прогона тестов.

Тесты с временными файлами я неоднократно писал на java, groovy и даже на scala. В этот раз решил зафиксировать в блоге scala реализацию (Да, что бы копипастить в следующие проекты).

В посте покажу 2 реализации:

грязные функции с эксэпшенами
F[_]: Sync и cats.effect.Resource

Грязные функции

Начинаем с проектирования. Для тестов мне нужны только текстовые файлы, поэтому метод будет принимать varargs с именами файлов и содержимым. Имя файла и контент пусть будут строками (В тестах обойдусь без refined и имплиситов)

Сигнатура функции может выглядеть следующим образом:

def withTempDirectory[A](files: (String, String)*)(f: Path => A): A

Пример теста:

val sum: Int = withTempDirectory(
  "dir1/a.txt" -> "1",
  "dir2/b.txt" -> "2"
)(path =>
  Files
    .walk(path)
    .iterator()
    .asScala
    .filter(Files.isRegularFile(_))
    .map(Files.readString)
    .map(_.toInt)
    .sum
)
assert(sum == 3)

Начнём со вспомогательных функций.

Удаление непустой директории. Метод postVisitDirectory вызывается, когда на всех внутренних файлах уже был вызван visitFile.

def deleteDirectoryRecursively(path: Path): Unit =
  Files.walkFileTree(
    path,
    new SimpleFileVisitor[Path] {
      override def postVisitDirectory(
          dir: Path,
          exc: IOException
      ): FileVisitResult = {
        Files.delete(dir)
        FileVisitResult.CONTINUE
      }
      override def visitFile(
          file: Path,
          attrs: BasicFileAttributes
      ): FileVisitResult = {
        Files.delete(file)
        FileVisitResult.CONTINUE
      }
    }
  )

Проверка, что удаляемый файл находится внутри временной директории. Для путей вида dir2/../dir1/b.txt необходима нормализация.

def isInside(parent: Path, child: Path): Boolean =
  child
    .normalize()
    .toAbsolutePath
    .startsWith(parent.normalize().toAbsolutePath)

Создание родительских директорий и запись текста в файл

def write(
    path: Path,
    text: String,
    openOptions: Seq[OpenOption] = Seq.empty,
    charset: Charset = Charset.defaultCharset()
): Path =
  Files.createDirectories(path.getParent)
  Files.write(path, text.getBytes(charset), openOptions: _*)

Вспомогательные функции готовы, переходим к реализации withTempDirectory.

Создаём временную директорию
Создаём файлы внутри
В случае успеха, выполняем пользовательскую функцию
Удаляем директорию, даже если не удалось создать файлы или произошла ошибка в пользовательской функции

def withTempDirectory[A](files: (String, String)*)(f: Path => A): A =
  val dir = Files.createTempDirectory("java_nio_tmp_dir")
  val t = Try {
    files.foreach { case (localPath, content) =>
      val resolved = dir.resolve(localPath)
      if (!isInside(dir, resolved))
        throw new IllegalArgumentException(
          s"child file is outside of parent directory (${dir.toString}, ${resolved.toString})"
        )
      write(resolved, content)
    }
  }
  val tryResult = t.map(_ => f(dir))
  deleteDirectoryRecursively(dir)
  tryResult.get

котоэффекты

Для тестовой директории идеально подходит cats.effect.Resource:

def tempDirectory(files: (String, String)*): Resource[F, Path]

Котовые ресурсы можно мапить в нужный для тестов тип, например java.io.File:

def tempDirectoryJavaFile(
  files: (String, String)*
): Resource[F, java.io.File] =
  tempDirectory(files: _*).map(_.toFile)

Код тестов несколько изменился:

FilesF[IO]
  .tempDirectory(
    "dir1/a.txt" -> "1",
    "dir2/b.txt" -> "2"
  )
  .use(path =>
    Sync[IO].interruptible(true)(
      Files
        .walk(path)
        .iterator()
        .asScala
        .filter(Files.isRegularFile(_))
        .map(Files.readString)
        .map(_.toInt)
        .sum
    )
  )
  .flatMap { sum =>
    IO(assert(sum == 3))
  }

Следующий код повторяет код из грязных функций выше, но теперь функции возвращают F[_].

import cats.effect.IO
import cats.effect.IOApp
import cats.effect.Resource
import cats.effect.Sync
import cats.syntax.all.*

import java.io.IOException
import java.nio.charset.Charset
import java.nio.file.FileVisitResult
import java.nio.file.Files
import java.nio.file.OpenOption
import java.nio.file.Path
import java.nio.file.SimpleFileVisitor
import java.nio.file.attribute.BasicFileAttributes

class FilesF[F[_]: Sync]:
  def deleteDirectoryRecursively(path: Path): F[Unit] =
    Sync[F].interruptible(true) {
      Files.walkFileTree(
        path,
        new SimpleFileVisitor[Path] {
          override def postVisitDirectory(
              dir: Path,
              exc: IOException
          ): FileVisitResult = {
            Files.delete(dir)
            FileVisitResult.CONTINUE
          }

          override def visitFile(
              file: Path,
              attrs: BasicFileAttributes
          ): FileVisitResult = {
            Files.delete(file)
            FileVisitResult.CONTINUE
          }
        }
      )
    }

  def createDirectories(path: Path): F[Unit] =
    Sync[F].delay(Files.createDirectories(path.getParent))

  def createTempDirectory(): F[Path] =
    Sync[F].delay(Files.createTempDirectory("java_nio_tmp_dir"))

  def write(
      path: Path,
      text: String,
      openOptions: Seq[OpenOption] = Seq.empty,
      charset: Charset = Charset.defaultCharset()
  ): F[Unit] =
    for
      _ <- createDirectories(path)
      _ <- Sync[F].interruptible(true) {
        Files.write(path, text.getBytes(charset), openOptions: _*)
      }
    yield ()

  def isInside(parent: Path, child: Path): Boolean =
    child
      .normalize()
      .toAbsolutePath
      .startsWith(parent.normalize().toAbsolutePath)

  def fillDirectory(dir: Path, files: (String, String)*): F[Unit] =
    files.traverse_ { case (localPath, content) =>
      val resolved = dir.resolve(localPath)
      if (!isInside(dir, resolved))
        Sync[F].raiseError[Unit](
          new IllegalArgumentException(
            s"child file is outside of parent directory (${dir.toString}, ${resolved.toString})"
          )
        )
      else
        write(resolved, content)
    }

  def tempDirectory(files: (String, String)*): Resource[F, Path] =
    def acquire: F[Path] =
      for
        dir <- createTempDirectory()
        _ <- fillDirectory(dir, files: _*)
      yield dir
    Resource.make[F, Path](acquire)(deleteDirectoryRecursively)

Если не нравится оборачивать каждое использование java.nio в Sync, есть библиотека, делающая это за вас "io.github.akiomik" %% "cats-nio-file"

Отдельный проект на github я не создавал под эти примеры.

Парсинг зависимостей из sbt файлов

Tue, 13 Apr 2021 00:00:00 +0000

Опишу одну из доработок sbt парсера для проекта jadd. Парсер основан на scalameta и занимается вытаскиванием зависимостей из build файлов проекта.

Зачем пишу эту статью?

Я нашел и исправил пару багов пока писал. Значит, пишу не зря. Это не последнее изменение sbt парсера в этом проекте и мне самому будет полезно перечитать этот пост спустя некоторое время.

Предыстория

Имплементация №1 была на antlr + регулярные выражения. Я пытался сделать валидный lexer+parser для sbt, у меня не получилось довести это до рабочего состояния и я решил упростить себе задачу. Я регулярками доставал куски кода, похожие на зависимости и отдавал их простенькому antlr парсеру. Версии в sbt зависимостях иногда выносят в переменные (иногда в другие файлы, в директории project), их я доставал регулярками и подставлял в нужные места(ну или не всегда нужные) Эта реализация была очень даже рабочей, несмотря на костыльность.

Имплементация №2. Объявления модулей и версии доставались уже не регулярками и antlr, а более удобным способом - паттерн матчингом на Scalameta деревьях. Версии библиотек точно так же искались по совпадению имени переменной.

better sbt parser

https://github.com/d10xa/jadd/pull/358

Это уже 3я по счету имплементация одного и того же.

Цель: уметь парсить более сложные объявления зависимостей. Например, такие:

val versions = new {
  val x = new {
    val v = "1"
  }
}
libraryDependencies += "a" %% "b" % versions.x.v

Из этого кода нужно вытащить "a" %% "b" %% "1", и при этом запомнить местоположение объявления константы "1", для дальнейшей модификации.

Упрощенное дерево SbtTree

В билд файлах есть не только объявление зависимостей, но и много “лишнего”. Я добавил свою структуру, повторяющую дерево из scalameta, но без шума.

SbtTree это sealed trait - упрощенное дерево для поиска зависимостей. Оно состоит из Scope, Module, Value.

Scope - деревьев общего вида.
Module - объявление зависимости (“a” % “aa” % aVersion)
Value - объявление строковой переменной (val aVersion = “3”)

Действия по шагам

Взял для примера такой исходный код файла build.sbt:

val versions = new {
  val aVersion = "1" // not used
  val bVersion = "2"
}
val dependencies = {
  val aVersion = "3"
  val bVersion = "4" // not used
  val depA = "a" % "aa" % aVersion
  val depB = "b" % "bb" % versions.bVersion
}

Зависимость a:aa должна подставить aVersion из ближайшей области видимости, то есть значение 3. Зависимость b:bb из текущей области видимости ничего подставить не может, но чуть выше есть подходящий объект versions, внутри которго объявлена константа bVersion со значением 2 - то, что надо.

Схема создана помочь верхнеуровнево понять действия при парсинге, который я подробнее опишу по шагам ниже.

В дальнейшем я пользуюсь библиотекой pprint для вывода в удобочитаемом виде case class’ов. (Дальше код не всегда валидный, например Self(name = , decltpe = None), но это output от pprintln как есть)

Распарсил исходник с помощью scalameta и получил AST:

Source(
  stats = List(
    Defn.Val(
      mods = List(),
      pats = List(Pat.Var(name = Term.Name(value = "versions"))),
      decltpe = None,
      rhs = Term.NewAnonymous(
        templ = Template(
          early = List(),
          inits = List(),
          self = Self(name = , decltpe = None),
          stats = List(
            Defn.Val(
              mods = List(),
              pats = List(Pat.Var(name = Term.Name(value = "aVersion"))),
              decltpe = None,
              rhs = Lit.String(value = "1")
            ),
            Defn.Val(
              mods = List(),
              pats = List(Pat.Var(name = Term.Name(value = "bVersion"))),
              decltpe = None,
              rhs = Lit.String(value = "2")
            )
          ),
          derives = List()
        )
      )
    ),
    Defn.Val(
      mods = List(),
      pats = List(Pat.Var(name = Term.Name(value = "dependencies"))),
      decltpe = None,
      rhs = Term.Block(
        stats = List(
          Defn.Val(
            mods = List(),
            pats = List(Pat.Var(name = Term.Name(value = "aVersion"))),
            decltpe = None,
            rhs = Lit.String(value = "3")
          ),
          Defn.Val(
            mods = List(),
            pats = List(Pat.Var(name = Term.Name(value = "bVersion"))),
            decltpe = None,
            rhs = Lit.String(value = "4")
          ),
          Defn.Val(
            mods = List(),
            pats = List(Pat.Var(name = Term.Name(value = "depA"))),
            decltpe = None,
            rhs = Term.ApplyInfix(
              lhs = Term.ApplyInfix(
                lhs = Lit.String(value = "a"),
                op = Term.Name(value = "%"),
                targs = List(),
                args = List(Lit.String(value = "aa"))
              ),
              op = Term.Name(value = "%"),
              targs = List(),
              args = List(Term.Name(value = "aVersion"))
            )
          ),
          Defn.Val(
            mods = List(),
            pats = List(Pat.Var(name = Term.Name(value = "depB"))),
            decltpe = None,
            rhs = Term.ApplyInfix(
              lhs = Term.ApplyInfix(
                lhs = Lit.String(value = "b"),
                op = Term.Name(value = "%"),
                targs = List(),
                args = List(Lit.String(value = "bb"))
              ),
              op = Term.Name(value = "%"),
              targs = List(),
              args = List(
                Term.Select(
                  qual = Term.Name(value = "versions"),
                  name = Term.Name(value = "bVersion")
                )
              )
            )
          )
        )
      )
    )
  )
)

С таким деревом сложно работать, слишком много шума. Преобразую структуру в SbtTree(описал выше), выкинув всё “лишнее”. Функция eval занимается паттерн матчингом кода. Ищет объявление зависимостей (“a” % “aa” % v) или строк(val v = “1”). Преобразует scala.meta.Tree в Option[SbtTree] игнорируя всё “лишнее”

Vector(
  Scope(
    name = None,
    items = Vector(
      Scope(
        name = Some(value = "versions"),
        items = Vector(
          Value(path = Vector("aVersion"), value = "1"),
          Value(path = Vector("bVersion"), value = "2")
        )
      ),
      Scope(
        name = Some(value = "dependencies"),
        items = Vector(
          Scope(
            name = None,
            items = Vector(
              Value(path = Vector("aVersion"), value = "3"),
              Value(path = Vector("bVersion"), value = "4"),
              Scope(
                name = Some(value = "depA"),
                items = Vector(
                  Module(
                    groupId = LitString(value = "a"),
                    percentsCount = 1,
                    artifactId = LitString(value = "aa"),
                    version = TermNameCompound(values = Vector("aVersion")),
                    terms = List()
                  )
                )
              ),
              Scope(
                name = Some(value = "depB"),
                items = Vector(
                  Module(
                    groupId = LitString(value = "b"),
                    percentsCount = 1,
                    artifactId = LitString(value = "bb"),
                    version = TermNameCompound(values = Vector("versions", "bVersion")),
                    terms = List()
                  )
                )
              )
            )
          )
        )
      )
    )
  )
)

Вложенность Scope глубже чем хотелось бы, и нужные версии не всегда лежат в пределах одной области видимости (Scope). Функция loopReduce выносит все элементы дерева ближе к корню и делает это до тех пор, пока дерево не перестанет меняться, попутно проставляя версии, лежащие в рамках одной Scope(обратить внимание на зависимость a:aa)

Scope(
  name = None,
  items = Vector(
    Value(path = Vector("versions", "aVersion"), value = "1"),
    Value(path = Vector("versions", "bVersion"), value = "2"),
    Scope(
      name = Some(value = "dependencies"),
      items = Vector(
        Scope(
          name = None,
          items = Vector(
            Value(path = Vector("aVersion"), value = "3"),
            Value(path = Vector("bVersion"), value = "4"),
            Module(
              groupId = LitString(value = "a"),
              percentsCount = 1,
              artifactId = LitString(value = "aa"),
              version = LitString(value = "3"),
              terms = List()
            ),
            Module(
              groupId = LitString(value = "b"),
              percentsCount = 1,
              artifactId = LitString(value = "bb"),
              version = TermNameCompound(values = Vector("versions", "bVersion")),
              terms = List()
            )
          )
        )
      )
    )
  )
)

Когда глубина дерева стала минимальной, вызывается функция substituteVersionTree. Она подставляет версии из разных областей видимости.

Scope(
  name = None,
  items = Vector(
    Scope(
      name = Some(value = "dependencies"),
      items = Vector(
        Scope(
          name = None,
          items = Vector(
            Module(
              groupId = LitString(value = "a"),
              percentsCount = 1,
              artifactId = LitString(value = "aa"),
              version = LitString(value = "3"),
              terms = List()
            ),
            Module(
              groupId = LitString(value = "b"),
              percentsCount = 1,
              artifactId = LitString(value = "bb"),
              version = LitString(value = "2"),
              terms = List()
            )
          )
        )
      )
    )
  )
)

На этом этапе подставлены все возможные значения. Осталось один раз пройтись по дереву и собрать готовые модули.

Чуть подробнее про scalameta

После долгих мучений с antlr, очень приятно рабоать с AST, используя scalameta. Почему я сразу не взял scalameta? Я просто не знал о нём.

В scalameta есть поддержка паттерн матчинга на квазиквотах, но я не знаю будет ли оно работать в scala3, поэтому не пользуюсь.

Допустим, есть задача распарсить следующий код:

libraryDependencies += "com.lihaoyi" %% "pprint" % "0.6.2"

Посмотрим на AST

import scala.util.chaining._
import scala.meta._
dialects
  .Sbt1("""libraryDependencies += "com.lihaoyi" %% "pprint" % "0.6.2"""")
  .parse[Source]
  .get
  .pipe(pprint.pprintln(_))

Source(
  stats = List(
    Term.ApplyInfix(
      lhs = Term.Name(value = "libraryDependencies"),
      op = Term.Name(value = "+="),
      targs = List(),
      args = List(
        Term.ApplyInfix(
          lhs = Term.ApplyInfix(
            lhs = Lit.String(value = "com.lihaoyi"),
            op = Term.Name(value = "%%"),
            targs = List(),
            args = List(Lit.String(value = "pprint"))
          ),
          op = Term.Name(value = "%"),
          targs = List(),
          args = List(Lit.String(value = "0.6.2"))
        )
      )
    )
  )
)

Простейшая функция, способная достать эту зависимость:

def eval(t: Tree): List[(String, String, String)] = t match {
  case Source(value) => value.flatMap(eval)
  case Term.ApplyInfix(
        Term.Name("libraryDependencies"),
        Term.Name("+="),
        targs,
        args
      ) =>
    args.flatMap(eval)
  case Term.ApplyInfix(
        Term.ApplyInfix(
          Lit.String(groupId),
          Term.Name("%%"),
          List(),
          List(Lit.String(artifactId))
        ),
        Term.Name("%"),
        List(),
        List(Lit.String(version))
      ) =>
    List((groupId, artifactId, version))
}

Чего нехватает функции eval?

match не покрывает все возможные варианты
В sbt файле могут быть различные блоки, объявления классов, объявления функций, констант и т.д.
Между groupId и artifactId процентов %% может быть 1, 2 и 3
нужно уметь не только inline-версии парсить, но и уметь подставлять переменные
ModuleId может иметь scope (“org.scalatest” %% “scalatest” % “3.2.6” % “it,test”)

Допустим, следующим шагом мы хотим понять сколько процентов между artifactId и groupId. Создадим unapply для процентов и заменим нижний case из паттерн матчинга в функции eval.

object UnapplyPercentChars {
  def unapply(s: String): Option[Int] =
    if (s.nonEmpty && s.forall(_ == '%')) {
      Some(s.length)
    } else {
      None
    }
}

// ...
case Term.ApplyInfix(
  Term.ApplyInfix(
    Lit.String(groupId),
    Term.Name(UnapplyPercentChars(count)),
    List(),
    List(Lit.String(artifactId))
  ),
  Term.Name("%"),
  List(),
  List(Lit.String(version))
) =>
  List(
    (
      groupId,
      if (count == 2) s"${artifactId}_2.13" else artifactId,
      version
    )
  )

Остальные пункты из списка делаются аналогично, за исключением подставления переменных. Не буду описывать последующие шаги, код при желании можно посмотреть в Pull Request #358