Validate and Plant user provided arguments
        - Go through and plants the seedlings
          for any user arguments provided.
        - Validate the arguments, cleaning and adapting (valideer wise)
        - Extract negatives "!" arguments

def _harvest_validate(self, userkwargs):
        """Validate and Plant user provided arguments
        - Go through and plants the seedlings
          for any user arguments provided.
        - Validate the arguments, cleaning and adapting (valideer wise)
        - Extract negatives "!" arguments
        """
        # the valideer to parse the
        # user arguemnts when watering
        parser = {}

        userkwargs.update(self.network_kwargs)
        # a simple set of original provided argument keys (used in IGNORES)
        original_kwargs = set(map(lambda k: k.split('_')[1] if k.find('_')>-1 else k, userkwargs.keys()))
        # list of columns that are required from seeds
        requires = []

        # -------------
        # Clean up Aggs
        # -------------
        for key in userkwargs.keys():
            # agg example: "avg_total", "max_tax"
            if key.find('_') > 0:
                agg, base = tuple(key.split('_'))
                if base in userkwargs:
                    if type(userkwargs[base]) is not list:
                        userkwargs[base] = [(None, userkwargs[base])]
                    userkwargs[base].append( (agg, userkwargs.pop(key)) )
                else:
                    userkwargs[base] = [(agg, userkwargs.pop(key))]

        # -----------------
        # Process Arguments
        # -----------------
        for key, seed in self.arguments.iteritems():
            # --------------
            # Argument Alias
            # --------------
            if seed.get('alias') and key in userkwargs:
                # pop the value form the user kwargs (to change the key later)
                value = userkwargs.pop(key) if key in userkwargs else NotImplemented
                # for duplicate keys
                oldkey = key+""
                # change the key
                key = seed.get('alias')
                # change the seed
                seed = get(self.arguments, seed.get('alias'))
                # set the new key:value
                if value is not NotImplemented:
                    if key in userkwargs:
                        raise valideer.ValidationError("Argument alias already specified for `%s` via `%s`" % (oldkey, key), oldkey)
                    userkwargs[key] = value

            # can provide multiple arguments
            if key.endswith('[]'):
                multi = True
                key = key[:-2]
            else:
                multi = False

            # get value(s) from user
            if key in userkwargs:
                value = userkwargs.pop(key)
            elif seed.get('copy'):
                value = userkwargs.get(seed.get('copy'))
            else:
                value = seed.get('default')

            # no argument provided, lets continue)
            if value is None or value == []:
                if seed.get('required'):
                    raise valideer.ValidationError("missing required property: %s" % key, key)
                else:
                    continue

            # add requires
            requires.extend(array(get(seed, 'requires', [])))

            # -----------
            # Inheritance
            # -----------
            # not permited from arguements yet. would need to happen above the ""PROCESS ARGUMENT"" block
            # self._inherit(*array(get(seed, 'inherit', [])))

            if type(value) is list and type(value[0]) is tuple:
                # complex
                for v in value:
                    ud, pd = self._harvest_args(key, seed, v, multi)
                    userkwargs.update(ud)
                    parser.update(pd)
            else:
                ud, pd = self._harvest_args(key, seed, value, multi)
                userkwargs.update(ud)
                parser.update(pd)

        # ------------
        # Ignored Keys
        # ------------
        for seed in self.seeds:
            ignores = set(array(get(seed, 'ignore')))
            if ignores:
                if ignores & original_kwargs:
                    if not get(seed, 'silent'):
                        additionals = ignores & original_kwargs
                        raise valideer.ValidationError("additional properties: %s" % ",".join(additionals), additionals)
                [userkwargs.pop(key) for key in ignores if key in userkwargs]

        # -------------------------
        # Custom Operators (part 1)
        # -------------------------
        operators = {}
        for key, value in userkwargs.items():
            rk = key
            agg = None
            if key.find('_')>-1:
                agg, rk = tuple(key.split('_'))
            seed = self.arguments.get(rk, self.arguments.get(rk+'[]'))
            if seed:
                if type(value) is list:
                    operators[key] = []
                    # need to remove the operator for validating
                    new_values = []
                    for v in value:
                        operator, v = self._operator(v, *seed.get('column', "").rsplit("::", 1))
                        new_values.append(v)
                        operators[key].append((agg, operator) if agg else operator)
                    userkwargs[key] = new_values
                else:
                    operator, value = self._operator(value, *seed.get('column', "").rsplit("::", 1))
                    operators[key] = (agg, operator) if agg else operator
                    userkwargs[key] = value

        # -----------------
        # Plant Sort Method
        # -----------------
        if 'sortby' in userkwargs:
            seed = self.arguments.get(userkwargs['sortby'].lower(), self.arguments.get(userkwargs['sortby'].lower()+'[]'))
            if seed:
                seed['id'] = str(userkwargs['sortby'].lower())

        for r in set(requires):
            if userkwargs.get(r) is None:
                raise valideer.ValidationError("required property not set: %s" % r, r)

        # --------
        # Validate
        # --------
        parser = valideer.parse(parser, additional_properties=False)
        validated = parser.validate(userkwargs, adapt=self.navigator.adapter())
        validated.update(self.network_kwargs)
        #   operators                   validated
        # --------------------------- | --------------------------------
        # {                           {
        #   "type": ["!", "!"],         "type": ['a', 'b'],
        #   "total": "<",               "total": "50",
        #   "tax": ("avg, ">"),         "tax": "1",
        #   "time": None                "time": "2014"
        # }                           }
        return operators, validated