mirror of
https://github.com/qvacua/vimr.git
synced 2024-11-24 03:25:03 +03:00
3863 lines
94 KiB
Swift
3863 lines
94 KiB
Swift
// Auto generated for nvim version 0.5.0.
|
|
// See bin/generate_api_methods.py
|
|
|
|
import Foundation
|
|
import MessagePack
|
|
import RxSwift
|
|
|
|
extension RxNeovimApi {
|
|
|
|
public enum Error: Swift.Error {
|
|
|
|
private static let exceptionRawValue = UInt64(0)
|
|
private static let validationRawValue = UInt64(1)
|
|
|
|
case exception(message: String)
|
|
case validation(message: String)
|
|
case blocked
|
|
case conversion(type: Any.Type)
|
|
case unknown
|
|
|
|
init(_ value: RxNeovimApi.Value?) {
|
|
let array = value?.arrayValue
|
|
guard array?.count == 2 else {
|
|
self = .unknown
|
|
return
|
|
}
|
|
|
|
guard let rawValue = array?[0].uint64Value, let message = array?[1].stringValue else {
|
|
self = .unknown
|
|
return
|
|
}
|
|
|
|
switch rawValue {
|
|
case Error.exceptionRawValue: self = .exception(message: message)
|
|
case Error.validationRawValue: self = .validation(message: message)
|
|
default: self = .unknown
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extension RxNeovimApi {
|
|
|
|
public func bufLineCount(
|
|
buffer: RxNeovimApi.Buffer,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_line_count", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_line_count", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufAttach(
|
|
buffer: RxNeovimApi.Buffer,
|
|
send_buffer: Bool,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.bool(send_buffer),
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_attach", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_attach", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufDetach(
|
|
buffer: RxNeovimApi.Buffer,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_detach", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_detach", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetLines(
|
|
buffer: RxNeovimApi.Buffer,
|
|
start: Int,
|
|
end: Int,
|
|
strict_indexing: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[String]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(start)),
|
|
.int(Int64(end)),
|
|
.bool(strict_indexing),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [String] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in v.stringValue })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [String].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_lines", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_lines", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufSetLines(
|
|
buffer: RxNeovimApi.Buffer,
|
|
start: Int,
|
|
end: Int,
|
|
strict_indexing: Bool,
|
|
replacement: [String],
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(start)),
|
|
.int(Int64(end)),
|
|
.bool(strict_indexing),
|
|
.array(replacement.map { .string($0) }),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_lines", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_lines", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufGetOffset(
|
|
buffer: RxNeovimApi.Buffer,
|
|
index: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(index)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_offset", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_offset", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetVar(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_var", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_var", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetChangedtick(
|
|
buffer: RxNeovimApi.Buffer,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_changedtick", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_changedtick", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetKeymap(
|
|
buffer: RxNeovimApi.Buffer,
|
|
mode: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[Dictionary<String, RxNeovimApi.Value>]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(mode),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [Dictionary<String, RxNeovimApi.Value>] {
|
|
guard let result = (msgPackArrayDictToSwift(value.arrayValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: [Dictionary<String, RxNeovimApi.Value>].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_keymap", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_keymap", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufSetKeymap(
|
|
buffer: RxNeovimApi.Buffer,
|
|
mode: String,
|
|
lhs: String,
|
|
rhs: String,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(mode),
|
|
.string(lhs),
|
|
.string(rhs),
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufDelKeymap(
|
|
buffer: RxNeovimApi.Buffer,
|
|
mode: String,
|
|
lhs: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(mode),
|
|
.string(lhs),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_del_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_del_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufGetCommands(
|
|
buffer: RxNeovimApi.Buffer,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_commands", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_commands", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufSetVar(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufDelVar(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufGetOption(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_option", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_option", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufSetOption(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufGetName(
|
|
buffer: RxNeovimApi.Buffer,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<String> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> String {
|
|
guard let result = (value.stringValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: String.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_name", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_name", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufSetName(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_name", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_name", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufIsLoaded(
|
|
buffer: RxNeovimApi.Buffer,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_is_loaded", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_is_loaded", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufIsValid(
|
|
buffer: RxNeovimApi.Buffer,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_is_valid", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_is_valid", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetMark(
|
|
buffer: RxNeovimApi.Buffer,
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[Int]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [Int] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in (v.int64Value == nil ? nil : Int(v.int64Value!)) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [Int].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_mark", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_mark", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetExtmarkById(
|
|
buffer: RxNeovimApi.Buffer,
|
|
ns_id: Int,
|
|
id: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[Int]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(ns_id)),
|
|
.int(Int64(id)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [Int] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in (v.int64Value == nil ? nil : Int(v.int64Value!)) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [Int].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_extmark_by_id", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_extmark_by_id", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetExtmarks(
|
|
buffer: RxNeovimApi.Buffer,
|
|
ns_id: Int,
|
|
start: RxNeovimApi.Value,
|
|
end: RxNeovimApi.Value,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(ns_id)),
|
|
start,
|
|
end,
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_extmarks", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_extmarks", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufSetExtmark(
|
|
buffer: RxNeovimApi.Buffer,
|
|
ns_id: Int,
|
|
id: Int,
|
|
line: Int,
|
|
col: Int,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(ns_id)),
|
|
.int(Int64(id)),
|
|
.int(Int64(line)),
|
|
.int(Int64(col)),
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_extmark", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_extmark", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufDelExtmark(
|
|
buffer: RxNeovimApi.Buffer,
|
|
ns_id: Int,
|
|
id: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(ns_id)),
|
|
.int(Int64(id)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_del_extmark", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_del_extmark", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufAddHighlight(
|
|
buffer: RxNeovimApi.Buffer,
|
|
src_id: Int,
|
|
hl_group: String,
|
|
line: Int,
|
|
col_start: Int,
|
|
col_end: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(src_id)),
|
|
.string(hl_group),
|
|
.int(Int64(line)),
|
|
.int(Int64(col_start)),
|
|
.int(Int64(col_end)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_add_highlight", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_add_highlight", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufClearNamespace(
|
|
buffer: RxNeovimApi.Buffer,
|
|
ns_id: Int,
|
|
line_start: Int,
|
|
line_end: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(ns_id)),
|
|
.int(Int64(line_start)),
|
|
.int(Int64(line_end)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_clear_namespace", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_clear_namespace", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufClearHighlight(
|
|
buffer: RxNeovimApi.Buffer,
|
|
ns_id: Int,
|
|
line_start: Int,
|
|
line_end: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(ns_id)),
|
|
.int(Int64(line_start)),
|
|
.int(Int64(line_end)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_clear_highlight", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_clear_highlight", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func bufSetVirtualText(
|
|
buffer: RxNeovimApi.Buffer,
|
|
src_id: Int,
|
|
line: Int,
|
|
chunks: RxNeovimApi.Value,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(src_id)),
|
|
.int(Int64(line)),
|
|
chunks,
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_set_virtual_text", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_set_virtual_text", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func bufGetVirtualText(
|
|
buffer: RxNeovimApi.Buffer,
|
|
line: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.int(Int64(line)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_buf_get_virtual_text", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_buf_get_virtual_text", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func tabpageListWins(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[RxNeovimApi.Window]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [RxNeovimApi.Window] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in RxNeovimApi.Window(v) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [RxNeovimApi.Window].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_list_wins", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_list_wins", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func tabpageGetVar(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_get_var", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_get_var", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func tabpageSetVar(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func tabpageDelVar(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
name: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func tabpageGetWin(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Window> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Window {
|
|
guard let result = (RxNeovimApi.Window(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Window.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_get_win", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_get_win", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func tabpageGetNumber(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_get_number", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_get_number", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func tabpageIsValid(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_tabpage_is_valid", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_tabpage_is_valid", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func uiAttach(
|
|
width: Int,
|
|
height: Int,
|
|
options: Dictionary<String, RxNeovimApi.Value>,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(width)),
|
|
.int(Int64(height)),
|
|
.map(options.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_attach", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_attach", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func uiDetach(
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_detach", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_detach", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func uiTryResize(
|
|
width: Int,
|
|
height: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(width)),
|
|
.int(Int64(height)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_try_resize", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_try_resize", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func uiSetOption(
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func uiTryResizeGrid(
|
|
grid: Int,
|
|
width: Int,
|
|
height: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(grid)),
|
|
.int(Int64(width)),
|
|
.int(Int64(height)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_try_resize_grid", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_try_resize_grid", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func uiPumSetHeight(
|
|
height: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(height)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_pum_set_height", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_pum_set_height", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func uiPumSetBounds(
|
|
width: Float,
|
|
height: Float,
|
|
row: Float,
|
|
col: Float,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.float(width),
|
|
.float(height),
|
|
.float(row),
|
|
.float(col),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_ui_pum_set_bounds", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_ui_pum_set_bounds", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func exec(
|
|
src: String,
|
|
output: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<String> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(src),
|
|
.bool(output),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> String {
|
|
guard let result = (value.stringValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: String.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_exec", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_exec", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func command(
|
|
command: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(command),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_command", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_command", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getHlByName(
|
|
name: String,
|
|
rgb: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
.bool(rgb),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_hl_by_name", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_hl_by_name", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getHlById(
|
|
hl_id: Int,
|
|
rgb: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(hl_id)),
|
|
.bool(rgb),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_hl_by_id", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_hl_by_id", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getHlIdByName(
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_hl_id_by_name", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_hl_id_by_name", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func feedkeys(
|
|
keys: String,
|
|
mode: String,
|
|
escape_csi: Bool,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(keys),
|
|
.string(mode),
|
|
.bool(escape_csi),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_feedkeys", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_feedkeys", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func input(
|
|
keys: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(keys),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_input", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_input", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func inputMouse(
|
|
button: String,
|
|
action: String,
|
|
modifier: String,
|
|
grid: Int,
|
|
row: Int,
|
|
col: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(button),
|
|
.string(action),
|
|
.string(modifier),
|
|
.int(Int64(grid)),
|
|
.int(Int64(row)),
|
|
.int(Int64(col)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_input_mouse", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_input_mouse", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func replaceTermcodes(
|
|
str: String,
|
|
from_part: Bool,
|
|
do_lt: Bool,
|
|
special: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<String> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(str),
|
|
.bool(from_part),
|
|
.bool(do_lt),
|
|
.bool(special),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> String {
|
|
guard let result = (value.stringValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: String.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_replace_termcodes", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_replace_termcodes", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func eval(
|
|
expr: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(expr),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_eval", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_eval", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func execLua(
|
|
code: String,
|
|
args: RxNeovimApi.Value,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(code),
|
|
args,
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_exec_lua", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_exec_lua", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func callFunction(
|
|
fn: String,
|
|
args: RxNeovimApi.Value,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(fn),
|
|
args,
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_call_function", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_call_function", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func callDictFunction(
|
|
dict: RxNeovimApi.Value,
|
|
fn: String,
|
|
args: RxNeovimApi.Value,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
dict,
|
|
.string(fn),
|
|
args,
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_call_dict_function", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_call_dict_function", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func strwidth(
|
|
text: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(text),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_strwidth", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_strwidth", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func listRuntimePaths(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[String]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [String] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in v.stringValue })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [String].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_list_runtime_paths", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_list_runtime_paths", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getRuntimeFile(
|
|
name: String,
|
|
all: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[String]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
.bool(all),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [String] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in v.stringValue })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [String].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_runtime_file", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_runtime_file", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setCurrentDir(
|
|
dir: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(dir),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_current_dir", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_current_dir", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getCurrentLine(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<String> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> String {
|
|
guard let result = (value.stringValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: String.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_current_line", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_current_line", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setCurrentLine(
|
|
line: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(line),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_current_line", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_current_line", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func delCurrentLine(
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_del_current_line", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_del_current_line", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getVar(
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_var", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_var", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setVar(
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func delVar(
|
|
name: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getVvar(
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_vvar", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_vvar", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setVvar(
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_vvar", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_vvar", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getOption(
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_option", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_option", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setOption(
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func outWrite(
|
|
str: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(str),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_out_write", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_out_write", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func errWrite(
|
|
str: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(str),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_err_write", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_err_write", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func errWriteln(
|
|
str: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(str),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_err_writeln", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_err_writeln", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func listBufs(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[RxNeovimApi.Buffer]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [RxNeovimApi.Buffer] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in RxNeovimApi.Buffer(v) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [RxNeovimApi.Buffer].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_list_bufs", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_list_bufs", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getCurrentBuf(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Buffer> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Buffer {
|
|
guard let result = (RxNeovimApi.Buffer(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Buffer.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_current_buf", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_current_buf", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setCurrentBuf(
|
|
buffer: RxNeovimApi.Buffer,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_current_buf", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_current_buf", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func listWins(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[RxNeovimApi.Window]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [RxNeovimApi.Window] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in RxNeovimApi.Window(v) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [RxNeovimApi.Window].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_list_wins", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_list_wins", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getCurrentWin(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Window> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Window {
|
|
guard let result = (RxNeovimApi.Window(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Window.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_current_win", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_current_win", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setCurrentWin(
|
|
window: RxNeovimApi.Window,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_current_win", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_current_win", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func createBuf(
|
|
listed: Bool,
|
|
scratch: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Buffer> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.bool(listed),
|
|
.bool(scratch),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Buffer {
|
|
guard let result = (RxNeovimApi.Buffer(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Buffer.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_create_buf", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_create_buf", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func openWin(
|
|
buffer: RxNeovimApi.Buffer,
|
|
enter: Bool,
|
|
config: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Window> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(buffer.handle)),
|
|
.bool(enter),
|
|
.map(config.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Window {
|
|
guard let result = (RxNeovimApi.Window(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Window.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_open_win", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_open_win", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func listTabpages(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[RxNeovimApi.Tabpage]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [RxNeovimApi.Tabpage] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in RxNeovimApi.Tabpage(v) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [RxNeovimApi.Tabpage].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_list_tabpages", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_list_tabpages", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getCurrentTabpage(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Tabpage> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Tabpage {
|
|
guard let result = (RxNeovimApi.Tabpage(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Tabpage.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_current_tabpage", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_current_tabpage", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setCurrentTabpage(
|
|
tabpage: RxNeovimApi.Tabpage,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(tabpage.handle)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_current_tabpage", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_current_tabpage", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func createNamespace(
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_create_namespace", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_create_namespace", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getNamespaces(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_namespaces", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_namespaces", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func paste(
|
|
data: String,
|
|
crlf: Bool,
|
|
phase: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(data),
|
|
.bool(crlf),
|
|
.int(Int64(phase)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_paste", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_paste", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func put(
|
|
lines: [String],
|
|
type: String,
|
|
after: Bool,
|
|
follow: Bool,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.array(lines.map { .string($0) }),
|
|
.string(type),
|
|
.bool(after),
|
|
.bool(follow),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_put", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_put", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func subscribe(
|
|
event: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(event),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_subscribe", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_subscribe", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func unsubscribe(
|
|
event: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(event),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_unsubscribe", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_unsubscribe", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getColorByName(
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_color_by_name", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_color_by_name", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getColorMap(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_color_map", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_color_map", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getContext(
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_context", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_context", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func loadContext(
|
|
dict: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.map(dict.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_load_context", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_load_context", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getMode(
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
return self
|
|
.rpc(method: "nvim_get_mode", params: params, expectsReturnValue: true)
|
|
.map { value in
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
}
|
|
|
|
public func getKeymap(
|
|
mode: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[Dictionary<String, RxNeovimApi.Value>]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(mode),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [Dictionary<String, RxNeovimApi.Value>] {
|
|
guard let result = (msgPackArrayDictToSwift(value.arrayValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: [Dictionary<String, RxNeovimApi.Value>].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_keymap", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_keymap", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setKeymap(
|
|
mode: String,
|
|
lhs: String,
|
|
rhs: String,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(mode),
|
|
.string(lhs),
|
|
.string(rhs),
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func delKeymap(
|
|
mode: String,
|
|
lhs: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(mode),
|
|
.string(lhs),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_del_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_del_keymap", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getCommands(
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_commands", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_commands", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getApiInfo(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_api_info", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_api_info", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func setClientInfo(
|
|
name: String,
|
|
version: Dictionary<String, RxNeovimApi.Value>,
|
|
type: String,
|
|
methods: Dictionary<String, RxNeovimApi.Value>,
|
|
attributes: Dictionary<String, RxNeovimApi.Value>,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(name),
|
|
.map(version.mapToDict({ (Value.string($0), $1) })),
|
|
.string(type),
|
|
.map(methods.mapToDict({ (Value.string($0), $1) })),
|
|
.map(attributes.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_set_client_info", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_set_client_info", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func getChanInfo(
|
|
chan: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(chan)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_chan_info", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_chan_info", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func listChans(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_list_chans", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_list_chans", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func callAtomic(
|
|
calls: RxNeovimApi.Value,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
calls,
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_call_atomic", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_call_atomic", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func parseExpression(
|
|
expr: String,
|
|
flags: String,
|
|
highlight: Bool,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.string(expr),
|
|
.string(flags),
|
|
.bool(highlight),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_parse_expression", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_parse_expression", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func listUis(
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_list_uis", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_list_uis", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getProcChildren(
|
|
pid: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(pid)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_proc_children", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_proc_children", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func getProc(
|
|
pid: Int,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(pid)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_get_proc", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_get_proc", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func selectPopupmenuItem(
|
|
item: Int,
|
|
insert: Bool,
|
|
finish: Bool,
|
|
opts: Dictionary<String, RxNeovimApi.Value>,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(item)),
|
|
.bool(insert),
|
|
.bool(finish),
|
|
.map(opts.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_select_popupmenu_item", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_select_popupmenu_item", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetBuf(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Buffer> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Buffer {
|
|
guard let result = (RxNeovimApi.Buffer(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Buffer.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_buf", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_buf", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetBuf(
|
|
window: RxNeovimApi.Window,
|
|
buffer: RxNeovimApi.Buffer,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.int(Int64(buffer.handle)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_buf", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_buf", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetCursor(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[Int]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [Int] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in (v.int64Value == nil ? nil : Int(v.int64Value!)) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [Int].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_cursor", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_cursor", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetCursor(
|
|
window: RxNeovimApi.Window,
|
|
pos: [Int],
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.array(pos.map { .int(Int64($0)) }),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_cursor", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_cursor", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetHeight(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_height", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_height", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetHeight(
|
|
window: RxNeovimApi.Window,
|
|
height: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.int(Int64(height)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_height", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_height", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetWidth(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_width", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_width", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetWidth(
|
|
window: RxNeovimApi.Window,
|
|
width: Int,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.int(Int64(width)),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_width", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_width", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetVar(
|
|
window: RxNeovimApi.Window,
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_var", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_var", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetVar(
|
|
window: RxNeovimApi.Window,
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winDelVar(
|
|
window: RxNeovimApi.Window,
|
|
name: String,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_del_var", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetOption(
|
|
window: RxNeovimApi.Window,
|
|
name: String,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Value> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.string(name),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Value {
|
|
guard let result = (Optional(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Value.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_option", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_option", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetOption(
|
|
window: RxNeovimApi.Window,
|
|
name: String,
|
|
value: RxNeovimApi.Value,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.string(name),
|
|
value,
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_option", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetPosition(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<[Int]> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> [Int] {
|
|
guard let result = (value.arrayValue?.compactMap({ v in (v.int64Value == nil ? nil : Int(v.int64Value!)) })) else {
|
|
throw RxNeovimApi.Error.conversion(type: [Int].self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_position", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_position", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winGetTabpage(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<RxNeovimApi.Tabpage> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> RxNeovimApi.Tabpage {
|
|
guard let result = (RxNeovimApi.Tabpage(value)) else {
|
|
throw RxNeovimApi.Error.conversion(type: RxNeovimApi.Tabpage.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_tabpage", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_tabpage", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winGetNumber(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Int> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Int {
|
|
guard let result = ((value.int64Value == nil ? nil : Int(value.int64Value!))) else {
|
|
throw RxNeovimApi.Error.conversion(type: Int.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_number", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_number", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winIsValid(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Bool> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Bool {
|
|
guard let result = (value.boolValue) else {
|
|
throw RxNeovimApi.Error.conversion(type: Bool.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_is_valid", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_is_valid", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winSetConfig(
|
|
window: RxNeovimApi.Window,
|
|
config: Dictionary<String, RxNeovimApi.Value>,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.map(config.mapToDict({ (Value.string($0), $1) })),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_set_config", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_set_config", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
public func winGetConfig(
|
|
window: RxNeovimApi.Window,
|
|
errWhenBlocked: Bool = true
|
|
) -> Single<Dictionary<String, RxNeovimApi.Value>> {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
]
|
|
|
|
func transform(_ value: Value) throws -> Dictionary<String, RxNeovimApi.Value> {
|
|
guard let result = (msgPackDictToSwift(value.dictionaryValue)) else {
|
|
throw RxNeovimApi.Error.conversion(type: Dictionary<String, RxNeovimApi.Value>.self)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
if errWhenBlocked {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_get_config", params: params, expectsReturnValue: true)
|
|
)
|
|
.map(transform)
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_get_config", params: params, expectsReturnValue: true)
|
|
.map(transform)
|
|
}
|
|
|
|
public func winClose(
|
|
window: RxNeovimApi.Window,
|
|
force: Bool,
|
|
expectsReturnValue: Bool = false
|
|
) -> Completable {
|
|
|
|
let params: [RxNeovimApi.Value] = [
|
|
.int(Int64(window.handle)),
|
|
.bool(force),
|
|
]
|
|
|
|
if expectsReturnValue {
|
|
return self
|
|
.checkBlocked(
|
|
self.rpc(method: "nvim_win_close", params: params, expectsReturnValue: expectsReturnValue)
|
|
)
|
|
.asCompletable()
|
|
}
|
|
|
|
return self
|
|
.rpc(method: "nvim_win_close", params: params, expectsReturnValue: expectsReturnValue)
|
|
.asCompletable()
|
|
}
|
|
|
|
}
|
|
|
|
extension RxNeovimApi.Buffer {
|
|
|
|
init?(_ value: RxNeovimApi.Value) {
|
|
guard let (type, data) = value.extendedValue else {
|
|
return nil
|
|
}
|
|
|
|
guard type == 0 else {
|
|
return nil
|
|
}
|
|
|
|
guard let handle = (try? unpack(data))?.value.int64Value else {
|
|
return nil
|
|
}
|
|
|
|
self.handle = Int(handle)
|
|
}
|
|
}
|
|
|
|
extension RxNeovimApi.Window {
|
|
|
|
init?(_ value: RxNeovimApi.Value) {
|
|
guard let (type, data) = value.extendedValue else {
|
|
return nil
|
|
}
|
|
|
|
guard type == 1 else {
|
|
return nil
|
|
}
|
|
|
|
guard let handle = (try? unpack(data))?.value.int64Value else {
|
|
return nil
|
|
}
|
|
|
|
self.handle = Int(handle)
|
|
}
|
|
}
|
|
|
|
extension RxNeovimApi.Tabpage {
|
|
|
|
init?(_ value: RxNeovimApi.Value) {
|
|
guard let (type, data) = value.extendedValue else {
|
|
return nil
|
|
}
|
|
|
|
guard type == 2 else {
|
|
return nil
|
|
}
|
|
|
|
guard let handle = (try? unpack(data))?.value.int64Value else {
|
|
return nil
|
|
}
|
|
|
|
self.handle = Int(handle)
|
|
}
|
|
}
|
|
|
|
fileprivate func msgPackDictToSwift(_ dict: Dictionary<RxNeovimApi.Value, RxNeovimApi.Value>?) -> Dictionary<String, RxNeovimApi.Value>? {
|
|
return dict?.compactMapToDict { k, v in
|
|
guard let strKey = k.stringValue else {
|
|
return nil
|
|
}
|
|
|
|
return (strKey, v)
|
|
}
|
|
}
|
|
|
|
fileprivate func msgPackArrayDictToSwift(_ array: [RxNeovimApi.Value]?) -> [Dictionary<String, RxNeovimApi.Value>]? {
|
|
return array?
|
|
.compactMap { v in v.dictionaryValue }
|
|
.compactMap { d in msgPackDictToSwift(d) }
|
|
}
|
|
|
|
extension Dictionary {
|
|
|
|
fileprivate func mapToDict<K, V>(_ transform: ((key: Key, value: Value)) throws -> (K, V)) rethrows -> Dictionary<K, V> {
|
|
let array = try self.map(transform)
|
|
return tuplesToDict(array)
|
|
}
|
|
|
|
fileprivate func compactMapToDict<K, V>(_ transform: ((key: Key, value: Value)) throws -> (K, V)?) rethrows -> Dictionary<K, V> {
|
|
let array = try self.compactMap(transform)
|
|
return tuplesToDict(array)
|
|
}
|
|
|
|
fileprivate func tuplesToDict<K:Hashable, V, S:Sequence>(_ sequence: S)
|
|
-> Dictionary<K, V> where S.Iterator.Element == (K, V) {
|
|
|
|
var result = Dictionary<K, V>(minimumCapacity: sequence.underestimatedCount)
|
|
|
|
for (key, value) in sequence {
|
|
result[key] = value
|
|
}
|
|
|
|
return result
|
|
}
|
|
}
|