nvim 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8207d1ea220ae3a18b71de6377beaac8f117b7b8fb2c816f773a36dc2852043
+  data.tar.gz: eb0c7bf8c52bc66a26952c5985edc3a0ffca154b0ba51560f9802428e51594b2
+SHA512:
+  metadata.gz: 17c4b731220d2da8b667da00bfba85b63f27664d0d6119f4d021b92e66c24ecabd279abc090b8cba6b5ff84baeb2561d6ce3410c7fabb1c91a94857c82d2f82e
+  data.tar.gz: 3197fe71bdd9506350206fff209e2b0c9fb93bfa926f204e4bebcbacfee849a566b42f9f576efdeb86ee751fbc7b8197a07329fe6e2e9191b735ad86ac3c9604

data/INFO.yaml

@@ -0,0 +1,18 @@
+#
+#  INFO.yaml  --  Version number etc.
+#
+
+nvim:
+  version: 1.0.0
+  license: BSD-2-Clause+
+  authors:
+    - Bertram Scharpf
+  email: software@bertram-scharpf.de
+
+  summary: Yet another Ruby client for Neovim
+  description: |-
+    A simple Ruby client for Neovim.
+    Clean code, minimal dependecies, no frills, no wokeness.
+
+  homepage: http://bertram-scharpf.de
+

data/LICENSE

@@ -0,0 +1,52 @@
+# BSD-2-clause license, extended by language use conditions
+
+Copyright (C) 2024, Bertram Scharpf <software@bertram-scharpf.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Redistributions must not contain any clauses about anticipated
+    harassment or discrimination, nor must they be held in a so-called
+    "inclusive language". As far as German language is used, the
+    conditions mentioned below additionally apply.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## Use of the German Language
+
+Beim Gebrauch deutscher Sprache sind Weiterentwicklungen und
+-verbreitungen nur gestattet unter Einhaltung folgender
+zusätzlicher Bedingungen:
+
+  * Keine Verwendung von sogenannter „geschlechtergerechter Sprache“,
+    also Anfügen von weiblichen Endungen mit Binnen-I, Sternchen,
+    Doppelpunkt, Unterstrich oder ähnlichem, oder Konstruktionen, die
+    den Sachverhalt falsch wiedergeben („Radfahrende“, „Studierende“).
+
+  * Keine Verwendung der „reformierten Rechtschreibung“ von 1996,
+    insbesondere Doppel-S am Silbenende, „plazieren“ mit T, sowie
+    Großschreibung von Wendungen wie „des weiteren“.
+
+
+<!-- vim:set ft=markdown : -->

data/README.md

@@ -0,0 +1,264 @@
+# Ruby-Nvim
+
+Ruby support for [Neovim](https://github.com/neovim/neovim).
+
+Clean code, minimal dependecies, no frills, no wokeness.
+
+*I would have written a shorter letter, but I did not have the time.* --
+Blaise Pascal
+
+
+## Installation
+
+```shell
+sudo gem uninstall neovim || true
+sudo gem install nvim
+```
+
+You may prefer to also install the dependencies. Yet, this is not
+neccessary, as they are small and Ruby-Nvim includes a copy of them.
+
+```shell
+sudo gem install supplement mplight
+```
+
+
+## Usage
+
+
+### Command, Function and Autoload Plugins
+
+Put this into a new buffer:
+
+```ruby
+Neovim.plugin do |dsl|
+  dsl.command :SetLine, nargs: 1 do |client,(str)|
+    client.set_current_line str
+  end
+  dsl.function :Sum, nargs: 2, sync: true do |client,(x,y)|
+    x + y
+  end
+  dsl.autocmd :BufEnter, pattern: "*.rb" do |client|
+    client.command "echom 'Hello, Ruby!'"
+  end
+end
+```
+
+Then run these Vim commands:
+
+```vim
+w ++p ~/.config/nvim/rplugin/ruby/demo.rb
+UpdateRemotePlugins
+
+" Check the generated manifest file
+split ~/.local/share/nvim/rplugin.vim
+help remote-plugin-manifest
+```
+
+Open a new Neovim and see what happens:
+
+```vim
+e dummy.rb
+SetLine some text
+echo Sum(13,7)
+```
+
+
+### Calling the :ruby... Interface
+
+The `:ruby...` commands and the `rubyeval()` function behave as descibed
+in `:h ruby`.
+
+Additionally you can directly execute the buffers contents:
+
+```vim
+set number
+```
+
+```
+ 1 class C
+ 2   def f
+ 3     :F
+ 4   end
+ 5 end
+ 6 c = C.new
+~
+~
+~
+:1,6ruby |
+```
+
+The last value, if it is not `nil`,  will be added through `#inspect` as
+a comment.
+
+```
+ 1 class C
+ 2   def f
+ 3     :F
+ 4   end
+ 5 end
+ 6 c = C.new
+ 7 #=> #<C:0x000001b347456478>
+~
+~
+:
+```
+
+The classes and variables will be preserved and are available during the
+next call.
+
+```
+ 5 end
+ 6 c = C.new
+ 7 #=> #<C:0x00001fd2fd1f89d0>
+ 8 [ c.f, C]
+~
+~
+~
+:8ruby |
+```
+
+This results in:
+
+```
+ 7 #=> #<C:0x00001fd2fd1f89d0>
+ 8 [ c.f, C]
+ 9 #=> [:F, C]
+~
+~
+:
+```
+
+Output will be added to the buffer, too.
+
+```
+ 1 puts "ba" + "na"*2
+ 2 print "hell"
+ 3 puts "o"
+~
+~
+:%ruby |
+```
+
+Further, a simple number/cash summing tool is included.
+
+```
+Apples    :     3.99
+Bananas   : 5 * 0.40          # multiplication
+Oranges   :     3.59 | -10%   # percentage added (here subtracted)
+Kiwi      :     0,40          # comma is allowed
+Coconut   :     5,-           # empty decimal places
+~
+~
+:%ruby +
+```
+
+
+### Modern rpcrequest() Calls
+
+Put this into a new buffer:
+
+```ruby
+require "neovim"
+counter = 0
+Neovim.start_remote do |dsl|
+  dsl.register_handler "rb_add" do |client,n|
+    counter += n
+    client.command "echo 'Counter value now is: '..#{counter}..'.'"
+  end
+  dsl.register_handler "rb_raise" do |client|
+    raise "Ouch!"
+  end
+end
+```
+
+Then enter these Vim commands:
+
+```vim
+w demo_remote.rb
+let chan = jobstart(['ruby','demo_remote.rb'], { 'rpc': v:true })
+call rpcrequest(chan, 'rb_add', 7)
+call rpcrequest(chan, 'rb_raise')
+call jobstop(chan)
+```
+
+If you prefer, you can also use a shebang line.
+
+```ruby
+#!/usr/bin/env ruby
+require "neovim"
+Neovim.start_remote do |dsl|
+  # ... (as above)
+end
+```
+
+Then enter these Vim commands:
+
+```vim
+w demo_remote.rb
+!chmod +x %
+let chan = jobstart('./demo_remote.rb', { 'rpc': v:true })
+" proceed as above
+```
+
+
+### Logging and Debugging
+
+Logging is a easy as this:
+
+```shell
+export NVIM_RUBY_LOG_LEVEL=all NVIM_RUBY_LOG_FILE=nvim.log
+nvim +'ruby puts "hi"*10'
+```
+
+To show the log levels, simply run in Neovim:
+
+```vim
+ruby puts Neovim::Logging::LEVELS.keys
+```
+
+If you are inside a [Tmux](https://tmux.github.io), you might prefer to trace the colored log in a split window.
+
+```shell
+tmux split-window -fhd 'echo -e "\e[33m==== $$ ==== `tty` ====\e[m" ; ln -sf `tty` /tmp/tmux-`id -u`/debug ; exec cat >/dev/null 2>&1'
+export NVIM_RUBY_LOG_LEVEL=all NVIM_RUBY_LOG_FILE=/tmp/tmux-`id -u`/debug
+
+examples/demo_attach
+
+nvim +'ruby puts "hi"*10'
+```
+
+You may start an interactive session and control a running Neovim through it.
+Open Neovim specifying the `--listen` option
+
+```shell
+nvim --listen /path/to/some.sock
+```
+
+or ask the running Neovim for its server name.
+
+```vim
+echo v:servername
+```
+
+Then connect to it. This requires the [Intar](https://github.com/BertramScharpf/ruby-intar) gem.
+
+```
+$ intar -r neovim/remote
+main:0:001> include Neovim
+=> Object
+main:0:002> Remote.start_client ConnectionUnix, "/path/to/some.sock" do |c|&
+main:1:001> c.command "e /etc/passwd"
+main:1:002> b = c.get_current_buf
+=> #<Neovim::Buffer:400 1>
+main:1:003> b[1]
+=> ["root:*:0:0:Charlie &:/root:/bin/sh"]
+main:1:004> \q!!
+```
+
+
+## Copyright
+
+  * (C) 2024 Bertram Scharpf <software@bertram-scharpf.de>
+  * License: [BSD-2-Clause+](./LICENSE)
+

data/Rakefile

@@ -0,0 +1,68 @@
+#
+#  Rakefile  --  Generate files
+#
+
+
+INFOFILE = "lib/neovim/info.rb"
+
+
+GENERATED = [ INFOFILE]
+
+task :default => GENERATED
+task :infofile => INFOFILE
+
+
+file INFOFILE => "INFO.yaml" do |f|
+  create_info f.name, f.source
+end
+
+
+task :clean do
+  rm *GENERATED
+end
+
+
+def commit
+  c = `git rev-parse --short HEAD`
+  c.chomp!
+  c
+end
+
+def create_info dst, src
+  File.open dst, "w" do |vf|
+    require "yaml"
+    m = YAML.load File.read src
+    name = m.keys.first
+    args = m[ name]
+    args[ :commit] = commit
+    unless args[ :authors] then
+      u = args.delete :author
+      args[ :authors] = [ u] if u
+    end
+    vf.puts 'require "neovim/meta.rb"'
+    vf.print "Neovim::INFO = Neovim::Meta.new #{name.inspect}"
+    args.each { |k,v|
+      vf.puts ","
+      vf.print "  #{k.to_sym}: #{v.inspect}"
+    }
+    vf.puts
+  end
+end
+
+
+task :diffdeps do
+  %w(mplight).each { |gem|
+    c = `gem contents #{gem}`
+    unless $?.success? then
+      puts "Gem #{gem} not installed. Cannot compare."
+      next
+    end
+    (c.split $/).each { |file|
+      if file =~ %r[/gems/#{gem}-.*/lib/(.*\.rb)$] then
+        ours = "lib/neovim/foreign/#$1"
+        sh *%W(nvim -d #{ours} #{file}) if File.exist? ours
+      end
+    }
+  }
+end
+

data/bin/neovim-ruby-host

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+#
+#  bin/neovim-ruby-host  --  Child started by Neovim
+#
+
+require "neovim/host"
+
+
+module Neovim
+
+  class <<self
+
+    def plugin &block
+      require "neovim/vimscript_provider"
+      run_dsl DslVimscript, &block
+    end
+
+    private
+
+    def run_dsl dsl
+      @host or raise "Can't add plugins outside of a running session."
+      dsl.open @path, @host do |dsl|
+        yield dsl
+      end
+    end
+
+  end
+
+  if $*.delete "--version" then
+    puts [ Neovim::INFO.name, Neovim::INFO.version].join " "
+    exit
+  end
+
+  r = Host.run do |h|
+    begin
+      @host = h
+      $*.each do |p|
+        @path = p
+        Kernel.load @path, true
+      ensure
+        @path = nil
+      end
+    ensure
+      @host = nil
+    end
+  end
+  exit r.to_i
+
+end
+

data/lib/neovim/client.rb

@@ -0,0 +1,108 @@
+#
+#  neovim/client.rb  --  Clients
+#
+
+require "neovim/foreign/supplement"
+
+require "neovim/remote_object"
+
+
+module Neovim
+
+  class Client
+
+    @strict = true
+    class <<self
+      attr_accessor :strict
+    end
+
+    class UnknownApiFunction       < RuntimeError ; end
+    class UnknownApiObjectFunction < RuntimeError ; end
+
+
+    attr_reader :channel_id
+
+    def initialize comm, channel_id
+      @comm, @channel_id = comm, channel_id
+      @functions = {}
+      @objfuncs  = Hash.new do |h,k| h[k] = {} end
+    end
+
+    def inspect
+      "#<#{self.class} #@channel_id>"
+    end
+
+    def add_functions list, prefixes
+      list.each { |fn|
+        next if fn[ "deprecated_since"] && self.class.strict
+        n = fn[ "name"]
+        next unless n =~ /\Anvim_/
+        @functions[ $'.to_sym] = n
+        t, = prefixes.find { |t,p| n =~ p }
+        @objfuncs[ t][ $'.to_sym] = n if t
+      }
+    end
+
+
+    def call_api name, *args
+      f = @functions[ name.to_sym]
+      f or raise UnknownApiFunction, "Function: #{name}"
+      @comm.request f, *args
+    end
+
+    def call_obj obj, name, *args
+      n = obj.type
+      f = @objfuncs[ n.to_sym][ name.to_sym]
+      f or raise UnknownApiObjectFunction, "Object: #{n}, Function: #{name}"
+      @comm.request f, obj.index, *args
+    end
+
+
+
+    def method_missing sym, *args
+      call_api sym, *args
+    rescue UnknownApiFunction
+      super
+    end
+
+    def respond_to_missing? sym, priv = nil
+      # Be aware that calling a proc (our handlers) with a single argument
+      # asks whether that argument is an array. In case it is a Client object,
+      # we end up here with +sym = to_ary+.
+      @functions[ sym.to_sym].to_bool
+    end
+
+    def methods regular = true
+      s = super
+      s |= @functions.keys if regular
+      s
+    end
+
+
+    def has_obj_function? obj, name
+      @objfuncs[ obj.type][ name.to_sym].to_bool
+    end
+
+    def obj_functions obj
+      @objfuncs[ obj.type].keys
+    end
+
+
+
+    def message str
+      call_api :out_write, str
+      str.end_with? $/ or call_api :out_write, $/
+    end
+
+
+    include OptionAccess
+    OPTION_PARAM = nil
+
+    def command arg ; call_api :command, arg ; end
+
+    def evaluate expr ; call_api :eval, expr ; end
+
+  end
+
+end
+

data/lib/neovim/connection.rb

@@ -0,0 +1,129 @@
+#
+#  neovim/connection.rb  --  Connections
+#
+
+require "neovim/logging"
+require "neovim/client"
+require "neovim/info"
+
+
+module Neovim
+
+  class Connection < MPLight::Types
+
+    include Logging
+
+    include MPLight::Packer, MPLight::Unpacker
+
+    attr_reader :client
+
+    def initialize rd, wr
+      super
+      default_to_string!
+      init_input  rd
+      init_output wr
+      @errors = {}
+    end
+
+    def additional_data ; [ *super, @client] ; end
+
+
+    def error id
+      @errors[ id] || "Error #{id}"
+    end
+
+
+    def start comm, client_name, client_type, client_methods = nil
+      comm.notify :nvim_set_client_info, client_name, Neovim::INFO.version_h, client_type, client_methods||{}, Neovim::INFO.attributes
+      channel_id, api_info = *(comm.request :nvim_get_api_info)
+      @client = Client.new comm, channel_id
+      prefixes = {}
+      api_info[ "types"].each do |type,info|
+        type = type.to_sym
+        prefixes[ type] = /\A#{info[ "prefix"]}/
+        register_type type, info[ "id"]
+      end
+      @client.add_functions api_info[ "functions"], prefixes
+      api_info[ "error_types"].each { |type,info|
+        register_error type, info[ "id"]
+      }
+      nil
+    end
+
+    private
+
+    def register_type type, id
+      klass = Neovim.const_get type
+      klass or raise "Class #{type} is not defined."
+      klass < RemoteObject or raise "Class #{klass} is not a descendant of RemoteObject."
+      log :debug2, "Registering type", type: type, id: id
+      register id, klass
+    end
+
+    def register_error id, type
+      @errors[ id] = type
+    end
+
+  end
+
+
+  class ConnectionTcp < Connection
+    class <<self
+      def open_files host, port
+        require "socket"
+        TCPSocket.open host, port do |socket|
+          yield (new socket, socket)
+        end
+      end
+    end
+  end
+
+  class ConnectionUnix < Connection
+    class <<self
+      def open_files path
+        require "socket"
+        UNIXSocket.open path do |socket|
+          yield (new socket, socket)
+        end
+      end
+    end
+  end
+
+  class ConnectionChild < Connection
+
+    class <<self
+
+      def open_files *argv
+        eb = "--embed"
+        argv.unshift eb unless argv.include? eb
+        argv.unshift path
+        IO.popen argv, "r+" do |io|
+          Process.detach io.pid
+          yield (new io, io)
+        end
+      end
+
+      def path
+        ENV[ "NVIM_EXECUTABLE"].notempty? || "nvim"
+      end
+
+      def version
+        IO.popen [ path, "--version"] do |io|
+          io.gets[ /\ANVIM +v?(.+)/, 1]
+        end
+      end
+
+    end
+
+  end
+
+  class ConnectionStdio < Connection
+    class <<self
+      def open_files *argv
+        yield (new $stdin, $stdout)
+      end
+    end
+  end
+
+end
+