hgl

README

HGL

HGL은 Hangulize 2에서 언어 별 전사 규칙을 표현하기 위한 형식이다. 이름은 hangulize의 자음 H, G, L에서 따왔다. HGL 파일의 미디어타입은 text/vnd.hgl이다.

문법

HGL 문서는 여러 섹션으로 구성된다. 섹션엔 이름이 있다. 가령 이름이 hangulize일 경우 hangulize:으로 표시한다:

hangulize:
    ...

섹션은 둘 중 한 형식으로 구성된다. 하나는 사전형이다. 사전형 섹션은 key = value[, value2, ...] 형식으로 키와 값의 연관 관계를 표현한다. 사전형 속에서 한 키는 단 한 번만 나타나야 하고 여러번 나타날 수 없다. 여기서 키들 사이의 순서는 중요하지 않다. 키는 하나의 문자열이고 값은 여러개의 문자열이다:

jaeum:
    "ㄱ" = "기역"
    "ㄴ" = "니은"

tossi:
    "은(는)" = "은", "는"
    "이(가)" = "이", "가"

다른 하나는 목록형이다. 목록형 섹션 역시 키와 값들의 연관을 표현하지만 그 관계는 작성한 순서대로 나열된다. 목록에서의 위치에 따라 의미가 다를 수 있어서 키는 중복돼도 괜찮다. key -> value[, value2, ...] 형식으로 표현한다:

romanize:
    "한" -> "han"
    "글" -> "gul", "geul"

#부터는 주석이다. 해석되지 않는다:

test:
    # 가장 단순한 테스트케이스
    "gloria" -> "글로리아"

Documentation

Overview

Package hgl implements a parser for the HGL format which is used for Hangulize.

The HGL format is a simple config language. A HGL config has sections. Each section contains string-strings pairs. A section can be one of a dictionary or a pair list:

# dictionary section
lang:
	id      = "ita"
	code    = "it", "ita", "ita"
	english = "Italian"
	korean  = "이탈리아어"
	script  = "roman"

# pair list section
rewrite:
	"^gli$"    -> "li"
	"^glia$"   -> "g.lia"
	"^glioma$" -> "g.lioma"
	"^gli{@}"  -> "li"
	"{@}gli"   -> "li"

Keys in a dictionary section must be unique, and the section won't keep their order. While a pair list section works in an inversed way. A pair list section just keeps described pairs in therir order.

The media type of HGL files: text/vnd.hgl

Index

• Constants
• type DictSection
  • func (s *DictSection) All(left string) []string
  • func (s *DictSection) Injective() (map[string]string, error)
  • func (s *DictSection) Map() map[string][]string
  • func (s *DictSection) One(left string) string
  • func (s *DictSection) Pairs() []Pair
• type HGL
  • func Parse(r io.Reader) (HGL, error)
• type ListSection
  • func (s *ListSection) Array() []Pair
  • func (s *ListSection) Pairs() []Pair
• type Pair
  • func (p Pair) Left() string
  • func (p Pair) Right() []string
  • func (p *Pair) String() string
• type Section

Constants

const (
	// Illegal represents any string not matched with legal tokens.
	Illegal token = iota

	// EOF represents the end-of-file.
	EOF

	// Space represents any of whitespace characters except "\n".
	Space

	// Comment represents a comment content excluding initial "#".
	Comment

	// Newline means only "\n". HGL is a line-sensitive format.
	Newline

	// String represents a text literal.
	String

	// Colon means only ":".
	Colon

	// Comma means only ",".
	Comma

	// Equal means only "=".
	Equal

	// Arrow means only "->".
	Arrow
)

const Version = "1.0.0"

Version is the version number of HGL package. The version follows Semantic Versioning 2.0.0.

Types

type DictSection

type DictSection struct {
	// contains filtered or unexported fields
}

DictSection has an unordered list of pairs. Each left of underlying pairs is unique.

func (*DictSection) All

func (s *DictSection) All(left string) []string

All returns the right values.

func (*DictSection) Injective

func (s *DictSection) Injective() (map[string]string, error)

Injective returns the underying 1-to-1 map of a dict section. If some right (values) has multiple values, it returns an error.

func (*DictSection) Map

func (s *DictSection) Map() map[string][]string

Map returns the underying map of a dict section.

func (*DictSection) One

func (s *DictSection) One(left string) string

One assumes the given left (key) has only one right (values). Then returns the only right value.

func (*DictSection) Pairs

func (s *DictSection) Pairs() []Pair

Pairs returns dict key-values as an array of pairs.

type HGL

type HGL map[string]Section

HGL is a decoding result of an HGL code.

func Parse

func Parse(r io.Reader) (HGL, error)

Parse parses an HGL formatted text.

type ListSection

type ListSection struct {
	// contains filtered or unexported fields
}

ListSection has an ordered list of pairs.

func (*ListSection) Array

func (s *ListSection) Array() []Pair

Array returns the underying pair array of a list section.

func (*ListSection) Pairs

func (s *ListSection) Pairs() []Pair

Pairs returns underlying pairs as an array.

type Pair

type Pair struct {
	// contains filtered or unexported fields
}

Pair is a left-right tuple:

aa -> "ㅏ", "ㅐ"
^^^^^^^^^^^^^^^^

func (Pair) Left

func (p Pair) Left() string

Left is a string. It is used for as keys in dict:

english = "Italian"
^^^^^^^

Or as left of pair:

aa -> "ㅏ", "ㅐ"
^^

func (Pair) Right

func (p Pair) Right() []string

Right is a string array. It is used for as values in dict:

 english = "Italian"
	          ^^^^^^^^^

Or as right of pair:

aa -> "ㅏ", "ㅐ"
      ^^^^^^^^^^

func (*Pair) String

func (p *Pair) String() string

type Section

type Section interface {
	Pairs() []Pair
	// contains filtered or unexported methods
}

Section contains pairs.