editorconfig

README

Editorconfig Core Go

A Editorconfig file parser and manipulator for Go.

Currently this package does some basic work but does not fully support EditorConfig specs, so using it in "real world" is not recommended.

Installing

We recommend the use of gopkg.in for this package:

go get -u gopkg.in/editorconfig/editorconfig-core-go.v1

Import by the same path. The package name you will use to access it is editorconfig.

import (
    "gopkg.in/editorconfig/editorconfig-core-go.v1"
)

Usage

Parse from file

editorConfig, err := editorconfig.ParseFile("path/to/.editorconfig")
if err != nil {
    log.Fatal(err)
}

Parse from slice of bytes

data := []byte("...")
editorConfig, err := editorconfig.ParseBytes(data)
if err != nil {
    log.Fatal(err)
}

Get definition to a given filename

This method builds a definition to a given filename. This definition is a merge of the properties with selectors that matched the given filename. The lasts sections of the file have preference over the priors.

def := editorConfig.GetDefinitionForFilename("my/file.go")

This definition have the following properties:

type Definition struct {
	Selector string

	Charset                string
	IndentStyle            string
	IndentSize             string
	TabWidth               int
	EndOfLine              string
	TrimTrailingWhitespace bool
	InsertFinalNewline     bool
	Raw                    map[string]string
}

Automatic search for .editorconfig files

If you want a definition of a file without having to manually parse the .editorconfig files, you can then use the static version of GetDefinitionForFilename:

def, err := editorconfig.GetDefinitionForFilename("foo/bar/baz/my-file.go")

In the example above, the package will automatically search for .editorconfig files on:

• foo/bar/baz/.editorconfig
• foo/baz/.editorconfig
• foo/.editorconfig

Until it reaches a file with root = true or the root of the filesystem.

Generating a .editorconfig file

You can easily convert a Editorconfig struct to a compatible INI file:

// serialize to slice of bytes
data, err := editorConfig.Serialize()
if err != nil {
    log.Fatal(err)
}

// save directly to file
err := editorConfig.Save("path/to/.editorconfig")
if err != nil {
    log.Fatal(err)
}

Contributing

To run the tests:

go test -v

Documentation

Overview

Package editorconfig can be used to parse and generate editorconfig files. For more information about editorconfig, see http://editorconfig.org/

Index

• Constants
• type Definition
  • func GetDefinitionForFilename(filename string) (*Definition, error)
  • func GetDefinitionForFilenameWithConfigname(filename string, configname string) (*Definition, error)
  • func (d *Definition) InsertToIniFile(iniFile *ini.File)
• type Editorconfig
  • func ParseBytes(data []byte) (*Editorconfig, error)
  • func ParseFile(f string) (*Editorconfig, error)
  • func (e *Editorconfig) GetDefinitionForFilename(name string) *Definition
  • func (e *Editorconfig) Save(filename string) error
  • func (e *Editorconfig) Serialize() ([]byte, error)

Constants

const (
	IndentStyleTab    = "tab"
	IndentStyleSpaces = "space"
)

IndentStyle possible values

const (
	EndOfLineLf   = "lf"
	EndOfLineCr   = "cr"
	EndOfLineCrLf = "crlf"
)

EndOfLine possible values

const (
	CharsetLatin1  = "latin1"
	CharsetUTF8    = "utf-8"
	CharsetUTF16BE = "utf-16be"
	CharsetUTF16LE = "utf-16le"
)

Charset possible values

const (
	ConfigNameDefault = ".editorconfig"
)

Types

type Definition

type Definition struct {
	Selector string `ini:"-" json:"-"`

	Charset                string `ini:"charset" json:"charset,omitempty"`
	IndentStyle            string `ini:"indent_style" json:"indent_style,omitempty"`
	IndentSize             string `ini:"indent_size" json:"indent_size,omitempty"`
	TabWidth               int    `ini:"tab_width" json:"tab_width,omitempty"`
	EndOfLine              string `ini:"end_of_line" json:"end_of_line,omitempty"`
	TrimTrailingWhitespace bool   `ini:"trim_trailing_whitespace" json:"trim_trailing_whitespace,omitempty"`
	InsertFinalNewline     bool   `ini:"insert_final_newline" json:"insert_final_newline,omitempty"`

	Raw map[string]string `ini:"-" json:"-"`
}

Definition represents a definition inside the .editorconfig file. E.g. a section of the file. The definition is composed of the selector ("*", "*.go", "*.{js.css}", etc), plus the properties of the selected files.

func GetDefinitionForFilename

func GetDefinitionForFilename(filename string) (*Definition, error)

GetDefinitionForFilename given a filename, searches for .editorconfig files, starting from the file folder, walking through the previous folders, until it reaches a folder with `root = true`, and returns the right editorconfig definition for the given file.

func GetDefinitionForFilenameWithConfigname

func GetDefinitionForFilenameWithConfigname(filename string, configname string) (*Definition, error)

func (*Definition) InsertToIniFile

func (d *Definition) InsertToIniFile(iniFile *ini.File)

type Editorconfig

type Editorconfig struct {
	Root        bool
	Definitions []*Definition
}

Editorconfig represents a .editorconfig file. It is composed by a "root" property, plus the definitions defined in the file.

func ParseBytes

func ParseBytes(data []byte) (*Editorconfig, error)

ParseBytes parses from a slice of bytes.

func ParseFile

func ParseFile(f string) (*Editorconfig, error)

ParseFile parses from a file.

func (*Editorconfig) GetDefinitionForFilename

func (e *Editorconfig) GetDefinitionForFilename(name string) *Definition

GetDefinitionForFilename returns a definition for the given filename. The result is a merge of the selectors that matched the file. The last section has preference over the priors.

func (*Editorconfig) Save

func (e *Editorconfig) Save(filename string) error

Save saves the Editorconfig to a compatible INI file.

func (*Editorconfig) Serialize

func (e *Editorconfig) Serialize() ([]byte, error)

Serialize converts the Editorconfig to a slice of bytes, containing the content of the file in the INI format.