bug: Fix parsing of nested objects in lists

This fixes tests, and the lke cluster-create operation.

As it happens, the CLI did not parse optional list arguments correctly
(namely, if an optional argument to a list was omitted, the list would
not be created and no items in the list would populate correctly.

Compounding this, objects nested in objects within lists did not
properly restructure after being flattened for the command line.  This
caused nested objects in lists to be sent incorrectly.

Both of the above broke the `linode-cli lke cluster-create` endpoint,
and thereby tests, when `autoscaler` was added to that endpoint, nested
within the `node_pools` object in a list.  This change fixes the issues,
allowing this endpoint to work again.

:warning: I did not write this to handle multiple layers of object
nesting in lists.  I will revisit this if it ever becomes necessary - I
left a comment noting where it would be handled.

Author: Dorthu

linodecli/operation.py

@@ -188,13 +188,14 @@ def parse_args(self, args):
                                             type=TYPES[arg.arg_type])
 
         parsed = parser.parse_args(args)
-
         lists = {}
         # group list items as expected
         for arg_name, list_name in list_items:
-            item_name = arg_name.split('.')[-1]
+            item_name = arg_name.split(list_name)[1][1:]
             if hasattr(parsed, arg_name):
                 val = getattr(parsed, arg_name) or []
+                if not val:
+                    continue
                 if  list_name not in lists:
                     new_list = [{item_name: c} for c in val]
                     lists[list_name] = new_list
@@ -203,6 +204,33 @@ def parse_args(self, args):
                     for obj, item in zip(update_list, val):
                         obj[item_name] = item
 
+        # break out list items with periods in their name into objects.  This
+        # allows supporting nested lists
+        for _, cur_list in lists.items():
+            # for each list in lists
+            for item in cur_list:
+                # for each item in the list (these are dicts)
+                new_dicts = {}
+                remove_keys = []
+                for k, v in item.items():
+                    # if there's a period in the key, split it into a dict and
+                    # possibly merge it with a dict that came from a prior split
+                    #
+                    # XXX: This only supports one layer of nested dicts in lists
+                    if "." in k:
+                        dict_key, key = k.split('.', 1)
+                        if dict_key in new_dicts:
+                            new_dicts[dict_key][key] = v
+                        else:
+                            new_dicts[dict_key] = {key: v}
+                        remove_keys.append(k)
+
+                # remove the original keys
+                for key in remove_keys:
+                    del item[key]
+                # and add the combined keys
+                item.update(new_dicts)
+
         # don't send along empty lists
         to_delete = []
         for k, v in lists.items():
@@ -219,6 +247,7 @@ def parse_args(self, args):
                 del parsed[name]
             parsed = argparse.Namespace(**parsed)
 
+
         return parsed
 
     def process_response_json(self, json, handler):