pikeman 0.0.1

data/lint_test.go

@@ -0,0 +1,317 @@
+// Copyright (c) 2013 The Go Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd.
+
+package lint
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var lintMatch = flag.String("lint.match", "", "restrict testdata matches to this pattern")
+
+func TestAll(t *testing.T) {
+	l := new(Linter)
+	rx, err := regexp.Compile(*lintMatch)
+	if err != nil {
+		t.Fatalf("Bad -lint.match value %q: %v", *lintMatch, err)
+	}
+
+	baseDir := "testdata"
+	fis, err := ioutil.ReadDir(baseDir)
+	if err != nil {
+		t.Fatalf("ioutil.ReadDir: %v", err)
+	}
+	if len(fis) == 0 {
+		t.Fatalf("no files in %v", baseDir)
+	}
+	for _, fi := range fis {
+		if !rx.MatchString(fi.Name()) {
+			continue
+		}
+		//t.Logf("Testing %s", fi.Name())
+		src, err := ioutil.ReadFile(path.Join(baseDir, fi.Name()))
+		if err != nil {
+			t.Fatalf("Failed reading %s: %v", fi.Name(), err)
+		}
+
+		ins := parseInstructions(t, fi.Name(), src)
+		if ins == nil {
+			t.Errorf("Test file %v does not have instructions", fi.Name())
+			continue
+		}
+
+		ps, err := l.Lint(fi.Name(), src)
+		if err != nil {
+			t.Errorf("Linting %s: %v", fi.Name(), err)
+			continue
+		}
+
+		for _, in := range ins {
+			ok := false
+			for i, p := range ps {
+				if p.Position.Line != in.Line {
+					continue
+				}
+				if in.Match.MatchString(p.Text) {
+					// check replacement if we are expecting one
+					if in.Replacement != "" {
+						// ignore any inline comments, since that would be recursive
+						r := p.ReplacementLine
+						if i := strings.Index(r, " //"); i >= 0 {
+							r = r[:i]
+						}
+						if r != in.Replacement {
+							t.Errorf("Lint failed at %s:%d; got replacement %q, want %q", fi.Name(), in.Line, r, in.Replacement)
+						}
+					}
+
+					// remove this problem from ps
+					copy(ps[i:], ps[i+1:])
+					ps = ps[:len(ps)-1]
+
+					//t.Logf("/%v/ matched at %s:%d", in.Match, fi.Name(), in.Line)
+					ok = true
+					break
+				}
+			}
+			if !ok {
+				t.Errorf("Lint failed at %s:%d; /%v/ did not match", fi.Name(), in.Line, in.Match)
+			}
+		}
+		for _, p := range ps {
+			t.Errorf("Unexpected problem at %s:%d: %v", fi.Name(), p.Position.Line, p.Text)
+		}
+	}
+}
+
+type instruction struct {
+	Line        int            // the line number this applies to
+	Match       *regexp.Regexp // what pattern to match
+	Replacement string         // what the suggested replacement line should be
+}
+
+// parseInstructions parses instructions from the comments in a Go source file.
+// It returns nil if none were parsed.
+func parseInstructions(t *testing.T, filename string, src []byte) []instruction {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, filename, src, parser.ParseComments)
+	if err != nil {
+		t.Fatalf("Test file %v does not parse: %v", filename, err)
+	}
+	var ins []instruction
+	for _, cg := range f.Comments {
+		ln := fset.Position(cg.Pos()).Line
+		raw := cg.Text()
+		for _, line := range strings.Split(raw, "\n") {
+			if line == "" || strings.HasPrefix(line, "#") {
+				continue
+			}
+			if line == "OK" && ins == nil {
+				// so our return value will be non-nil
+				ins = make([]instruction, 0)
+				continue
+			}
+			if strings.Contains(line, "MATCH") {
+				rx, err := extractPattern(line)
+				if err != nil {
+					t.Fatalf("At %v:%d: %v", filename, ln, err)
+				}
+				matchLine := ln
+				if i := strings.Index(line, "MATCH:"); i >= 0 {
+					// This is a match for a different line.
+					lns := strings.TrimPrefix(line[i:], "MATCH:")
+					lns = lns[:strings.Index(lns, " ")]
+					matchLine, err = strconv.Atoi(lns)
+					if err != nil {
+						t.Fatalf("Bad match line number %q at %v:%d: %v", lns, filename, ln, err)
+					}
+				}
+				var repl string
+				if r, ok := extractReplacement(line); ok {
+					repl = r
+				}
+				ins = append(ins, instruction{
+					Line:        matchLine,
+					Match:       rx,
+					Replacement: repl,
+				})
+			}
+		}
+	}
+	return ins
+}
+
+func extractPattern(line string) (*regexp.Regexp, error) {
+	a, b := strings.Index(line, "/"), strings.LastIndex(line, "/")
+	if a == -1 || a == b {
+		return nil, fmt.Errorf("malformed match instruction %q", line)
+	}
+	pat := line[a+1 : b]
+	rx, err := regexp.Compile(pat)
+	if err != nil {
+		return nil, fmt.Errorf("bad match pattern %q: %v", pat, err)
+	}
+	return rx, nil
+}
+
+func extractReplacement(line string) (string, bool) {
+	// Look for this:  / -> `
+	// (the end of a match and start of a backtick string),
+	// and then the closing backtick.
+	const start = "/ -> `"
+	a, b := strings.Index(line, start), strings.LastIndex(line, "`")
+	if a < 0 || a > b {
+		return "", false
+	}
+	return line[a+len(start) : b], true
+}
+
+func render(fset *token.FileSet, x interface{}) string {
+	var buf bytes.Buffer
+	if err := printer.Fprint(&buf, fset, x); err != nil {
+		panic(err)
+	}
+	return buf.String()
+}
+
+func TestLine(t *testing.T) {
+	tests := []struct {
+		src    string
+		offset int
+		want   string
+	}{
+		{"single line file", 5, "single line file"},
+		{"single line file with newline\n", 5, "single line file with newline\n"},
+		{"first\nsecond\nthird\n", 2, "first\n"},
+		{"first\nsecond\nthird\n", 9, "second\n"},
+		{"first\nsecond\nthird\n", 14, "third\n"},
+		{"first\nsecond\nthird with no newline", 16, "third with no newline"},
+		{"first byte\n", 0, "first byte\n"},
+	}
+	for _, test := range tests {
+		got := srcLine([]byte(test.src), token.Position{Offset: test.offset})
+		if got != test.want {
+			t.Errorf("srcLine(%q, offset=%d) = %q, want %q", test.src, test.offset, got, test.want)
+		}
+	}
+}
+
+func TestLintName(t *testing.T) {
+	tests := []struct {
+		name, want string
+	}{
+		{"foo_bar", "fooBar"},
+		{"foo_bar_baz", "fooBarBaz"},
+		{"Foo_bar", "FooBar"},
+		{"foo_WiFi", "fooWiFi"},
+		{"id", "id"},
+		{"Id", "ID"},
+		{"foo_id", "fooID"},
+		{"fooId", "fooID"},
+		{"fooUid", "fooUID"},
+		{"idFoo", "idFoo"},
+		{"uidFoo", "uidFoo"},
+		{"midIdDle", "midIDDle"},
+		{"APIProxy", "APIProxy"},
+		{"ApiProxy", "APIProxy"},
+		{"apiProxy", "apiProxy"},
+		{"_Leading", "_Leading"},
+		{"___Leading", "_Leading"},
+		{"trailing_", "trailing"},
+		{"trailing___", "trailing"},
+		{"a_b", "aB"},
+		{"a__b", "aB"},
+		{"a___b", "aB"},
+		{"Rpc1150", "RPC1150"},
+		{"case3_1", "case3_1"},
+		{"case3__1", "case3_1"},
+		{"IEEE802_16bit", "IEEE802_16bit"},
+		{"IEEE802_16Bit", "IEEE802_16Bit"},
+	}
+	for _, test := range tests {
+		got := lintName(test.name)
+		if got != test.want {
+			t.Errorf("lintName(%q) = %q, want %q", test.name, got, test.want)
+		}
+	}
+}
+
+func TestExportedType(t *testing.T) {
+	tests := []struct {
+		typString string
+		exp       bool
+	}{
+		{"int", true},
+		{"string", false}, // references the shadowed builtin "string"
+		{"T", true},
+		{"t", false},
+		{"*T", true},
+		{"*t", false},
+		{"map[int]complex128", true},
+	}
+	for _, test := range tests {
+		src := `package foo; type T int; type t int; type string struct{}`
+		fset := token.NewFileSet()
+		file, err := parser.ParseFile(fset, "foo.go", src, 0)
+		if err != nil {
+			t.Fatalf("Parsing %q: %v", src, err)
+		}
+		// use the package name as package path
+		config := &types.Config{}
+		pkg, err := config.Check(file.Name.Name, fset, []*ast.File{file}, nil)
+		if err != nil {
+			t.Fatalf("Type checking %q: %v", src, err)
+		}
+		tv, err := types.Eval(fset, pkg, token.NoPos, test.typString)
+		if err != nil {
+			t.Errorf("types.Eval(%q): %v", test.typString, err)
+			continue
+		}
+		if got := exportedType(tv.Type); got != test.exp {
+			t.Errorf("exportedType(%v) = %t, want %t", tv.Type, got, test.exp)
+		}
+	}
+}
+
+func TestIsGenerated(t *testing.T) {
+	tests := []struct {
+		source    string
+		generated bool
+	}{
+		{"// Code Generated by some tool. DO NOT EDIT.", false},
+		{"// Code generated by some tool. DO NOT EDIT.", true},
+		{"// Code generated by some tool. DO NOT EDIT", false},
+		{"// Code generated  DO NOT EDIT.", true},
+		{"// Code generated DO NOT EDIT.", false},
+		{"\t\t// Code generated by some tool. DO NOT EDIT.\npackage foo\n", false},
+		{"// Code generated by some tool. DO NOT EDIT.\npackage foo\n", true},
+		{"package foo\n// Code generated by some tool. DO NOT EDIT.\ntype foo int\n", true},
+		{"package foo\n // Code generated by some tool. DO NOT EDIT.\ntype foo int\n", false},
+		{"package foo\n// Code generated by some tool. DO NOT EDIT. \ntype foo int\n", false},
+		{"package foo\ntype foo int\n// Code generated by some tool. DO NOT EDIT.\n", true},
+		{"package foo\ntype foo int\n// Code generated by some tool. DO NOT EDIT.", true},
+	}
+
+	for i, test := range tests {
+		got := isGenerated([]byte(test.source))
+		if got != test.generated {
+			t.Errorf("test %d, isGenerated() = %v, want %v", i, got, test.generated)
+		}
+	}
+}

data/misc/emacs/golint.el

@@ -0,0 +1,54 @@
+;;; golint.el --- lint for the Go source code
+
+;; Copyright 2013 The Go Authors. All rights reserved.
+
+;; License: BSD-3-clause
+;; URL: https://github.com/golang/lint
+
+;;; Commentary:
+
+;; To install golint, add the following lines to your .emacs file:
+;;   (add-to-list 'load-path "PATH CONTAINING golint.el" t)
+;;   (require 'golint)
+;;
+;; After this, type M-x golint on Go source code.
+;;
+;; Usage:
+;;   C-x `
+;;     Jump directly to the line in your code which caused the first message.
+;;
+;;   For more usage, see Compilation-Mode:
+;;     http://www.gnu.org/software/emacs/manual/html_node/emacs/Compilation-Mode.html
+
+;;; Code:
+
+(require 'compile)
+
+(defun go-lint-buffer-name (mode)
+  "*Golint*")
+
+(defun golint-process-setup ()
+  "Setup compilation variables and buffer for `golint'."
+  (run-hooks 'golint-setup-hook))
+
+(define-compilation-mode golint-mode "golint"
+  "Golint is a linter for Go source code."
+  (set (make-local-variable 'compilation-scroll-output) nil)
+  (set (make-local-variable 'compilation-disable-input) t)
+  (set (make-local-variable 'compilation-process-setup-function)
+       'golint-process-setup))
+
+;;;###autoload
+(defun golint ()
+  "Run golint on the current file and populate the fix list.
+Pressing \"C-x `\" jumps directly to the line in your code which
+caused the first message."
+  (interactive)
+  (compilation-start
+   (mapconcat #'shell-quote-argument
+              (list "golint" (expand-file-name buffer-file-name)) " ")
+   'golint-mode))
+
+(provide 'golint)
+
+;;; golint.el ends here

data/misc/vim/ftplugin/go/lint.vim

@@ -0,0 +1,31 @@
+" Copyright 2013 The Go Authors. All rights reserved.
+" Use of this source code is governed by a BSD-style
+" license that can be found in the LICENSE file.
+"
+" lint.vim: Vim command to lint Go files with golint.
+"
+"   https://github.com/golang/lint
+"
+" This filetype plugin add a new commands for go buffers:
+"
+"   :Lint
+"
+"       Run golint for the current Go file.
+"
+if exists("b:did_ftplugin_go_lint")
+    finish
+endif
+
+if !executable("golint")
+    finish
+endif
+
+command! -buffer Lint call s:GoLint()
+
+function! s:GoLint() abort
+    cexpr system('golint ' . shellescape(expand('%')))
+endfunction
+
+let b:did_ftplugin_go_lint = 1
+
+" vim:ts=4:sw=4:et

data/pikeman.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pikeman/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pikeman"
+  spec.version       = Pikeman::VERSION
+  spec.authors       = ["Maxime Bedard"]
+  spec.email         = ["maxime.bedard@shopify.com"]
+
+  spec.summary       = %q{Very opinionated version of google/golint}
+  spec.description   = %q{Very opinionated version of google/golint}
+  spec.homepage      = "https://github.com/maximebedard/pikeman"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.executables   = ["pikeman"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "cli-kit"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry-byebug"
+end

data/testdata/4.go

@@ -0,0 +1,38 @@
+// Test that exported names have correct comments.
+
+// Package pkg does something.
+package pkg
+
+import "time"
+
+type T int // MATCH /exported type T.*should.*comment.*or.*unexport/
+
+func (T) F() {} // MATCH /exported method T\.F.*should.*comment.*or.*unexport/
+
+// this is a nice type.
+// MATCH /comment.*exported type U.*should.*form.*"U ..."/
+type U string
+
+// this is a neat function.
+// MATCH /comment.*exported method U\.G.*should.*form.*"G ..."/
+func (U) G() {}
+
+// A V is a string.
+type V string
+
+// V.H has a pointer receiver
+
+func (*V) H() {} // MATCH /exported method V\.H.*should.*comment.*or.*unexport/
+
+var W = "foo" // MATCH /exported var W.*should.*comment.*or.*unexport/
+
+const X = "bar" // MATCH /exported const X.*should.*comment.*or.*unexport/
+
+var Y, Z int // MATCH /exported var Z.*own declaration/
+
+// Location should be okay, since the other var name is an underscore.
+var Location, _ = time.LoadLocation("Europe/Istanbul") // not Constantinople
+
+// this is improperly documented
+// MATCH /comment.*const.*Thing.*form.*"Thing ..."/
+const Thing = "wonderful"