quorum/vendor/gopkg.in/sourcemap.v1/consumer.go

package sourcemap // import "gopkg.in/sourcemap.v1"

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/url"
	"path"
	"sort"
	"strconv"
	"strings"

	"gopkg.in/sourcemap.v1/base64vlq"
)

type Consumer struct {
	sourceRootURL *url.URL
	smap          *sourceMap
	mappings      []mapping
}

func Parse(mapURL string, b []byte) (*Consumer, error) {
	smap := new(sourceMap)
	err := json.Unmarshal(b, smap)
	if err != nil {
		return nil, err
	}

	if smap.Version != 3 {
		return nil, errors.New("sourcemap: only 3rd version is supported")
	}

	var sourceRootURL *url.URL
	if smap.SourceRoot != "" {
		u, err := url.Parse(smap.SourceRoot)
		if err != nil {
			return nil, err
		}
		if u.IsAbs() {
			sourceRootURL = u
		}
	} else if mapURL != "" {
		u, err := url.Parse(mapURL)
		if err != nil {
			return nil, err
		}
		if u.IsAbs() {
			u.Path = path.Dir(u.Path)
			sourceRootURL = u
		}
	}

	mappings, err := parseMappings(smap.Mappings)
	if err != nil {
		return nil, err
	}
	// Free memory.
	smap.Mappings = ""

	return &Consumer{
		sourceRootURL: sourceRootURL,
		smap:          smap,
		mappings:      mappings,
	}, nil
}

func (c *Consumer) File() string {
	return c.smap.File
}

func (c *Consumer) Source(genLine, genCol int) (source, name string, line, col int, ok bool) {
	i := sort.Search(len(c.mappings), func(i int) bool {
		m := &c.mappings[i]
		if m.genLine == genLine {
			return m.genCol >= genCol
		}
		return m.genLine >= genLine
	})

	// Mapping not found.
	if i == len(c.mappings) {
		return
	}

	match := &c.mappings[i]

	// Fuzzy match.
	if match.genCol > genCol && i > 0 {
		match = &c.mappings[i-1]
	}

	if match.sourcesInd >= 0 {
		source = c.absSource(c.smap.Sources[match.sourcesInd])
	}
	if match.namesInd >= 0 {
		iv := c.smap.Names[match.namesInd]
		switch v := iv.(type) {
		case string:
			name = v
		case float64:
			name = strconv.FormatFloat(v, 'f', -1, 64)
		default:
			name = fmt.Sprint(iv)
		}
	}
	line = match.sourceLine
	col = match.sourceCol
	ok = true
	return
}

func (c *Consumer) absSource(source string) string {
	if path.IsAbs(source) {
		return source
	}

	if u, err := url.Parse(source); err == nil && u.IsAbs() {
		return source
	}

	if c.sourceRootURL != nil {
		u := *c.sourceRootURL
		u.Path = path.Join(c.sourceRootURL.Path, source)
		return u.String()
	}

	if c.smap.SourceRoot != "" {
		return path.Join(c.smap.SourceRoot, source)
	}

	return source
}

func (c *Consumer) SourceName(genLine, genCol int, genName string) (name string, ok bool) {
	ind := sort.Search(len(c.mappings), func(i int) bool {
		m := c.mappings[i]
		if m.genLine == genLine {
			return m.genCol >= genCol
		}
		return m.genLine >= genLine
	})

	// Mapping not found.
	if ind == len(c.mappings) {
		return "", false
	}

	for i := ind; i >= 0; i-- {
		m := c.mappings[i]
		if m.namesInd == -1 {
			continue
		}
		if c.smap.Names[m.namesInd] == "" {

		}
	}

	return
}

type fn func() (fn, error)

type sourceMap struct {
	Version    int           `json:"version"`
	File       string        `json:"file"`
	SourceRoot string        `json:"sourceRoot"`
	Sources    []string      `json:"sources"`
	Names      []interface{} `json:"names"`
	Mappings   string        `json:"mappings"`
}

type mapping struct {
	genLine    int
	genCol     int
	sourcesInd int
	sourceLine int
	sourceCol  int
	namesInd   int
}

type mappings struct {
	rd  *strings.Reader
	dec *base64vlq.Decoder

	genLine    int
	genCol     int
	sourcesInd int
	sourceLine int
	sourceCol  int
	namesInd   int

	value  mapping
	values []mapping
}

func parseMappings(s string) ([]mapping, error) {
	rd := strings.NewReader(s)
	m := &mappings{
		rd:  rd,
		dec: base64vlq.NewDecoder(rd),

		genLine:    1,
		sourceLine: 1,
	}
	m.zeroValue()
	err := m.parse()
	if err != nil {
		return nil, err
	}
	return m.values, nil
}

func (m *mappings) parse() error {
	next := m.parseGenCol
	for {
		c, err := m.rd.ReadByte()
		if err == io.EOF {
			m.pushValue()
			return nil
		} else if err != nil {
			return err
		}

		switch c {
		case ',':
			m.pushValue()
			next = m.parseGenCol
		case ';':
			m.pushValue()

			m.genLine++
			m.genCol = 0

			next = m.parseGenCol
		default:
			m.rd.UnreadByte()

			var err error
			next, err = next()
			if err != nil {
				return err
			}
		}
	}
}

func (m *mappings) parseGenCol() (fn, error) {
	n, err := m.dec.Decode()
	if err != nil {
		return nil, err
	}
	m.genCol += n
	m.value.genCol = m.genCol
	return m.parseSourcesInd, nil
}

func (m *mappings) parseSourcesInd() (fn, error) {
	n, err := m.dec.Decode()
	if err != nil {
		return nil, err
	}
	m.sourcesInd += n
	m.value.sourcesInd = m.sourcesInd
	return m.parseSourceLine, nil
}

func (m *mappings) parseSourceLine() (fn, error) {
	n, err := m.dec.Decode()
	if err != nil {
		return nil, err
	}
	m.sourceLine += n
	m.value.sourceLine = m.sourceLine
	return m.parseSourceCol, nil
}

func (m *mappings) parseSourceCol() (fn, error) {
	n, err := m.dec.Decode()
	if err != nil {
		return nil, err
	}
	m.sourceCol += n
	m.value.sourceCol = m.sourceCol
	return m.parseNamesInd, nil
}

func (m *mappings) parseNamesInd() (fn, error) {
	n, err := m.dec.Decode()
	if err != nil {
		return nil, err
	}
	m.namesInd += n
	m.value.namesInd = m.namesInd
	return m.parseGenCol, nil
}

func (m *mappings) zeroValue() {
	m.value = mapping{
		genLine:    m.genLine,
		genCol:     0,
		sourcesInd: -1,
		sourceLine: 0,
		sourceCol:  0,
		namesInd:   -1,
	}
}

func (m *mappings) pushValue() {
	m.values = append(m.values, m.value)
	m.zeroValue()
}