Skip to content

Commit

Permalink
Add DropLeft And Right wesovilabs#40 wesovilabs#41 (wesovilabs#51)
Browse files Browse the repository at this point in the history
  • Loading branch information
@somen440 @ivancorrales
somen440 authored and ivancorrales committed Mar 5, 2019
1 parent e24d804 commit e432001
Show file tree
Hide file tree
Showing 8 changed files with 317 additions and 39 deletions.
6 changes: 4 additions & 2 deletions internal/drop/dispatcher.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,10 +35,12 @@ var dispatcher = map[string]dispatchFunction{
"*float64": dropPtrFloat64,
}

func dispatch(items reflect.Value, itemValue interface{}, info *dropInfo) (bool, interface{}) {
func dispatch(items reflect.Value, itemValue interface{}, info *dropInfo, option Option) (bool, interface{}) {
input := (*info.itemType).String()
if fnVal, ok := dispatcher[input]; ok {
return true, fnVal(items, itemValue)
if option == None {
return true, fnVal(items, itemValue)
}
}
return false, nil
}
Expand Down
77 changes: 47 additions & 30 deletions internal/drop/dispatcher_test.go
View file
Original file line number Diff line number Diff line change
@@ -1,16 +1,17 @@
package drop

import (
"github.com/stretchr/testify/assert"
"github.com/wesovilabs/koazee/utils"
"reflect"
"testing"

"github.com/stretchr/testify/assert"
"github.com/wesovilabs/koazee/utils"
)

func Test_dropString(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayString[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayString), utils.ArrayString[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayString), utils.ArrayString[1], info, None)
assert.True(t, found)
for index := range output.([]string) {
assert.NotEqual(t, utils.ArrayString[1], output.([]string)[index])
Expand All @@ -20,7 +21,7 @@ func Test_dropString(t *testing.T) {
func Test_dropStringPtr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayStringPtr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayStringPtr), utils.ArrayStringPtr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayStringPtr), utils.ArrayStringPtr[1], info, None)
assert.True(t, found)
for index := range output.([]*string) {
assert.NotEqual(t, *utils.ArrayStringPtr[1], *output.([]*string)[index])
Expand All @@ -30,7 +31,7 @@ func Test_dropStringPtr(t *testing.T) {
func Test_dropBool(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayBool[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayBool), utils.ArrayBool[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayBool), utils.ArrayBool[1], info, None)
assert.True(t, found)
for index := range output.([]bool) {
assert.NotEqual(t, utils.ArrayBool[1], output.([]bool)[index])
Expand All @@ -40,7 +41,7 @@ func Test_dropBool(t *testing.T) {
func Test_dropBoolPtr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayBoolPtr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayBoolPtr), utils.ArrayBoolPtr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayBoolPtr), utils.ArrayBoolPtr[1], info, None)
assert.True(t, found)
for index := range output.([]*bool) {
assert.NotEqual(t, *utils.ArrayBoolPtr[1], *output.([]*bool)[index])
Expand All @@ -50,7 +51,7 @@ func Test_dropBoolPtr(t *testing.T) {
func Test_dropInt(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt), utils.ArrayInt[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt), utils.ArrayInt[1], info, None)
assert.True(t, found)
for index := range output.([]int) {
assert.NotEqual(t, utils.ArrayInt[1], output.([]int)[index])
Expand All @@ -60,7 +61,7 @@ func Test_dropInt(t *testing.T) {
func Test_dropIntPtr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayIntPtr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayIntPtr), utils.ArrayIntPtr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayIntPtr), utils.ArrayIntPtr[1], info, None)
assert.True(t, found)
for index := range output.([]*int) {
assert.NotEqual(t, *utils.ArrayIntPtr[1], *output.([]*int)[index])
Expand All @@ -70,7 +71,7 @@ func Test_dropIntPtr(t *testing.T) {
func Test_dropInt8(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt8[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt8), utils.ArrayInt8[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt8), utils.ArrayInt8[1], info, None)
assert.True(t, found)
for index := range output.([]int8) {
assert.NotEqual(t, utils.ArrayInt8[1], output.([]int8)[index])
Expand All @@ -80,7 +81,7 @@ func Test_dropInt8(t *testing.T) {
func Test_dropInt8Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt8Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt8Ptr), utils.ArrayInt8Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt8Ptr), utils.ArrayInt8Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*int8) {
assert.NotEqual(t, *utils.ArrayInt8Ptr[1], *output.([]*int8)[index])
Expand All @@ -90,7 +91,7 @@ func Test_dropInt8Ptr(t *testing.T) {
func Test_dropInt16(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt16[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt16), utils.ArrayInt16[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt16), utils.ArrayInt16[1], info, None)
assert.True(t, found)
for index := range output.([]int16) {
assert.NotEqual(t, utils.ArrayInt16[1], output.([]int16)[index])
Expand All @@ -100,7 +101,7 @@ func Test_dropInt16(t *testing.T) {
func Test_dropInt16Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt16Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt16Ptr), utils.ArrayInt16Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt16Ptr), utils.ArrayInt16Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*int16) {
assert.NotEqual(t, *utils.ArrayInt16Ptr[1], *output.([]*int16)[index])
Expand All @@ -110,7 +111,7 @@ func Test_dropInt16Ptr(t *testing.T) {
func Test_dropInt32(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt32[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt32), utils.ArrayInt32[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt32), utils.ArrayInt32[1], info, None)
assert.True(t, found)
for index := range output.([]int32) {
assert.NotEqual(t, utils.ArrayInt32[1], output.([]int32)[index])
Expand All @@ -120,7 +121,7 @@ func Test_dropInt32(t *testing.T) {
func Test_dropInt32Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt32Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt32Ptr), utils.ArrayInt32Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt32Ptr), utils.ArrayInt32Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*int32) {
assert.NotEqual(t, *utils.ArrayInt32Ptr[1], *output.([]*int32)[index])
Expand All @@ -130,7 +131,7 @@ func Test_dropInt32Ptr(t *testing.T) {
func Test_dropInt64(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt64[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt64), utils.ArrayInt64[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt64), utils.ArrayInt64[1], info, None)
assert.True(t, found)
for index := range output.([]int64) {
assert.NotEqual(t, utils.ArrayInt64[1], output.([]int64)[index])
Expand All @@ -140,7 +141,7 @@ func Test_dropInt64(t *testing.T) {
func Test_dropInt64Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayInt64Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayInt64Ptr), utils.ArrayInt64Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayInt64Ptr), utils.ArrayInt64Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*int64) {
assert.NotEqual(t, *utils.ArrayInt64Ptr[1], *output.([]*int64)[index])
Expand All @@ -150,7 +151,7 @@ func Test_dropInt64Ptr(t *testing.T) {
func Test_dropUint(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint), utils.ArrayUint[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint), utils.ArrayUint[1], info, None)
assert.True(t, found)
for index := range output.([]uint) {
assert.NotEqual(t, utils.ArrayUint[1], output.([]uint)[index])
Expand All @@ -160,7 +161,7 @@ func Test_dropUint(t *testing.T) {
func Test_dropUintPtr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUintPtr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUintPtr), utils.ArrayUintPtr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUintPtr), utils.ArrayUintPtr[1], info, None)
assert.True(t, found)
for index := range output.([]*uint) {
assert.NotEqual(t, *utils.ArrayUintPtr[1], *output.([]*uint)[index])
Expand All @@ -170,7 +171,7 @@ func Test_dropUintPtr(t *testing.T) {
func Test_dropUint8(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint8[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint8), utils.ArrayUint8[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint8), utils.ArrayUint8[1], info, None)
assert.True(t, found)
for index := range output.([]uint8) {
assert.NotEqual(t, utils.ArrayUint8[1], output.([]uint8)[index])
Expand All @@ -180,7 +181,7 @@ func Test_dropUint8(t *testing.T) {
func Test_dropUint8Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint8Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint8Ptr), utils.ArrayUint8Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint8Ptr), utils.ArrayUint8Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*uint8) {
assert.NotEqual(t, *utils.ArrayUint8Ptr[1], *output.([]*uint8)[index])
Expand All @@ -190,7 +191,7 @@ func Test_dropUint8Ptr(t *testing.T) {
func Test_dropUint16(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint16[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint16), utils.ArrayUint16[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint16), utils.ArrayUint16[1], info, None)
assert.True(t, found)
for index := range output.([]uint16) {
assert.NotEqual(t, utils.ArrayUint16[1], output.([]uint16)[index])
Expand All @@ -200,7 +201,7 @@ func Test_dropUint16(t *testing.T) {
func Test_dropUint16Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint16Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint16Ptr), utils.ArrayUint16Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint16Ptr), utils.ArrayUint16Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*uint16) {
assert.NotEqual(t, *utils.ArrayUint16Ptr[1], *output.([]*uint16)[index])
Expand All @@ -210,7 +211,7 @@ func Test_dropUint16Ptr(t *testing.T) {
func Test_dropUint32(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint32[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint32), utils.ArrayUint32[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint32), utils.ArrayUint32[1], info, None)
assert.True(t, found)
for index := range output.([]uint32) {
assert.NotEqual(t, utils.ArrayUint32[1], output.([]uint32)[index])
Expand All @@ -220,7 +221,7 @@ func Test_dropUint32(t *testing.T) {
func Test_dropUint32Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint32Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint32Ptr), utils.ArrayUint32Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint32Ptr), utils.ArrayUint32Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*uint32) {
assert.NotEqual(t, *utils.ArrayUint32Ptr[1], *output.([]*uint32)[index])
Expand All @@ -230,7 +231,7 @@ func Test_dropUint32Ptr(t *testing.T) {
func Test_dropUint64(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint64[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint64), utils.ArrayUint64[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint64), utils.ArrayUint64[1], info, None)
assert.True(t, found)
for index := range output.([]uint64) {
assert.NotEqual(t, utils.ArrayUint64[1], output.([]uint64)[index])
Expand All @@ -240,7 +241,7 @@ func Test_dropUint64(t *testing.T) {
func Test_dropUint64Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayUint64Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayUint64Ptr), utils.ArrayUint64Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayUint64Ptr), utils.ArrayUint64Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*uint64) {
assert.NotEqual(t, *utils.ArrayUint64Ptr[1], *output.([]*uint64)[index])
Expand All @@ -250,7 +251,7 @@ func Test_dropUint64Ptr(t *testing.T) {
func Test_dropFloat32(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayFloat32[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat32), utils.ArrayFloat32[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat32), utils.ArrayFloat32[1], info, None)
assert.True(t, found)
for index := range output.([]float32) {
assert.NotEqual(t, utils.ArrayFloat32[1], output.([]float32)[index])
Expand All @@ -260,7 +261,7 @@ func Test_dropFloat32(t *testing.T) {
func Test_dropFloat32Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayFloat32Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat32Ptr), utils.ArrayFloat32Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat32Ptr), utils.ArrayFloat32Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*float32) {
assert.NotEqual(t, *utils.ArrayFloat32Ptr[1], *output.([]*float32)[index])
Expand All @@ -270,7 +271,7 @@ func Test_dropFloat32Ptr(t *testing.T) {
func Test_dropFloat64(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayFloat64[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat64), utils.ArrayFloat64[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat64), utils.ArrayFloat64[1], info, None)
assert.True(t, found)
for index := range output.([]float64) {
assert.NotEqual(t, utils.ArrayFloat64[1], output.([]float64)[index])
Expand All @@ -280,9 +281,25 @@ func Test_dropFloat64(t *testing.T) {
func Test_dropFloat64Ptr(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayFloat64Ptr[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat64Ptr), utils.ArrayFloat64Ptr[1], info)
found, output := dispatch(reflect.ValueOf(utils.ArrayFloat64Ptr), utils.ArrayFloat64Ptr[1], info, None)
assert.True(t, found)
for index := range output.([]*float64) {
assert.NotEqual(t, *utils.ArrayFloat64Ptr[1], *output.([]*float64)[index])
}
}

func Test_dropString_With_Left(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayString[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayString), utils.ArrayString[1], info, Left)
assert.False(t, found)
assert.Nil(t, output)
}

func Test_dropString_With_Right(t *testing.T) {
typeElement := reflect.TypeOf(utils.ArrayString[1])
info := &dropInfo{itemType: &typeElement}
found, output := dispatch(reflect.ValueOf(utils.ArrayString), utils.ArrayString[1], info, Right)
assert.False(t, found)
assert.Nil(t, output)
}
48 changes: 42 additions & 6 deletions internal/drop/drop.go
View file
Original file line number Diff line number Diff line change
@@ -1,18 +1,30 @@
package drop

import (
"github.com/wesovilabs/koazee/errors"
"reflect"

"github.com/wesovilabs/koazee/errors"
)

// OpCode identifier for operation drop
const OpCode = "drop"

// Option defines drop option
type Option int

// Options
const (
None Option = iota
Left
Right
)

// Drop struct for operation
type Drop struct {
ItemsValue reflect.Value
ItemsType reflect.Type
Item interface{}
Option Option
}

// Run performs the operations whenever is called
Expand All @@ -21,23 +33,47 @@ func (op *Drop) Run() (reflect.Value, *errors.Error) {
if err != nil {
return reflect.ValueOf(nil), err
}
if found, result := dispatch(op.ItemsValue, op.Item, info); found {
if found, result := dispatch(op.ItemsValue, op.Item, info, op.Option); found {
return reflect.ValueOf(result), nil
}

isFounded := false
newItems := reflect.MakeSlice(reflect.SliceOf(op.ItemsType), 0, 0)
for index := 0; index < op.ItemsValue.Len(); index++ {
val := op.ItemsValue.Index(index)
if equalsValues(val, info.itemValue) {
newItems = reflect.Append(newItems, val)
switch op.Option {
case None:
if equalsValues(val, info.itemValue) == false {
isFounded = true
newItems = reflect.Append(newItems, val)
}
case Left:
if isFounded || equalsValues(val, info.itemValue) {
isFounded = true
newItems = reflect.Append(newItems, val)
}
case Right:
if equalsValues(val, info.itemValue) {
isFounded = true
newItems = reflect.Append(newItems, val)
} else if isFounded == false {
newItems = reflect.Append(newItems, val)
}
}
}
return newItems, nil

if isFounded {
return newItems, nil
}
return op.ItemsValue, nil
}

func (op *Drop) validate() (*dropInfo, *errors.Error) {
itemType := reflect.TypeOf(op.Item)
if info := cache.get(op.ItemsType, itemType); info != nil {
return info, nil
if equalsValues(info.itemValue, reflect.ValueOf(op.Item)) {
return info, nil
}
}
info := &dropInfo{itemType: &itemType}
if op.ItemsValue.Len() > 0 {
Expand Down
Loading

0 comments on commit e432001

Please sign in to comment.