(this._element = elem)} className="stack layer" />
}
private _onResize(): void {
if (!this._element) {
return
}
const width = this._element.offsetWidth
const height = this._element.offsetHeight
this.props.neovimInstance
.resize(width, height)
.then(() => this.props.renderer.redrawAll(this.props.screen))
}
}
================================================
FILE: browser/src/Editor/NeovimEditor/NeovimSurface.tsx
================================================
/**
* NeovimSurface.tsx
*
* UI layer for the Neovim editor surface
*/
import * as React from "react"
import { connect } from "react-redux"
import { IEvent } from "oni-types"
import { NeovimInstance, NeovimScreen } from "./../../neovim"
import { INeovimRenderer } from "./../../Renderer"
import FileDropHandler from "./FileDropHandler"
import { TypingPredictionManager } from "./../../Services/TypingPredictionManager"
import { Cursor } from "./../../UI/components/Cursor"
import { CursorLine } from "./../../UI/components/CursorLine"
import { InstallHelp } from "./../../UI/components/InstallHelp"
import { TabsContainer } from "./../../UI/components/Tabs"
import { ToolTips } from "./../../UI/components/ToolTip"
import { StackLayer } from "../../UI/components/common"
import { setViewport } from "./../NeovimEditor/NeovimEditorActions"
import { NeovimBufferLayers } from "./NeovimBufferLayersView"
import { NeovimEditorLoadingOverlay } from "./NeovimEditorLoadingOverlay"
import { NeovimInput } from "./NeovimInput"
import { NeovimRenderer } from "./NeovimRenderer"
export interface INeovimSurfaceProps {
autoFocus: boolean
neovimInstance: NeovimInstance
renderer: INeovimRenderer
screen: NeovimScreen
typingPrediction: TypingPredictionManager
onActivate: IEvent
onKeyDown?: (key: string) => void
onBufferClose?: (bufferId: number) => void
onBufferSelect?: (bufferId: number) => void
onFileDrop?: (files: FileList) => void
onImeStart: () => void
onImeEnd: () => void
onBounceStart: () => void
onBounceEnd: () => void
onTabClose?: (tabId: number) => void
onTabSelect?: (tabId: number) => void
setViewport: any
}
class NeovimSurface extends React.Component {
private observer: any
private _editor: HTMLDivElement
public componentDidMount(): void {
// tslint:disable-next-line
this.observer = new window["ResizeObserver"](([entry]: any) => {
this.setDimensions(entry.contentRect.width, entry.contentRect.height)
})
this.observer.observe(this._editor)
}
public setDimensions = (width: number, height: number) => {
this.props.setViewport(width, height)
}
public render(): JSX.Element {
return (
{({ setRef }) => (
)}
)
}
}
export default connect(null, { setViewport })(NeovimSurface)
================================================
FILE: browser/src/Editor/NeovimEditor/Rename.tsx
================================================
/**
* Rename.tsx
*/
import * as React from "react"
import * as Oni from "oni-api"
import * as Log from "oni-core-logging"
import * as Helpers from "./../../Plugins/Api/LanguageClient/LanguageClientHelpers"
import { LanguageManager } from "./../../Services/Language"
import { RenameView } from "./../../Services/Language/RenameView"
import { Workspace } from "./../../Services/Workspace"
import { IToolTipsProvider } from "./ToolTipsProvider"
const _renameToolTipName = "rename-tool-tip"
export class Rename {
private _isRenameActive: boolean
constructor(
private _editor: Oni.Editor,
private _languageManager: LanguageManager,
private _toolTipsProvider: IToolTipsProvider,
private _workspace: Workspace,
) {}
public async startRename(): Promise {
if (this._isRenameActive) {
return
}
const activeBuffer = this._editor.activeBuffer
const activeToken = await activeBuffer.getTokenAt(
activeBuffer.cursor.line,
activeBuffer.cursor.column,
)
if (!activeToken || !activeToken.tokenName) {
return
}
this._isRenameActive = true
this._toolTipsProvider.showToolTip(
_renameToolTipName,
this.cancelRename()}
onComplete={newValue => this.commitRename(newValue)}
tokenName={activeToken.tokenName}
/>,
{
position: null,
openDirection: 2,
onDismiss: () => this.cancelRename(),
},
)
}
public commitRename(newValue: string): void {
Log.verbose("[RENAME] Committing rename")
this.doRename(newValue)
this.closeToolTip()
}
public cancelRename(): void {
Log.verbose("[RENAME] Cancelling")
this.closeToolTip()
}
public closeToolTip(): void {
Log.verbose("[RENAME] closeToolTip")
this._isRenameActive = false
this._toolTipsProvider.hideToolTip(_renameToolTipName)
}
public async doRename(newName: string): Promise {
const activeBuffer = this._editor.activeBuffer
const args = {
textDocument: {
uri: Helpers.wrapPathInFileUri(activeBuffer.filePath),
},
position: {
line: activeBuffer.cursor.line,
character: activeBuffer.cursor.column,
},
newName,
}
let result = null
try {
result = await this._languageManager.sendLanguageServerRequest(
activeBuffer.language,
activeBuffer.filePath,
"textDocument/rename",
args,
)
} catch (ex) {
Log.debug(ex)
}
if (result) {
await this._workspace.applyEdits(result)
}
}
}
================================================
FILE: browser/src/Editor/NeovimEditor/Symbols.ts
================================================
/**
* CodeAction.ts
*
*/
import * as _ from "lodash"
import { ErrorCodes } from "vscode-jsonrpc/lib/messages"
import * as types from "vscode-languageserver-types"
import * as Oni from "oni-api"
import * as Log from "oni-core-logging"
import { LanguageManager } from "./../../Services/Language"
import { Menu, MenuManager } from "./../../Services/Menu"
import * as Helpers from "./../../Plugins/Api/LanguageClient/LanguageClientHelpers"
import { asObservable, sleep } from "./../../Utility"
import { Definition } from "./Definition"
export class Symbols {
constructor(
private _editor: Oni.Editor,
private _definition: Definition,
private _languageManager: LanguageManager,
private _menuManager: MenuManager,
) {}
public async openWorkspaceSymbolsMenu() {
const menu = this._menuManager.create()
menu.show()
menu.setItems([
{
label: "Type to search symbols....",
},
])
menu.setLoading(true)
const filterTextChanged$ = asObservable(menu.onFilterTextChanged)
menu.onItemSelected.subscribe((selectedItem: Oni.Menu.MenuOption) => {
const key = selectedItem.label + selectedItem.detail
const loc = keyToLocation[key]
if (loc) {
this._definition.gotoPositionInUri(
loc.uri,
loc.range.start.line,
loc.range.start.character,
)
}
})
let keyToLocation: any = {}
const getKey = (si: types.SymbolInformation) => si.name + this._getDetailFromSymbol(si)
filterTextChanged$
.debounceTime(25)
.do(() => menu.setLoading(true))
.concatMap(async (newText: string) => {
return this._requestSymbols(this._editor.activeBuffer, "workspace/symbol", menu, {
query: newText,
})
})
.subscribe((newItems: types.SymbolInformation[]) => {
menu.setLoading(false)
menu.setItems(newItems.map(item => this._symbolInfoToMenuItem(item)))
keyToLocation = newItems.reduce((prev, curr) => {
return {
...prev,
[getKey(curr)]: curr.location,
}
}, {})
})
}
public async openDocumentSymbolsMenu(): Promise {
const menu = this._menuManager.create()
menu.show()
menu.setLoading(true)
const buffer = this._editor.activeBuffer
const result: types.SymbolInformation[] = await this._requestSymbols(
buffer,
"textDocument/documentSymbol",
menu,
)
const options: Oni.Menu.MenuOption[] = result.map(item => this._symbolInfoToMenuItem(item))
const labelToLocation = result.reduce((prev, curr) => {
return {
...prev,
[curr.name]: curr.location,
}
}, {})
menu.onItemSelected.subscribe(selectedItem => {
const location: types.Location = labelToLocation[selectedItem.label]
if (location) {
this._definition.gotoPositionInUri(
location.uri,
location.range.start.line,
location.range.start.character,
)
}
})
menu.setItems(options)
menu.setLoading(false)
}
private _getDetailFromSymbol(si: types.SymbolInformation): string {
const unwrappedPath = Helpers.unwrapFileUriPath(si.location.uri)
if (si.containerName) {
return si.containerName + "|" + unwrappedPath
} else {
return unwrappedPath
}
}
private _symbolInfoToMenuItem(si: types.SymbolInformation): Oni.Menu.MenuOption {
return {
label: si.name,
detail: this._getDetailFromSymbol(si),
icon: this._convertSymbolKindToIconName(si.kind),
}
}
private _convertSymbolKindToIconName(symbolKind: types.SymbolKind): string {
switch (symbolKind) {
case types.SymbolKind.Class:
return "cube"
case types.SymbolKind.Constructor:
return "building"
case types.SymbolKind.Enum:
return "sitemap"
case types.SymbolKind.Field:
return "var"
case types.SymbolKind.File:
return "file"
case types.SymbolKind.Function:
return "cog"
case types.SymbolKind.Interface:
return "plug"
case types.SymbolKind.Method:
return "flash"
case types.SymbolKind.Module:
return "cubes"
case types.SymbolKind.Property:
return "wrench"
case types.SymbolKind.Variable:
return "code"
default:
return "question"
}
}
/**
* Send a request for symbols, retrying if the server is not ready, as long as the menu is open.
*/
private async _requestSymbols(
buffer: Oni.Buffer,
command: string,
menu: Menu,
options: any = {},
): Promise {
while (menu.isOpen()) {
try {
return await this._languageManager.sendLanguageServerRequest(
buffer.language,
buffer.filePath,
command,
_.extend(
{
textDocument: {
uri: Helpers.wrapPathInFileUri(buffer.filePath),
},
},
options,
),
)
} catch (e) {
if (e.code === ErrorCodes.ServerNotInitialized) {
Log.warn("[Symbols] Language server not yet initialised, trying again...")
await sleep(1000)
} else {
throw e
}
}
}
return []
}
}
================================================
FILE: browser/src/Editor/NeovimEditor/ToolTipsProvider.ts
================================================
import * as Oni from "oni-api"
import * as Actions from "./NeovimEditorActions"
export interface IToolTipsProvider {
showToolTip(id: string, element: JSX.Element, options: Oni.ToolTip.ToolTipOptions): void
hideToolTip(id: string): void
}
export class NeovimEditorToolTipsProvider implements IToolTipsProvider {
constructor(private _actions: typeof Actions) {}
public showToolTip(
id: string,
element: JSX.Element,
options: Oni.ToolTip.ToolTipOptions,
): void {
this._actions.showToolTip(id, element, options)
}
public hideToolTip(id: string): void {
this._actions.hideToolTip(id)
}
}
================================================
FILE: browser/src/Editor/NeovimEditor/WelcomeBufferLayer.tsx
================================================
/**
* NeovimEditor.ts
*
* IEditor implementation for Neovim
*/
import * as Oni from "oni-api"
import * as Log from "oni-core-logging"
import { Event } from "oni-types"
import * as React from "react"
import { getMetadata } from "./../../Services/Metadata"
import { ISession, SessionManager } from "./../../Services/Sessions"
import styled, {
boxShadowInset,
Css,
css,
enableMouse,
getSelectedBorder,
keyframes,
lighten,
} from "./../../UI/components/common"
import { Icon } from "./../../UI/Icon"
// const entrance = keyframes`
// 0% { opacity: 0; transform: translateY(2px); }
// 100% { opacity: 0.5; transform: translateY(0px); }
// `
// const enterLeft = keyframes`
// 0% { opacity: 0; transform: translateX(-4px); }
// 100% { opacity: 1; transform: translateX(0px); }
// `
// const enterRight = keyframes`
// 0% { opacity: 0; transform: translateX(4px); }
// 100% { opacity: 1; transform: translateX(0px); }
// `
const entranceFull = keyframes`
0% {
opacity: 0;
transform: translateY(8px);
}
100% {
opacity: 1;
transform: translateY(0px);
}
`
const WelcomeWrapper = styled.div`
background-color: ${p => p.theme["editor.background"]};
color: ${p => p.theme["editor.foreground"]};
overflow-y: hidden;
user-select: none;
pointer-events: all;
width: 100%;
height: 100%;
opacity: 0;
animation: ${entranceFull} 0.25s ease-in 0.1s forwards ${enableMouse};
`
interface IColumnProps {
alignment?: string
justify?: string
flex?: string
height?: string
extension?: Css
}
const Column = styled("div")`
background: inherit;
display: flex;
justify-content: ${({ justify }) => justify || `center`};
align-items: ${({ alignment }) => alignment || "center"};
flex-direction: column;
width: 100%;
flex: ${({ flex }) => flex || "1"};
height: ${({ height }) => height || `auto`};
${({ extension }) => extension};
`
const sectionStyles = css`
display: flex;
flex-direction: column;
justify-content: flex-start;
align-items: center;
height: 90%;
overflow-y: hidden;
direction: rtl;
&:hover {
overflow-y: overlay;
}
& > * {
direction: ltr;
}
`
const LeftColumn = styled.div`
${sectionStyles};
padding: 0;
padding-left: 1rem;
overflow-y: hidden;
width: 60%;
`
const RightColumn = styled.div`
${sectionStyles};
width: 30%;
border-left: 1px solid ${({ theme }) => theme["editor.background"]};
`
const Row = styled<{ extension?: Css }, "div">("div")`
display: flex;
justify-content: center;
align-items: center;
flex-direction: row;
opacity: 0;
${({ extension }) => extension};
`
const TitleText = styled.div`
font-size: 2em;
text-align: right;
`
const SubtitleText = styled.div`
font-size: 1.2em;
text-align: right;
`
const HeroImage = styled.img`
width: 192px;
height: 192px;
opacity: 0.4;
`
export const SectionHeader = styled.div`
margin-top: 1em;
margin-bottom: 1em;
font-size: 1.2em;
font-weight: bold;
text-align: left;
width: 100%;
`
const WelcomeButtonHoverStyled = `
transform: translateY(-1px);
box-shadow: 0 4px 8px 2px rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19);
`
export interface WelcomeButtonWrapperProps {
isSelected: boolean
borderSize: string
}
const WelcomeButtonWrapper = styled("button")`
box-sizing: border-box;
font-size: inherit;
font-family: inherit;
border: 0px solid ${props => props.theme.foreground};
border-left: ${getSelectedBorder};
border-right: 4px solid transparent;
cursor: pointer;
color: ${({ theme }) => theme.foreground};
background-color: ${({ theme }) => lighten(theme.background)};
transform: ${({ isSelected }) => (isSelected ? "translateX(-4px)" : "translateX(0px)")};
transition: transform 0.25s;
width: 100%;
margin: 0.8em 0;
padding: 0.8em;
display: flex;
flex-direction: row;
&:hover {
${WelcomeButtonHoverStyled};
}
`
const AnimatedContainer = styled<{ duration: string }, "div">("div")`
width: 100%;
animation: ${entranceFull} ${p => p.duration} ease-in 1s both;
`
const WelcomeButtonTitle = styled.span`
font-size: 1em;
font-weight: bold;
margin: 0.4em;
width: 100%;
text-align: left;
`
const WelcomeButtonDescription = styled.span`
font-size: 0.8em;
opacity: 0.75;
margin: 4px;
width: 100%;
text-align: right;
`
const boxStyling = css`
width: 60%;
height: 60%;
padding: 0 1em;
opacity: 1;
margin-top: 64px;
box-sizing: border-box;
border: 1px solid ${p => p.theme["editor.hover.contents.background"]};
border-radius: 4px;
overflow: hidden;
justify-content: space-around;
background-color: ${p => p.theme["editor.hover.contents.codeblock.background"]};
${boxShadowInset};
`
const titleRow = css`
width: 100%;
padding-top: 32px;
animation: ${entranceFull} 0.25s ease-in 0.25s forwards};
`
const selectedSectionItem = css`
${({ theme }) => `
text-decoration: underline;
color: ${theme["highlight.mode.normal.background"]};
`};
`
export const SectionItem = styled<{ isSelected?: boolean }, "li">("li")`
width: 100%;
margin: 0.2em;
text-align: left;
height: auto;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
${({ isSelected }) => isSelected && selectedSectionItem};
&:hover {
text-decoration: underline;
}
`
export const SessionsList = styled.ul`
width: 70%;
margin: 0;
list-style-type: none;
border-radius: 4px;
padding: 0 1em;
border: 1px solid ${p => p.theme["editor.hover.contents.codeblock.background"]};
`
export interface WelcomeButtonProps {
title: string
description: string
command: string
selected: boolean
onClick: () => void
}
interface IChromeDiv extends HTMLButtonElement {
scrollIntoViewIfNeeded: () => void
}
export class WelcomeButton extends React.PureComponent {
private _button = React.createRef()
public componentDidUpdate(prevProps: WelcomeButtonProps) {
if (!prevProps.selected && this.props.selected) {
this._button.current.scrollIntoViewIfNeeded()
}
}
public render() {
return (
{this.props.title}
{this.props.description}
)
}
}
export interface WelcomeHeaderState {
version: string
}
export interface OniWithActiveSection extends Oni.Plugin.Api {
sessions: SessionManager
getActiveSection(): string
}
type ExecuteCommand = (command: string, args?: T) => void
export interface IWelcomeInputEvent {
select: boolean
vertical: number
horizontal?: number
}
interface ICommandMetadata {
execute: (args?: T) => void
command: string
}
export interface IWelcomeCommandsDictionary {
openFile: ICommandMetadata
openTutor: ICommandMetadata
openDocs: ICommandMetadata
openConfig: ICommandMetadata
openThemes: ICommandMetadata
openWorkspaceFolder: ICommandMetadata
commandPalette: ICommandMetadata
commandline: ICommandMetadata
restoreSession: (sessionName: string) => Promise
}
export class WelcomeBufferLayer implements Oni.BufferLayer {
public inputEvent = new Event()
constructor(private _oni: OniWithActiveSection) {}
public showCommandline = async () => {
const remapping: string = await this._oni.editors.activeEditor.neovim.callFunction(
"mapcheck",
[":", "n"],
)
const mapping = remapping || ":"
this._oni.automation.sendKeys(mapping)
}
public executeCommand: ExecuteCommand = (cmd, args) => {
this._oni.commands.executeCommand(cmd, args)
}
public restoreSession = async (name: string) => {
await this._oni.sessions.restoreSession(name)
}
// tslint:disable-next-line
public readonly welcomeCommands: IWelcomeCommandsDictionary = {
openFile: {
execute: args => this.executeCommand("oni.editor.newFile", args),
command: "oni.editor.newFile",
},
openWorkspaceFolder: {
execute: args => this.executeCommand("workspace.openFolder", args),
command: "workspace.openFolder",
},
commandPalette: {
execute: args => this.executeCommand("commands.show", args),
command: "commands.show",
},
commandline: {
execute: this.showCommandline,
command: "editor.executeVimCommand",
},
openTutor: {
execute: args => this.executeCommand("oni.tutor.open", args),
command: "oni.tutor.open",
},
openDocs: {
execute: args => this.executeCommand("oni.docs.open", args),
command: "oni.docs.open",
},
openConfig: {
execute: args => this.executeCommand("oni.config.openUserConfig", args),
command: "oni.config.openUserConfig",
},
openThemes: {
execute: args => this.executeCommand("oni.themes.choose", args),
command: "oni.themes.open",
},
restoreSession: args => this.restoreSession(args),
}
public get id() {
return "oni.welcome"
}
public get friendlyName() {
return "Welcome"
}
public isActive(): boolean {
const activeSection = this._oni.getActiveSection()
return activeSection === "editor"
}
public handleInput(key: string) {
Log.info(`ONI WELCOME INPUT KEY: ${key}`)
switch (key) {
case "j":
this.inputEvent.dispatch({ vertical: 1, select: false })
break
case "k":
this.inputEvent.dispatch({ vertical: -1, select: false })
break
case "l":
this.inputEvent.dispatch({ vertical: 0, select: false, horizontal: 1 })
break
case "h":
this.inputEvent.dispatch({ vertical: 0, select: false, horizontal: -1 })
break
case "":
this.inputEvent.dispatch({ vertical: 0, select: true })
break
default:
this.inputEvent.dispatch({ vertical: 0, select: false })
}
}
public getProps() {
const active = this._oni.getActiveSection() === "editor"
const commandIds = Object.values(this.welcomeCommands)
.map(({ command }) => command)
.filter(Boolean)
const sessions = this._oni.sessions ? this._oni.sessions.allSessions : ([] as ISession[])
const sessionIds = sessions.map(({ id }) => id)
const ids = [...commandIds, ...sessionIds]
const sections = [commandIds.length, sessionIds.length].filter(Boolean)
return { active, ids, sections, sessions }
}
public render(context: Oni.BufferLayerRenderContext) {
const props = this.getProps()
return (
)
}
}
export interface WelcomeViewProps {
active: boolean
sessions: ISession[]
sections: number[]
ids: string[]
inputEvent: Event
commands: IWelcomeCommandsDictionary
getMetadata: () => Promise<{ version: string }>
restoreSession: (name: string) => Promise
executeCommand: ExecuteCommand
}
export interface WelcomeViewState {
version: string
selectedId: string
currentIndex: number
}
export class WelcomeView extends React.PureComponent {
public state: WelcomeViewState = {
version: null,
currentIndex: 0,
selectedId: this.props.ids[0],
}
private _welcomeElement = React.createRef()
public async componentDidMount() {
const metadata = await this.props.getMetadata()
this.setState({ version: metadata.version })
this.props.inputEvent.subscribe(this.handleInput)
}
public handleInput = async ({ vertical, select, horizontal }: IWelcomeInputEvent) => {
const { currentIndex } = this.state
const { sections, ids, active } = this.props
const newIndex = this.getNextIndex(currentIndex, vertical, horizontal, sections)
const selectedId = ids[newIndex]
this.setState({ currentIndex: newIndex, selectedId })
const selectedSession = this.props.sessions.find(session => session.id === selectedId)
if (select && active) {
if (selectedSession) {
await this.props.commands.restoreSession(selectedSession.name)
} else {
const currentCommand = this.getCurrentCommand(selectedId)
currentCommand.execute()
}
}
}
public getCurrentCommand(selectedId: string): ICommandMetadata {
const { commands } = this.props
const currentCommand = Object.values(commands).find(({ command }) => command === selectedId)
return currentCommand
}
public getNextIndex(
currentIndex: number,
vertical: number,
horizontal: number,
sections: number[],
) {
const nextPosition = currentIndex + vertical
const numberOfItems = this.props.ids.length
const multipleSections = sections.length > 1
// TODO: this currently handles *TWO* sections if more sections
// are to be added will need to rethink how to allow navigation across multiple sections
switch (true) {
case multipleSections && horizontal === 1:
return sections[0]
case multipleSections && horizontal === -1:
return 0
case nextPosition < 0:
return numberOfItems - 1
case nextPosition === numberOfItems:
return 0
default:
return nextPosition
}
}
public componentDidUpdate() {
if (this.props.active && this._welcomeElement && this._welcomeElement.current) {
this._welcomeElement.current.focus()
}
}
public render() {
const { version, selectedId } = this.state
return (
Oni
Modern Modal Editing
{version && {`v${version}`}}
{"https://onivim.io"}
Sessions
{this.props.sessions.length ? (
this.props.sessions.map(session => (
this.props.restoreSession(session.name)}
key={session.id}
>
{" "}
{session.name}
))
) : (
No Sessions Available
)}
)
}
}
export interface IWelcomeCommandsViewProps extends Partial {
selectedId: string
}
export const WelcomeCommandsView: React.SFC = props => {
const isSelected = (command: string) => command === props.selectedId
const { commands } = props
return (
Quick Commands
commands.openFile.execute()}
description="Control + N"
command={commands.openFile.command}
selected={isSelected(commands.openFile.command)}
/>
commands.openWorkspaceFolder.execute()}
command={commands.openWorkspaceFolder.command}
selected={isSelected(commands.openWorkspaceFolder.command)}
/>
commands.commandPalette.execute()}
description="Control + Shift + P"
command={commands.commandPalette.command}
selected={isSelected(commands.commandPalette.command)}
/>
commands.commandline.execute()}
selected={isSelected(commands.commandline.command)}
/>
Learn
commands.openTutor.execute()}
description="Learn modal editing with an interactive tutorial."
command={commands.openTutor.command}
selected={isSelected(commands.openTutor.command)}
/>
commands.openDocs.execute()}
description="Discover what Oni can do for you."
command={commands.openDocs.command}
selected={isSelected(commands.openDocs.command)}
/>
Customize
commands.openConfig.execute()}
description="Make Oni work the way you want."
command={commands.openConfig.command}
selected={isSelected(commands.openConfig.command)}
/>
commands.openThemes.execute()}
description="Choose a theme that works for you."
command={commands.openThemes.command}
selected={isSelected(commands.openThemes.command)}
/>
)
}
================================================
FILE: browser/src/Editor/NeovimEditor/index.ts
================================================
export * from "./NeovimEditor"
================================================
FILE: browser/src/Editor/NeovimEditor/markdown.ts
================================================
import { unescape } from "lodash"
import * as marked from "marked"
import * as Log from "oni-core-logging"
import { IGrammarPerLine, IGrammarToken } from "./../../Services/SyntaxHighlighting/TokenGenerator"
import * as DOMPurify from "dompurify"
const renderer = new marked.Renderer()
interface IRendererArgs {
tokens?: IGrammarPerLine
text: string
element?: TextElement
container?: TextElement
}
interface Symbols {
[symbol: string]: string[]
}
export const scopesToString = (scope: string[]) => {
if (scope) {
return scope
.map(s => {
if (s.includes(".")) {
const lastStop = s.lastIndexOf(".")
const remainder = s.substring(0, lastStop)
return remainder.replace(/\./g, "-")
}
return s
})
.filter(value => !!value)
.join(" ")
}
return null
}
/**
* escapeRegExp
* Escapes a string intended for use as a regexp
* @param {string} str
* @returns {string}
*/
export function escapeRegExp(str: string) {
// NOTE This does NOT escape the "|" operator as it's needed for the Reg Exp
// Also does not escape "\-" as hypenated tokens can be found
return str.replace(/[\[\]\/\{\}\(\)\*\+\?\.\\\^\$\n\r]/g, "\\$&")
}
type TextElement = "code" | "pre" | "p" | "span"
export const createContainer = (type: TextElement, content: string) => {
switch (type) {
case "pre":
return `${content}`
case "p":
return `<${type} class="marked-paragraph">${content}`
case "code":
default:
return content
}
}
interface WrapTokenArgs {
tokens: IGrammarToken[]
element: string
text: string
}
export function wrapTokens({ tokens, element, text }: WrapTokenArgs): string {
try {
const symbols: Symbols = tokens.reduce((acc, token) => {
const symbol = text.substring(token.range.start.character, token.range.end.character)
acc[symbol] = token.scopes
return acc
}, {})
const symbolNames = Object.keys(symbols)
const banned = ["\n", "\r", " ", "|"]
const filteredNames = symbolNames.filter(str => !banned.includes(str))
// Check if a word is alphabetical if so make sure to match full words only
// if not alphabetical escape the string
const wholeWordMatch = filteredNames.map(
str => (/^[A-Za-z]/.test(str) ? `\\b${str}\\b` : escapeRegExp(str)),
)
const symbolRegex = new RegExp("(" + wholeWordMatch.join("|") + ")", "g")
const html = text.replace(symbolRegex, (match, ...args) => {
const className = scopesToString(symbols[match])
return `<${element} class="marked ${className}">${match}`
})
return html
} catch (e) {
Log.warn(`Regex construction failed with: ${e.message}`)
return text
}
}
/**
* Takes a list of tokens which contain ranges, the text from marked (3rd party lib)
* uses a reg exp to replace all matching tokens with an element with a class that is styled
* else where
* @returns {string}
*/
export function renderWithClasses({
tokens,
text,
element = "span",
container = "p",
}: IRendererArgs) {
// This is critical because marked's renderer refuses to leave html untouched so it converts
// special chars to html entities
const unescapedText = unescape(text)
const whiteSpaceForCode = (line: string, code: boolean) => (code ? line.trim() : line)
if (tokens) {
const isCodeBlock = container === "code"
const tokenValues = Object.values(tokens)
const tokenLines = tokenValues.map(l => whiteSpaceForCode(l.line, isCodeBlock))
const parts = unescapedText.split("\n")
// Find common lines in lines to render and lines in tokenisation map
const intersection = tokenLines.filter(x => parts.includes(x))
const lineToToken = tokenValues.reduce((acc, t) => {
const key = whiteSpaceForCode(t.line, isCodeBlock)
acc[key] = t
return acc
}, {})
if (intersection.length) {
const html = intersection.reduce((acc, match) => {
return `${(acc += wrapTokens({
tokens: lineToToken[match].tokens,
element,
text: lineToToken[match].line,
}))}\n`
}, "")
if (container) {
return createContainer(container, html)
}
return html
}
}
return text
}
interface IConversionArgs {
markdown: string
tokens?: IGrammarPerLine
type?: string
}
const config = {
FORBID_TAGS: ["img", "script"],
}
/**
* Takes a markdown string and defines a custom renderer then for the element type and returns an html string
*
* @name convertMarkdown
* @function
* @param {string} {markdown A Markdown String
* @param {Object} tokens An Object of lines with tokens for each line
* @param {string} type the section of the quickfix being processed
* @returns {string} An html string
*/
export const convertMarkdown = ({ markdown, tokens, type = "title" }: IConversionArgs): string => {
marked.setOptions({
sanitize: true,
gfm: true,
renderer,
highlight: (code, lang) => {
return renderWithClasses({ text: code, tokens, container: "code" })
},
})
switch (type) {
case "documentation":
renderer.html = htmlString => DOMPurify.sanitize(htmlString, config)
renderer.paragraph = text => createContainer("p", DOMPurify.sanitize(text, config))
break
case "title":
default:
renderer.html = htmlString => DOMPurify.sanitize(htmlString, config)
renderer.paragraph = text => {
const stringWithClasses = renderWithClasses({ text, tokens })
return DOMPurify.sanitize(stringWithClasses, config)
}
renderer.blockquote = text => {
const stringWithClasses = renderWithClasses({
text,
tokens,
container: "pre",
})
return DOMPurify.sanitize(stringWithClasses, config)
}
}
const html = marked(markdown)
return html
}
================================================
FILE: browser/src/Editor/OniEditor/ColorHighlightLayer.tsx
================================================
import * as Color from "color"
import * as memoize from "lodash/memoize"
import * as Oni from "oni-api"
import * as Log from "oni-core-logging"
import * as React from "react"
import styled, { pixel, withProps } from "../../UI/components/common"
interface IBackground {
top: number
left: number
height: number
width: number
}
interface IHighlight {
color: string
fontFamily: string
height: number
fontSize: string
}
const Background = withProps(styled.div).attrs({
style: (props: IBackground) => ({
top: pixel(props.top),
left: pixel(props.left),
height: pixel(props.height),
width: pixel(props.width),
}),
})`
background-color: ${p => p.theme["editor.background"]};
position: absolute;
white-space: nowrap;
`
const HighlightSpan = withProps(styled.div)`
display: block;
height: 100%;
width: 100%;
color: ${p => (Color(p.color).dark() ? "white" : "black")};
font-family: ${p => p.fontFamily};
font-size: ${p => p.fontSize};
line-height: ${p => pixel(p.height + 5)}; /* vertically center text inside the highlight */
background-color: ${p => p.color};
`
interface IState {
error: Error
}
type IProps = IHighlight & IBackground
class Highlight extends React.PureComponent {
public state: IState = {
error: null,
}
public componentDidCatch(error: Error) {
this.setState({ error })
}
public render() {
return (
!this.state.error && (
{this.props.children}
)
)
}
}
export default class ColorHighlightLayer implements Oni.BufferLayer {
public render = memoize((context: Oni.BufferLayerRenderContext) => (
<>{this._getColorHighlights(context)}
))
private readonly CSS_COLOR_NAMES = [
"AliceBlue",
"AntiqueWhite",
"Aqua",
"Aquamarine",
"Azure",
"Beige",
"Bisque",
"Black",
"BlanchedAlmond",
"Blue",
"BlueViolet",
"Brown",
"BurlyWood",
"CadetBlue",
"Chartreuse",
"Chocolate",
"Coral",
"CornflowerBlue",
"Cornsilk",
"Crimson",
"Cyan",
"DarkBlue",
"DarkCyan",
"DarkGoldenRod",
"DarkGray",
"DarkGrey",
"DarkGreen",
"DarkKhaki",
"DarkMagenta",
"DarkOliveGreen",
"Darkorange",
"DarkOrchid",
"DarkRed",
"DarkSalmon",
"DarkSeaGreen",
"DarkSlateBlue",
"DarkSlateGray",
"DarkSlateGrey",
"DarkTurquoise",
"DarkViolet",
"DeepPink",
"DeepSkyBlue",
"DimGray",
"DimGrey",
"DodgerBlue",
"FireBrick",
"FloralWhite",
"ForestGreen",
"Fuchsia",
"Gainsboro",
"GhostWhite",
"Gold",
"GoldenRod",
"Gray",
"Grey",
"Green",
"GreenYellow",
"HoneyDew",
"HotPink",
"IndianRed",
"Indigo",
"Ivory",
"Khaki",
"Lavender",
"LavenderBlush",
"LawnGreen",
"LemonChiffon",
"LightBlue",
"LightCoral",
"LightCyan",
"LightGoldenRodYellow",
"LightGray",
"LightGrey",
"LightGreen",
"LightPink",
"LightSalmon",
"LightSeaGreen",
"LightSkyBlue",
"LightSlateGray",
"LightSlateGrey",
"LightSteelBlue",
"LightYellow",
"Lime",
"LimeGreen",
"Linen",
"Magenta",
"Maroon",
"MediumAquaMarine",
"MediumBlue",
"MediumOrchid",
"MediumPurple",
"MediumSeaGreen",
"MediumSlateBlue",
"MediumSpringGreen",
"MediumTurquoise",
"MediumVioletRed",
"MidnightBlue",
"MintCream",
"MistyRose",
"Moccasin",
"NavajoWhite",
"Navy",
"OldLace",
"Olive",
"OliveDrab",
"Orange",
"OrangeRed",
"Orchid",
"PaleGoldenRod",
"PaleGreen",
"PaleTurquoise",
"PaleVioletRed",
"PapayaWhip",
"PeachPuff",
"Peru",
"Pink",
"Plum",
"PowderBlue",
"Purple",
"Red",
"RosyBrown",
"RoyalBlue",
"SaddleBrown",
"Salmon",
"SandyBrown",
"SeaGreen",
"SeaShell",
"Sienna",
"Silver",
"SkyBlue",
"SlateBlue",
"SlateGray",
"SlateGrey",
"Snow",
"SpringGreen",
"SteelBlue",
"Tan",
"Teal",
"Thistle",
"Tomato",
"Turquoise",
"Violet",
"Wheat",
"White",
"WhiteSmoke",
"Yellow",
"YellowGreen",
]
// Match hex/rgb/rgba/hsl/hsla colors -
// courtesy of https://gist.github.com/olmokramer/82ccce673f86db7cda5e
// the first section matches a hex code which can be 3 or 6 digits long the
// next section matches rgb or hsl value with an a optionally
// NB - the regex was tweaked so it could match inside a string
private _colorCodeRegex = /#(?:[0-9a-f]{3}){1,2}|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\)/gi
private _colorRegex: RegExp
private _fontSize: string
private _fontFamily: string
constructor(private _config: Oni.Configuration) {
this._fontSize = this._config.getValue("editor.fontSize")
this._fontFamily = this._config.getValue("editor.fontFamily")
this._config.onConfigurationChanged.subscribe(this._updateFontFamily)
this._constructRegex()
}
public get id() {
return "color-highlight"
}
public get friendlyName() {
return "CSS color highlight layer"
}
private _updateFontFamily = (configChanges: Partial) => {
const fontFamilyChanged = Object.keys(configChanges).includes("editor.fontFamily")
if (fontFamilyChanged) {
this._fontFamily = configChanges["editor.fontFamily"]
}
}
private _constructRegex() {
// Construct a regex checking for both color codes and all the different css colornames
const colorNames = this.CSS_COLOR_NAMES.map(name => `\\b${name}\\b`)
const colorNamesRegex = new RegExp("(" + colorNames.join("|") + ")")
this._colorRegex = new RegExp(
colorNamesRegex.source + "|" + this._colorCodeRegex.source,
"gi",
)
}
private _getColorHighlights = (context: Oni.BufferLayerRenderContext) => {
return context.visibleLines.map((line, idx) => {
try {
const matches = line.match(this._colorRegex)
if (matches) {
const colors = matches.filter(Boolean)
if (colors.length) {
const locations = colors.map(c => ({
color: c,
start: line.indexOf(c),
end: line.indexOf(c) + c.length,
}))
const currentLine = context.topBufferLine + idx - 1
return locations.map(location => {
const startPosition = context.bufferToPixel({
line: currentLine,
character: location.start,
})
const endPosition = context.bufferToPixel({
line: currentLine,
character: location.end,
})
if (!startPosition || !endPosition) {
return null
}
const width = endPosition.pixelX - startPosition.pixelX
return (
{location.color}
)
})
}
}
} catch (e) {
Log.warn(`Failed to create color highlights because ${e.message}`)
return null
}
return null
})
}
}
================================================
FILE: browser/src/Editor/OniEditor/ImageBufferLayer.tsx
================================================
/**
* ImageBufferLayer.tsx
*/
import * as React from "react"
import styled from "styled-components"
// import { inputManager, InputManager } from "./../../Services/InputManager"
import * as Oni from "oni-api"
import { withProps } from "./../../UI/components/common"
// import { VimNavigator } from "./../../UI/components/VimNavigator"
export class ImageBufferLayer implements Oni.BufferLayer {
constructor(private _buffer: Oni.Buffer) {}
public get id(): string {
return "oni.image"
}
public get friendlyName(): string {
return "Image"
}
public render(context: Oni.BufferLayerRenderContext): JSX.Element {
return
}
}
export interface IImageLayerViewProps {
imagePath: string
}
export interface IImageLayerViewState {
width: number
height: number
}
const ImageContainer = withProps<{}>(styled.div)`
background-color: ${props => props.theme["editor.background"]};
color: ${props => props.theme["editor.foreground"]};
position: absolute;
top: 0px;
left: 0px;
right: 0px;
bottom: 0px;
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
opacity: 0.95;
& img {
max-width: 90%;
max-height: 90%;
padding-bottom: 2em;
}
`
export class ImageLayerView extends React.PureComponent<
IImageLayerViewProps,
IImageLayerViewState
> {
constructor(props: IImageLayerViewProps) {
super(props)
this.state = {
width: -1,
height: -1,
}
}
public componentDidMount(): void {
const image = new Image()
image.onload = () => {
this.setState({
width: image.width,
height: image.height,
})
}
image.src = this.props.imagePath
}
public render(): JSX.Element {
const dimensions = this.state ? `${this.state.width}x${this.state.height}` : ""
return (
{this.props.imagePath}
{dimensions}
)
}
}
================================================
FILE: browser/src/Editor/OniEditor/IndentGuideBufferLayer.tsx
================================================
import * as React from "react"
import * as detectIndent from "detect-indent"
import * as flatten from "lodash/flatten"
import * as last from "lodash/last"
import * as memoize from "lodash/memoize"
import * as Oni from "oni-api"
import { IBuffer } from "../BufferManager"
import styled, { pixel, withProps } from "./../../UI/components/common"
interface IWrappedLine {
start: number
end: number
line: string
}
interface IProps {
height: number
left: number
top: number
color?: string
}
interface ConfigOptions {
skipFirst: boolean
color?: string
}
interface LinePropsWithLevels extends IndentLinesProps {
levelOfIndentation: number
}
interface IndentLinesProps {
top: number
left: number
height: number
line: string
indentBy: number
indentSize: number
characterWidth: number
}
const Container = styled.div``
const IndentLine = withProps(styled.span).attrs({
style: ({ height, left, top }: IProps) => ({
height: pixel(height),
left: pixel(left),
top: pixel(top),
}),
})`
border-left: 1px solid ${p => p.color || "rgba(100, 100, 100, 0.4)"};
position: absolute;
`
interface IndentLayerArgs {
buffer: IBuffer
configuration: Oni.Configuration
}
class IndentGuideBufferLayer implements Oni.BufferLayer {
public render = memoize((bufferLayerContext: Oni.BufferLayerRenderContext) => {
return {this._renderIndentLines(bufferLayerContext)}
})
private _buffer: IBuffer
private _userSpacing: number
private _configuration: Oni.Configuration
constructor({ buffer, configuration }: IndentLayerArgs) {
this._buffer = buffer
this._configuration = configuration
this._userSpacing = this._buffer.shiftwidth || this._buffer.tabstop
}
get id() {
return "indent-guides"
}
get friendlyName() {
return "Indent Guide Lines"
}
private _getIndentLines = (guidePositions: IndentLinesProps[], options: ConfigOptions) => {
return flatten(
guidePositions.map((props, idx) => {
const indents: JSX.Element[] = []
// Create a line per indentation
for (
let levelOfIndentation = 0;
levelOfIndentation < props.indentBy;
levelOfIndentation++
) {
const lineProps = { ...props, levelOfIndentation }
const adjustedLeft = this._calculateLeftPosition(lineProps)
const shouldSkip = this._determineIfShouldSkip(lineProps, options)
const key = `${props.line.trim()}-${idx}-${levelOfIndentation}`
indents.push(
!shouldSkip && (
),
)
}
return indents
}),
)
}
private _determineIfShouldSkip(props: LinePropsWithLevels, options: ConfigOptions) {
const skipFirstIndentLine =
options.skipFirst && props.levelOfIndentation === props.indentBy - 1
return skipFirstIndentLine
}
/**
* Remove one indent from left positioning and move lines slightly inwards -
* by a third of a character for a better visual appearance
*/
private _calculateLeftPosition(props: LinePropsWithLevels) {
const adjustedLeft =
props.left -
props.indentSize -
props.levelOfIndentation * props.indentSize +
props.characterWidth / 3
return adjustedLeft
}
private _getWrappedLines(context: Oni.BufferLayerRenderContext): IWrappedLine[] {
const { lines } = context.visibleLines.reduce(
(acc, line, index) => {
const currentLine = context.topBufferLine + index
const bufferInfo = context.bufferToScreen({ line: currentLine, character: 0 })
if (bufferInfo && bufferInfo.screenY) {
const { screenY: screenLine } = bufferInfo
if (acc.expectedLine !== screenLine) {
acc.lines.push({
start: acc.expectedLine,
end: screenLine,
line,
})
acc.expectedLine = screenLine + 1
} else {
acc.expectedLine += 1
}
}
return acc
},
{ lines: [], expectedLine: 1 },
)
return lines
}
private _regulariseIndentation(indentation: detectIndent.IndentInfo) {
const isOddBy = indentation.amount % this._userSpacing
const amountToIndent = isOddBy ? indentation.amount - isOddBy : indentation.amount
return amountToIndent
}
/**
* Calculates the position of each indent guide element using shiftwidth or tabstop if no
* shift width available
* @name _renderIndentLines
* @function
* @param {Oni.BufferLayerRenderContext} bufferLayerContext The buffer layer context
* @returns {JSX.Element[]} An array of react elements
*/
private _renderIndentLines = (bufferLayerContext: Oni.BufferLayerRenderContext) => {
// TODO: If the beginning of the visible lines is wrapping no lines are drawn
const wrappedScreenLines = this._getWrappedLines(bufferLayerContext)
const options = {
color: this._configuration.getValue("experimental.indentLines.color"),
skipFirst: this._configuration.getValue("experimental.indentLines.skipFirst"),
}
const { visibleLines, fontPixelHeight, fontPixelWidth, topBufferLine } = bufferLayerContext
const indentSize = this._userSpacing * fontPixelWidth
const { allIndentations } = visibleLines.reduce(
(acc, line, currenLineNumber) => {
const rawIndentation = detectIndent(line)
const regularisedIndent = this._regulariseIndentation(rawIndentation)
const previous = last(acc.allIndentations)
const height = Math.ceil(fontPixelHeight)
// start position helps determine the initial indent offset
const startPosition = bufferLayerContext.bufferToScreen({
line: topBufferLine,
character: regularisedIndent,
})
const wrappedLine = wrappedScreenLines.find(wrapped => wrapped.line === line)
const levelsOfWrapping = wrappedLine ? wrappedLine.end - wrappedLine.start : 1
const adjustedHeight = height * levelsOfWrapping
if (!startPosition) {
return acc
}
const { pixelX: left, pixelY: top } = bufferLayerContext.screenToPixel({
screenX: startPosition.screenX,
screenY: currenLineNumber,
})
const adjustedTop = top + acc.wrappedHeightAdjustment
// Only adjust height for Subsequent lines!
if (wrappedLine) {
acc.wrappedHeightAdjustment += adjustedHeight
}
if (!line && previous) {
acc.allIndentations.push({
...previous,
line,
top: adjustedTop,
})
return acc
}
const indent = {
left,
line,
indentSize,
top: adjustedTop,
height: adjustedHeight,
characterWidth: fontPixelWidth,
indentBy: regularisedIndent / this._userSpacing,
}
acc.allIndentations.push(indent)
return acc
},
{ allIndentations: [], wrappedHeightAdjustment: 0 },
)
return this._getIndentLines(allIndentations, options)
}
}
export default IndentGuideBufferLayer
================================================
FILE: browser/src/Editor/OniEditor/OniEditor.tsx
================================================
/**
* OniEditor.ts
*
* Editor implementation for Oni
*
* Extends the capabilities of the NeovimEditor
*/
import * as path from "path"
import * as React from "react"
import * as types from "vscode-languageserver-types"
import * as Oni from "oni-api"
import * as Log from "oni-core-logging"
import { IEvent } from "oni-types"
// import { remote } from "electron"
import * as App from "./../../App"
import * as Utility from "./../../Utility"
import { PluginManager } from "./../../Plugins/PluginManager"
import { IColors } from "./../../Services/Colors"
import { commandManager } from "./../../Services/CommandManager"
import { CompletionProviders } from "./../../Services/Completion"
import { Configuration } from "./../../Services/Configuration"
import { IDiagnosticsDataSource } from "./../../Services/Diagnostics"
import { editorManager } from "./../../Services/EditorManager"
import { LanguageManager } from "./../../Services/Language"
import { MenuManager } from "./../../Services/Menu"
import { OverlayManager } from "./../../Services/Overlay"
import { SnippetManager } from "./../../Services/Snippets"
import { ISyntaxHighlighter } from "./../../Services/SyntaxHighlighting"
import { ThemeManager } from "./../../Services/Themes"
import { TokenColors } from "./../../Services/TokenColors"
import { Workspace } from "./../../Services/Workspace"
import { BufferScrollBarContainer } from "./containers/BufferScrollBarContainer"
import { DefinitionContainer } from "./containers/DefinitionContainer"
import { ErrorsContainer } from "./containers/ErrorsContainer"
import { NeovimEditor } from "./../NeovimEditor"
import { SplitDirection, windowManager } from "./../../Services/WindowManager"
import { ISession } from "../../Services/Sessions"
import { IBuffer } from "../BufferManager"
import { OniWithActiveSection, WelcomeBufferLayer } from "../NeovimEditor/WelcomeBufferLayer"
import ColorHighlightLayer from "./ColorHighlightLayer"
import { ImageBufferLayer } from "./ImageBufferLayer"
import IndentLineBufferLayer from "./IndentGuideBufferLayer"
// Helper method to wrap a react component into a layer
const wrapReactComponentWithLayer = (id: string, component: JSX.Element): Oni.BufferLayer => {
return {
id,
render: (context: Oni.BufferLayerRenderContext) => (context.isActive ? component : null),
}
}
export class OniEditor extends Utility.Disposable implements Oni.Editor {
private _neovimEditor: NeovimEditor
public get mode(): string {
return this._neovimEditor.mode
}
public get onCursorMoved(): IEvent {
return this._neovimEditor.onCursorMoved
}
public get onModeChanged(): IEvent {
return this._neovimEditor.onModeChanged
}
public get onBufferEnter(): IEvent {
return this._neovimEditor.onBufferEnter
}
public get onBufferLeave(): IEvent {
return this._neovimEditor.onBufferLeave
}
public get onBufferChanged(): IEvent {
return this._neovimEditor.onBufferChanged
}
public get onBufferSaved(): IEvent {
return this._neovimEditor.onBufferSaved
}
public get onBufferScrolled(): IEvent {
return this._neovimEditor.onBufferScrolled
}
public get /* override */ activeBuffer(): Oni.Buffer {
return this._neovimEditor.activeBuffer
}
public get onQuit(): IEvent {
return this._neovimEditor.onNeovimQuit
}
// Capabilities
public get neovim(): Oni.NeovimEditorCapability {
return this._neovimEditor.neovim
}
public get syntaxHighlighter(): ISyntaxHighlighter {
return this._neovimEditor.syntaxHighlighter
}
constructor(
private _colors: IColors,
private _completionProviders: CompletionProviders,
private _configuration: Configuration,
private _diagnostics: IDiagnosticsDataSource,
private _languageManager: LanguageManager,
private _menuManager: MenuManager,
private _overlayManager: OverlayManager,
private _pluginManager: PluginManager,
private _snippetManager: SnippetManager,
private _themeManager: ThemeManager,
private _tokenColors: TokenColors,
private _workspace: Workspace,
) {
super()
this._neovimEditor = new NeovimEditor(
this._colors,
this._completionProviders,
this._configuration,
this._diagnostics,
this._languageManager,
this._menuManager,
this._overlayManager,
this._pluginManager,
this._snippetManager,
this._themeManager,
this._tokenColors,
this._workspace,
)
editorManager.registerEditor(this)
this.trackDisposable(
this._neovimEditor.onNeovimQuit.subscribe(() => {
const handle = windowManager.getSplitHandle(this)
handle.close()
editorManager.unregisterEditor(this)
this.dispose()
}),
)
this.trackDisposable(
App.registerQuitHook(async () => {
if (!this.isDisposed) {
this.quit()
}
}),
)
this._neovimEditor.bufferLayers.addBufferLayer("*", buf =>
wrapReactComponentWithLayer("oni.layer.scrollbar", ),
)
this._neovimEditor.bufferLayers.addBufferLayer("*", buf =>
wrapReactComponentWithLayer("oni.layer.definition", ),
)
this._neovimEditor.bufferLayers.addBufferLayer("*", buf =>
wrapReactComponentWithLayer("oni.layer.errors", ),
)
const imageExtensions = this._configuration.getValue("editor.imageLayerExtensions")
const bannedIndentExtensions = this._configuration.getValue(
"experimental.indentLines.bannedFiletypes",
)
this._neovimEditor.bufferLayers.addBufferLayer(
buf => imageExtensions.includes(path.extname(buf.filePath)),
buf => new ImageBufferLayer(buf),
)
if (this._configuration.getValue("experimental.indentLines.enabled")) {
this._neovimEditor.bufferLayers.addBufferLayer(
buf => {
const extension = path.extname(buf.filePath)
return extension && !bannedIndentExtensions.includes(extension)
},
buffer =>
new IndentLineBufferLayer({
buffer: buffer as IBuffer,
configuration: this._configuration,
}),
)
}
if (this._configuration.getValue("experimental.colorHighlight.enabled")) {
this._neovimEditor.bufferLayers.addBufferLayer(
buf =>
this._configuration
.getValue("experimental.colorHighlight.filetypes")
.includes(path.extname(buf.filePath)),
_buf => new ColorHighlightLayer(this._configuration),
)
}
this._neovimEditor.onShowWelcomeScreen.subscribe(this.openWelcomeScreen)
}
public dispose(): void {
super.dispose()
if (this._neovimEditor) {
this._neovimEditor.dispose()
this._neovimEditor = null
}
}
public enter(): void {
Log.info("[OniEditor::enter]")
editorManager.setActiveEditor(this)
this._neovimEditor.enter()
commandManager.registerCommand({
name: "Oni: Show Welcome",
detail: "Open the welcome screen",
command: "oni.welcome.open",
execute: this.openWelcomeScreen,
enabled: () => this._configuration.getValue("experimental.welcome.enabled"),
})
commandManager.registerCommand({
command: "editor.split.horizontal",
execute: () => this._split("horizontal"),
enabled: () => editorManager.activeEditor === this,
name: null,
detail: null,
})
commandManager.registerCommand({
command: "editor.split.vertical",
execute: () => this._split("vertical"),
enabled: () => editorManager.activeEditor === this,
name: null,
detail: null,
})
}
public leave(): void {
Log.info("[OniEditor::leave]")
this._neovimEditor.leave()
}
public openWelcomeScreen = async () => {
const oni = this._pluginManager.getApi()
const welcomeBuffer = await this._neovimEditor.createWelcomeBuffer()
const welcomeLayer = new WelcomeBufferLayer(oni as OniWithActiveSection)
welcomeBuffer.addLayer(welcomeLayer)
}
public async openFile(
file: string,
openOptions: Oni.FileOpenOptions = Oni.DefaultFileOpenOptions,
): Promise {
const openMode = openOptions.openMode
if (this._configuration.getValue("editor.split.mode") === "oni") {
if (
openMode === Oni.FileOpenMode.HorizontalSplit ||
openMode === Oni.FileOpenMode.VerticalSplit
) {
const splitDirection =
openMode === Oni.FileOpenMode.HorizontalSplit ? "horizontal" : "vertical"
const newEditor = await this._split(splitDirection)
return newEditor.openFile(file, { openMode: Oni.FileOpenMode.Edit })
}
}
return this._neovimEditor.openFile(file, openOptions)
}
public async newFile(filePath: string): Promise {
return this._neovimEditor.newFile(filePath)
}
public async clearSelection(): Promise {
return this._neovimEditor.clearSelection()
}
public async setSelection(range: types.Range): Promise {
return this._neovimEditor.setSelection(range)
}
public async setTextOptions(textOptions: Oni.EditorTextOptions): Promise {
return this._neovimEditor.setTextOptions(textOptions)
}
public async blockInput(
inputFunction: (input: Oni.InputCallbackFunction) => Promise,
): Promise {
return this._neovimEditor.blockInput(inputFunction)
}
public executeCommand(command: string): void {
this._neovimEditor.executeCommand(command)
}
public restoreSession(sessionDetails: ISession) {
return this._neovimEditor.restoreSession(sessionDetails)
}
public getCurrentSession() {
return this._neovimEditor.getCurrentSession()
}
public persistSession(sessionDetails: ISession) {
return this._neovimEditor.persistSession(sessionDetails)
}
public getBuffers(): Array {
return this._neovimEditor.getBuffers()
}
public async bufferDelete(bufferId: string = this.activeBuffer.id): Promise {
this._neovimEditor.bufferDelete(bufferId)
}
public async init(filesToOpen: string[]): Promise {
Log.info("[OniEditor::init] Called with filesToOpen: " + filesToOpen)
return this._neovimEditor.init(filesToOpen)
}
public async input(key: string): Promise {
return this._neovimEditor.input(key)
}
public render(): JSX.Element {
return this._neovimEditor.render()
}
public async quit(): Promise {
return this._neovimEditor.quit()
}
private async _split(direction: SplitDirection): Promise {
if (this._configuration.getValue("editor.split.mode") !== "oni") {
if (direction === "horizontal") {
await this._neovimEditor.neovim.command(":sp")
} else {
await this._neovimEditor.neovim.command(":vsp")
}
return this
}
const newEditor = new OniEditor(
this._colors,
this._completionProviders,
this._configuration,
this._diagnostics,
this._languageManager,
this._menuManager,
this._overlayManager,
this._pluginManager,
this._snippetManager,
this._themeManager,
this._tokenColors,
this._workspace,
)
windowManager.createSplit(direction, newEditor, this)
await newEditor.init([])
return newEditor
}
}
================================================
FILE: browser/src/Editor/OniEditor/containers/BufferScrollBarContainer.ts
================================================
import * as types from "vscode-languageserver-types"
import { connect } from "react-redux"
import { createSelector } from "reselect"
import { getColorFromSeverity } from "./../../../Services/Diagnostics"
import {
BufferScrollBar,
IBufferScrollBarProps,
IScrollBarMarker,
} from "./../../../UI/components/BufferScrollBar"
import * as Selectors from "./../../NeovimEditor/NeovimEditorSelectors"
import * as State from "./../../NeovimEditor/NeovimEditorStore"
export const getCurrentLine = createSelector([Selectors.getActiveWindow], activeWindow => {
return activeWindow.line
})
const NoScrollBar: IBufferScrollBarProps = {
windowId: null,
bufferSize: -1,
height: -1,
windowTopLine: -1,
windowBottomLine: -1,
markers: [],
visible: false,
}
export const shouldIncludeCursorMarker = (state: State.IState) => {
return state.configuration["editor.scrollBar.cursorTick.visible"]
}
export const getMarkers = createSelector(
[getCurrentLine, Selectors.getErrorsForActiveFile, shouldIncludeCursorMarker],
(activeLine, fileErrors, includeCursor) => {
const errorMarkers = fileErrors.map((e: types.Diagnostic) => ({
line: e.range.start.line || 0,
height: 1,
color: getColorFromSeverity(e.severity),
}))
if (!includeCursor) {
return errorMarkers
} else {
const cursorMarker: IScrollBarMarker = {
line: activeLine - 1,
height: 1,
color: "rgb(200, 200, 200)",
}
return [...errorMarkers, cursorMarker]
}
},
)
const mapStateToProps = (state: State.IState): IBufferScrollBarProps => {
const visible = state.configuration["editor.scrollBar.visible"]
const activeWindow = Selectors.getActiveWindow(state)
if (!activeWindow) {
return NoScrollBar
}
const dimensions = Selectors.getActiveWindowPixelDimensions(state)
const file = activeWindow.file
const buffer = Selectors.getActiveBuffer(state)
if (file === null || !buffer) {
return NoScrollBar
}
const bufferSize = buffer.totalLines
const markers = getMarkers(state)
return {
windowId: activeWindow.windowId,
windowTopLine: activeWindow.topBufferLine,
windowBottomLine: activeWindow.bottomBufferLine,
bufferSize,
markers,
height: dimensions.height,
visible,
}
}
export const BufferScrollBarContainer = connect(mapStateToProps)(BufferScrollBar)
================================================
FILE: browser/src/Editor/OniEditor/containers/DefinitionContainer.ts
================================================
import { connect } from "react-redux"
import * as types from "vscode-languageserver-types"
import { Definition, IDefinitionProps } from "./../../../UI/components/Definition"
import * as Selectors from "./../../NeovimEditor/NeovimEditorSelectors"
import * as State from "./../../NeovimEditor/NeovimEditorStore"
const emptyRange = types.Range.create(types.Position.create(-1, -1), types.Position.create(-1, -1))
const getActiveDefinition = (state: State.IState) => state.definition
const mapStateToProps = (state: State.IState): IDefinitionProps => {
const window = Selectors.getActiveWindow(state)
const noop = (): any => null
const activeDefinition = getActiveDefinition(state)
const range = activeDefinition ? activeDefinition.token.range : emptyRange
return {
color: state.colors["editor.foreground"],
range,
fontWidthInPixels: state.fontPixelWidth,
fontHeightInPixels: state.fontPixelHeight,
bufferToScreen: window ? window.bufferToScreen : noop,
screenToPixel: window ? window.screenToPixel : noop,
}
}
export const DefinitionContainer = connect(mapStateToProps)(Definition)
================================================
FILE: browser/src/Editor/OniEditor/containers/ErrorsContainer.ts
================================================
import { connect } from "react-redux"
import { Errors, IErrorsProps } from "./../../../UI/components/Error"
import * as Selectors from "./../../NeovimEditor/NeovimEditorSelectors"
import * as State from "./../../NeovimEditor/NeovimEditorStore"
const mapStateToProps = (state: State.IState): IErrorsProps => {
const window = Selectors.getActiveWindow(state)
const errors = Selectors.getErrorsForActiveFile(state)
const noop = (): any => null
return {
errors,
fontWidthInPixels: state.fontPixelWidth,
fontHeightInPixels: state.fontPixelHeight,
bufferToScreen: window ? window.bufferToScreen : noop,
screenToPixel: window ? window.screenToPixel : noop,
}
}
export const ErrorsContainer = connect(mapStateToProps)(Errors)
================================================
FILE: browser/src/Editor/OniEditor/index.ts
================================================
export * from "./OniEditor"
================================================
FILE: browser/src/Font.ts
================================================
export const FallbackFonts =
"Consolas,Monaco,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New, monospace"
export interface IFontMeasurement {
width: number
height: number
}
export function measureFont(
fontFamily: string,
fontSize: string,
fontWeight: string,
characterToTest = "H",
) {
const div = document.createElement("div")
div.style.position = "absolute"
div.style.left = "10px"
div.style.top = "10px"
div.style.backgroundColor = "red"
div.style.left = "-1000px"
div.style.top = "-1000px"
div.textContent = characterToTest
div.style.fontFamily = `${fontFamily},${FallbackFonts}`
div.style.fontSize = fontSize
div.style.fontWeight = fontWeight
const isItalicAvailable = isStyleAvailable(fontFamily, "italic", fontSize)
const isBoldAvailable = isStyleAvailable(fontFamily, "bold", fontSize)
document.body.appendChild(div)
const rect = div.getBoundingClientRect()
const width = rect.width
const height = rect.height
document.body.removeChild(div)
return {
width,
height,
isItalicAvailable,
isBoldAvailable,
}
}
export function addDefaultUnitIfNeeded(fontSize: string) {
const roundFont = `${Math.round(parseFloat(fontSize))}px`
return roundFont
}
export function isStyleAvailable(fontName: string, style: string, fontSize = "12px") {
const text = "abcdefghijklmnopqrstuvwxyz0123456789"
let canvas = document.createElement("canvas")
const context = canvas.getContext("2d")
context.font = `${fontSize} ${fontName}`
const baselineSize = context.measureText(text).width
context.font = `${style} ${fontSize} ${fontName}`
const newSize = context.measureText(text).width
canvas = null
return newSize === baselineSize
}
================================================
FILE: browser/src/Grid.ts
================================================
export class Grid {
private _cells: any = {}
private _width: number = 0
private _height: number = 0
public get width(): number {
return this._width
}
public get height(): number {
return this._height
}
public getCell(x: number, y: number): null | T {
const row = this._cells[y]
if (!row) {
return null
}
const col = row[x]
if (typeof col === "undefined") {
return null
}
return col
}
public setCell(x: number, y: number, val: T | null) {
let row = this._cells[y]
row = row || {}
row[x] = val
this._cells[y] = row
if (x >= this._width) {
this._width = x + 1
}
if (y >= this._height) {
this._height = y + 1
}
}
public clear(): void {
this._cells = {}
this._width = 0
this._height = 0
}
public shiftRows(rowsToShift: number): void {
// var val = typeof defaultVal === "undefined" ? null : defaultVal
let dir: any
let start: any
if (rowsToShift >= 0) {
dir = 1
start = 0
} else {
dir = -1
start = this._height - 1
}
let current = start
while (current >= 0 && current < this._height) {
const srcRow = current + rowsToShift
for (let x = 0; x < this._width; x++) {
const oldCell = this.getCell(x, srcRow)
this.setCell(x, current, oldCell as any)
}
current += dir
}
}
public setRegionFromGrid(grid: Grid, xPosition: number, yPosition: number): void {
for (let x = 0; x < grid.width; x++) {
for (let y = 0; y < grid.height; y++) {
const sourceCell = grid.getCell(x, y)
this.setCell(xPosition + x, yPosition + y, sourceCell)
}
}
}
public setRegion(
startX: number,
startY: number,
width: number,
height: number,
val?: T | null,
): void {
const valToSet = typeof val === "undefined" ? null : val
for (let x = startX; x < startX + width; x++) {
for (let y = startY; y < startY + height; y++) {
this.setCell(x, y, valToSet)
}
}
}
public cloneRegion(x: number, y: number, width: number, height: number): Grid {
const outputGrid = new Grid()
for (let cloneX = 0; cloneX < width; cloneX++) {
for (let cloneY = 0; cloneY < height; cloneY++) {
const sourceCell = this.getCell(cloneX + x, cloneY + y)
outputGrid.setCell(cloneX, cloneY, sourceCell)
}
}
return outputGrid
}
}
================================================
FILE: browser/src/Input/KeyBindings.ts
================================================
/**
* KeyBindings.ts
*
* Default, out-of-the-box keybindings for Oni
*/
import * as Oni from "oni-api"
import * as Platform from "./../Platform"
import { Configuration } from "./../Services/Configuration"
interface ISidebar {
sidebar: {
activeEntryId: string
isFocused: boolean
}
}
export const applyDefaultKeyBindings = (oni: Oni.Plugin.Api, config: Configuration): void => {
const { editors, input, menu } = oni
input.unbindAll()
const isVisualMode = () => editors.activeEditor.mode === "visual"
const isNormalMode = () => editors.activeEditor.mode === "normal"
const isNotInsertMode = () => editors.activeEditor.mode !== "insert"
const isInsertOrCommandMode = () =>
editors.activeEditor.mode === "insert" || editors.activeEditor.mode === "cmdline_normal"
const oniWithSidebar = oni as Oni.Plugin.Api & ISidebar
const isSidebarPaneOpen = (paneId: string) =>
oniWithSidebar.sidebar.activeEntryId === paneId &&
oniWithSidebar.sidebar.isFocused &&
!isInsertOrCommandMode() &&
!isMenuOpen()
const isExplorerActive = () => isSidebarPaneOpen("oni.sidebar.explorer")
const areSessionsActive = () => isSidebarPaneOpen("oni.sidebar.sessions")
const isVCSActive = () => isSidebarPaneOpen("oni.sidebar.vcs")
const isMenuOpen = () => menu.isMenuOpen()
if (Platform.isMac()) {
input.bind("", "oni.quit")
input.bind("", "quickOpen.show", () => isNormalMode() && !isMenuOpen())
input.bind("", "commands.show", isNormalMode)
input.bind("", "language.codeAction.expand")
input.bind("", "language.symbols.workspace", () => !menu.isMenuOpen())
input.bind("", "language.symbols.document")
input.bind("", "oni.editor.minimize")
input.bind("", "oni.editor.hide")
input.bind("", "buffer.toggle")
input.bind("", "search.searchAllFiles")
input.bind("", "explorer.toggle")
input.bind("", "sidebar.decreaseWidth")
input.bind("", "sidebar.increaseWidth")
input.bind("", "oni.config.openConfigJs")
if (config.getValue("editor.clipboard.enabled")) {
input.bind("", "editor.clipboard.yank", isVisualMode)
input.bind("", "editor.clipboard.paste", isInsertOrCommandMode)
}
// Browser
input.bind("", "browser.goBack")
input.bind("", "browser.goForward")
input.bind("", "browser.reload")
} else {
input.bind("", "oni.quit")
input.bind("", "sidebar.decreaseWidth")
input.bind("", "sidebar.increaseWidth")
input.bind("", "quickOpen.show", () => isNormalMode() && !isMenuOpen())
input.bind("", "commands.show", isNormalMode)
input.bind("", "language.codeAction.expand")
input.bind("", "language.symbols.workspace", () => !menu.isMenuOpen())
input.bind("", "language.symbols.document")
input.bind("", "buffer.toggle")
input.bind("", "search.searchAllFiles")
input.bind("", "explorer.toggle")
input.bind("", "oni.config.openConfigJs")
if (config.getValue("editor.clipboard.enabled")) {
input.bind("", "editor.clipboard.yank", isVisualMode)
input.bind("", "editor.clipboard.paste", isInsertOrCommandMode)
}
// Browser
input.bind("", "browser.goBack")
input.bind("", "browser.goForward")
input.bind("", "browser.reload")
}
input.bind("", "editor.rename", () => isNormalMode())
input.bind("", "language.format")
input.bind([""], "language.gotoDefinition", () => isNormalMode() && !menu.isMenuOpen())
input.bind(
["", ""],
"language.gotoDefinition.openVertical",
() => isNormalMode() && !menu.isMenuOpen(),
)
input.bind(
["", ""],
"language.gotoDefinition.openHorizontal",
() => isNormalMode() && !menu.isMenuOpen(),
)
input.bind("", "commands.show", isNormalMode)
input.bind("", "oni.process.cyclePrevious")
input.bind("", "oni.process.cycleNext")
// QuickOpen
input.bind("", "quickOpen.showBufferLines", isNormalMode)
input.bind([""], "quickOpen.openFileVertical")
input.bind([""], "quickOpen.openFileHorizontal")
input.bind("", "quickOpen.openFileNewTab")
input.bind([""], "quickOpen.openFileAlternative")
// Snippets
input.bind("", "snippet.nextPlaceholder")
input.bind("", "snippet.previousPlaceholder")
input.bind("", "snippet.cancel")
// Completion
input.bind([""], "contextMenu.select")
input.bind(["", ""], "contextMenu.next")
input.bind(["", ""], "contextMenu.previous")
input.bind(
[""],
"contextMenu.close",
isNotInsertMode /* In insert mode, the mode change will close the popupmenu anyway */,
)
// Menu
input.bind(["", ""], "menu.next")
input.bind(["", ""], "menu.previous")
input.bind(["", "", "
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at admin@onivim.io. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/
================================================
FILE: CONTRIBUTING.md
================================================
# Contribute
## Introduction
First, thank you for considering contributing to oni! It's people like you that make the open source community such a great community! 😊
We welcome any type of contribution, not only code. You can help with
* **QA**: file bug reports, the more details you can give the better (e.g. screenshots with the console open)
* **Marketing**: writing blog posts, howto's, printing stickers, ...
* **Community**: presenting the project at meetups, organizing a dedicated meetup for the local community, ...
* **Code**: take a look at the [open issues](issues). Even if you can't write code, commenting on them, showing that you care about a given issue matters. It helps us triage them.
* **Money**: we welcome financial contributions in full transparency on our [open collective](https://opencollective.com/oni).
## Your First Contribution
Working on your first Pull Request? You can learn how from this _free_ series, [How to Contribute to an Open Source Project on GitHub](https://egghead.io/series/how-to-contribute-to-an-open-source-project-on-github).
## Submitting code
Any code change should be submitted as a pull request. The description should explain what the code does and give steps to execute it. The pull request should also contain tests. We welcome and appreciate pull requests!
## Code review guidelines
* Keep PRs **small and scoped**. The bigger the pull request, the longer it will take to review and merge. Break down large pull requests into smaller incremental chunks - this will help catch issues earlier and be easier on both you and the maintainer.
* Following from the previous bullet point, **do not include unrelated changes in a PR**. It can be tempting to include extra styling changes or additional functionality, but these should be added as separate PRs.
* Think of each PR as **improving the quality of the codebase**. Codebases tend towards entropy and disorder unless actively managed - make sure that your change moves the quality needle in the right direction. This can take a variety of forms, including adding test coverage, reducing coupling, etc. _As we are a small team moving fast, we cannot afford to accumulate technical debt._
* If there is ambiguity in terms of design, architecture, or implementation, it's best to get **feedback before implementing**, to save both you and the maintainer time. If you're not sure, feel free to ask!
* For your first few PRs, **don't try and change the world** - pick some small issues and get familiar with the codebase. Then, work your way up to bigger issues - this will set you up for success.
PRs require approval from one other person, either a maintainer or a contributor. Keep in mind that when you approve code, you are accountable for it, too! Reviewers are the gatekeepers of quality and ensuring adherence to the guidelines above.
## Financial contributions
We also welcome financial contributions in full transparency on our [open collective](https://opencollective.com/oni).
Anyone can file an expense. If the expense makes sense for the development of the community, it will be "merged" in the ledger of our open collective by the core contributors and the person who filed the expense will be reimbursed.
### Bounties
The primary allotment of our [open collective](https://opencollective.com/oni) budget is dedicated to bounties. Developing features and fixing bugs is a lot of work, and those go directly to the developers doing this work via bounties. It is the role of the _maintainer_ to set bounties and clear completion criteria. Issues that have a bounty associated with them will have a `bounty` label as well as an amount, ie, `bounty-50` means a $50 bounty.
* Guidelines:
* The fix for the bug/feature/issue _MUST_ be complete and _MUST_ be covered by tests to be eligible for a bounty.
* Any associated documentation relevant to the bug/feature _MUST_ be updated.
* If you begin working on an issue with an associated bounty, open a PR with "WIP" and the bug number in the title, as well as reference the issue #. This is important to reduce duplicate work.
#### Claiming a bounty
* Upon completion of an issue with an associated bounty, bounties are payable by [Submitting an Expense](https://opencollective.com/oni/expenses/new) on our [OpenCollective](https://opencollective.com/oni). Note that OpenCollective requires a PDF or Photo of an expense form for an expense claim to be accepted - more information, including an example expense form can be found [here](https://opencollective.com/faq#expense). Check out our [expenses](https://opencollective.com/oni/expenses#) page for an example.
* A collaborator will approve the expense once we have verified it meets the criteria outlined above (complete fix, covered by tests, associated documentation updated)
If you questions about the guidelines, please don't hesitate to contact the maintainer.
## Roles
There are various roles and responsibilities in managing an open-source project. Users that are active and have a positive impact on the project and community will be recognized and have the option of assuming additional responsibilities.
* **Maintainer** - A maintainer communicates goals and drives the vision for the project. The maintainer is responsible for breaking down hurdles and supporting contributors. In addition, the maintainer triages issues, produces releases, assigns bounties, and establishes completion criteria. Today, there is one maintainer, but that isn't a strict requirement.
* **Collaborator** - A collaborator is an established member of the project that is recognized for their impact and contributions. They can triage and close issues, approve PRs from other contributors / collaborators, and can approve expenses on our [open collective](https://opencollective.com/oni)
* **Contributor** - A contributor is a developer that has submitted a successful PR for the project.
### Becoming a collaborator
A collaborator is a contributor who has been recognized for the impact they've had on the project, over a sustained period of time. In general, this means the following:
* **Supporting the community** - helping others in issues and chat, supporting new developers, creating a positive and supportive environment.
* **Technical impact** - involvement in a core technical piece of the editor, or a broad impact on the ecosystem.
* **Positive and collaborative mindset** - creating good vibes, willingness to give and receive constructive feedback, being a team player.
## Questions
If you have any questions, create an [issue](issue) (protip: do a quick search first to see if someone else didn't ask the same question before!).
You can also reach us at hello@oni.opencollective.com.
## Credits
### Contributors
Thank you to all the people who have already contributed to oni!
### Backers
Thank you to all our backers! [[Become a backer](https://opencollective.com/oni#backer)]
### Sponsors
Thank you to all our sponsors! (please ask your company to also support this open source project by [becoming a sponsor](https://opencollective.com/oni#sponsor))
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2016
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
---
__NOTE:__ This repository is unmaintained - we are focusing on [Onivim 2](https://github.com/onivim/oni2) and [libvim](https://github.com/onivim/libvim).
---
