company_banner

Todo-лист для командной строки на Deno

  • Tutorial

Вы уже наверняка слышали про Deno и, скорее всего, прочитали пару-тройку обзоров. В рамках своей статьи я предлагаю испытать Deno на практике, написав приложение для командной строки, попутно размышляя о преимуществах и возможных способах его применения.


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



Основные преимущества, такие как безопасность, TypeScript «из коробки», встроенные инструменты, обширная стандартная библиотека, а также возможность импортировать и запускать скрипты по URL, выгодно отличают Deno от Node и Bash. С помощью Deno мы можем написать скрипт, залить на GitHub Gist и запускать при необходимости командой deno run https://path.to/script.ts, не заботясь о зависимостях и настройке окружения.


Для начала работы нужно только установить Deno одним из предложенных способов https://deno.land/#installation.


Todo для Todo


Todo-лист должен уметь:


  • добавлять, редактировать, удалять и отмечать задачи;
  • выводить список задач;
  • сохранять состояние;
  • работать в интерактивном режиме;
  • устанавливаться на компьютер.

Аргументы командной строки


Практически любая консольная утилита управляется с помощью передаваемых при запуске аргументов. В Deno они лежат массивом в Deno.args. А, к примеру, в Node мы бы использовали process.argv, в котором помимо аргументов находятся строки node и путь к скрипту.


// deno run args.ts first second

console.log(Deno.args) // [ "first", "second" ]

В простых случаях Deno.args будет достаточно, а в более сложных можно воспользоваться парсером из стандартной библиотеки: https://deno.land/std/flags или любым другим на выбор.


Итак, начнём…


Реализуем первую команду – вывод информации.


Создадим главный файл нашего приложения – todo.ts. Лучше назвать файл осмысленно, так как в будущем он понадобится нам для запуска и установки.


Далее создадим файл /src/ui.ts, в котором будем хранить элементы «пользовательского интерфейса». Добавим константу help, содержащую информационный текст.


export const help = `todo help - to show available commands`;

В todo.ts напишем свитч для обработки команд и выведем справку с помощью console.log().


#!/usr/bin/env deno run

import { help } from "./src/ui.ts";

const [command, ...args] = Deno.args;

switch (command) {
  case "help":
    console.log(help);
}

Проверим работу команды:


deno run todo.ts help


Для того, чтобы при каждом запуске не писать deno run, добавим шебанг #!.


#!/usr/bin/env deno run

Разрешим запуск файла:


chmod +x todo.ts


Теперь для вывода справки можно использовать:


./todo.ts help


Стандартный вывод


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


В Deno за стандартный вывод отвечает Deno.stdout, за ввод, соответственно, Deno.stdin.


/** A handle for `stdin`. */
export const stdin: Reader & ReaderSync & Closer & { rid: number };
/** A handle for `stdout`. */
export const stdout: Writer & WriterSync & Closer & { rid: number };

И stdin, и stdout типизированы пересечением интерфейсов и объекта, содержащего rid, – идентификатор ресурса.


Более подробно рассмотрим stdout и выведем «Hello world!» в консоль.


const textEncoder = new TextEncoder();

const message: string = "Hello world!\n";
const encodedMessage: Uint8Array = textEncoder.encode(message);

await Deno.stdout.write(encodedMessage);

Запустим скрипт hello.ts:


deno run hello.ts


На экране появляется наш «Hello world!».


export interface Writer {
  write(p: Uint8Array): Promise<number>;
}

Функция Deno.stdout.write принимает на вход массив байтов и возвращает количество записанных байтов. Deno.stdout.writeSync работает точно так же, только синхронно.


Строку необходимо предварительно закодировать с помощью объекта TextEncoder.
Можно не создавать TextEncoder, а импортировать функцию encode из стандартной библиотеки, которая делает то же самое, точно так же.


import { encode } from 'https://deno.land/std/encoding/utf8.ts';

Воспользуемся полученными знаниями и создадим файл terminal.ts с двумя функциями print и printLines. Последняя выводит строку и переводит каретку.


import { encode } from "https://deno.land/std/encoding/utf8.ts";

export async function print(message: string) {
  await Deno.stdout.write(encode(message));
}

export async function printLines(message: string) {
  await print(message + "\n");
}

Заменим console.log на printLines.


#!/usr/bin/env deno run

import { help } from "./src/ui.ts";
import { printLines } from "./src/Terminal.ts";

const [command, ...args] = Deno.args;

switch (command) {
  case "help":
    await printLines(help);
}

Чтение и запись файла


В Deno для чтения файла используется функция Deno.readFile и её синхронный аналог Deno.readFileSync.


function Deno.readFile(path: string | URL): Promise<Uint8Array>

const decoder = new TextDecoder("utf-8");
const data = await Deno.readFile("hello.txt");
console.log(decoder.decode(data));

Для записи в файл соответственно используются Deno.writeFile и Deno.writeFileSync.


function Deno.writeFile(path: string | URL, data: Uint8Array, options?: WriteFileOptions): Promise<void>

const encoder = new TextEncoder();
const data = encoder.encode("Hello world\n");
await Deno.writeFile("hello1.txt", data);  // overwrite "hello1.txt" or create it

В стандартной библиотеке Deno содержатся функции, позволяющие упростить взаимодействие с файловой системой: https://deno.land/std/fs. Например, код выше можно заменить вызовами функций readFileStr и writeFileStr.


Создадим интерфейс Task в src/Task.ts


export interface Task { 
  title: string;
  isDone: boolean;
}

и класс Todo в файле src/Todo.ts.


import {
  writeJsonSync,
  readJsonSync, 
} from "https://deno.land/std/fs/mod.ts"; 
import { Task } from "./Task.ts";

export class Todo {
  tasks: Task[] = [];

  constructor(private file: string = "tasks.json") {
    this.open();
  }

  open() {
    try {
      this.tasks = readJsonSync(this.file) as Task[];
    } catch (e) {
      console.log(e);
      this.tasks = [];
    }
  }

  save() {
    writeJsonSync(this.file, this.tasks, { spaces: 2 });
  }
}

Как можно заметить, для чтения и записи данных я использовал специальные функции из стандартной библиотеки для работы с json-файлами.


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


Для реализации команды todo add "implement add command" добавляем в класс Todo метод add.


add(title: string) {
    const task: Task = {
        title,
        isDone: false
    };

    this.tasks.push(task);
    this.save();
}

Так как мы добавили чтение и запись в файл, необходимо добавить права --allow-read --allow-write.


#!/usr/bin/env deno run --allow-read --allow-write 

import { help } from "./src/ui.ts";
import { printLines } from "./src/terminal.ts";
import { Todo } from "./src/Todo.ts";

const [command, ...args] = Deno.args;

const todo = new Todo();

switch (command) {
  case "help":
    await printLines(help);
    break;

  case "add":
    todo.add(args[0]);
}

Вывод списка задач


В файл src/ui.ts добавляем функцию для форматирования списка задач.


import { Task } from "./Task.ts";
import { green, red, yellow, bold } from "https://deno.land/std/fmt/colors.ts";

export function formatTaskList(tasks: Task[]): string {
  const title = `${bold("TODO LIST:")}`;

  const list = tasks.map((task, index) => {
    const number = yellow(index.toString());
    const checkbox = task.isDone ? green("[*]") : red("[ ]");

    return `${number} ${checkbox} ${task.title}`;
  });

  const lines = [
    title,
    ...list,
  ];

  return lines.join("\n");
}

Для задания стиля и цвета текста используем функции форматирования из https://deno.land/std/fmt/colors.ts.


Добавляем метод list в класс Todo и команду ls в свитч.


async list() {
  await printLines(formatTaskList(this.tasks));
}

case "ls":
  await todo.list();
  break;

Таким же образом добавляем остальные методы и команды.


done(index: number): void {
  const task = this.tasks[index];

  if (task) {
    task.isDone = true;
    this.save();
  }
}

undone(index: number): void {
  const task = this.tasks[index];

  if (task) {
    task.isDone = false;
    this.save();
  }
}

edit(index: number, title: string) {
  const task = this.tasks[index];

  if (task) {
    task.title = title;
    this.save();
  }
}

remove(index: number) {
  this.tasks.splice(index);
  this.save();
}

case "edit": // todo edit 1 "edit second task"
  await todo.edit(parseInt(args[0], 10), args[1]);
  break;

case "done" : // todo done 1
  todo.done(parseInt(args[0], 10));
  break;

case "undone" : // todo undone 1
  todo.undone(parseInt(args[0], 10));
  break;

case "remove" : // todo remove 1
  todo.remove(parseInt(args[0], 10));
  break;

Реализованные команды отвечают первым трём пунктам наших требований.


Работа в интерактивном режиме


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


Создадим в свитче кейс по умолчанию,


default:
  await todo.interactive();

а в классе Todo асинхронный метод interactive.


async interactive() {
  while (true) {
    // show list
    // read keypress

    // do action
  }
}

Метод interactive содержит бесконечный цикл, в котором выводится пользовательский интерфейс, ожидается ответ пользователя и, в зависимости от нажатой клавиши, совершается действие.


Для управления курсором в интерактивном режиме необходимо импортировать функции из библиотеки cursor.
Добавляем права для доступа к энвайронменту, так как библиотека проверяет, в каком окружении программа запущена --allow-env.


import { clearDown, goUp, goLeft } from "https://denopkg.com/iamnathanj/cursor@v2.0.0/mod.ts";

В файле terminal.ts создадим функцию printInteractive.


export async function printInteractive(message: string) {
  const lines = message.split("\n");
  const numberOfLines = lines.length;
  const lengthOfLastLine = lines[numberOfLines - 1].length;

  await clearDown();
  await print(message);
  await goLeft(lengthOfLastLine);

  if (numberOfLines > 1) {
    await goUp(numberOfLines - 1);
  }
}

Она выводит текст на экран и возвращает курсор в начало. При следующем вызове всё стирается и печатается заново. Для того чтобы квадрат курсора не мешался, его можно скрыть функцией hideCursor.


Добавим в файл ui.ts константу toolbar, в которой будут перечислены доступные действия.


const toolbar = `${yellow("d")}one ${yellow("a")}dd ${yellow("e")}dit ${yellow("r")}emove`;

В функцию formatTaskList добавляем параметр showToolbar:


export function formatTaskList(tasks: Task[], showToolbar: boolean): string {
// ...
if (showToolbar) {
  lines.push(toolbar);
}

В зависимости от флага showToolbar мы будем показывать или скрывать подсказку.


Дорабатываем метод list:


async list(interactive: boolean = false) {
  if (interactive) {
    await printInteractive(formatTaskList(this.tasks, true));
  } else {
    await printLines(formatTaskList(this.tasks, false));
  }
}

Вывод реализован, перейдём к вводу.


Стандартный ввод


Интерфейс ввода, аналогично выводу работает с Uint8Array, поэтому для декодирования используется TextDecoder.


const textDecoder = new TextDecoder();
const buffer: Uint8Array = new Uint8Array(1024);

const n: number = <number>await Deno.stdin.read(buffer);
const message: string = textDecoder.decode(buffer.subarray(0, n));

Создаём буфер размером, например, в 1024 байта. Передаём его в функцию Deno.stdin.read и ждём пока пользователь закончит ввод. Как только будет нажата клавиша enter, функция наполнит буфер и вернёт количество прочитанных байтов. Стоит отметить, что перевод строки «\n» будет в конце прочитанной последовательности. Обрезаем лишнее и декодируем полученную строку. Синхронная функция Deno.stdin.readSync работает аналогично.


Обработка клавиш


Для того чтобы получить информацию о нажатии клавиш, необходимо воспользоваться функцией Deno.setRaw. На текущий момент она доступна под флагом --unstable. setRaw и позволяет получить символы по одному, без обработки. В функцию необходимо передать идентификатор ресурса и флаг. Как только мы воспользовались этим режимом, нажатие CTRL+C перестаёт приводить к закрытию программы, и это поведение нужно реализовать самостоятельно.


Deno.setRaw(Deno.stdin.rid, true);
const length = <number> await Deno.stdin.read(buffer);
Deno.setRaw(Deno.stdin.rid, false);

В файл terminal.ts добавляем функцию readKeypress:


export async function readKeypress(): Promise<string> {
  const buffer = new Uint8Array(1024);
  Deno.setRaw(Deno.stdin.rid, true);
  const length = <number> await Deno.stdin.read(buffer);
  Deno.setRaw(Deno.stdin.rid, false);

  return decode(buffer.subarray(0, length));
}

В метод interactive добавляем возможность выйти из приложения.


async interactive() {
  while (true) {
    await this.list(true);
    const key = await readKeypress();

    if (key == "\u0003") { // ctrl-c
      Deno.exit();
    }
  }
}

Не отходя далеко от ввода текста, реализуем добавление задачи в интерактивном режиме.


В файл terminal.ts добавляем 2 функции:


export async function readLine(): Promise<string> {
  const buffer = new Uint8Array(1024);
  const length = <number> await Deno.stdin.read(buffer);
  return decode(buffer.subarray(0, length - 1));
}

export async function prompt(question: string): Promise<string> {
  await clearDown();
  await print(question);
  const answer = await readLine();
  await goLeft(question.length + answer.length);
  await goUp(1);

  return answer;
}

Функция readLine позволяет прочитать одну строку, исключая последний символ, – перевод строки.


Функция prompt очищает экран, печатает вопрос, читает ввод пользователя, а затем перемещает курсор в начало, аналогично функции printInteractive.


В метод interactive добавляем обработку клавиши «а»:


if (key === "a") {
  const title = await prompt("Add task: ");

  if (title) {
    await this.add(title);
  }
}

Перемещение по списку задач


Добавим поддержку стрелок клавиатуры. Для того чтобы понимать, какой элемент сейчас выбран, добавляем свойство currentIndex в класс Todo:


  private currentIndex: number = 0;

А в функции formatTaskList активную строку выделяем жирным и красим в жёлтый:


export function formatTaskList(
  tasks: Task[],
  showToolbar: boolean = false,
  activeIndex?: number,
): string {
  const title = `${bold("TODO LIST:")}`;

  const list = tasks.map((task, index) => {
    // ...
    const isActive = activeIndex === index;
    const title = isActive ? bold(yellow(task.title)) : task.title;

    return `${number} ${checkbox} ${title}`;
  });

  // ...
}

В Todo создаём методы, которые будут изменять currentIndex:


up() {
  this.currentIndex = this.currentIndex === 0
    ? this.tasks.length - 1
    : this.currentIndex - 1;
}

down() {
  this.currentIndex = this.currentIndex === this.tasks.length - 1
    ? 0
    : this.currentIndex + 1;
}

В метод interactive добавляем обработку стрелок:


if (key === "\u001B\u005B\u0041" || key === "\u001B\u005B\u0044") { // вверх или влево
  this.up();
} else if (key === "\u001B\u005B\u0042" || key === "\u001B\u005B\u0043") { // вниз или вправо
  this.down();
}

Аналогичным образом добавляем возможность отмечать выполненные задачи:


toggle(index: number = this.currentIndex) {
  const task = this.tasks[index];

  if (task) {
    task.isDone = !task.isDone;
    this.save();
  }
}

if (key === "d" || key === " ") {
    this.toggle();
} else if ('0' <= key && key <= '9') {
    this.toggle(parseInt(key, 10));
} 

Дорабатываем удаление:


remove(index: number = this.currentIndex) {
  if (index === this.tasks.length - 1) {
    this.up();
  }

  this.tasks.splice(index, 1);
  this.save();
}

if (key === "r") {
    this.remove();
} 

И, наконец, редактирование:


if (key === "e") {
  if (!this.tasks[this.currentIndex]) {
    return;
  }

  const title = await prompt("Edit task (" + this.tasks[this.currentIndex].title + "): ");

  if (title) {
    this.edit(this.currentIndex, title);
  }
}

Проверяем работу приложения:


deno run --allow-read --allow-write --allow-env --unstable ./todo.ts

или


./todo.ts

Установка


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


deno install --allow-read --allow-write --allow-env --unstable ./todo.ts

Установка, так же как и запуск, может производиться по URL.


deno install --allow-read --allow-write --allow-env --unstable  https://raw.githubusercontent.com/dmitriytat/todo/master/todo.ts

Имя файла будет использовано как название программы по умолчанию, но с помощью опции -n/--name можно задать другое.


После чего todo можно использовать в командной строке.


Импорт зависимостей


Последняя фича, которую мы использовали, но ещё не обсудили – импорт зависимостей. В отличие от Node, в Deno подход к импортированию несколько иной: предполагается, что зависимости импортируются по URL. В этом подходе, на мой взгляд, есть как достоинства, так и недостатки.


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


Для управления сложностью существует два основных решения: файл dep.ts и файл с картой импортов.


В первом случае мы делаем реэкспорт библиотек, собирая все импорты в одном месте.


export { green, red, yellow, bold } from "https://deno.land/std@0.55.0/fmt/colors.ts";
export { decode, encode } from "https://deno.land/std@v0.55.0/encoding/utf8.ts";
export { clearDown, goUp, goLeft } from "https://denopkg.com/iamnathanj/cursor@v2.0.0/mod.ts"; 

Во втором случае в JSON файле мы пишем alias:


import_map.json


{
   "imports": {
      "fmt/": "https://deno.land/std@0.55.0/fmt/"
   }
}

color.ts


import { red } from "fmt/colors.ts";

console.log(red("hello world"));

При запуске программы указываем путь до карты и флаг --unstable, так как фича не готова для продакшена.


deno run --importmap=import_map.json --unstable color.ts.

Резюме


В целом, работой Deno я доволен. Новый инструмент позволяет не тратить время на настройку окружения и сразу приступать к написанию кода, что оказалось очень удобно.
Таким образом, я могу рекомендовать Deno для написания небольших скриптов и программ, упрощающих жизнь разработчика, но пока воздержался бы от использования Deno для создания продакшен-приложений.

FunCorp
Разработка развлекательных сервисов

Похожие публикации

Комментарии 13

    +3

    Выглядит очень интересно. Deno очень удобный инструмент для написания системных скриптов. Ждём, когда фишки setRaw перестанут быть unstable.

      +1
      Кстати про unstable, есть еще одна неприятная особенность. Если импортировать функции из deno.land/std/fs/mod.ts как это сделал я, то тоже придется использовать --unstable, так как в mod.ts есть функция ensureSymlink которая использует нестабильный Deno.symlink. Лучше сразу импортировать из нужного файла deno.land/std/fs/read_json.ts.
      +1
      прикольно…

      сразу понятно было, что явный пиар любимой платформы…

      но вот так вот — смешать в кучу сразу три модных слова — v8, rust, typescript — и это всё вместе работает? спасибо, очень интересно!

      сразу вопрос — «линковаться» к сишным библиотекам можно?
        0
        На сколько я понял, сейчас для того что бы «прилинковаться» к сишным библиотекам нужно написать биндинги на расте и подключить как плагин через Deno.openPlugin.
        Что-то похожее в webview_deno.
          0
          спасибо:)
          выглядит как ядерная вещь
        0
        nodeнет спасибо!
          +1
          а также возможность импортировать и запускать скрипты по URL, выгодно отличают Deno от Node и Bash.


          Простите, но
          curl http://remoteserver.com/myshellscript.sh | bash
            0
            Это, конечно, верно, но мой поинт был скорее в том что имея все перечисленные возможности код писать удобнее.
            А запуск скрипта из интернета с явным указанием что ему можно делать прям киллер-фича. Могу ошибаться, но для того что бы в bash ограничить, например, доступ к интернету нужно запускать скрипт от пользователя с этими ограничениями. Как тут serverfault.com/questions/550276/how-to-block-internet-access-to-certain-programs-on-linux.
              0
              код писать удобнее.

              Но ведь это зависит от того, какой язык тебе привычнее. Мне вот bash более чем привычен.

              А запуск скрипта из интернета с явным указанием что ему можно делать прям киллер-фича.

              Запуск чужих скриптов из инета как бы не есть гуд в любом случае. И доступ к инету ограничивать не самое главное, тут сперва доступ к rm -rf / ограничить.

              Могу ошибаться, но для того что бы в bash ограничить, например, доступ к интернету нужно запускать скрипт от пользователя с этими ограничениями.

              можно просто прописать несуществующий прокси в виде http_proxy, https_proxy, да и баш сам по себе в инет не лезет, туда лезут различные утилиты, каждой можно индивидуально доступ дать.

              Я просто думаю, что вашу утилиту некорректно сравнивать с bash. Ее корректно сравнивать с похожими инструментами — какиминить google tasks, todoist for chrome, веб-интерфейсом к кронтабу и тому подобным.
                0
                Я просто думаю, что вашу утилиту некорректно сравнивать с bash. Ее корректно сравнивать с похожими инструментами — какиминить google tasks, todoist for chrome, веб-интерфейсом к кронтабу и тому подобным.

                Не, со специализированными программами в целом еще один todo лист сравнивать не нужно. В самом todo смысла мало, а как «hello world» на новой технологии вполне.
            0

            А разве в линуксе нет проблемы в том, что в шебанге нельзя передавать несколько аргументов?


            Т.е. если файл test.ts


            #!/usr/bin/env deno run
            
            console.log('GGGGG')

            с пермишенном на исполнение попытаться запустить, то получится следующая картина:


            ./test.ts 
            /usr/bin/env: 'deno run': No such file or directory
            /usr/bin/env: use -[v]S to pass options in shebang lines

            Это в принципе на корню уничтожает смысл половины статьи.

              0
              Верное замечание, зависит от env. Где-то решается добавлением -S, где-то как, например, в windows не работает вовсе, а на MacOs работает как есть.

              Можно попробовать запускать с помощью exec:

              #!/bin/sh
              ':' //; exec "$(command -v deno)" "run" "--allow-env" "$0" "$@"
              
              console.log('GGGGG', Deno.args)
              


              Конкретно в статье использование шебанга это способ поскорее взглянуть на конечный результат. Можно было без этого обойтись. В итоге все приходит к deno install, а после установки, не зависимо от платформы, все работает как надо.
                0
                так вся суть env заключается в том, что ты не знаешь что есть на компе — sh, bash, ksh или deno

                И именно поэтому env универсальный и для линукс и для виндовс — он разрулит что запускать на конкретной платформе.

            Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

            Самое читаемое