feat: added copy image to clipboard command

Author: AlejandroSuero

lua/freeze-code/commands.lua

@@ -1,10 +1,28 @@
 local M = {}
 
-local config = require("freeze-code.config")
+local os_utils = require("freeze-code.utils").os
+local is_win = os_utils.is_win
+local is_macos = os_utils.is_macos
+-- local is_unix = os_utils.is_unix
+
+local tmp_freeze_path = "/tmp/freeze-code.nvim"
+
+local setup_bin_path = function()
+  if not vim.loop.fs_stat(tmp_freeze_path) then
+    vim.fn.system({
+      "git",
+      "clone",
+      "--filter=blob:none",
+      "https://github.com/AlejandroSuero/freeze-code.nvim.git",
+      "--branch=main", -- latest stable release
+      tmp_freeze_path,
+    })
+  end
+end
 
-local job = {}
+M.job = {}
 
-local stdio = { stdout = "", stderr = "" }
+M.stdio = { stdout = "", stderr = "" }
 
 ---Closing job in a safely way
 ---@param h uv_pipe_t|uv_process_t: `stdout|stderr|handle`
@@ -15,52 +33,56 @@ local function safe_close(h)
 end
 
 local function stop_job()
-  if job == nil then
+  if M.job == nil then
     return
   end
-  if not job.stdout == nil then
-    job.stdout:read_stop()
-    safe_close(job.stdout)
+  if not M.job.stdout == nil then
+    M.job.stdout:read_stop()
+    safe_close(M.job.stdout)
   end
-  if not job.stderr == nil then
-    job.stderr:read_stop()
-    safe_close(job.stderr)
+  if not M.job.stderr == nil then
+    M.job.stderr:read_stop()
+    safe_close(M.job.stderr)
   end
-  if not job.handle == nil then
-    safe_close(job.handle)
+  if not M.job.handle == nil then
+    safe_close(M.job.handle)
   end
-  job = nil
+  M.job = nil
 end
 
 ---The function called on exit of from the event loop
 ---@param msg string: Message to display if success
 ---@return function cb: Schedule wrap callback function
-local function on_exit(msg)
+function M.on_exit(msg)
+  local freeze_code = require("freeze-code")
   return vim.schedule_wrap(function(code, _)
     if code == 0 then
       vim.notify("[freeze-code] " .. msg, vim.log.levels.INFO, { title = "FreezeCode" })
     else
-      vim.notify(stdio.stdout, vim.log.levels.ERROR, { title = "Freeze" })
+      vim.notify(M.stdio.stdout, vim.log.levels.ERROR, { title = "Freeze" })
+    end
+    if freeze_code.config.copy == true then
+      freeze_code.copy(freeze_code.config)
     end
     stop_job()
   end)
 end
 
-local function on_output(err, data)
+function M.on_output(err, data)
   if err then
     -- what should we really do here?
     vim.api.nvim_err_writeln(vim.inspect(err))
   end
   if data then
-    stdio.stdout = stdio.stdout .. data
+    M.stdio.stdout = M.stdio.stdout .. data
   end
 end
 
 ---Checks if the given cmd executes.
 ---@param cmd string
 ---@param path_to_check string
 ---@return boolean success: true if executes, false otherwise
-local function check_executable(cmd, path_to_check)
+function M.check_executable(cmd, path_to_check)
   if vim.fn.executable(cmd) == 0 then
     vim.api.nvim_err_write(
       string.format(
@@ -73,64 +95,36 @@ local function check_executable(cmd, path_to_check)
   return true
 end
 
----Freeze file with a range
----@param s_line? number: line to start range
----@param e_line? number: line to start range
----@param opts? FreezeConfig
-M.freeze = function(s_line, e_line, opts)
-  config = vim.tbl_extend("force", {}, config, opts or {})
-  s_line = s_line or 1
-  e_line = e_line or vim.api.nvim_buf_line_count(0)
-
-  local cmd = config.freeze_path
+local copy_by_os = function(opts)
+  setup_bin_path()
+  local bin_path = tmp_freeze_path .. "/bin"
+  local binaries = {
+    macos = bin_path .. "/pngcopy-macos",
+    linux = bin_path .. "/pngcopy-linux",
+    windows = bin_path .. "/pngcopy-windows.ps1",
+  }
 
-  if not check_executable("freeze", cmd) then
-    return
+  local cmd = ""
+  if is_win then
+    cmd = "pwsh " .. binaries.windows .. " " .. opts.output
+    return os.execute(cmd)
+  elseif is_macos then
+    cmd = "sh " .. binaries.macos .. " " .. opts.output
+    return os.execute(cmd)
   end
+  cmd = "sh " .. binaries.linux .. " " .. opts.output
+  os.execute(cmd)
+end
 
-  local lang = vim.api.nvim_buf_get_option(0, "filetype")
-  local file = vim.api.nvim_buf_get_name(0)
-  local conf = config.freeze_config.config
-  local dir = config.dir
-  local theme = config.freeze_config.theme
-  local output = config.freeze_config.output
-
-  if output ~= "freeze" then
-    local t_stamp = os.date("%Y%m%d%H%M%S")
-    local filename = file:match("^.+/(.*)$") or file
-
-    output = string.format("%s_%s_%s", tostring(t_stamp), filename, output)
+M.copy = function(opts)
+  copy_by_os(opts)
+  local cmd = ""
+  if is_win then
+    cmd = "rm -r -Force " .. tmp_freeze_path
+  else
+    cmd = "rm -rf " .. tmp_freeze_path
   end
-
-  config.output = dir .. "/" .. output .. ".png"
-
-  local cmd_args = {
-    "--output",
-    config.output,
-    "--language",
-    lang,
-    "--lines",
-    s_line .. "," .. e_line,
-    "--config",
-    conf,
-    "--theme",
-    theme,
-    file,
-  }
-
-  job = {}
-  job.stdout = vim.loop.new_pipe(false)
-  job.stderr = vim.loop.new_pipe(false)
-
-  local job_opts = {
-    args = cmd_args,
-    stdio = { nil, job.stdout, job.stderr },
-  }
-
-  local msg = "frozen frame in path=" .. config.output
-  job.handle = vim.loop.spawn(cmd, job_opts, on_exit(msg))
-  vim.loop.read_start(job.stdout, vim.schedule_wrap(on_output))
-  vim.loop.read_start(job.stderr, vim.schedule_wrap(on_output))
+  os.execute(cmd)
 end
 
 return M

lua/freeze-code/config.lua

@@ -5,8 +5,10 @@ local ok = health.ok or health.report_ok
 local warn = health.warn or health.report_warn
 local error = health.error or health.report_error
 
-local is_win = vim.api.nvim_call_function("has", { "win32" }) == 1
-local is_macos = vim.api.nvim_call_function("has", { "macunix" }) == 1
+local os_util = require("freeze-code.utils").os
+
+local is_win = os_util.is_win
+local is_macos = os_util.is_macos
 
 ---@class FreezeCodeHealthPackage
 ---@field name string: package name

lua/freeze-code/health.lua

@@ -1,19 +1,129 @@
+---@meta
+---@class FreezeConfig
+---@field output string: Freeze output filename `--output "freeze.png"`
+---@field theme string: Freeze theme `--theme "default"`
+---@field config string: Freeze configuration `--config "base"`
+
+---@class FreezeCodeConfig
+---@field freeze_path string: Path to `freeze` executable
+---@field copy_cmd string: Path to copy `image/png` to clipboard command
+---@field copy boolean: Open image after creation option
+---@field open boolean: Open image after creation option
+---@field dir string: Directory to create image
+---@field freeze_config FreezeConfig
+---@field output string|nil: output filename
+
+---@type FreezeConfig
+local freeze_config = {
+  output = "freeze",
+  config = "base",
+  theme = "default",
+}
+
+---@type FreezeCodeConfig
+local config = {
+  freeze_path = vim.fn.exepath("freeze"),
+  copy_cmd = vim.env.HOME .. "/dev/nvim_plugins/freeze-code.nvim/bin/pngcopy-macos",
+  copy = false,
+  open = false,
+  dir = vim.env.PWD,
+  freeze_config = freeze_config,
+  output = nil,
+}
+
 ---@class FreezeCode
 ---@field setup function
 ---@field config FreezeCodeConfig
 ---@field freeze function: Running `freeze` function
+---@field copy function: Copying image to clipboard
 
 ---@type FreezeCode|{}
 local freeze_code = {}
 
-freeze_code.config = require("freeze-code.config")
-freeze_code.freeze = require("freeze-code.commands").freeze
+local commands = require("freeze-code.commands")
+
+freeze_code.config = config
+
+freeze_code.copy = function(opts)
+  commands.copy(opts)
+end
+
+---Freeze file with a range
+---@param s_line? number: line to start range
+---@param e_line? number: line to start range
+freeze_code.freeze = function(s_line, e_line)
+  s_line = s_line or 1
+  e_line = e_line or vim.api.nvim_buf_line_count(0)
+
+  local cmd = freeze_code.config.freeze_path
+
+  if not commands.check_executable("freeze", cmd) then
+    return
+  end
+
+  local lang = vim.api.nvim_buf_get_option(0, "filetype")
+  local file = vim.api.nvim_buf_get_name(0)
+  local conf = freeze_code.config.freeze_config.config
+  local dir = freeze_code.config.dir
+  local theme = freeze_code.config.freeze_config.theme
+  local output = freeze_code.config.freeze_config.output
+
+  if output ~= "freeze" then
+    local t_stamp = os.date("%Y%m%d%H%M%S")
+    local filename = file:match("^.+/(.*)$") or file
+
+    output = string.format("%s_%s_%s", tostring(t_stamp), filename, output)
+  end
+
+  freeze_code.config.output = dir .. "/" .. output .. ".png"
+
+  local cmd_args = {
+    "--output",
+    freeze_code.config.output,
+    "--language",
+    lang,
+    "--lines",
+    s_line .. "," .. e_line,
+    "--config",
+    conf,
+    "--theme",
+    theme,
+    file,
+  }
+
+  commands.job = {}
+  commands.job.stdout = vim.loop.new_pipe(false)
+  commands.job.stderr = vim.loop.new_pipe(false)
+
+  local job_opts = {
+    args = cmd_args,
+    stdio = { nil, commands.job.stdout, commands.job.stderr },
+  }
+
+  local msg = "🍧 frozen frame in path=" .. freeze_code.config.output
+  commands.job.handle = vim.loop.spawn(cmd, job_opts, commands.on_exit(msg))
+  vim.loop.read_start(commands.job.stdout, vim.schedule_wrap(commands.on_output))
+  vim.loop.read_start(commands.job.stderr, vim.schedule_wrap(commands.on_output))
+end
+
+local create_autocmds = function()
+  vim.api.nvim_create_user_command("Freeze", function(opts)
+    vim.api.nvim_out_write("[freeze-code] Freeze called")
+    if opts.count > 0 then
+      freeze_code.freeze(opts.line1, opts.line2)
+    else
+      freeze_code.freeze()
+    end
+  end, {
+    range = true,
+  })
+end
 
 ---freeze-code's set up function
 ---@param opts {}|nil
 freeze_code.setup = function(opts)
-  freeze_code.config = require("freeze-code.config")
-  freeze_code.config = vim.tbl_extend("force", {}, freeze_code.config, opts or {})
+  freeze_code.config = vim.tbl_deep_extend("force", {}, freeze_code.config, opts or {})
+  create_autocmds()
 end
 
 return freeze_code

lua/freeze-code/init.lua

@@ -1,8 +1,22 @@
+---@meta
+
+---@class FreezeCodeOS
+---@field is_win boolean
+---@field is_macos boolean
+---@field is_unix boolean
+
 ---@class FreezeCodeUtils
 ---@field logger FreezeCodeLogger
+---@fiels os FreezeCodeOS
 ---@type FreezeCodeUtils|{}
 local M = {}
 
 M.logger = require("freeze-code.utils.logger")
 
+M.os = {
+  is_win = vim.api.nvim_call_function("has", { "win32" }) == 1,
+  is_macos = vim.api.nvim_call_function("has", { "macunix" }) == 1,
+  is_unix = vim.api.nvim_call_function("has", { "unix" }) == 1,
+}
+
 return M