nvim 1.0.0

data/lib/neovim/foreign/mplight/bufferio.rb

@@ -0,0 +1,51 @@
+#
+#  neovim/foreign/mplight/bufferio.rb  --  Buffer behaving like an IO
+#
+
+# The purpose of this is simply to reduce dependencies.
+
+begin
+  require "mplight/bufferio"
+rescue LoadError
+
+# ----------------------------------------------------------------
+#
+#  mplight/bufferio.rb  --  Buffer behaving like an IO
+#
+
+
+module MPLight
+
+  class BufferIO
+
+    attr_reader :data
+
+    def initialize str = nil
+      @data = str||""
+    end
+
+    def binmode
+      @data.force_encoding Encoding::ASCII_8BIT
+    end
+    def sync= _ ; end
+    def sync    ; true ; end
+
+    def write d
+      @data << d
+    end
+
+    def read n
+      @data.slice! 0, n
+    end
+
+    def flush
+    end
+
+  end
+
+end
+
+# ----------------------------------------------------------------
+
+end
+

data/lib/neovim/foreign/mplight.rb

@@ -0,0 +1,327 @@
+#
+#  neovim/foreign/mplight.rb  --  Lightweight MessagePack implementation
+#
+
+# The purpose of this is simply to reduce dependencies.
+
+begin
+  require "mplight"
+rescue LoadError
+
+# ----------------------------------------------------------------
+#
+#  mplight.rb  --  Lightweight MessagePack implementation
+#
+
+
+module MPLight
+
+  VERSION = "1.0".freeze
+
+  class Error ; end
+
+
+  class Types
+
+    def initialize *args, **kwargs
+      @cls = {}
+      @ids = {}
+      register -1, Time
+    end
+
+    def register id, klass
+      @cls[ id], @ids[ klass] = klass, id
+    end
+
+    def dump obj
+      t = @ids[ obj.class]
+      unless t then
+        return if @default_to_string
+        raise Error, "Unregistered class: #{obj.class}"
+      end
+      [ t, obj.to_mpdata]
+    end
+
+    def default_to_string! ; @default_to_string = true ; end
+
+    def create id, data
+      c = @cls[ id]
+      c or raise Error, "Unregistered type id: #{obj.class}"
+      c.from_mpdata data, *additional_data
+    end
+
+    def additional_data
+      []
+    end
+
+  end
+
+
+  module Packer
+
+    attr_reader :output
+
+    def init_output output
+      @output = output
+      @output.binmode
+      @output.sync = true
+      self
+    end
+
+    def do_output output
+      oi = @output
+      init_output output
+      yield
+    ensure
+      @output = oi
+    end
+
+    def put obj
+      case obj
+      when nil   then write_fmt 0xc0
+      when false then write_fmt 0xc2
+      when true  then write_fmt 0xc3
+      when Integer then
+        if obj >= 0 then
+          case obj
+          when                ...0x80 then write_fmt obj
+          when               ...0x100 then write_fmt 0xcc ; write_pack obj, "C"
+          when             ...0x10000 then write_fmt 0xcd ; write_pack obj, "S>"
+          when         ...0x100000000 then write_fmt 0xce ; write_pack obj, "L>"
+          when ...0x10000000000000000 then write_fmt 0xcf ; write_pack obj, "Q>"
+          else                                 raise ArgumentError, "Integer too large: #{obj}"
+          end
+        else
+          case obj
+          when               -0x20... then write_fmt obj+256
+          when               -0x80... then write_fmt 0xd0 ; write_pack obj, "c"
+          when             -0x8000... then write_fmt 0xd1 ; write_pack obj, "s>"
+          when         -0x80000000... then write_fmt 0xd2 ; write_pack obj, "l>"
+          when -0x8000000000000000... then write_fmt 0xd3 ; write_pack obj, "q>"
+          else                             raise ArgumentError, "Integer too large: #{obj}"
+          end
+        end
+      when Float then
+        case
+        when false then write_fmt 0xca ; write_pack obj, "g"
+        else            write_fmt 0xcb ; write_pack obj, "G"
+        end
+      when String then
+        if obj.encoding == Encoding::ASCII_8BIT then
+          l = obj.size
+          case l
+          when       ...0x100 then write_fmt 0xc4 ; write_pack l, "C"
+          when     ...0x10000 then write_fmt 0xc5 ; write_pack l, "S>"
+          when ...0x100000000 then write_fmt 0xc6 ; write_pack l, "L>"
+          else                     raise ArgumentError, "Byte array too long: #{l} bytes"
+          end
+        else
+          obj = obj.encode Encoding::UTF_8 unless obj.encoding == Encoding::UTF_8
+          l = obj.bytesize
+          case l
+          when        ...0x20 then write_fmt 0xa0+l
+          when       ...0x100 then write_fmt 0xd9 ; write_pack l, "C"
+          when     ...0x10000 then write_fmt 0xda ; write_pack l, "S>"
+          when ...0x100000000 then write_fmt 0xdb ; write_pack l, "L>"
+          else                     raise ArgumentError, "String too long: #{l} bytes"
+          end
+        end
+        write_pack obj, "A*"
+      when Array then
+        l = obj.length
+        case l
+        when        ...0x10 then write_fmt 0x90+l
+        when     ...0x10000 then write_fmt 0xdc ; write_pack l, "S>"
+        when ...0x100000000 then write_fmt 0xdd ; write_pack l, "L>"
+        else                     raise ArgumentError, "Array too long: #{l} elements"
+        end
+        obj.each { |o| put o }
+      when Hash then
+        l = obj.length
+        case l
+        when        ...0x10 then write_fmt 0x80+l
+        when     ...0x10000 then write_fmt 0xde ; write_pack l, "S>"
+        when ...0x100000000 then write_fmt 0xdf ; write_pack l, "L>"
+        else                     raise ArgumentError, "Hash too long: #{l} keys"
+        end
+        obj.each { |k,v| put k ; put v }
+      when Symbol then
+        put obj.to_s
+      else
+        type, data = dump obj
+        type or return put obj.to_s
+        l = data.bytesize
+        case l
+        when           0x01 then write_fmt 0xd4 ;                      write_pack type, "c"
+        when           0x02 then write_fmt 0xd5 ;                      write_pack type, "c"
+        when           0x04 then write_fmt 0xd6 ;                      write_pack type, "c"
+        when           0x08 then write_fmt 0xd7 ;                      write_pack type, "c"
+        when           0x10 then write_fmt 0xd8 ;                      write_pack type, "c"
+        when       ...0x100 then write_fmt 0xc7 ; write_pack l, "C"  ; write_pack type, "c"
+        when     ...0x10000 then write_fmt 0xc8 ; write_pack l, "S>" ; write_pack type, "c"
+        when ...0x100000000 then write_fmt 0xc9 ; write_pack l, "L>" ; write_pack type, "c"
+        else                     raise ArgumentError, "Object too large: #{l} bytes"
+        end
+        write_pack data, "A*"
+      end
+      self
+    end
+
+    private
+
+    def write_pack i, t
+      d = [i].pack t
+      @output.write d
+    end
+
+    def write_fmt i
+      write_pack i, "C"
+    end
+
+  end
+
+
+  module Unpacker
+
+    attr_reader :input
+
+    def init_input input
+      @input = input
+      @input.binmode
+      self
+    end
+
+    def do_input input
+      oi = @input
+      init_input input
+      yield
+    ensure
+      @input = oi
+    end
+
+    def eof?
+      @input.eof?
+    end
+
+    def get
+      fmt = (read 1).unpack1 "C"
+      case fmt >> 7
+      when 0b0 then fmt
+      else
+        case fmt >> 5
+        when 0b111 then fmt - 256
+        when 0b101 then get_str fmt&0b11111
+        else
+          case fmt >> 4
+          when 0b1000 then get_hsh fmt&0b1111
+          when 0b1001 then get_ary fmt&0b1111
+          else
+            case fmt
+            when 0xc0 then nil
+            when 0xc1 then raise ArgumentError, "Illegal format: #{fmt}"
+            when 0xc2 then false
+            when 0xc3 then true
+            when 0xc4 then read    get_len1
+            when 0xc5 then read    get_len2
+            when 0xc6 then read    get_len4
+            when 0xc7 then get_ext get_len1
+            when 0xc8 then get_ext get_len2
+            when 0xc9 then get_ext get_len4
+            when 0xca then (read 4).unpack1 "g"
+            when 0xcb then (read 8).unpack1 "G"
+            when 0xcc then (read 1).unpack1 "C"
+            when 0xcd then (read 2).unpack1 "S>"
+            when 0xce then (read 4).unpack1 "L>"
+            when 0xcf then (read 8).unpack1 "Q>"
+            when 0xd0 then (read 1).unpack1 "c"
+            when 0xd1 then (read 2).unpack1 "s>"
+            when 0xd2 then (read 4).unpack1 "l>"
+            when 0xd3 then (read 8).unpack1 "q>"
+            when 0xd4 then get_ext  1
+            when 0xd5 then get_ext  2
+            when 0xd6 then get_ext  4
+            when 0xd7 then get_ext  8
+            when 0xd8 then get_ext 16
+            when 0xd9 then get_str get_len1
+            when 0xda then get_str get_len2
+            when 0xdb then get_str get_len4
+            when 0xdc then get_ary get_len2
+            when 0xdd then get_ary get_len4
+            when 0xde then get_hsh get_len2
+            when 0xdf then get_hsh get_len4
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def read n
+      @input.read n
+    end
+
+    def get_len1 ; (read 1).unpack1 "C"  ; end
+    def get_len2 ; (read 2).unpack1 "S>" ; end
+    def get_len4 ; (read 4).unpack1 "L>" ; end
+
+    def get_str len
+      (read len).force_encoding Encoding::UTF_8
+    end
+
+    def get_ary len
+      (0...len).map { get }
+    end
+
+    def get_hsh len
+      (0...len).inject Hash.new do |h,| k = get ; h[k] = get ; h end
+    end
+
+    def get_ext len
+      type = (read 1).unpack1 "c"
+      create type, (read len)
+    end
+
+  end
+
+end
+
+
+class Time
+
+  class <<self
+
+    def from_mpdata data, *args
+      case data.length
+      when  4 then
+        s, = data.unpack "L>"
+        Time.at s
+      when  8 then
+        t, = data.unpack "Q>"
+        n = t >> 34
+        t &= 0x3ffffffff
+        Time.at t, n, :nanosecond
+      when 12 then
+        n, s = data.unpack "L>Q>"
+        Time.at s, n, :nanosecond
+      else
+        raise ArgumentError, "Illegal time data: #{data.inspect}"
+      end
+    end
+
+  end
+
+  def to_mpdata
+    case
+    when tv_nsec.zero? && tv_sec < 0x100000000 then [ tv_sec].pack "L>"
+    when                  tv_sec < 0x400000000 then [ (tv_nsec << 34)|tv_sec].pack "Q>"
+    else                                            [ tv_nsec, tv_sec].pack "L>Q>"
+    end
+  end
+
+end
+
+# ----------------------------------------------------------------
+
+end
+

data/lib/neovim/foreign/supplement/socket.rb

@@ -0,0 +1,20 @@
+#
+#  neovim/foreign/supplement/socket.rb  --  Addition usefull Ruby socket functions
+#
+
+# The purpose of this is simply to reduce dependencies.
+
+begin
+  require "supplement/socket"
+rescue LoadError
+  require "socket"
+  class TCPServer
+    alias accept_orig accept
+    private :accept_orig
+    def accept
+      a = accept_orig
+      if block_given? then yield a else a end
+    end
+  end
+end
+

data/lib/neovim/foreign/supplement.rb

@@ -0,0 +1,34 @@
+#
+#  neovim/foreign/supplement.rb  --  Addition usefull Ruby functions
+#
+
+# The purpose of this is simply to reduce dependencies.
+
+begin
+  require "supplement"
+rescue LoadError
+  class NilClass ; def notempty? ;                      end ; end
+  class String   ; def notempty? ; self unless empty? ; end ; end
+  class Array    ; def notempty? ; self unless empty? ; end ; end
+  class NilClass   ; def to_bool ; false ; end ; end
+  class FalseClass ; def to_bool ; false ; end ; end
+  class Object     ; def to_bool ; true  ; end ; end
+  class <<Struct ; alias [] new ; end
+  class String
+    def axe n
+      if n < length then
+        e = "..."
+        l = e.length
+        if n > l then
+          n -= l
+        else
+          l = 0
+        end
+        (slice 0, n) << "..."[0,l]
+      else
+        self
+      end
+    end
+  end
+end
+

data/lib/neovim/handler.rb

@@ -0,0 +1,139 @@
+#
+#  lib/neovim/handler.rb  --  Handlers
+#
+
+require "neovim/foreign/supplement"
+
+
+module Neovim
+
+  class Handler
+
+    attr_reader :spec
+
+    def initialize name, type = nil, sync = nil, **options, &block
+      @block = block
+      standardize options
+      @spec = {
+        name: name,
+        opts: options,
+        type: type,
+        sync: sync,
+      }
+      @spec.compact!
+    end
+
+    def name ; @spec[ :name] ; end
+    def opts ; @spec[ :opts] ; end
+    alias options opts
+    def sync ; @spec[ :sync] ; end
+    alias sync? sync
+
+    def execute *args
+      @block.call *args
+    end
+
+    private
+
+    def standardize opts
+      opts.each { |k,v|
+        case v
+        when false           then opts[ k] = nil
+        when true            then opts[ k] = ""
+        when String, Integer then
+        else                      opts[ k] = v.to_s
+        end
+      }
+      opts.compact!
+    end
+
+  end
+
+  class DslBase
+
+    class Plugins
+
+      attr_reader :type
+
+      def initialize type, setup_blocks, handlers
+        @type, @setup_blocks, @handlers = type, setup_blocks, handlers
+      end
+
+      def setup client
+        @setup_blocks.each { |b| b.call client }
+      end
+
+      def get_handler name
+        @handlers[ name]
+      end
+
+      def specs
+        @handlers.map { |_,handler| handler.spec }
+      end
+
+      def options
+        @handlers.each { |name,handler| yield name, handler.options }
+      end
+
+    end
+
+    include Logging
+
+    class <<self
+      private :new
+      def open source, host
+        i = new source
+        yield i
+        i.add_plugins source, host
+      end
+    end
+
+    def initialize source
+      @setup_blocks = []
+      @handlers = {}
+    end
+
+    def add_plugins source, host
+      host.add_plugins source, (Plugins.new self.class::TYPE, @setup_blocks, @handlers)
+    end
+
+    private
+
+    def add_handler qualified_name, name, type = nil, sync = nil, **opts, &block
+      name = name.to_s
+      qualified_name ||= name
+      h = Handler.new name, type, sync, **opts, &block
+      log :info, "Adding Handler", qualified_name: qualified_name, handler: h.spec
+      @handlers[ qualified_name] = h
+    end
+
+    def add_setup_block &block
+      @setup_blocks.push block
+    end
+
+  end
+
+  class DslPlain < DslBase
+
+    TYPE = :base
+
+    def plain name, **opts
+      add_handler nil, name, **opts do |client,*args|
+        yield *args
+      end
+    end
+
+  end
+
+  class DslRemote < DslBase
+
+    TYPE = :remote
+
+    def register_handler name, &block
+      add_handler nil, name, &block
+    end
+
+  end
+
+end
+

data/lib/neovim/host.rb

@@ -0,0 +1,87 @@
+#
+#  neovim/host.rb  --  Host for Neovim
+#
+
+require "neovim/remote"
+
+
+module Neovim
+
+  class Host < Remote
+
+    class <<self
+
+      def start
+        super ConnectionStdio do |h|
+          yield h
+        end
+      end
+
+    end
+
+    attr_reader :plugins
+
+    BASE = :base
+
+    def initialize conn
+      super
+      DslPlain.open BASE, self do |dsl|
+        dsl.plain "poll" do
+          start
+          @plugins.each_value { |p| p.setup @conn.client }
+          "ok"
+        end
+        dsl.plain "specs", nargs: 1 do |source|
+          p = @plugins[ source]
+          p or raise "Unknown plugin #{source}"
+          p.specs
+        end
+        dsl.plain "nvim_error_event", nargs: 2 do |errid,msg|
+          raise "#{@conn.error errid} from Neovim: #{msg}"
+        end
+      end
+    end
+
+    def client_name
+      types = @plugins.map { |_,p| p.type if p.type != BASE }
+      types.uniq!
+      types.compact!
+      name = types.join "-"
+      log :info, "Client Name", name: name
+      "ruby-#{name}-host"
+    end
+
+    def client_methods
+      r = {}
+      @plugins[ BASE].options { |name,opts| r[ name] = opts }
+      r
+    end
+
+
+    class <<self
+
+      def run
+        $stdin.tty? and raise "This program expects to be called by Neovim. It can't run interactively."
+        Host.start do |h|
+          yield h
+          h.run
+          nil
+        rescue Messager::Disconnected
+          log :fatal, "Disconnected"
+          nil
+        rescue SignalException
+          n = $!.signm
+          log :fatal, "Signal was caught: #{n}"
+          (n =~ /\A(?:SIG)?TERM\z/) ? 0 : 1
+        rescue Exception
+          log_exception :fatal
+          2
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/neovim/info.rb

@@ -0,0 +1,10 @@
+require "neovim/meta.rb"
+Neovim::INFO = Neovim::Meta.new "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.\nClean code, minimal dependecies, no frills, no wokeness.",
+  homepage: "http://bertram-scharpf.de",
+  commit: "e927f7e"