nvim 1.0.0 → 1.2.0

data/lib/neovim/output.rb

@@ -0,0 +1,142 @@
+#
+#  neovim/output.rb  --  Output to Neovim
+#
+
+
+module Neovim
+
+  class Write
+    class <<self
+      def open *args, **kwargs
+        i = new *args, **kwargs
+        yield i
+      ensure
+        i.finish
+      end
+    end
+    def initialize client, *rest
+      @client = client
+    end
+    def << arg
+      write arg.to_s
+      self
+    end
+    def print *args
+      args.each { |a| write a.to_s }
+      nil
+    end
+    def puts *args
+      if args.empty? then
+        write $/
+      else
+        args.each { |a|
+          case a
+          when Array then
+            a.each { |e|
+              puts e
+            }
+          else
+            a = a.to_s
+            write a
+            write $/ unless a.end_with? $/
+          end
+        }
+      end
+      nil
+    end
+    def flush
+    end
+  end
+
+  class WriteStd < Write
+    class <<self
+      def redirect *args, **kwargs
+        open *args, **kwargs do |i|
+          old, $stdout = $stdout, i
+          yield
+        ensure
+          $stdout = old
+        end
+      end
+    end
+  end
+
+  class WriteOut < WriteStd
+    def write *args
+      args.each { |a|
+        a = a.to_s
+        a.notempty? or next
+        @client.out_write a
+        @line_open = !(a.end_with? $/)
+      }
+      nil
+    end
+    def finish
+      if @line_open then
+        @client.out_write $/
+        @line_open = nil
+      end
+    end
+  end
+
+  class WriteErr < Write
+    class <<self
+      def redirect *args, **kwargs
+        open *args, **kwargs do |i|
+          old, $stderr = $stderr, i
+          yield
+        ensure
+          $stderr = old
+        end
+      end
+    end
+    def write *args
+      args.each { |a|
+        @rest ||= ""
+        @rest << a.to_s
+        while @rest =~ /#$// do
+          @client.err_writeln $`
+          @rest = $'
+        end
+      }
+      nil
+    end
+    def finish
+      if @rest.notempty? then
+        @client.err_writeln @rest
+        @rest = nil
+      end
+    end
+  end
+
+  class WriteBuf < WriteStd
+    def initialize *args, whole: nil, top: nil
+      super
+      @lines, @last = [], ""
+      @whole, @top = whole, top
+    end
+    def write *args
+      args.each { |a| @last << a.to_s }
+      loop do
+        n, r = @last.split $/, 2
+        r or break
+        @lines.push n
+        @last = r
+      end
+      nil
+    end
+    def finish
+      if @last.notempty? then
+        @lines.push @last
+        @last = nil
+      end
+      if @whole then
+        @client.buf_set_lines 0, 0, -1, true, @lines
+      else
+        @client.put @lines, "l", true, !@top
+      end
+    end
+  end
+
+end
+

data/lib/neovim/remote.rb

@@ -1,53 +1,276 @@
 #
-#  neovim/remote.rb  --  Host for Neovim
+#  neovim/remote.rb  --  Remote access for Neovim
 #
 
-require "neovim/session"
-require "neovim/handler"
+require "neovim/foreign/supplement"
+
+require "neovim/logging"
+require "neovim/connection"
 
 
 module Neovim
 
-  class Remote < Session
+  class Remote
+
+    class Message
+
+      @subs, @subh = [], {}
+
+      class <<self
+
+        def from_array ary
+          kind, *payload = *ary
+          klass = find kind
+          klass or raise "No message type for id #{kind.inspect}"
+          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
+        "#<#{self.class.plain_name} #@cont>"
+      end
+
+      def to_s
+        j = @cont.map { |k,v| "#{k}:#{v}" if v }.compact.join ","
+        "#{self.class.plain_name}(#{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 ; end
+
+
+    include Logging
 
     class <<self
 
+      include Logging
+
+      private :new
+
+      def open_conn conntype, *args, **kwargs
+        conntype.open_files *args, **kwargs do |conn|
+          yield conn
+        end
+      end
+
+      public
+
+      def open conntype, *args, **kwargs
+        open_conn conntype, *args, **kwargs do |conn|
+          i = new nil, conn
+          yield i
+        end
+      end
+
+      def start plugins, *args
+        open_logfile do
+          log :info, "Starting", args: $*
+          open_conn *args do |conn|
+            i = new plugins, conn
+            yield i
+          end
+        ensure
+          log :info, "Leaving"
+        end
+      end
+
       def start_client *args
-        start *args do |i|
+        start nil, *args do |i|
           yield i.start
         end
       end
 
     end
 
-    def initialize conn
-      super
+    def initialize plugins, conn
+      @conn = conn
+      @request_id = 0
+      @responses = {}
       @plugins = {}
+      @plugins.update plugins if plugins
     end
 
+    def client_name
+      l = @plugins.values.select { |p| p.type }
+      if l.notempty? then
+        l.map! { |p| p.type }
+        l.uniq!
+        name = l.join "-"
+        log :info, "Client Name", name: name
+        "ruby-#{name}-host"
+      else
+        "ruby-client"
+      end
+    end
+
+    def client_type ; self.class.plain_name.downcase ; end
+
+    def client_methods
+      l = @plugins.values.reject { |p| p.type }
+      if l.notempty? then
+        r = {}
+        l.each { |p| p.options { |name,opts| r[ name] = opts } }
+        r
+      end
+    end
+
+
     def start
-      @conn.start @comm, client_name, self.class.name.downcase.to_sym, client_methods
+      @conn.start self
       @conn.client
     end
 
-    def client_name    ; "ruby-client" ; end
-    def client_methods ;                 end
+    def run until_id = nil
+      loop do
+        if @deferred and @conn.client then
+          d, @deferred = @deferred, nil
+          d.each { |p| p.call }
+        end
+        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, Message::Notification then
+          h = find_handler message.method_name
+          if h then
+            p = proc do
+              begin
+                log :debug1, "Calling handler", name: message.method_name, args: message.arguments
+                r = h.execute @conn.client, *message.arguments
+                log :debug1, "Handler result", result: r
+              rescue
+                e = [ 0, $!.to_s]
+                log_exception :error
+              end
+              put Message::Response[ message.request_id, e, r] if message.respond_to? :request_id
+            end
+            if @conn.client or not h.needs_client? then
+              p.call
+            else
+              log :info, "Deferred handler for", name: message.method_name
+              @deferred ||= []
+              @deferred.push p
+            end
+          else
+            if message.respond_to? :request_id then
+              put Message::Response[ message.request_id, [0, "No handler #{message.method_name}."], nil]
+            end
+          end
+        end
+        break if until_id and @responses[ until_id]
+      end
+    end
+
+    def request method, *args
+      rid = @request_id = @request_id.succ
+      put Message::Request[ rid, method, args]
+      @responses[ rid] = nil
+      run rid
+      r = @responses.delete rid
+      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 :debug2, "Sending Message", data: msg
+      @conn.put msg.to_a
+      self
+    rescue Errno::EPIPE
+      raise Disconnected, "Broken pipe on write"
+    end
 
-    def add_plugins source, plugins
-      @plugins[ source] = plugins
+    def get
+      IO.select [@conn.input], nil, nil
+      raise Disconnected, "EOF on wait" if @conn.eof?
+      msg = Message.from_array @conn.get
+      log :debug2, "Received Message", data: msg
+      msg
+    rescue EOFError
+      raise Disconnected, "EOF on read"
     end
 
-    def execute_handler name, args
+    def find_handler name
       @plugins.each_value do |plugin|
-        handler = plugin.get_handler name
-        if handler then
+        h = plugin.get_handler name
+        if h then
           log :info, "Found handler", name: name
-          log :debug1, "Calling with", args: args
-          return handler.execute @conn.client, *args
+          return h
         end
       end
-      super
+      log :error, "No handler found for #{name}."
+      nil
     end
 
   end

data/lib/neovim/remote_object.rb

@@ -55,7 +55,7 @@ module Neovim
       end
 
       def type
-        @type ||= (name.sub /.*::/, "").to_sym
+        @type ||= plain_name.to_sym
       end
 
     end
@@ -231,7 +231,7 @@ module Neovim
     def line_indices pos, len
       if Range === pos then
         r = pos
-        pos, lst = r.begin, r.end
+        pos, lst = r.begin||1, r.end||-1
         lst += 1 unless r.exclude_end?
       elsif pos.nil? then
         pos, lst = 1, 0
@@ -241,7 +241,7 @@ module Neovim
       if len then
         lst = pos + (len >= 0 ? len : 0)
       end
-      lst = 0 if pos < 0 and lst >= 0
+      lst = 0 if pos < 0 and lst > 0
       yield pos-1, lst-1
     end
 
@@ -249,11 +249,11 @@ module Neovim
       line_indices pos, len do |*fl|
         c = nil
         fl.map! { |y|
-          if y >= 0 then
-            y
-          else
-            y + 1 + (c ||= count)
+          unless y >= 0 then
+            c ||= count
+            y += 1 + c
           end
+          y
         }
         yield *fl
       end

data/lib/neovim/ruby_provider.rb

@@ -4,6 +4,7 @@
 
 require "neovim/handler"
 require "neovim/remote_object"
+require "neovim/output"
 
 
 class Object
@@ -51,118 +52,14 @@ end
 
 module Neovim
 
-  class Write
-    class <<self
-      def open client
-        i = new client
-        yield i
-      ensure
-        i.finish
-      end
-    end
-    def initialize client
-      @client = client
-    end
-    def print *args
-      args.each { |a| write a.to_s }
-      nil
-    end
-    def puts *args
-      args.each { |a|
-        a = a.to_s
-        write a
-        write "\n" unless a.end_with? $/
-      }
-      nil
-    end
-    def flush
-    end
-  end
-
-  class WriteStd < Write
-    class <<self
-      def redirect client
-        open client do |i|
-          old, $stdout = $stdout, i
-          yield
-        ensure
-          $stdout = old
-        end
-      end
-    end
-  end
-
-  class WriteOut < WriteStd
-    def write *args
-      args.each { |a|
-        a.notempty? or next
-        @client.out_write a
-        @line_open = !(a.end_with? $/)
-      }
-      nil
-    end
-    def finish
-      if @line_open then
-        @client.out_write $/
-        @line_open = nil
-      end
-    end
-  end
-
-  class WriteErr < Write
-    class <<self
-      def redirect client
-        open client do |i|
-          old, $stderr = $stderr, i
-          yield
-        ensure
-          $stderr = old
-        end
-      end
-    end
-    def write *args
-      args.each { |a|
-        @rest ||= ""
-        @rest << a
-        while @rest =~ /#$// do
-          @client.err_writeln $`
-          @rest = $'
-        end
-      }
-      nil
-    end
-    def finish
-      if @rest.notempty? then
-        @client.err_writeln @rest
-        @rest = nil
-      end
-    end
-  end
-
-  class WriteBuf < WriteStd
-    def write *args
-      s = @rest||""
-      args.each { |a|
-        s << a
-      }
-      s = s.split $/, -1
-      @rest = s.pop
-      @client.put s, "l", true, false
-      nil
-    end
-    def finish
-      if @rest.notempty? then
-        @client.put [@rest], "l", true, false
-        @rest = nil
-      end
-    end
-  end
-
-
   class DslProvider < DslBase
 
     TYPE = :script
 
+    def initialize source
+      super *[]
+    end
+
     def setup &block
       add_setup_block &block
     end
@@ -220,58 +117,26 @@ module Neovim
       run_dsl DslProvider, &block
     end
 
-    def build_sum lines
-      require "bigdecimal"
-      sum = BigDecimal 0
-      prev, decs = 0, 0
-      sep = "."
-      lines.each { |l|
-        l.slice! /^.*:/
-        l.slice! /#.*/
-        l = l.split /(?:\+\s+|\|)/
-        l.map! { |m|
-          m.strip!
-          if m =~ %r/ *%\z/ then
-            prev * (BigDecimal $`) / 100
-          else
-            m = m.split "*"
-            m.map! { |n|
-              n.sub! /,/ do sep = $& ; "." end
-                n.sub! /\.(?:-+|([0-9]+))/ do
-                  if $1 then
-                    d = $1.length
-                    decs = d if decs < d
-                    ".#$1"
-                  else
-                    decs = 2
-                    nil
-                  end
-                end
-                BigDecimal n
-            }
-            prev = m.inject do |p,e| p*e end
-          end
-        }
-        sum = l.inject sum do |s,e| s+e end
-      }
-      sum = sum.round decs
-      case sum
-      when BigDecimal then
-        sum = sum.to_s "F"
-        sum.sub! /(?:\.([0-9]+))?\z/ do
-          sep + ($1.to_s.ljust decs, "0")
-        end
-      when Integer    then
-        sum = sum.to_s
-      end
-      sum
-    end
-
   end
 
   plugin_provider do |dsl|
 
     dsl.setup do |client|
+      r = client.get_var "ruby_require" rescue nil
+      case r
+      when Array then r = r.notempty?
+      when nil   then nil
+      else            r = [r]
+      end
+      if r then
+        WriteOut.redirect client do  # Protect the RPC interface against erroneous output.
+          r.each do |l|
+            require l
+          rescue LoadError
+            client.out_write "Warning: #$!"
+          end
+        end
+      end
       $curbuf = client.get_current_buf
       $curwin = client.get_current_win
     end
@@ -301,19 +166,29 @@ module Neovim
       if !code.notempty? or code == "|" then  # Workaround because Neovim doesn't allow empty code (the ultimate Quine)
         set_global_client client do
           client.command "#{lst}"
-          code = (get_lines client, fst..lst).join "\n"
+          code = (get_lines client, fst..lst).join $/
           WriteBuf.redirect client do
             r = script_binding.eval code, "ruby_run"
-            r.nil? or puts "#=> #{r.inspect}"
+            unless r.nil? then
+              script_binding.local_variable_set :_, r
+              puts "#=> #{r.inspect}"
+            end
           end
         end
       elsif code == "+" then
         client.command "#{lst}"
         set_globals client, fst..lst do |lines|
           WriteBuf.redirect client do
-            s = build_sum lines
-            puts "-"*(s.length + 4)
-            puts s
+            require "neovim/tools/calculator"
+            @calc ||= Calculator.new
+            @calc.reset!
+            w = 0
+            lines.each { |l|
+              l.length.tap { |g| w = g if g > w }
+              @calc.add l
+            }
+            puts "-"*w
+            puts @calc.result
           rescue
             puts "Error: #$! (#{$!.class})"
           end