nvim 1.0.0

data/lib/neovim/logging.rb

@@ -0,0 +1,249 @@
+#
+#  neovim/logging.rb  --  Logging facility
+#
+
+require "neovim/foreign/supplement"
+
+
+module Neovim
+
+  module Logging
+
+    class Logger
+
+      class <<self
+
+        private :new
+
+        SUBS = []
+
+        def inherited cls
+          SUBS.push cls
+        end
+
+        def provide str
+          opened = nil
+          args = str.to_s.split ":"
+          args.each { |a| a.gsub! %r/%(\h\h)/ do ($1.to_i 0x10).chr end }
+          cls =
+            if args.first =~ /\A\w+\z/ then
+              prot = args.shift
+              (SUBS.find { |s| s::NAME == prot rescue nil }) or raise "Logger not found: #{str}"
+            else
+              Text
+            end
+          dest = args.shift
+          cls.open dest, **(parse_arguments args) do |i|
+            opened = true
+            yield i
+          end
+        rescue  # Errno::EACCES, Errno::ENOENT
+          raise unless not opened and str.notempty?
+          $stderr.puts "Failed to open log file '#{str}'. Logging to stderr."
+          str = nil
+          retry
+        end
+
+        private
+
+        def parse_arguments args
+          r = {}
+          args.each { |a|
+            k, v = a.split "=", 2
+            r[ k.to_sym] = parse_value v
+          }
+          r
+        end
+
+        def parse_value val
+          if val.nil? then
+            true
+          elsif val =~ /\A(?:0x)?\d+\z/ then
+            Integer val
+          else
+            case val.downcase
+            when "true", "yes", "on"  then true
+            when "false", "no", "off" then false
+            else                           val.notempty?
+            end
+          end
+        end
+
+      end
+
+    end
+
+    class Null < Logger
+      NAME = "null"
+      class <<self
+        def open dest = nil
+          yield new
+        end
+      end
+      def put **fields
+      end
+    end
+
+    class Stream < Logger
+
+      class <<self
+        def open path = nil, **kwargs
+          if path.notempty? and path != "-" then
+            params = {}
+            %i(external_encoding newline).each do |k|
+              v = kwargs.delete k
+              params[ k] = v if v
+            end
+            File.open path, "a", **params do |f|
+              yield (new f, **kwargs)
+            end
+          else
+            yield (new $stderr, **kwargs)
+          end
+        end
+      end
+
+      def initialize file, **kwargs
+        @file = file
+      end
+
+    end
+
+    class Text < Stream
+      NAME = "file"
+      def initialize file, color: nil, short: nil
+        super
+        @color =
+          case color
+          when true, false then color
+          when 0           then false
+          when Integer     then true
+          else                  @file.tty?
+          end
+        @short = short
+      end
+      COLORS = %w(33 32 34;1 4 31;1 35;1 36)
+      def put **fields
+        put_sep
+        l = [
+          ((fields.delete :time).strftime "%H:%M:%S"),
+          ((fields.delete :pid).to_s.rjust 5),
+          (fields.delete :caller).to_s[ %r([^/]+:\d+)],
+          (fields.delete :level),
+          (fields.delete :message).inspect,
+          ((fields.delete :class).to_s.sub /.*::/, ""),
+          ((fields.map { |k,v| "#{k}:#{v}" }.join " ").axe 256),
+        ]
+        if @color then
+          l = l.zip COLORS
+          l.map! do |f,c| "\e[#{c}m#{f}\e[m" end
+        end
+        if @short then
+          s = l.shift 3
+          if not @nexttime or @nexttime < Time.now then
+            @file.puts s.join " "
+            @nexttime = Time.now + 120
+          end
+        end
+        @file.puts l.join " "
+        @file.flush
+        nil
+      end
+      def put_sep
+        if @file.tty? then
+          if not @nextsep or @nextsep < Time.now then
+            @file.puts $/*5
+            @nextsep = Time.now + 300
+          end
+        end
+      end
+    end
+
+    class Plain < Stream
+      NAME = "plain"
+      def put **fields
+        @file.puts fields.to_s
+        @file.flush
+      end
+    end
+
+    class Json < Stream
+      NAME = "json"
+      def initialize file
+        super
+        require "json"
+        require "time"
+      end
+      def put **fields
+        fields[ :time] = fields[ :time].iso8601 rescue nil
+        @file.puts fields.to_json
+        @file.flush
+      end
+    end
+
+
+    LEVELS = {}
+    %i(panic fatal error warn info debug1 debug2 debug3).each_with_index { |l,i| LEVELS[ l] = i }
+    LEVELS.default = LEVELS.length
+    DEFAULT_LEVEL = :warn
+
+    class <<self
+
+      attr_reader   :level
+      attr_accessor :channel
+
+      def level= l
+        @level = l.to_sym.downcase
+      rescue NoMethodError
+        l = l.to_s
+        retry
+      end
+
+      def put level, message, **kwargs
+        return unless @channel
+        return if LEVELS[ level] > LEVELS[ @level]
+        @channel.put time: Time.now, pid: $$, level: level, message: message, **kwargs
+        nil
+      rescue
+        $stderr.puts "Failed to log: #$! (#{$!.class})"
+        $stderr.puts $@
+      end
+
+    end
+
+
+    private
+
+    def log level, message, **kwargs
+      Logging.put level, message,
+        class: self.class, caller: (caller 1, 1).first,
+        **kwargs
+    end
+
+    def log_exception level
+      Logging.put level, "Exception: #$!",
+        class: self.class, caller: (caller 1, 1).first,
+        exception: $!.class
+      $@.each { |b|
+        Logging.put :debug3, "Backtrace", line: b
+      }
+      nil
+    end
+
+
+    def open_logfile level: nil, path: nil
+      level ||= ENV[ "NVIM_RUBY_LOG_LEVEL"].notempty?
+      path  ||= ENV[ "NVIM_RUBY_LOG_FILE" ].notempty?
+      Logger.provide path do |l|
+        ov, Logging.level   = Logging.level,   level||DEFAULT_LEVEL
+        ol, Logging.channel = Logging.channel, l
+        yield
+      ensure
+        Logging.level, Logging.channel = ov, ol
+      end
+    end
+
+  end
+
+end
+

data/lib/neovim/messager.rb

@@ -0,0 +1,185 @@
+#
+#  neovim/messager.rb  --  Send and Receive Messages
+#
+
+require "neovim/foreign/supplement"
+
+require "neovim/logging"
+
+
+module Neovim
+
+  class Messager
+
+    class Message
+
+      @subs, @subh = [], {}
+
+      class <<self
+
+        def from_array ary
+          kind, *payload = *ary
+          klass = find kind
+          klass[ *payload]
+        end
+
+        def inherited cls ; @subs.push cls ; end
+        def find id
+          @subh[ id] ||= @subs.find { |c| c::ID == id }
+        end
+
+        alias [] new
+
+      end
+
+      def initialize *args
+        z = self.class::KEYS.zip args
+        @cont = z.inject Hash.new do |c,(h,k)| c[h] = k ; c end
+      end
+
+      def inspect
+        c = self.class.name.sub /.*::/, ""
+        "#<#{c} #@cont>"
+      end
+
+      def to_s
+        c = self.class.name.sub /.*::/, ""
+        j = @cont.map { |k,v| "#{k}:#{v}" if v }.compact.join ","
+        "#{c}(#{j})"
+      end
+
+      def method_missing sym, *args
+        if @cont.key? sym then @cont[ sym] else super end
+      end
+
+      def respond_to_missing? sym, priv = nil
+        @cont.key? sym.to_sym
+      end
+
+      def methods *args
+        super.concat @cont.keys
+      end
+
+      def to_h ; @cont ; end
+
+      def fields ; @cont.fetch_values *self.class::KEYS ; end
+
+      def to_a
+        [self.class::ID, *fields]
+      end
+
+      class Request < Message
+        ID = 0
+        KEYS = %i(request_id method_name arguments)
+      end
+
+      class Response < Message
+        ID = 1
+        KEYS = %i(request_id error value)
+        def initialize *args
+          super
+          e = @cont[ :error]
+          if e and not Array === e then
+            @cont[ :error] = [0, e]
+          end
+        end
+
+      end
+
+      class Notification < Message
+        ID = 2
+        KEYS = %i(method_name arguments)
+      end
+
+    end
+
+    class ResponseError < StandardError ; end
+
+    class Disconnected < RuntimeError
+      def initialize
+        super "Lost connection to nvim process"
+      end
+    end
+
+
+    include Logging
+
+    def initialize conn, session
+      @conn, @session = conn, session
+      @request_id = 0
+      @responses = {}
+    end
+
+    def run until_id = nil
+      loop do
+        message = get
+        case message
+        when Message::Response then
+          if @responses.key? message.request_id then
+            @responses[ message.request_id] = message
+          else
+            log :warning, "Dropped response", message.request_id
+          end
+        when Message::Request then
+          begin
+            r = @session.execute_handler message.method_name, message.arguments
+            log :debug1, "Request result", result: r
+          rescue
+            e = [ 0, $!.to_s]
+            log_exception :error
+          end
+          rsp = Message::Response.new message.request_id, e, r
+          put rsp
+        when Message::Notification then
+          begin
+            @session.execute_handler message.method_name, message.arguments
+          rescue
+            log_exception :error
+          end
+        end
+        break if until_id and @responses[ until_id]
+      end
+    end
+
+    def request method, *args
+      @request_id += 1
+      put Message::Request[ @request_id, method, args]
+      @responses[ @request_id] = nil
+      run @request_id
+      r = @responses.delete @request_id
+      if r.error then
+        t, e = *r.error
+        t = @conn.error t
+        raise ResponseError, "#{t}: #{e}"
+      end
+      r.value
+    end
+
+    def notify method, *args
+      put Message::Notification[ method, args]
+    end
+
+    private
+
+    def put msg
+      log :debug1, "Sending Message", data: msg
+      @conn.put msg.to_a
+      self
+    rescue Errno::EPIPE
+      raise Disconnected
+    end
+
+    def get
+      IO.select [@conn.input], nil, nil
+      raise Disconnected if @conn.eof?
+      msg = Message.from_array @conn.get
+      log :debug1, "Received Message", data: msg
+      msg
+    rescue EOFError
+      raise Disconnected
+    end
+
+  end
+
+end
+

data/lib/neovim/meta.rb

@@ -0,0 +1,68 @@
+#
+#  neovim/meta.rb  --  Metadata: Version info etc.
+#
+
+module Neovim
+
+  class Meta
+
+    def initialize name, **params
+      @name, @params = name, params
+    end
+
+    attr_reader :name
+
+    %i(
+      commit
+      version
+      license
+      summary
+      description
+      homepage
+      authors
+      email
+      metadata
+    ).each { |p|
+      define_method p do @params[ p] end
+    }
+
+    alias website homepage
+
+
+    def version_h
+      @params[ :version] =~ /\Av?(\d+)(?:\.(\d+)(?:\.(\d+)))(?:-(.*))?\z/
+      {
+        major:      $1,
+        minor:      $2,
+        patch:      $3,
+        prerelease: $4,
+        commit:     @params[ :commit],
+      }
+    end
+
+    def version_a
+      version_h.values_at :major, :minor, :patch, :prerelease
+    end
+
+    def attributes
+      {
+        website: @params[ :homepage],
+        license: @params[ :license ],
+      }
+    end
+
+
+    def mk_gemspec spec
+      spec.name          = @name
+      spec.version       = @params[:version ]
+      spec.authors       = @params[:authors ]
+      spec.email         = @params[:email   ]
+      spec.summary       = @params[:summary ]
+      spec.homepage      = @params[:homepage]
+      spec.license       = @params[:license ]
+    end
+
+  end
+
+end
+

data/lib/neovim/remote.rb

@@ -0,0 +1,56 @@
+#
+#  neovim/remote.rb  --  Host for Neovim
+#
+
+require "neovim/session"
+require "neovim/handler"
+
+
+module Neovim
+
+  class Remote < Session
+
+    class <<self
+
+      def start_client *args
+        start *args do |i|
+          yield i.start
+        end
+      end
+
+    end
+
+    def initialize conn
+      super
+      @plugins = {}
+    end
+
+    def start
+      @conn.start @comm, client_name, self.class.name.downcase.to_sym, client_methods
+      @conn.client
+    end
+
+    def client_name    ; "ruby-client" ; end
+    def client_methods ;                 end
+
+
+    def add_plugins source, plugins
+      @plugins[ source] = plugins
+    end
+
+    def execute_handler name, args
+      @plugins.each_value do |plugin|
+        handler = plugin.get_handler name
+        if handler then
+          log :info, "Found handler", name: name
+          log :debug1, "Calling with", args: args
+          return handler.execute @conn.client, *args
+        end
+      end
+      super
+    end
+
+  end
+
+end
+