From fabffed6d1cb1493bdc14141babb1bcb6e76c200 Mon Sep 17 00:00:00 2001
From: Breno Almeida <breno_17@live.com>
Date: Mon, 28 Sep 2020 16:50:27 -0300
Subject: [PATCH] apply linter suggestions & make structToMap public
---
kiss_orm.go | 25 +++++++++++--------------
kiss_orm_test.go | 8 ++++----
2 files changed, 15 insertions(+), 18 deletions(-)
diff --git a/kiss_orm.go b/kiss_orm.go
index 0aef518..fcc1df4 100644
--- a/kiss_orm.go
+++ b/kiss_orm.go
@@ -15,7 +15,7 @@ type ORMProvider interface {
GetByID(ctx context.Context, item interface{}, id interface{}) error
Insert(ctx context.Context, items ...interface{}) error
Delete(ctx context.Context, ids ...interface{}) error
- Update(ctx context.Context, intems ...interface{}) error
+ Update(ctx context.Context, items ...interface{}) error
Query(ctx context.Context, query string, params ...interface{}) (Iterator, error)
QueryNext(ctx context.Context, rawIt Iterator, item interface{}) (done bool, err error)
}
@@ -169,11 +169,11 @@ func (c Client) Update(
items ...interface{},
) error {
for _, item := range items {
- m, err := structToMap(item)
+ m, err := StructToMap(item)
if err != nil {
return err
}
-
+ delete(m, "id")
r := c.db.Table(c.tableName).Model(item).Updates(m)
if r.Error != nil {
return r.Error
@@ -187,20 +187,20 @@ func (c Client) Update(
// because the total number of types on a program
// should be finite. So keeping a single cache here
// works fine.
-var tagInfoCache = map[reflect.Type]StructInfo{}
+var tagInfoCache = map[reflect.Type]structInfo{}
-type StructInfo struct {
+type structInfo struct {
Names map[int]string
Index map[string]int
}
-// structToMap converts any struct type to a map based on
+// StructToMap converts any struct type to a map based on
// the tag named `gorm`, i.e. `gorm:"map_key_name"`
//
// This function is efficient in the fact that it caches
// the slower steps of the reflection required to do perform
// this task.
-func structToMap(obj interface{}) (map[string]interface{}, error) {
+func StructToMap(obj interface{}) (map[string]interface{}, error) {
v := reflect.ValueOf(obj)
t := v.Type()
@@ -220,9 +220,6 @@ func structToMap(obj interface{}) (map[string]interface{}, error) {
m := map[string]interface{}{}
for i := 0; i < v.NumField(); i++ {
- if info.Names[i] == "id" {
- continue
- }
field := v.Field(i)
ft := field.Type()
if ft.Kind() == reflect.Ptr {
@@ -244,8 +241,8 @@ func structToMap(obj interface{}) (map[string]interface{}, error) {
//
// This should save several calls to `Field(i).Tag.Get("foo")`
// which improves performance by a lot.
-func getTagNames(t reflect.Type) StructInfo {
- info := StructInfo{
+func getTagNames(t reflect.Type) structInfo {
+ info := structInfo{
Names: map[int]string{},
Index: map[string]int{},
}
@@ -267,7 +264,7 @@ func getTagNames(t reflect.Type) StructInfo {
// The first argument is any struct you are passing to a kissorm func,
// and the second is a map representing a database row you want
// to use to update this struct.
-func UpdateStructWith(entity interface{}, db_row map[string]interface{}) error {
+func UpdateStructWith(entity interface{}, dbRow map[string]interface{}) error {
v := reflect.ValueOf(entity)
t := v.Type()
@@ -294,7 +291,7 @@ func UpdateStructWith(entity interface{}, db_row map[string]interface{}) error {
tagInfoCache[t] = info
}
- for colName, attr := range db_row {
+ for colName, attr := range dbRow {
attrValue := reflect.ValueOf(attr)
field := v.Field(info.Index[colName])
fieldType := t.Field(info.Index[colName]).Type
diff --git a/kiss_orm_test.go b/kiss_orm_test.go
index a75b60c..b9bd2d3 100644
--- a/kiss_orm_test.go
+++ b/kiss_orm_test.go
@@ -263,7 +263,7 @@ func TestStructToMap(t *testing.T) {
Age int `gorm:"age_attr"`
}
t.Run("should convert plain structs to maps", func(t *testing.T) {
- m, err := structToMap(S1{
+ m, err := StructToMap(S1{
Name: "my name",
Age: 22,
})
@@ -276,7 +276,7 @@ func TestStructToMap(t *testing.T) {
})
t.Run("should not ignore zero value attrs, if they are not pointers", func(t *testing.T) {
- m, err := structToMap(S1{
+ m, err := StructToMap(S1{
Name: "",
Age: 0,
})
@@ -296,7 +296,7 @@ func TestStructToMap(t *testing.T) {
t.Run("should not ignore not nil pointers", func(t *testing.T) {
str := ""
age := 0
- m, err := structToMap(S2{
+ m, err := StructToMap(S2{
Name: &str,
Age: &age,
})
@@ -309,7 +309,7 @@ func TestStructToMap(t *testing.T) {
})
t.Run("should ignore nil pointers", func(t *testing.T) {
- m, err := structToMap(S2{
+ m, err := StructToMap(S2{
Name: nil,
Age: nil,
})