DEV Community: Saltaformajo

Neovim plugin for synchronization with remote servers

Saltaformajo — Wed, 01 Nov 2023 15:16:04 +0000

Transfer.nvim is a Neovim plugin that enables you to synchronize files between your local machine and a remote server using rsync and OpenSSH. It is a lightweight and user-friendly plugin suitable for syncing various types of files, including code, configuration files, and documents.

It's integrated with nvim-notify and will show you the status of the transfer in the animated colorful notification.

Features

File Synchronization using rsync and OpenSSH.
Lua Configuration: Configuration for synchronization is written in Lua, making it accessible for those familiar with Neovim configuration.
Excluded Paths: Excluded paths can be defined to avoid synchronizing specific directories.
Commands includes creating a configuration file, opening a diff view, repeating the last transfer command, uploading, downloading, and directory diff.
Customization: Change deployment config template, rsync params, keybindings.
Notifications: Integrated with nvim-notify.

Who Benefits from Transfer.nvim

Transfer.nvim is a valuable tool for individuals who regularly need to synchronize files with remote servers, including:

Developers: Developers often require file synchronization between their local machines and remote development servers. Transfer.nvim simplifies and streamlines this process.
System Administrators: System administrators can edit configuration files locally and upload them to the server with ease using Transfer.nvim.
Users with Multiple Devices: Whether you need to sync files between your work computer and home computer, Transfer.nvim makes the process more straightforward.

It's important to note that the synchronization configuration is written in Lua, making it accessible for those familiar with Neovim configuration. To simplify configuration, you can create the configuration file using the :TransferInit command.

Deployment config example

-- .nvim/deployment.lua
return {
  ["example_name"] = {
    host = "myhost",
    username = "web", -- optional
    mappings = {
      {
        ["local"] = "live", -- path relative to project root
        ["remote"] = "/var/www/example.com", -- absolute path or relative to user home
      },
      {
        ["local"] = "test",
        ["remote"] = "/var/www/test.example.com",
      },
    },
    excludedPaths = { -- optional
      "live/src/", -- local path relative to project root
      "test/src/",
    },
  },
}

You only need to edit this configuration to specify which local directory corresponds to which remote directory on a server. You can also define excluded paths.

Installation

With Lazy.nvim:

{
  "coffebar/transfer.nvim",
  lazy = true,
  cmd = { 
    "TransferInit", 
    "DiffRemote", 
    "TransferUpload", 
    "TransferDownload", 
    "TransferDirDiff", 
    "TransferRepeat"
  },
  opts = {},
},

Commands

TransferInit - Creates a configuration file and opens it for editing.
DiffRemote - Opens a diff view with the remote file.
TransferRepeat - Repeats the last transfer command (except TransferInit, DiffRemote).
TransferUpload [path] - Upload.
TransferDownload [path] - Download.
TransferDirDiff [path] - Compares the local directory with its remote counterpart and displays the changed files in the quickfix.

Keybindings

Transfer.nvim does not provide any keybindings by default. The only exception is the <leader>b, which is mapped to remote buffer in diff view to close it with :diffoff and bdelete. You can change or disable this mapping in the opts.

Also, You can find pre-made solutions on the plugin page. Copy them to add all commands to your which-key keybindings and to the Neo-tree.

Current limitations

Auth only by ssh key (passwordless).
You can have multiple servers, but you need to map one local directory to one remote directory, not one to many.
You can't change deployment config path. It's not an issue, file doesn't contain any sensitive data.
Windows is not supported.
If you need auto-upload on BufWritePost event - it is on you.

Probably, some of this may change after the publication of the article. Pay attention to the date and the current README of the plugin.

It might be a good idea to add support for Amazon S3, Google Cloud Storage, and other cloud storage services in the future.

Conclusion

Transfer.nvim offers a user-friendly and efficient solution for individuals seeking hassle-free file synchronization in their Neovim environment. Streamline your workflow and stay in control of your data with this feature-rich plugin.

Boost Your Productivity with This Neovim Plugin for Project Management!

Saltaformajo — Thu, 12 Oct 2023 14:19:15 +0000

Introduction

Neovim, with its extensible architecture and plugin ecosystem, holds immense potential to transform into an exceptional IDE (PDE). If you've ever experienced the struggles of navigating between projects in traditional IDEs, you know how sluggish and cumbersome it can be. The frustration of switching contexts and dealing with delays often leads us to haphazardly bundle projects into a single chaotic workspace.

Neovim, however, offers a refreshing change. It introduces a world of possibilities:

The built-in :mksession command allows you to save and restore the current state of the editor.
There are various plugins tailored for project management.
tmux (You will use a separate instance of Neovim for each project)

The first option, using :mksession, is functional but requires some manual effort to streamline your workflow. Fortunately, many plugins have put in significant work to make your life easier. As for tmux, it can be customized, but configuring it to be unobtrusive and seamless is no small task. Moreover, Neovim already incorporates many features offered by tmux, eliminating the need for redundancy.

The most efficient and convenient choice is utilizing Neovim plugins. I've experimented with a few, and I'm excited to share my experiences with you.

Neovim Session Manager

Neovim Session Manager is a popular plugin, that uses built-in :mksession command. It simplifies the process of saving and restoring sessions by implementing auto-commands and user-commands. This plugin can automatically save your session when you close Neovim and restore it the next time you open it.

It is stable and well-maintained, but it is not an all-in-one solution for project management.

UI

Uses vim.ui.select()

Project.nvim

Project.nvim is a plugin that aims to provide a simple and intuitive project management experience. Unfortunately, it can't save sessions like Neovim Session Manager, and can't work in tandem with it. The main function of the Project.nvim is to detect project root by patterns and LSP, but this task is quite challenging and sometimes it misses. This project has a lot of opened PR. It seems that developer is not interested in these changes or is no longer interested in supporting this plugin.

UI

It uses a Telescope:

Neovim Project

Neovim Project bridges the gap and addresses the challenges of comprehensive project management. It not only works seamlessly with Neovim Session Manager but also incorporates it as a module. Therefore, when you install Neovim Project, you also acquire Session Manager, eliminating the need to configure two separate plugins.

UI

It uses a Telescope:

Configuration and project structure

Neovim Project encourages a structured and organized approach to project management. It adopts a declarative project structure, requiring you to decide in which directory your projects should be placed. This effectively resolves the issue of determining project root directories and enables the plugin to automatically discover all your projects as soon as you create a single project directory. You have the flexibility to categorize projects by context, programming language, or any other criteria, depending on the masks you add to the plugin's configuration. It even supports nested projects.

Here's an example of my configuration:



  opts = {
    projects = {
      "~/proj/work/*",
      "~/proj/github/*",
      "~/proj/aur/*",
      "~/.config/*",
    },
  },

Here is another interesting thing. Project's README suggests adding .config/* mask. This is an excellent idea, as it allows you to see your Neovim configuration as a project. This is particularly useful for editing other dotfiles. For instance, you can open a project like bspwm to quickly locate and edit your bspwmrc file.

Keybindings

I have set up three keybindings for Neovim Project. These keybindings trigger the following commands:

:Telescope neovim-project history - This command allows you to select a project from your recent history.
:Telescope neovim-project discover - Use this command to find a project based on patterns.
:NeovimProjectLoadRecent - This command is used to open the previous session.

The most frequently used command among these is the first one (history). I use it to switch between projects with Telescope fuzzy finder. It displays projects sorted by access time. However, it won't show a project until it has been accessed at least once. To address this, I use the discover command.

NeovimProjectLoadRecent command is invaluable when you need to swiftly return to the previously accessed project, whether for reference or to copy something.

Conclusion

Efficiency and organization are at the core of every developer's success. The right tools and plugins can significantly enhance your productivity and project management. With Neovim ecosystem, you have the power to create a tailored development environment that meets your specific needs. Whether you opt for Neovim Session Manager, Project.nvim, or Neovim Project, each plugin brings its unique strengths to the table. Choose the one that aligns with your workflow and enjoy a more streamlined, efficient, and organized coding experience. Happy coding!

Telegram bot for Google Sheets in cloud

Saltaformajo — Sun, 06 Sep 2020 07:05:26 +0000

Google Sheets is a powerful cross-platform app with a rich set of formulas and the ability to integrate with other apps.
However, such functionality is often redundant for simple tasks, which makes the work not very convenient. This is especially true for mobile devices. So it would be cool to make it possible to work with tables through other interfaces.

One option is to create a Telegram bot. This bot will receive some data from user and write it as new row into Google Sheets table.
It can be hosted for free!
With zero cost, we get a convenient combination of 2 powerful tools.

Tables API

The first step is to look at the tables documentation: https://developers.google.com/sheets/api/quickstart/nodejs
You can found a very useful button on this page:

Click on that button to create a new project and download credentials file (credentials.json).

Create a new file package.json

{
  "name": "spreadsheets-bot",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "googleapis": "^59.0.0",
    "telegraf": "^3.38.0"
  }
}

This package file contains 2 dependencies:

googleapis - library for google api
telegraf - Telegram Bot framework

You can run npm install to install this dependencies.

In the meantime, let's look at an example provided by Google.

const fs = require('fs');
const readline = require('readline');
const {google} = require('googleapis');

// If modifying these scopes, delete token.json.
const SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly'];
// The file token.json stores the user's access and refresh tokens, and is
// created automatically when the authorization flow completes for the first
// time.
const TOKEN_PATH = 'token.json';

// Load client secrets from a local file.
fs.readFile('credentials.json', (err, content) => {
  if (err) return console.log('Error loading client secret file:', err);
  // Authorize a client with credentials, then call the Google Sheets API.
  authorize(JSON.parse(content), listMajors);
});
...

Quickstart code solves the authorization problem to gain access to your personal tables, which is what we need.
However, it is advisable to immediately make a change: remove ".readonly" from the line

const SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly'];

This will change readonly access to read & write.

You need to put your credentials.json into project folder, run this file (index.json) by node index.js, open given link in browser, obtain a key, put this key into console.

If everything is done correctly, a file token.json will be created. Next authorizationы will work using the token from this file. Your bot will have access to all of your spreadsheets.

Create a Telegram Bot

Open @botfather in Telegram and send command /newbot. Provide a name for bot and you will get access token.
For our example we can hardcode this token in the script index.js

const fs = require('fs');
const readline = require('readline');
const {google} = require('googleapis');

const { Telegraf } = require('telegraf'); // import Telegraf
// Telegram bot access token:
const BOT_TOKEN = '1234567890:a1b2Cg2cLR4LGO1EpvDHawYPVjunkW3Bfk9';
// spreadsheets scope: read & write
const SCOPES = ['https://www.googleapis.com/auth/spreadsheets'];

telegraf.js docs

You can receive messages and send replies:

const bot = new Telegraf(BOT_TOKEN);

// Load client secrets from a local file.
fs.readFile('credentials.json', (err, content) => {
    if (err) return console.log('Error loading client secret file:', err);
    // Authorize a client with credentials, then call the Google Sheets API.
    authorize(JSON.parse(content), startBot);
});

function startBot(auth) {
    bot.on('message', (ctx) => {
        if (ctx.from.id !== '123456789') { // your user id
            return ctx.reply('Access Denied');
        }
        console.log(ctx.message.text);
        ctx.reply("Hi, " + ctx.from.id);
    });
    bot.launch();
}

Depending on the task, you can compose commands or a dialogue with the bot, in which you can use the ability to read and write from tables.

Here is an example of writing to a table:

...
const rowNumber = "2";
let values = [
    [
        "Formula:", // string value
        "=128/2+ROUND(8/3;2)", // any formula
        "User:",
        "Ben", 
        '', // empty cell
     ]
];
const resource = {values};
let valueInputOption = [
   'RAW', // as string
   'USER_ENTERED',// will be parsed as user input
   'USER_ENTERED',
   'USER_ENTERED',
   'USER_ENTERED',
];
const range = sheet + '!A' + rowNumber + ':E' + rowNumber;
const spreadsheetId = 'mKj7bEUzG7miu4m5nsBt4KWTM6IIgstwn9g1a7IvVwz0';

sheets.spreadsheets.values.update({
   spreadsheetId,
   range,
   valueInputOption,
   resource,
}, (err, result) => {
   if (err) {
      // Handle error
      console.log(err);
      ctx.reply(err.toString());
   } else {
      ctx.reply("Data saved."); //reply from bot to user
      console.log('%d cells updated.', result.data.updatedCells);
   }

});

Upload your bot to cloud for free

For convenience, the bot must be running 24/7. Then you can use it from your phone even when all your computers are turned off.

One of the options is Free Trial on Google Cloud Platform:
https://console.cloud.google.com/

For me this is not charging anything. Because the load on the server is too low.

You need to setup a new minimal cloud VM with Ubuntu or what you like.

When you connect to your new server by ssh, you can install node, npm and run your bot.

I recommend using PM2 to run script.

# install node & npm
curl -sL https://nsolid-deb.nodesource.com/nsolid_setup_3.x | sudo bash
sudo apt install -y nodejs npm
# install pm2
sudo npm install pm2@latest -g

Simple upload your script with rsync from local host to google cloud host:
rsync -ruv LOCAL_PROJECT_PATH SERVER_HOST:REMOTE_PATH

and start on the remote:

cd REMOTE_PATH
pm2 start index.js

Note that you should replace all my "uppercase" with your data (path to the project, server's ip, etc.)

Bot is started and you can use it 24/7