go/ferret
go/ferret
1
0
Fork 0
mirror of https://github.com/MontFerret/ferret.git synced 2025-02-13 13:58:32 +02:00
Code Issues Releases Activity

Updated operators

Browse Source
This commit is contained in:
Tim Voronov 2018-09-22 20:28:33 -04:00
parent bbb9f7b68f
commit 8436fa7425
5 changed files with 176 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
pkg/compiler/compiler_test.go
View File

@ -978,6 +978,81 @@ func TestLogicalOperators(t *testing.T) {
So(err, ShouldBeNil)
So(string(out), ShouldEqual, "true")
})
Convey("1 || 7 should return 1", t, func() {
c := compiler.New()
prog, err := c.Compile(`
RETURN 1 || 7
`)
So(err, ShouldBeNil)
out, err := prog.Run(context.Background())
So(err, ShouldBeNil)
So(string(out), ShouldEqual, "1")
})
Convey("NONE || 'foo' should return 'foo'", t, func() {
c := compiler.New()
prog, err := c.Compile(`
RETURN NONE || 'foo'
`)
So(err, ShouldBeNil)
out, err := prog.Run(context.Background())
So(err, ShouldBeNil)
So(string(out), ShouldEqual, `"foo"`)
})
Convey("NONE && true should return null", t, func() {
c := compiler.New()
prog, err := c.Compile(`
RETURN NONE && true
`)
So(err, ShouldBeNil)
out, err := prog.Run(context.Background())
So(err, ShouldBeNil)
So(string(out), ShouldEqual, `null`)
})
Convey("'' && true should return ''", t, func() {
c := compiler.New()
prog, err := c.Compile(`
RETURN '' && true
`)
So(err, ShouldBeNil)
out, err := prog.Run(context.Background())
So(err, ShouldBeNil)
So(string(out), ShouldEqual, `""`)
})
Convey("true && 23 should return '23", t, func() {
c := compiler.New()
prog, err := c.Compile(`
RETURN true && 23
`)
So(err, ShouldBeNil)
out, err := prog.Run(context.Background())
So(err, ShouldBeNil)
So(string(out), ShouldEqual, `23`)
})
}
func TestMathOperators(t *testing.T) {

19
pkg/runtime/expressions/condition.go
View File

@ -42,7 +42,7 @@ func (e *ConditionExpression) Exec(ctx context.Context, scope *core.Scope) (core
return values.None, core.SourceError(e.src, err)
}
cond := e.evalTestValue(out)
cond := values.ToBoolean(out)
var next core.Expression
@ -65,20 +65,3 @@ func (e *ConditionExpression) Exec(ctx context.Context, scope *core.Scope) (core
return res, nil
}
func (e *ConditionExpression) evalTestValue(value core.Value) values.Boolean {
switch value.Type() {
case core.BooleanType:
return value.(values.Boolean)
case core.NoneType:
return values.False
case core.StringType:
return values.NewBoolean(value.String() != "")
case core.IntType:
return values.NewBoolean(value.(values.Int) != 0)
case core.FloatType:
return values.NewBoolean(value.(values.Float) != 0)
default:
return values.True
}
}

30
pkg/runtime/expressions/operators/logical.go
View File

@ -57,18 +57,22 @@ func (operator *LogicalOperator) Exec(ctx context.Context, scope *core.Scope) (c
return nil, err
}
left = operator.ensureType(left)
if operator.value == NotType {
return Not(left, values.None), nil
}
if operator.value == AndType && left == values.False {
return values.False, nil
leftBool := values.ToBoolean(left)
if operator.value == AndType && leftBool == values.False {
if left.Type() == core.BooleanType {
return values.False, nil
}
return left, nil
}
if operator.value == OrType && left == values.True {
return values.True, nil
if operator.value == OrType && leftBool == values.True {
return left, nil
}
right, err := operator.right.Exec(ctx, scope)
@ -77,17 +81,5 @@ func (operator *LogicalOperator) Exec(ctx context.Context, scope *core.Scope) (c
return nil, err
}
return operator.ensureType(right), nil
}
func (operator *LogicalOperator) ensureType(value core.Value) core.Value {
if value.Type() != core.BooleanType {
if value.Type() == core.NoneType {
return values.False
}
return values.True
}
return value
return right, nil
}

144
pkg/runtime/expressions/operators/operator.go
View File

@ -72,13 +72,13 @@ func GreaterOrEqual(left, right core.Value) core.Value {
}
func Not(left, _ core.Value) core.Value {
if left == values.True {
b := values.ToBoolean(left)
if b == values.True {
return values.False
} else if left == values.False {
return values.True
}
return values.False
return values.True
}
// Adds numbers
@ -86,33 +86,33 @@ func Not(left, _ core.Value) core.Value {
func Add(left, right core.Value) core.Value {
if left.Type() == core.IntType {
if right.Type() == core.IntType {
l := left.Unwrap().(int)
r := right.Unwrap().(int)
l := left.(values.Int)
r := right.(values.Int)
return values.NewInt(l + r)
return l + r
}
if right.Type() == core.FloatType {
l := left.Unwrap().(int)
r := right.Unwrap().(float64)
l := left.(values.Int)
r := right.(values.Float)
return values.Float(float64(l) + r)
return values.Float(l) + r
}
}
if left.Type() == core.FloatType {
if right.Type() == core.FloatType {
l := left.Unwrap().(float64)
r := right.Unwrap().(float64)
l := left.(values.Float)
r := right.(values.Float)
return values.Float(l + r)
return l + r
}
if right.Type() == core.IntType {
l := left.Unwrap().(float64)
r := right.Unwrap().(int)
l := left.(values.Float)
r := right.(values.Int)
return values.Float(l + float64(r))
return l + values.Float(r)
}
}
@ -122,33 +122,33 @@ func Add(left, right core.Value) core.Value {
func Subtract(left, right core.Value) core.Value {
if left.Type() == core.IntType {
if right.Type() == core.IntType {
l := left.Unwrap().(int)
r := right.Unwrap().(int)
l := left.(values.Int)
r := right.(values.Int)
return values.NewInt(l - r)
return l - r
}
if right.Type() == core.FloatType {
l := left.Unwrap().(int)
r := right.Unwrap().(float64)
l := left.(values.Int)
r := right.(values.Float)
return values.Float(float64(l) - r)
return values.Float(l) - r
}
}
if left.Type() == core.FloatType {
if right.Type() == core.FloatType {
l := left.Unwrap().(float64)
r := right.Unwrap().(float64)
l := left.(values.Float)
r := right.(values.Float)
return values.Float(l - r)
return l - r
}
if right.Type() == core.IntType {
l := left.Unwrap().(float64)
r := right.Unwrap().(int)
l := left.(values.Float)
r := right.(values.Int)
return values.Float(l - float64(r))
return l - values.Float(r)
}
}
@ -158,33 +158,33 @@ func Subtract(left, right core.Value) core.Value {
func Multiply(left, right core.Value) core.Value {
if left.Type() == core.IntType {
if right.Type() == core.IntType {
l := left.Unwrap().(int)
r := right.Unwrap().(int)
l := left.(values.Int)
r := right.(values.Int)
return values.NewInt(l * r)
return l * r
}
if right.Type() == core.FloatType {
l := left.Unwrap().(int)
r := right.Unwrap().(float64)
l := left.(values.Int)
r := right.(values.Float)
return values.Float(float64(l) * r)
return values.Float(l) * r
}
}
if left.Type() == core.FloatType {
if right.Type() == core.FloatType {
l := left.Unwrap().(float64)
r := right.Unwrap().(float64)
l := left.(values.Float)
r := right.(values.Float)
return values.Float(l * r)
return l * r
}
if right.Type() == core.IntType {
l := left.Unwrap().(float64)
r := right.Unwrap().(int)
l := left.(values.Float)
r := right.(values.Int)
return values.Float(l * float64(r))
return l * values.Float(r)
}
}
@ -194,33 +194,33 @@ func Multiply(left, right core.Value) core.Value {
func Divide(left, right core.Value) core.Value {
if left.Type() == core.IntType {
if right.Type() == core.IntType {
l := left.Unwrap().(int)
r := right.Unwrap().(int)
l := left.(values.Int)
r := right.(values.Int)
return values.NewInt(l / r)
return l / r
}
if right.Type() == core.FloatType {
l := left.Unwrap().(int)
r := right.Unwrap().(float64)
l := left.(values.Int)
r := right.(values.Float)
return values.Float(float64(l) / r)
return values.Float(l) / r
}
}
if left.Type() == core.FloatType {
if right.Type() == core.FloatType {
l := left.Unwrap().(float64)
r := right.Unwrap().(float64)
l := left.(values.Float)
r := right.(values.Float)
return values.Float(l / r)
return l / r
}
if right.Type() == core.IntType {
l := left.Unwrap().(float64)
r := right.Unwrap().(int)
l := left.(values.Float)
r := right.(values.Int)
return values.Float(l / float64(r))
return l / values.Float(r)
}
}
@ -230,33 +230,33 @@ func Divide(left, right core.Value) core.Value {
func Modulus(left, right core.Value) core.Value {
if left.Type() == core.IntType {
if right.Type() == core.IntType {
l := left.Unwrap().(int)
r := right.Unwrap().(int)
l := left.(values.Int)
r := right.(values.Int)
return values.NewInt(l % r)
return l % r
}
if right.Type() == core.FloatType {
l := left.Unwrap().(int)
r := right.Unwrap().(float64)
l := left.(values.Int)
r := right.(values.Float)
return values.Float(l % int(r))
return l % values.Int(r)
}
}
if left.Type() == core.FloatType {
if right.Type() == core.FloatType {
l := left.Unwrap().(float64)
r := right.Unwrap().(float64)
l := left.(values.Float)
r := right.(values.Float)
return values.Float(int(l) % int(r))
return values.Int(l) % values.Int(r)
}
if right.Type() == core.IntType {
l := left.Unwrap().(float64)
r := right.Unwrap().(int)
l := left.(values.Float)
r := right.(values.Int)
return values.Float(int(l) % r)
return values.Int(l) % r
}
}
@ -265,15 +265,15 @@ func Modulus(left, right core.Value) core.Value {
func Increment(left, _ core.Value) core.Value {
if left.Type() == core.IntType {
l := left.Unwrap().(int)
l := left.(values.Int)
return values.NewInt(l + 1)
return l + 1
}
if left.Type() == core.FloatType {
l := left.Unwrap().(float64)
l := left.(values.Float)
return values.Float(l + 1)
return l + 1
}
return values.None
@ -281,15 +281,15 @@ func Increment(left, _ core.Value) core.Value {
func Decrement(left, _ core.Value) core.Value {
if left.Type() == core.IntType {
l := left.Unwrap().(int)
l := left.(values.Int)
return values.NewInt(l - 1)
return l - 1
}
if left.Type() == core.FloatType {
l := left.Unwrap().(float64)
l := left.(values.Float)
return values.Float(l - 1)
return l - 1
}
return values.None

17
pkg/runtime/values/helpers.go
View File

@ -209,3 +209,20 @@ func Parse(input interface{}) core.Value {
return None
}
func ToBoolean(input core.Value) core.Value {
switch input.Type() {
case core.BooleanType:
return input
case core.NoneType:
return False
case core.StringType:
return NewBoolean(input.String() != "")
case core.IntType:
return NewBoolean(input.(Int) != 0)
case core.FloatType:
return NewBoolean(input.(Float) != 0)
default:
return True
}
}