Initial commit

Author: Dean Karn

.gitignore

@@ -0,0 +1,15 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Go template
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+

.travis.yml

@@ -0,0 +1,29 @@
+language: go
+go:
+  - 1.12.4
+  - tip
+matrix:
+  allow_failures:
+    - go: tip
+
+notifications:
+  email:
+    recipients: [email protected]
+    on_success: change
+    on_failure: always
+
+before_install:
+  - go get -u github.com/go-playground/overalls
+  - go get -u github.com/mattn/goveralls
+  - go get -u golang.org/x/tools/cmd/cover
+
+before_script:
+  - go get -t ./...
+
+script:
+  - make test
+
+after_success: |
+  [ $TRAVIS_GO_VERSION = 1.11.4 ] &&
+  overalls -project="github.com/go-playground/pkg" -covermode=count -ignore=.git,_examples,testdata -debug &&
+  goveralls -coverprofile=overalls.coverprofile -service travis-ci -repotoken $COVERALLS_TOKEN

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Dean Karn
+
+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.

Makefile

@@ -0,0 +1,18 @@
+GOCMD=GO111MODULE=on go
+
+linters-install:
+	@golangci-lint --version >/dev/null 2>&1 || { \
+		echo "installing linting tools..."; \
+		$(GOCMD) get github.com/golangci/golangci-lint/cmd/golangci-lint; \
+	}
+
+lint: linters-install
+	golangci-lint run
+
+test:
+	$(GOCMD) test -cover -race ./...
+
+bench:
+	$(GOCMD) test -bench=. -benchmem ./...
+
+.PHONY: linters-install lint test bench

README.md

@@ -0,0 +1,19 @@
+# pkg
+======
+![Project status](https://img.shields.io/badge/version-1.0.0-green.svg)
+![License](https://img.shields.io/dub/l/vibe-d.svg)
+
+pkg extends the core go packages with missing or additional functionality built in. All packages correspond to the std go package name with an additional suffix of `util` to avoid naming conflicts.
+
+Motivation
+----------
+This is a place to put comman reusable code that is not quite a library but extends upon the core library or it's failings.
+
+How to Contribute
+------
+
+Make a pull request... can't guarantee it will be added, going to strictly vet what goes in.
+
+License
+------
+Distributed under MIT License, please see license file within the code for more details.

go.mod

@@ -0,0 +1,3 @@
+module github.com/go-playground/pkg
+
+go 1.11

io/limit_reader.go

@@ -0,0 +1,45 @@
+package ioutil
+
+import (
+	"errors"
+	"io"
+)
+
+var (
+	// LimitedReaderEOF is an error returned by LimitedReader to give feedback to the fact that we did not hit an
+	// EOF of the Reader but hit the limit imposed by the LimitedReader.
+	LimitedReaderEOF = errors.New("LimitedReader EOF: limit reached")
+)
+
+// LimitReader returns a Reader that reads from r
+// but stops with LimitedReaderEOF after n bytes.
+// The underlying implementation is a *LimitedReader.
+func LimitReader(r io.Reader, n int64) io.Reader {
+	return &LimitedReader{R: r, N: n}
+}
+
+// A LimitedReader reads from R but limits the amount of
+// data returned to just N bytes. Each call to Read
+// updates N to reflect the new amount remaining.
+// Read returns LimitedReaderEOF when N <= 0 or when the underlying R returns EOF.
+// Unlike the std io.LimitedReader this provides feedback
+// that the limit was reached through the returned error.
+type LimitedReader struct {
+	R io.Reader
+	N int64 // bytes alloted
+}
+
+func (l *LimitedReader) Read(p []byte) (n int, err error) {
+	if int64(len(p)) > l.N {
+		p = p[0 : l.N+1]
+	}
+	n, err = l.R.Read(p)
+	if err == io.EOF {
+		return
+	}
+	l.N -= int64(n)
+	if l.N < 0 {
+		return len(p), LimitedReaderEOF
+	}
+	return
+}

io/limit_reader_test.go

@@ -0,0 +1,76 @@
+package ioutil
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestLimitedReader_Read(t *testing.T) {
+	eofLimited := LimitReader(strings.NewReader("all"), 5).(*LimitedReader)
+
+	type args struct {
+		p []byte
+	}
+	tests := []struct {
+		name    string
+		l       *LimitedReader
+		args    args
+		wantN   int
+		wantErr bool
+	}{
+		{
+			name:    "not-limited",
+			l:       LimitReader(strings.NewReader("all"), 3).(*LimitedReader),
+			args:    args{p: make([]byte, 4)},
+			wantN:   3,
+			wantErr: false,
+		},
+		{
+			name:    "not-limited-exact",
+			l:       LimitReader(strings.NewReader("all"), 3).(*LimitedReader),
+			args:    args{p: make([]byte, 3)},
+			wantN:   3,
+			wantErr: false,
+		},
+		{
+			name:    "not-limited-EOF-OK",
+			l:       eofLimited,
+			args:    args{p: make([]byte, 4)},
+			wantN:   3,
+			wantErr: false,
+		},
+		{
+			name:    "not-limited-EOF",
+			l:       eofLimited,
+			args:    args{p: make([]byte, 4)},
+			wantN:   0,
+			wantErr: true,
+		},
+		{
+			name:    "limited",
+			l:       LimitReader(strings.NewReader("limited"), 1).(*LimitedReader),
+			args:    args{p: make([]byte, 3)},
+			wantN:   2, // need to read one past to know we're past
+			wantErr: true,
+		},
+		{
+			name:    "limited-buff-under-N",
+			l:       LimitReader(strings.NewReader("limited"), 0).(*LimitedReader),
+			args:    args{p: make([]byte, 1)},
+			wantN:   1,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotN, err := tt.l.Read(tt.args.p)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("LimitedReader.Read() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if gotN != tt.wantN {
+				t.Errorf("LimitedReader.Read() = %v, want %v", gotN, tt.wantN)
+			}
+		})
+	}
+}