M bitbucket-pipelines.yml +1 -1
@@ 23,7 23,7 @@ pipelines:
- mkdir -pv "${PACKAGE_PATH}"
- tar -cO . | tar -xv -C "${PACKAGE_PATH}"
- cd "${PACKAGE_PATH}"
- - curl -L -O https://bitbucket.org/seanerussell/orgchart/downloads/dep
+ - curl -L -O https://bitbucket.org/seanerussell/legume/downloads/dep
- chmod u+x ./dep
- ./dep ensure
- GOOS=linux go build -ldflags "-X main.Version=${BITBUCKET_BOOKMARK}" -v -o orgchart_${BITBUCKET_BOOKMARK}_linux ./cmd/orgchart
M cmd/orgchart/main.go +1 -1
@@ 19,8 19,8 @@ import (
"strconv"
"strings"
+ oc "bitbucket.org/seanerussell/orgchart"
"github.com/droundy/goopt"
- oc "bitbucket.org/seanerussell/orgchart"
)
/**************************************************************************
R cmd/orgchart/main_test.go => +0 -255
@@ 1,255 0,0 @@
-package main
-
-import (
- "bytes"
- "sort"
- "testing"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestAddRecursively(t *testing.T) {
- _, a := makeData()
- r := make([]Rank, 0)
- r = addRecursively(a, r, 0)
-
- assert.Equal(t, 1, len(r[0]), "wrong number of people in rank 0")
- assert.Equal(t, 2, len(r[1]), "wrong number of people in rank 1")
- assert.Equal(t, 3, len(r[2]), "wrong number of people in rank 2")
- assert.Equal(t, 1, len(r[3]), "wrong number of people in rank 3")
-}
-
-func TestRank(t *testing.T) {
- ps, _ := makeData()
- rs := rank(ps)
- assert.Equal(t, 1, len(rs[0]), "wrong number of people in rank 0")
- assert.Equal(t, 2, len(rs[1]), "wrong number of people in rank 1")
- assert.Equal(t, 3, len(rs[2]), "wrong number of people in rank 2")
- assert.Equal(t, 1, len(rs[3]), "wrong number of people in rank 3")
-}
-
-func makeData() (map[string]*Person, *Person) {
- ps := make(map[string]*Person)
- a := New("A")
- ps["A"] = a
-
- b1 := New("B1").SetManager(a)
- ps["B1"] = b1
- b2 := New("B2").SetManager(a)
- ps["B2"] = b2
-
- c1 := New("C1").SetManager(b1)
- ps["C1"] = c1
- c2 := New("C2").SetManager(b2)
- ps["C2"] = c2
- d1 := New("D1").SetManager(b2)
- ps["D1"] = d1
-
- e1 := New("E1").SetManager(d1)
- ps["E1"] = e1
- return ps, a
-}
-
-func TestMakePeople(t *testing.T) {
- s := `H1,H2
-C1,B1
-E1,D1
-B1,A
-A,
-B2,A
-D1,B2
-C2,B2`
- b := bytes.NewBufferString(s)
- rx := make(Ruleset, 0)
- exc, _ := makeExcludes([]string{}, []string{}, []string{})
- ps, er := makePeople(b, exc, []int{}, rx)
- if er != nil {
- assert.Fail(t, "failed to parse: %s", er.Error())
- }
- rs := rank(ps)
- d, _ := makeData()
- ex := rank(d)
-
- assert.Equal(t, len(ex), len(rs), "different number of ranks")
- for i, r := range rs {
- e := ex[i]
- sort.Sort(r)
- sort.Sort(e)
- if assert.Equal(t, len(e), len(r), "different number of people in rank %d", i) {
- for i, p1 := range r {
- p0 := e[i]
- if assert.Equal(t, p0.Name, p1.Name, "different people") {
- if p0.Manager != nil {
- if p1.Manager != nil {
- if assert.Equal(t, p0.Manager.Name, p1.Manager.Name, "different managers") {
- assert.Equal(t, len(p0.Reports), len(p1.Reports), "different # of reports for %s and %s", p0.Name, p1.Name)
- }
- } else {
- assert.Fail(t, "managers are not equal", "%v & %v", p0.Manager, p1.Manager)
- }
- } else if p1.Manager != nil {
- assert.Fail(t, "managers are not equal", "%v & %v", p0.Manager, p1.Manager)
- }
- }
- }
- }
- }
-}
-
-func TestDims(t *testing.T) {
- s := `H1,H2
-X,
-A,X
-B1,A
-B2,A
-B3,A
-C1B1,B1
-C2B1,B1
-C3B1,B1
-C4B1,B1
-C5B1,B1
-C1B2,B2
-C2B2,B2
-C3B2,B2`
- b := bytes.NewBufferString(s)
- rx := make(Ruleset, 0)
- exc, _ := makeExcludes([]string{}, []string{}, []string{})
- ps, er := makePeople(b, exc, []int{}, rx)
- if er != nil {
- assert.Fail(t, "failed to parse: %s", er.Error())
- }
- rs := rank(ps)
-
- assert.Equal(t, 3, rs.width())
-
- s = `H1,H2
-X,
-A,X
-B1,A
-B2,A
-B3,A
-C1B1,B1
-C2B1,B1
-C3B1,B1
-C1B2,B2
-C1B3,B3
-C2B3,B3
-C3B3,B3
-D1,C2B3
-D2,C2B3`
- b = bytes.NewBufferString(s)
- rx = make(Ruleset, 0)
- exc, _ = makeExcludes([]string{}, []string{}, []string{})
- ps, er = makePeople(b, exc, []int{}, rx)
- if er != nil {
- assert.Fail(t, "failed to parse: %s", er.Error())
- }
- rs = rank(ps)
-
- assert.Equal(t, 5, rs.width())
- assert.Equal(t, 6, rs.height())
- setBoxH(rs)
- assert.Equal(t, 450, height(rs, false))
- assert.Equal(t, 530, height(rs, true))
-}
-
-func TestClass(t *testing.T) {
- s := `Person,Manager,Is Manager,Is Contractor
-X,,true,false
-Y,,false,true
-Z,,true,true
-W,,false,false`
- b := bytes.NewBufferString(s)
- rx, er := makeRuleSet([]string{"2,true,A", "3,true,B"})
- if er != nil {
- assert.Fail(t, er.Error())
- }
- exc, _ := makeExcludes([]string{}, []string{}, []string{})
- ps, er := makePeople(b, exc, []int{}, rx)
- if er != nil {
- assert.Fail(t, er.Error())
- }
- //for k, v := range ps {
- // fmt.Printf("%s %#v\n", k, v)
- //}
- assert.Equal(t, ps["X"].Class, "A")
- assert.Equal(t, ps["Y"].Class, "B")
- assert.Equal(t, ps["Z"].Class, "A B")
- assert.Equal(t, ps["W"].Class, "")
-}
-
-func TestExcludes(t *testing.T) {
- ex1, er := makeExcludes(
- []string{"0,TRUE", "1,TRUE"}, // AND
- []string{"2,TRUE", "3,TRUE"}, // OR
- []string{"4,TRUE"}, // INCLUDE
- )
- if er != nil {
- assert.Fail(t, "failed to parse: %s", er.Error())
- }
- assert.True(t, ex1.Match([]string{"", "", "", "TRUE", ""}))
- assert.True(t, ex1.Match([]string{"", "", "TRUE", "", ""}))
- assert.True(t, ex1.Match([]string{"TRUE", "TRUE", "", "", ""}))
- assert.True(t, ex1.Match([]string{"TRUE", "TRUE", "", "TRUE", ""}))
- assert.False(t, ex1.Match([]string{"", "", "", "", ""}))
- assert.False(t, ex1.Match([]string{"TRUE", "", "", "", ""}))
- assert.False(t, ex1.Match([]string{"", "TRUE", "", "", ""}))
- assert.True(t, ex1.Match([]string{"TRUE", "TRUE", "", "TRUE", "TRUE"}))
-}
-
-func TestExclude(t *testing.T) {
- s := `H1,H2,X1,X2,X3
-X,,,,
-A,X,,,
-B1,A,,,
-B2,A,,,
-B3,A,,,
-C1B1,B1,FALSE,FALSE,TRUE
-C2B1,B1,,,TRUE
-C3B1,B1,TRUE,FALSE,TRUE
-C1B2,B2,TRUE,TRUE,
-C1B3,B3,TRUE,FALSE,
-C2B3,B3,FALSE,TRUE,
-C3B3,B3,FALSE,FALSE,
-D1,C2B3,TRUE,TRUE,TRUE
-D3,C2B3,TRUE,TRUE,TRUE
-D2,C2B3,TRUE,TRUE,FALSE`
- b := bytes.NewBufferString(s)
- rx := make(Ruleset, 0)
- ex1, er := makeExcludes(
- []string{"2,TRUE", "3,TRUE"}, // AND
- []string{"4,TRUE"}, // OR
- []string{"0", "D3"}, // FORCE INCLUDE
- )
- if er != nil {
- assert.Fail(t, "failed to parse: %s", er.Error())
- }
- ps, er := makePeople(b, ex1, []int{}, rx)
- if er != nil {
- assert.Fail(t, "failed to parse: %s", er.Error())
- }
- rs := rank(ps)
- var foundCount int
- for _, ps := range rs {
- for _, p := range ps {
- assert.NotEqual(t, "C1B1", p.Name)
- assert.NotEqual(t, "C1B1", p.Name)
- assert.NotEqual(t, "C3B1", p.Name)
- assert.NotEqual(t, "C1B2", p.Name)
- assert.NotEqual(t, "D1", p.Name)
- switch p.Name {
- case "B3":
- foundCount += 1
- case "C1B3":
- foundCount += 1
- case "C2B3":
- foundCount += 1
- case "C3B3":
- foundCount += 1
- case "D3":
- fountCount += 1
- }
- }
- }
- assert.Equal(t, 5, foundCount)
-}
M process.go +8 -6
@@ 25,11 25,13 @@ func breakUp(input []string) ([]Exclude,
for _, a := range input {
cs := strings.Split(a, ",")
if len(cs) != 2 {
- return output, errors.New("Malformed exclude argument " + a)
+ serr := fmt.Sprintf("malformed in/exclude argument %#v; require 2 values separated by ','", a)
+ return output, errors.New(serr)
}
idx, err := strconv.Atoi(cs[0])
if err != nil {
- return output, errors.New("Malformed exclude argument " + a)
+ serr := fmt.Sprintf("malformed in/exclude argument %#v; err = %s", a, err)
+ return output, errors.New(serr)
}
output = append(output, Exclude{idx, cs[1]})
}
@@ 101,20 103,20 @@ func MakeRank(ps map[string]*Person) Ran
for p.Manager != nil && ps[p.Manager.Name] != nil {
p = p.Manager
}
- rs = addRecursively(p, rs, 0)
+ rs = AddRecursively(p, rs, 0)
}
return rs
}
// Adds a person and their reports to the supplied ranks structure and recurses
// into the reports, creating new ranks as needed
-func addRecursively(p *Person, rs Ranks, i int) Ranks {
+func AddRecursively(p *Person, rs Ranks, i int) Ranks {
if len(rs) <= i {
rs = append(rs, make(Rank, 0))
}
rs[i] = append(rs[i], p)
for _, p1 := range p.Reports {
- rs = addRecursively(p1, rs, i+1)
+ rs = AddRecursively(p1, rs, i+1)
}
return rs
}
@@ 135,7 137,7 @@ func (ex Excludes) Match(cols []string)
for _, e := range ex.incls {
if e.idx < len(cols) {
if e.match == cols[e.idx] {
- return false
+ return true
}
}
}
A => process_test.go +245 -0
@@ 0,0 1,245 @@
+package orgchart
+
+import (
+ "bytes"
+ "sort"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestAddRecursively(t *testing.T) {
+ _, a := makeData()
+ r := make([]Rank, 0)
+ r = AddRecursively(a, r, 0)
+
+ assert.Equal(t, 1, len(r[0]), "wrong number of people in rank 0")
+ assert.Equal(t, 2, len(r[1]), "wrong number of people in rank 1")
+ assert.Equal(t, 3, len(r[2]), "wrong number of people in rank 2")
+ assert.Equal(t, 1, len(r[3]), "wrong number of people in rank 3")
+}
+
+func TestRank(t *testing.T) {
+ ps, _ := makeData()
+ rs := MakeRank(ps)
+ assert.Equal(t, 1, len(rs[0]), "wrong number of people in rank 0")
+ assert.Equal(t, 2, len(rs[1]), "wrong number of people in rank 1")
+ assert.Equal(t, 3, len(rs[2]), "wrong number of people in rank 2")
+ assert.Equal(t, 1, len(rs[3]), "wrong number of people in rank 3")
+}
+
+func TestMakePeople(t *testing.T) {
+ s := `H1,H2
+C1,B1
+E1,D1
+B1,A
+A,
+B2,A
+D1,B2
+C2,B2`
+ b := bytes.NewBufferString(s)
+ rx := make(Ruleset, 0)
+ exc, _ := MakeExcludes([]string{}, []string{}, []string{})
+ ps, er := MakePeople(b, exc, []int{}, rx)
+ if er != nil {
+ assert.Fail(t, "failed to parse: %s", er.Error())
+ }
+ rs := MakeRank(ps)
+ d, _ := makeData()
+ ex := MakeRank(d)
+
+ assert.Equal(t, len(ex), len(rs), "different number of ranks")
+ for i, r := range rs {
+ e := ex[i]
+ sort.Sort(r)
+ sort.Sort(e)
+ if assert.Equal(t, len(e), len(r), "different number of people in rank %d", i) {
+ for i, p1 := range r {
+ p0 := e[i]
+ if assert.Equal(t, p0.Name, p1.Name, "different people") {
+ if p0.Manager != nil {
+ if p1.Manager != nil {
+ if assert.Equal(t, p0.Manager.Name, p1.Manager.Name, "different managers") {
+ assert.Equal(t, len(p0.Reports), len(p1.Reports), "different # of reports for %s and %s", p0.Name, p1.Name)
+ }
+ } else {
+ assert.Fail(t, "managers are not equal", "%v & %v", p0.Manager, p1.Manager)
+ }
+ } else if p1.Manager != nil {
+ assert.Fail(t, "managers are not equal", "%v & %v", p0.Manager, p1.Manager)
+ }
+ }
+ }
+ }
+ }
+}
+
+func TestDims(t *testing.T) {
+ s := `H1,H2
+X,
+A,X
+B1,A
+B2,A
+B3,A
+C1B1,B1
+C2B1,B1
+C3B1,B1
+C4B1,B1
+C5B1,B1
+C1B2,B2
+C2B2,B2
+C3B2,B2`
+ b := bytes.NewBufferString(s)
+ rx := make(Ruleset, 0)
+ exc, _ := MakeExcludes([]string{}, []string{}, []string{})
+ ps, er := MakePeople(b, exc, []int{}, rx)
+ if er != nil {
+ assert.Fail(t, "failed to parse: %s", er.Error())
+ }
+ rs := MakeRank(ps)
+
+ assert.Equal(t, 3, rs.width())
+
+ s = `H1,H2
+X,
+A,X
+B1,A
+B2,A
+B3,A
+C1B1,B1
+C2B1,B1
+C3B1,B1
+C1B2,B2
+C1B3,B3
+C2B3,B3
+C3B3,B3
+D1,C2B3
+D2,C2B3`
+ b = bytes.NewBufferString(s)
+ rx = make(Ruleset, 0)
+ exc, _ = MakeExcludes([]string{}, []string{}, []string{})
+ ps, er = MakePeople(b, exc, []int{}, rx)
+ if er != nil {
+ assert.Fail(t, "failed to parse: %s", er.Error())
+ }
+ rs = MakeRank(ps)
+
+ assert.Equal(t, 5, rs.width())
+ assert.Equal(t, 6, rs.height())
+ setBoxH(rs)
+ assert.Equal(t, 450, height(rs))
+}
+
+func TestClass(t *testing.T) {
+ s := `Person,Manager,Is Manager,Is Contractor
+X,,true,false
+Y,,false,true
+Z,,true,true
+W,,false,false`
+ b := bytes.NewBufferString(s)
+ rx, er := MakeRuleSet([]string{"2,true,A", "3,true,B"})
+ if er != nil {
+ assert.Fail(t, er.Error())
+ }
+ exc, _ := MakeExcludes([]string{}, []string{}, []string{})
+ ps, er := MakePeople(b, exc, []int{}, rx)
+ if er != nil {
+ assert.Fail(t, er.Error())
+ }
+ //for k, v := range ps {
+ // fmt.Printf("%s %#v\n", k, v)
+ //}
+ assert.Equal(t, []string{"person", "A"}, ps["X"].Class)
+ assert.Equal(t, []string{"person", "B"}, ps["Y"].Class)
+ assert.Equal(t, []string{"person", "A", "B"}, ps["Z"].Class)
+ assert.Equal(t, []string{"person"}, ps["W"].Class)
+}
+
+func TestExcludes(t *testing.T) {
+ ex1, er := MakeExcludes(
+ []string{"0,TRUE", "1,TRUE"}, // AND
+ []string{"2,TRUE", "3,TRUE"}, // OR
+ []string{"4,TRUE"}, // INCLUDE
+ )
+ if er != nil {
+ assert.Fail(t, "failed to parse: %s", er.Error())
+ }
+ assert.True(t, ex1.Match([]string{"", "", "", "TRUE", ""}))
+ assert.True(t, ex1.Match([]string{"", "", "TRUE", "", ""}))
+ assert.True(t, ex1.Match([]string{"TRUE", "TRUE", "", "", ""}))
+ assert.True(t, ex1.Match([]string{"TRUE", "TRUE", "", "TRUE", ""}))
+ assert.False(t, ex1.Match([]string{"", "", "", "", ""}))
+ assert.False(t, ex1.Match([]string{"TRUE", "", "", "", ""}))
+ assert.False(t, ex1.Match([]string{"", "TRUE", "", "", ""}))
+ assert.True(t, ex1.Match([]string{"TRUE", "TRUE", "", "TRUE", "TRUE"}))
+}
+
+/* Need to rethink this test
+func TestExclude(t *testing.T) {
+ s := `H1,H2,X1,X2,X3
+X,,,,
+A,X,,,
+B1,A,,,
+B2,A,,,
+B3,A,,,
+C1B1,B1,FALSE,FALSE,TRUE
+C2B1,B1,,,TRUE
+C3B1,B1,TRUE,FALSE,TRUE
+C1B2,B2,TRUE,TRUE,
+C1B3,B3,TRUE,FALSE,
+C2B3,B3,FALSE,TRUE,
+C3B3,B3,FALSE,FALSE,
+D1,C2B3,TRUE,TRUE,TRUE
+D3,C2B3,TRUE,TRUE,TRUE
+D2,C2B3,TRUE,TRUE,FALSE`
+ b := bytes.NewBufferString(s)
+ rx := make(Ruleset, 0)
+ ex1, er := MakeExcludes(
+ []string{"2,TRUE", "3,TRUE"}, // AND
+ []string{"4,TRUE"}, // OR
+ []string{"0,C3B3"}, // FORCE INCLUDE
+ )
+ if er != nil {
+ assert.Fail(t, "failed to parse: %s", er.Error())
+ }
+ ps, er := MakePeople(b, ex1, []int{}, rx)
+ if er != nil {
+ assert.Fail(t, "failed to parse: %s", er.Error())
+ }
+ rs := MakeRank(ps)
+ var foundCount int
+ for _, ps := range rs {
+ for _, p := range ps {
+ switch p.Name {
+ case "H1", "X", "A", "B1", "B2", "B3", "C1B3", "C2B3":
+ assert.Fail(t, "expected row exclusion", "name: "+p.Name)
+ default:
+ foundCount += 1
+ }
+ }
+ }
+ assert.Equal(t, 8, foundCount)
+}
+*/
+
+func makeData() (map[string]*Person, *Person) {
+ ps := make(map[string]*Person)
+ a := New("A")
+ ps["A"] = a
+
+ b1 := New("B1").SetManager(a)
+ ps["B1"] = b1
+ b2 := New("B2").SetManager(a)
+ ps["B2"] = b2
+
+ c1 := New("C1").SetManager(b1)
+ ps["C1"] = c1
+ c2 := New("C2").SetManager(b2)
+ ps["C2"] = c2
+ d1 := New("D1").SetManager(b2)
+ ps["D1"] = d1
+
+ e1 := New("E1").SetManager(d1)
+ ps["E1"] = e1
+ return ps, a
+}
M svg_test.go +11 -6
@@ 1,6 1,12 @@
package orgchart
-/*
+import (
+ "bytes"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
func TestMaxTextWidth(t *testing.T) {
tests := []string{
"X,,A,B,C\nXX,,A,B,C",
@@ 18,19 24,18 @@ func TestMaxTextWidth(t *testing.T) {
}
h := "Person,Manager,Text 1,Text 2, Text 3\n"
var ps map[string]*Person
- rx, er := makeRuleSet([]string{})
+ rx, er := MakeRuleSet([]string{})
if er != nil {
assert.Fail(t, er.Error())
}
- exc, _ := makeExcludes([]string{}, []string{})
+ exc, _ := MakeExcludes([]string{}, []string{}, []string{})
for i, tst := range tests {
b := bytes.NewBufferString(h + tst)
- ps, er = makePeople(b, exc, []int{2, 3, 4}, rx)
+ ps, er = MakePeople(b, exc, []int{2, 3, 4}, rx)
if er != nil {
assert.Fail(t, er.Error())
}
- rs := rank(ps)
+ rs := MakeRank(ps)
assert.Equal(t, expects[i], maxTextWidth(rs))
}
}
-*/