func()

in wstl1/mapping_engine/mapping/mapping.go [59:139]

• 64 lines of code
• 20 McCabe index (conditional complexity)

func (w Whistler) EvaluateMapping(m *mappb.FieldMapping, args []jsonutil.JSONMetaNode, output *jsonutil.JSONToken, pctx *types.Context) error {
	if m.Condition != nil {
		var cb bool
		var err error
		if cb, err = checkCondition(m.Condition, args, output, pctx, w.accessor); err != nil {
			return errs.Wrap(errs.NewProtoLocation(m.Condition, m), err)
		}
		if !cb {
			return nil
		}
	}

	var src jsonutil.JSONMetaNode
	var err error
	if src, err = EvaluateValueSource(m.ValueSource, args, *output, pctx, w.accessor); err != nil {
		return errs.Wrap(errs.NewProtoLocation(m.ValueSource, m), err)
	}

	srcToken, err := jsonutil.NodeToToken(src)
	if err != nil {
		return err
	}
	srcToken = postProcessValue(srcToken)

	// Skip nil-check if target is var, since we still want to define the var even assign nil to it.
	// Once the var is used, and written to something else that isn't a var, that's when nil-check
	// will happen on this value.
	if _, isVar := m.Target.(*mappb.FieldMapping_TargetLocalVar); !isVar && isNil(srcToken) {
		return nil
	}

	// No target field defaults to self.
	if m.Target == nil {
		m.Target = &mappb.FieldMapping_TargetField{TargetField: ""}
	}

	iterateSrc := isSrcIteratable(m.ValueSource)

	switch t := m.Target.(type) {
	case *mappb.FieldMapping_TargetField:
		if err := writeField(srcToken, t.TargetField, output, false, iterateSrc, w.accessor); err != nil {
			return fmt.Errorf("could not write field %q: %v", t.TargetField, err)
		}
		return nil
	case *mappb.FieldMapping_TargetLocalVar:
		cval, name, err := getVar(t.TargetLocalVar, pctx)
		// Undefined var errors are safe to ignore here.
		if _, ok := err.(undefinedVarError); !ok && err != nil {
			return err
		}

		if cval != nil {
			cval = jsonutil.Deepcopy(cval)
		}

		field := strings.TrimPrefix(strings.TrimPrefix(t.TargetLocalVar, name), ".")
		// For variables, we allow to overwrite them without "!" except for array appending.
		forceOverwrite := !isSelectorArray(field)

		if err := writeField(srcToken, field, &cval, forceOverwrite, iterateSrc, w.accessor); err != nil {
			return err
		}

		err = pctx.Variables.Set(name, &cval)
		if err != nil {
			return fmt.Errorf("error setting var %q: %v", t.TargetLocalVar, err)
		}

		return nil
	case *mappb.FieldMapping_TargetObject:
		addObject(srcToken, t.TargetObject, pctx)
		return nil
	case *mappb.FieldMapping_TargetRootField:
		if err := writeField(srcToken, t.TargetRootField, pctx.Output, false, iterateSrc, w.accessor); err != nil {
			return fmt.Errorf("could not write root field %q: %v", t.TargetRootField, err)
		}
		return nil
	default:
		return fmt.Errorf("unknown target %T", m.Target)
	}
}