├── README.md ├── main.go └── model ├── basket ├── basket.go └── basket_test.go └── basket_item ├── basket_item.go └── basket_item_test.go /README.md: -------------------------------------------------------------------------------- 1 | Golang Is Good, Structure Is Bad 2 | =============== 3 | I begin with `imports`. Nomarlly you just import a package and the last element of the package path would be the package you want to use. 4 | 5 | ```go 6 | import "foo/bar/baz" 7 | ``` 8 | 9 | Problem 10 | ------- 11 | 12 | So what if there's (probably is) type called `Baz` and you use it: 13 | 14 | ```go 15 | import "foo/bar/baz" 16 | 17 | func main() { 18 | baz := baz.New() 19 | } 20 | ``` 21 | 22 | ![wat.](http://i0.kym-cdn.com/photos/images/newsfeed/000/173/576/Wat8.jpg) 23 | 24 | You just shadowed the package name with calling a variable `baz` and you writing baz twice `baz.Baz` in linguistics terms which is not good (remember DRY!) and probably you'd write a factory function called `NewBaz` that's even worse. 25 | 26 | ```go 27 | package baz 28 | 29 | type Baz struct{} 30 | 31 | func NewBaz() { 32 | // do something 33 | } 34 | ``` 35 | 36 | Solution 37 | -------- 38 | 39 | I found a solution or trick to naming things in decent way IMO. So you just name your package whatever you want and there must be only one exported type inside the package and you should call it `Type` and you `must` separate each type into different packages and you `must` name packages explicitly with in `PascalCase`. 40 | 41 | ```go 42 | import Baz "foo/bar/baz" 43 | 44 | var baz Baz.Type{} 45 | ``` 46 | 47 | Why? 48 | ---- 49 | 50 | With that trick I can use packages as metaphor to classes and you can write: 51 | 52 | ```go 53 | package main 54 | 55 | import Basket "gigsib/model/basket" 56 | import BasketItem "gigsib/model/basket_item" 57 | 58 | func main() { 59 | basket := Basket.New(nil) 60 | basket.AddItemBang(BasketItem.New("NikeLab ACG 07 KMTR", "1100")) 61 | basket.AddItemBang(BasketItem.New("Nike Kobe A.D. Triple Black", "750")) 62 | basket.TotalPrice() 63 | } 64 | ``` 65 | 66 | ```ruby 67 | require "gigsib/model/basket" 68 | require "gigsib/model/basket_item" 69 | 70 | basket = Basket.new(nil) 71 | basket.add_item!(BasketItem.new("NikeLab ACG 07 KMTR", "1100")) 72 | basket.add_item!(BasketItem.new("Nike Kobe A.D. Triple Black", "750")) 73 | basket.total_price() 74 | ``` 75 | 76 | Do you see a big difference between ruby and golang? (expect ! and naming convention and entrypoint) 77 | -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | BasketHandler "gigsib/handler/basket" 5 | "log" 6 | "net/http" 7 | 8 | "github.com/husobee/vestigo" 9 | ) 10 | 11 | func main() { 12 | router := vestigo.NewRouter() 13 | router.Post("/basket", BasketHandler.Create) 14 | log.Fatal(http.ListenAndServe(":3000", router)) 15 | } 16 | -------------------------------------------------------------------------------- /model/basket/basket.go: -------------------------------------------------------------------------------- 1 | package basket 2 | 3 | import basket_item "gigsib/model/basket_item" 4 | 5 | type Type struct { 6 | Items []*basket_item.Type 7 | } 8 | 9 | func (b *Type) TotalPrice() float64 { 10 | total := 0.0 11 | for _, item := range b.Items { 12 | total += item.Price 13 | } 14 | return total 15 | } 16 | 17 | func (b *Type) AddItemBang(item *basket_item.Type) { 18 | b.Items = append(b.Items, item) 19 | } 20 | 21 | func (b *Type) AddItem(item *basket_item.Type) []*basket_item.Type { 22 | return append(b.Items, item) 23 | } 24 | 25 | func New(items []*basket_item.Type) *Type { 26 | return &Type{items} 27 | } 28 | -------------------------------------------------------------------------------- /model/basket/basket_test.go: -------------------------------------------------------------------------------- 1 | package basket_test 2 | 3 | import ( 4 | Basket "gigsib/model/basket" 5 | BasketItem "gigsib/model/basket_item" 6 | "testing" 7 | 8 | "github.com/stretchr/testify/assert" 9 | ) 10 | 11 | func TestNew(t *testing.T) { 12 | basket := &Basket.Type{} 13 | 14 | newBasket := Basket.New(nil) 15 | 16 | assert.Equal(t, newBasket, basket) 17 | } 18 | 19 | func TestTotalPrice(t *testing.T) { 20 | basket := Basket.New(nil) 21 | basket.AddItemBang(BasketItem.New("foo", 1.25)) 22 | basket.AddItemBang(BasketItem.New("bar", 1.69)) 23 | 24 | totalPrice := basket.TotalPrice() 25 | 26 | assert.Equal(t, totalPrice, 1.25+1.69) 27 | } 28 | func TestAddItemBang(t *testing.T) { 29 | basket := Basket.New(nil) 30 | 31 | basket.AddItemBang(BasketItem.New("foo", 1.25)) 32 | basket.AddItemBang(BasketItem.New("bar", 1.69)) 33 | 34 | assert.Len(t, basket.Items, 2) 35 | } 36 | 37 | func TestAddItem(t *testing.T) { 38 | basket := Basket.New(nil) 39 | 40 | basket.AddItem(BasketItem.New("foo", 1.25)) 41 | basket.AddItem(BasketItem.New("bar", 1.69)) 42 | 43 | assert.Len(t, basket.Items, 0) 44 | } 45 | -------------------------------------------------------------------------------- /model/basket_item/basket_item.go: -------------------------------------------------------------------------------- 1 | package basket_item 2 | 3 | type Type struct { 4 | Id string 5 | Price float64 6 | } 7 | 8 | func New(id string, price float64) *Type { 9 | return &Type{id, price} 10 | } 11 | -------------------------------------------------------------------------------- /model/basket_item/basket_item_test.go: -------------------------------------------------------------------------------- 1 | package basket_item_test 2 | 3 | import ( 4 | BasketItem "gigsib/model/basket_item" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestNew(t *testing.T) { 11 | basketItem := &BasketItem.Type{} 12 | 13 | newBasketItem := BasketItem.New("", 0.0) 14 | 15 | assert.Equal(t, newBasketItem, basketItem) 16 | } 17 | --------------------------------------------------------------------------------