Merge branch 'feature/open-new-buffer'

Closes #7, #4, #2, #1

Author: aiya000

CONTRIBUTING.md

@@ -0,0 +1,13 @@
+# How to run test
+
+`.github/workflows/test.yml`は実際に動いているので、これを見るのが一番わかりやすいですが、一応記しておきます。
+
+1. [vim-themis](https://github.com/thinca/vim-themis)をcloneする
+1. `themis`を`$PATH`に通す（以下の例では、`~/bin`が`$PATH`に含まれているとします）
+1. テストを実行する
+    - `--reporter`は自由に指定できます
+
+```shell-session
+$ git clone https://github.com/thinca/vim-themis ~/bin/vim-themis
+$ themis test --reporter spec
+```

README.md

@@ -14,31 +14,28 @@ This Vim plugin is created by **Cline (Roo Code)** and me!
 
 - - -
 
-## :wrench: Quick Start
+## Table of Contents
 
-```vim
-" Open a new scratch buffer without file extension and filetype
-:ScratchBufferOpen
-:ScratchBufferOpen --no-file-ext
-```
+- [:sparkles: scratch-buffer.vim :sparkles:](#sparkles-scratch-buffervim-sparkles)
+  - [:wrench: Quick Start](#wrench-quick-start)
+  - [:fire: Why scratch-buffer.vim?](#fire-why-scratch-buffervim)
+  - [:zap: Supercharge with vim-quickrun!](#zap-supercharge-with-vim-quickrun)
+  - [:balance_scale: Comparison with scratch.vim](#balance_scale-comparison-with-scratchvim)
+    - [:gear: Detailed Usage](#gear-detailed-usage)
+  - [:keyboard: Default Keymappings](#keyboard-default-keymappings)
+  - [:sparkles: scratch.vim Compatibility](#sparkles-scratchvim-compatibility)
 
-```vim
-" Open a new scratch buffer with Markdown filetype
-:ScratchBufferOpen md
-```
+## :wrench: Quick Start
 
 ```vim
-" Open a small buffer at the top for quick notes
-:ScratchBufferOpen md sp 5
-:ScratchBufferOpen --no-file-ext sp 5
+:ScratchBufferOpen  " Open a temporary buffer using default options
+:ScratchBufferOpen md sp 5  " Open a temporary Markdown buffer with :sp and height 5
+:ScratchBufferOpenFile ts vsp 100  " Open a persistent TypeScript buffer with :vsp and width 100
+:ScratchBufferOpenNext  " Open next temporary buffer
+:ScratchBufferOpenFileNext  " Open next persistent buffer
 ```
 
-Of course, you can open other file types too!
-
-```vim
-" Open a TypeScript buffer
-:ScratchBufferOpen ts
-```
+Please see '[Detailed Usage](#gear-detailed-usage)' section for more information.
 
 ## :fire: Why scratch-buffer.vim?
 
@@ -65,15 +62,60 @@ However, vim-scratch-buffer adds more features.
 
 Compared to scratch.vim, vim-scratch-buffer provides these additional features:
 
-- Open multiple buffers with sequential numbering
+- Flexible buffer management
+    - Open multiple buffers with sequential numbering (`:ScratchBufferOpenNext`)
+    - Quick access to recently used buffers (`:ScratchBufferOpen`)
     - When you want to take notes on different topics, scratch.vim only allows one buffer
-    - See [`:ScratchBufferOpen`](https://github.com/aiya000/vim-scratch-buffer/blob/736eef08b531b91c95497917ddb97ffbc2047c73/doc/vim-scratch-buffer.txt#L86)
-- Choose between writeable buffers or temporary buffers
-    - See [`:ScratchBufferOpen`](https://github.com/aiya000/vim-scratch-buffer/blob/736eef08b531b91c95497917ddb97ffbc2047c73/doc/vim-scratch-buffer.txt#L86) and [`:ScratchBufferOpenFile`](https://github.com/aiya000/vim-scratch-buffer/blob/736eef08b531b91c95497917ddb97ffbc2047c73/doc/vim-scratch-buffer.txt#L120)
-- Specify filetype, opening method (`:split` or `:vsplit`), and buffer height (width)
-    - Filetype specification enables syntax highlighting
+    - See `:help :ScratchBufferOpen` and `:help :ScratchBufferOpenNext`
+
+- Buffer type options
+    - Choose between writeable buffers or temporary buffers
+    - Automatic saving for file buffers when enabled
+    - Convert temporary buffers to persistent ones when needed
+    - See `:help :ScratchBufferOpen` and `:help :ScratchBufferOpenFile`
+
+- Customization options
+    - Specify filetype for syntax highlighting
+    - Choose opening method (`:split` or `:vsplit`)
+    - Control buffer height/width
+    - Configurable auto-hiding behavior
+
+### :gear: Detailed Usage
+
+```vim
+" Basic Usage
+
+" Open a temporary buffer using default settings
+:ScratchBufferOpen
+
+" Same as :ScratchBufferOpen but opens a writable persistent buffer
+:ScratchBufferOpenFile
+```
+
+```vim
+" Open a new scratch buffer with a specific filetype
+
+" Example: Markdown
+:ScratchBufferOpen md
+
+" Example: TypeScript
+:ScratchBufferOpen ts
+
+" Example: No filetype
+:ScratchBufferOpen --no-file-ext
+```
+
+```vim
+" Open multiple scratch buffers
+:ScratchBufferOpen md      " Opens most recently used buffer
+:ScratchBufferOpenNext md  " Always creates a new buffer
+```
 
-## :gear: Other Features
+```vim
+" Open a small buffer at the top for quick notes
+:ScratchBufferOpen md sp 5
+:ScratchBufferOpen --no-file-ext sp 5
+```
 
 ```vim
 " Delete all scratch files and buffers
@@ -82,21 +124,34 @@ Compared to scratch.vim, vim-scratch-buffer provides these additional features:
 
 ## :keyboard: Default Keymappings
 
-By default (`g:scratch_buffer_use_default_keymappings` is enabled), the following keymappings are available:
+When `g:scratch_buffer_use_default_keymappings` is enabled (default: `v:false`), the following keymappings are available:
 
 ```vim
+" Quick open commands (execute immediately)
 nnoremap <silent> <leader>b <Cmd>ScratchBufferOpen<CR>
 nnoremap <silent> <leader>B <Cmd>ScratchBufferOpenFile<CR>
+
+" Interactive commands (allows adding arguments)
 nnoremap <leader><leader>b :<C-u>ScratchBufferOpen<Space>
 nnoremap <leader><leader>B :<C-u>ScratchBufferOpenFile<Space>
 ```
 
-You can disable these default keymappings by setting:
+The quick open commands create buffers with default settings, while the interactive commands let you specify file extension, open method, and buffer size.
+
+You can customize these mappings by disabling the defaults:
 
 ```vim
 let g:scratch_buffer_use_default_keymappings = v:false
 ```
 
+And then defining your own:
+
+```vim
+" Example custom mappings
+nnoremap <silent> <leader>s <Cmd>ScratchBufferOpen<CR>
+nnoremap <silent> <leader>S <Cmd>ScratchBufferOpenFile<CR>
+```
+
 ## :sparkles: scratch.vim Compatibility
 
 To make the plugin behave like scratch.vim, you can enable automatic buffer hiding!

autoload/scratch_buffer.vim

@@ -8,68 +8,94 @@ scriptversion 3
 "     - If omitted, creates a buffer without file extension
 " - (second argument) {'sp' | 'vsp' | undefined} (Optional) An open method. How to open the new buffer
 " - (third argument) {number | undefined} (Optional) A positive number to `:resize buffer_size`
-function! scratch_buffer#open(...) abort
-  return s:open_buffer(v:true, a:000)
+function! scratch_buffer#open(opening_next_fresh_buffer, ...) abort
+  return s:open_buffer(#{
+    \ opening_temporary_buffer: v:true,
+    \ opening_next_fresh_buffer: a:opening_next_fresh_buffer,
+    \ args: a:000,
+  \ })
 endfunction
 
-function! scratch_buffer#open_file(...) abort
-  return s:open_buffer(v:false, a:000)
+function! scratch_buffer#open_file(opening_next_fresh_buffer, ...) abort
+  return s:open_buffer(#{
+    \ opening_temporary_buffer: v:false,
+    \ opening_next_fresh_buffer: a:opening_next_fresh_buffer,
+    \ args: a:000,
+  \ })
 endfunction
 
-function! s:open_buffer(temp_buffer, args) abort
-  const file_ext = get(a:args, 0, g:scratch_buffer_default_file_ext)
+function! s:open_buffer(options) abort
+  const args = a:options.args
+  const opening_temporary_buffer = a:options.opening_temporary_buffer
+  const opening_next_fresh_buffer = a:options.opening_next_fresh_buffer
+
+  const file_ext = get(args, 0, g:scratch_buffer_default_file_ext)
   const file_pattern = (file_ext ==# '--no-file-ext' || file_ext ==# '')
     \ ? $'{g:scratch_buffer_tmp_file_pattern}'
     \ : $'{g:scratch_buffer_tmp_file_pattern}.{file_ext}'
 
-  const file_name = s:find_fresh_tmp_file(file_pattern)
-  if file_name is v:null
-    throw 'No fresh scratch file found.'
-  endif
+  const index = s:find_current_index(file_pattern) + (opening_next_fresh_buffer ? 1 : 0)
+  const file_name = expand(printf(file_pattern, index))
 
-  const open_method = get(a:args, 1, g:scratch_buffer_default_open_method)
-  const buffer_size = get(a:args, 2, g:scratch_buffer_default_buffer_size)
+  const open_method = get(args, 1, g:scratch_buffer_default_open_method)
+  const buffer_size = get(args, 2, g:scratch_buffer_default_buffer_size)
 
   execute 'silent' open_method file_name
 
-  if a:temp_buffer
-    setlocal noswapfile
+  if opening_temporary_buffer
     setlocal buftype=nofile
     setlocal bufhidden=hide
+  else
+    setlocal buftype=
+    setlocal bufhidden=
   endif
 
   if buffer_size !=# v:null
     execute (open_method ==# 'vsp' ? 'vertical' : '') 'resize' buffer_size
   endif
 endfunction
 
-function! s:find_fresh_tmp_file(pattern) abort
-  const all_buffer_names = scratch_buffer#helper#get_all_buffer_names()
+function! s:find_current_index(pattern) abort
+  " NOTE: `[]->max()` returns 0
+  const max_buffer_index = scratch_buffer#helper#get_all_buffer_names()
+    \ ->mapnew({ _, buffer_name -> s:extract_index_from_name(buffer_name, a:pattern)})
+    \ ->max()
+  const max_file_index = glob(substitute(a:pattern, '%d', '*', ''), v:false, v:true)
+    \ ->mapnew({ _, file_name -> s:extract_index_from_name(file_name, a:pattern) })
+    \ ->max()
+  return [max_buffer_index, max_file_index]->max()
+endfunction
 
-  for i in range(0, 100000)
-    let scratch = expand(printf(a:pattern, i))
-    if !filereadable(scratch) && !all_buffer_names->scratch_buffer#helper#contains(scratch)
-      return scratch
-    endif
-  endfor
-  return v:null
+function! s:extract_index_from_name(name, pattern) abort
+  const getting_index_regex = substitute(a:pattern, '%d', '\\(\\d\\+\\)', '')
+  const matches = matchlist(a:name, getting_index_regex)
+  return len(matches) > 1 ? str2nr(matches[1]) : v:null
+endfunction
+
+function! s:find_next_index(pattern) abort
+  return  + 1
 endfunction
 
 " Clean up all scratch buffers and files
 function! scratch_buffer#clean() abort
-  const all_buffer_names = scratch_buffer#helper#get_all_buffer_names()
-  const base_pattern = printf(g:scratch_buffer_tmp_file_pattern, '*')
-  const files = glob(base_pattern .. '*', 0, 1)
-
-  for scratch in files
-    if filereadable(scratch)
-      call delete(scratch)
-    endif
+  const files = glob(
+    \ substitute(g:scratch_buffer_tmp_file_pattern, '%d', '*', ''),
+    \ v:false,
+    \ v:true,
+  \ )
+  for file in files
+    call delete(file)
   endfor
 
-  for scratch in all_buffer_names
-    if scratch =~# base_pattern
-      execute ':bwipe!' bufnr(scratch)
-    endif
+  const scratch_prefix = '^' .. substitute(
+    \ g:scratch_buffer_tmp_file_pattern,
+    \ '%d',
+    \ '',
+    \ '',
+  \ )
+  const buffers = scratch_buffer#helper#get_all_buffer_names()
+    \ ->filter({ _, buffer_name -> buffer_name =~# scratch_prefix })
+  for buffer in buffers
+    execute ':bwipe!' bufnr(buffer)
   endfor
 endfunction