Go Challenge #1

package drum

import (
    "bytes"
    "encoding/binary"
    "encoding/hex"
    "fmt"
    "os"
    "strconv"
    "strings"
)

// DecodeFile decodes the drum machine file found at the provided path
// and returns a pointer to a parsed pattern which is the entry point to the
// rest of the data.
func DecodeFile(path string) (*Pattern, error) {
    // Open the file
    f, ferr := os.Open(path)
    defer f.Close()
    if ferr != nil {
        return decodeError("Error reading file: "+path, ferr)
    }

    // skip start of file
    f.Seek(13, 0)

    // check how much of the file we should read to avoid invalid file (see sample 5)
    h, e := readNBytesAsHex(1, f)
    if e != nil {
        return decodeError("Error reading file size: ", e)
    }
    bytesToRead, _ := strconv.ParseInt(h, 16, 32)

    // Read the version
    r, e := readNBytes(1, f)
    if e != nil {
        return decodeError("Error reading version: ", e)
    }
    bytesToRead--
    version := make([]string, 0)
    for r[0] != 0 {
        version = append(version, string(r))
        r, e = readNBytes(1, f)
        if e != nil {
            return decodeError("Error reading version: ", e)
        }
        bytesToRead--
    }

    // Keep track of position to correctly update bytesToRead after
    // we'll read the tempo from the .splice
    lastPosition, _ := f.Seek(0, 1)

    // Go to the tempo location in .splice file
    f.Seek(46, 0)
    var tempo float32
    tempoBytes, e := readNBytes(4, f)
    if e != nil {
        return decodeError("Error reading tempo: ", e)
    }

    buf := bytes.NewReader(tempoBytes)
    binary.Read(buf, binary.LittleEndian, &tempo)

    // Compute how much bytes we skipped between last known position
    // and byte ending the tempo data
    currentPosition, _ := f.Seek(0, 1)
    bytesToRead -= 4 + (currentPosition - lastPosition + 2)

    // Now that we've got the version & tempo, init our Pattern
    pattern := NewPattern(strings.Join(version, ""), tempo)

    // iterates on tracks until we reach our limit to read
    for bytesToRead > 0 {
        // Retrieve the track id
        b, e := readNBytesAsHex(1, f)
        if e != nil {
            return decodeError("Error reading track id: ", e)
        }

        id, _ := strconv.ParseInt(b, 16, 32)
        bytesToRead -= 3
        f.Seek(3, 1) // skip 3 bytes

        // Read the track name and its length
        s, e := readNBytes(1, f)
        if e != nil {
            return decodeError("Error reading track name (length): ", e)
        }
        trackNameLength := readIntFromHex(s)

        name, e := readNBytes(trackNameLength, f)
        if e != nil {
            return decodeError("Error reading track name: ", e)
        }

        bytesToRead -= int64(trackNameLength + 1)

        // Read the sequence
        sequence, e := readNBytes(16, f)
        if e != nil {
            return decodeError("Error reading track sequence: ", e)
        }
        bytesToRead -= 16

        // add the current track to our Pattern
        track := NewTrack(id, string(name), sequence)
        pattern.AddTrack(track)
    }

    // ensure Close
    f.Close()

    return pattern, nil
}

// Struct representing a Track inside a Splice
type Track struct {
    number   int64
    name     string
    sequence string
}

// Pattern is the high level representation of the
// drum pattern contained in a .splice file.
type Pattern struct {
    version string
    tempo   float32
    tracks  []Track
}

// decodeError returns a nil Pattern and a custom error
func decodeError(label string, e error) (*Pattern, error) {
    return nil, fmt.Errorf(label+"\n\t%#v", e)
}

// readIntFromHex reads an integer from hexadecimal representation of bytes
func readIntFromHex(data []byte) int {
    x := hex.EncodeToString(data)
    i, _ := strconv.Atoi(x)
    return i
}

// readNBytes reads `n` bytes from the file `f`
func readNBytes(n int, f *os.File) ([]byte, error) {
    bytesToRead := make([]byte, n)
    _, e := f.Read(bytesToRead)
    return bytesToRead, e
}

// readNBytesAsHex reads `n` byte from the file `f` as hexadecimal
func readNBytesAsHex(n int, f *os.File) (string, error) {
    bytes, e := readNBytes(n, f)
    if e != nil {
        return "", e
    } else {
        return hex.EncodeToString(bytes), nil
    }
}

package drum

import (
    "encoding/hex"
    "fmt"
    "regexp"
    "strings"
)

// NewTrack creates a new track instance from its id, name and sequence
func NewTrack(id int64, name string, seq []byte) *Track {
    sequence := strings.Replace(strings.Replace(hex.EncodeToString(seq), "01", "x", 100), "00", "-", 100)
    return &Track{id, name, string(sequence)}
}

// String formats a Track as a String where steps are grouped by 4 and separated with a pipe character
func (t *Track) String() string {
    reg, _ := regexp.Compile("(....)")
    return fmt.Sprintf("(%d) %s\t%s", t.number, t.name, reg.ReplaceAllString(t.sequence, "|$1")+"|")
}

// NewPattern creates a new Pattern instance from its Splice version and tempo
func NewPattern(version string, tempo float32) *Pattern {
    return &Pattern{version, tempo, make([]Track, 0)}
}

// AddTrack adds a Track to a Pattern
func (p *Pattern) AddTrack(track *Track) {
    p.tracks = append(p.tracks, *track)
}

// String formats a Pattern as a String using the challenge specified format
func (p *Pattern) String() string {
    str := fmt.Sprintf("Saved with HW Version: %s\nTempo: %g\n", p.version, p.tempo)
    for _, track := range p.tracks {
        str += track.String() + "\n"
    }
    return str
}