edit readme;

changes to named values (-> dictionary);
unit tests complete;
feature complete;
initial complete;

Author: razorware

README.md

@@ -33,7 +33,7 @@ Window {
 ```
 
 Jargon is more flexible than JSON. For instance, in the example of above, there are only a couple of elements encapsulated with '"'. Also, there is no root symbol
-required as in JSON. A JSON document must start with `{` and close with `}`. Jargon does not require anything. As a matter of fact, one could write the following:
+required as in JSON. A JSON document must start with `{` and close with `}`. Jargon does not require anything. The following is a valid jargon data structure:
 
 ```
 Person {
@@ -58,8 +58,9 @@ Address {
 }
 ```
 
-`Person` and `Address` are separate keys with their own child nodes. Only the streets needed double quotes due to the spaces in the values. If quotes had not encapsulated
-the values, then street would end up as a tuple of values: ex. (123, Main, St)
+`Person` and `Address` are separate keys with their own child nodes. Apply double quotes to values with spaces. If quotes had not encapsulated
+the (street, for example) values. Otherwise, `street: 123 Main St` result is problematic.  
+_NOTE: this behavior has not yet been determined and would most likely throw an exception._
 
 If a keyed value were expected to be a list, then the following format is required:
 
@@ -79,19 +80,30 @@ cleaner markup for a data structure than XML. Look for an implementation of Jarg
 
 Jargon recognizes several formats for data:
 
-integers:  i:500
-floats:    f:29.75
-named tuple:
-
+integers:       500
+floats:         29.75
+dictionary:
 ```
 size:   w:500 h:500
 ```
+results in: `{'w': 500, 'h': 500}`
 
-results in a tuple identical to what the following Python creates:
-
-```Python
-size = namedtuple('size', 'w h')
-my_size = size(500, 500)
+lists: 
+```
+list:   100, "text information", 1/1/2000
 ```
+results in: `[100, 'text information', '1/1/2000']`
 
-lists: 100, "text informationn", 1/1/2000
+In progress (_TODO's and other stuff_):
+* add handling of unique node value collections, see Ex: 1 
+* add validator (validation template)
+
+Ex: 1
+```
+data: People {
+    ...
+}
+data: Addresses {
+    ...
+}    
+```

__init__.py

@@ -80,31 +80,57 @@ def ignore_comments(buffer, idx):
     return idx
 
 
-def isdigit(buffer):
+def iterate(tup_coll):
+    length = None
+    for l in tup_coll:
+        if not length:
+            length = len(l)
+            continue
+        if len(l) != length:
+            # invalid iteration - lengths not equal
+            raise IndexError("collection lengths not equal")
+
+    idx = 0
+    while idx < length:
+        tpl = []
+        for l in tup_coll:
+            tpl.append(l[idx])
+
+        yield tuple(tpl)
+
+        idx += 1
+
+
+def is_digit(buffer):
     digits = bytes(b'0123456789')
     idx = 0
     length = len(buffer)
-    is_digit = True
+    digit = True
     has_decimal = False
 
     if buffer.startswith(b'-'):
         idx += 1
 
-    while idx < length and is_digit:
-        is_digit = buffer[idx] in digits
-        if not is_digit and buffer[idx] != 46:       # '.'
+    while idx < length and digit:
+        digit = buffer[idx] in digits
+        if not digit and buffer[idx] != 46:       # '.'
             break
 
         if not has_decimal:
             if buffer[idx] == 46:
                 has_decimal = True
-                is_digit = is_digit or True
+                digit = digit or True
         elif has_decimal and buffer[idx] == 46:
-            is_digit = is_digit and False
+            digit = digit and False
 
         idx += 1
 
-    return is_digit
+    return digit
+
+
+def is_collection(candidate):
+    import collections
+    return not isinstance(candidate, str) and isinstance(candidate, collections.Sequence)
 
 
 def read_text(buffer, idx, escapes=True):
@@ -170,7 +196,7 @@ def decode_value(value):
         """
         Determines if there are any special results expected from the formatting of the value:
             bytearray(b'w:500 h:300') expects to return a tuple with 'w' and 'h' attributes and
-            values of 500 & 300 respective
+            nodes of 500 & 300 respective
         :param value:
         :type value: bytearray
 
@@ -190,7 +216,7 @@ def decode_value(value):
         if result and len(result):
             return result
 
-        if isdigit(value):
+        if is_digit(value):
             if len(value.split(b'.')) > 1:
                 result = float(value)
             elif int(value):
@@ -199,7 +225,7 @@ def decode_value(value):
         if result:
             return result
 
-        tags, values = ([], [])
+        tags, nodes = ([], [])
         while idx < length:
             idx = ignore_whitespace(value, idx)
 
@@ -215,7 +241,7 @@ def decode_value(value):
                         temp, idx = read_text(value, idx)
                         idx += 1
 
-                        values.append(temp.decode())
+                        nodes.append(temp.decode())
                         temp.clear()
 
                         continue
@@ -224,7 +250,7 @@ def decode_value(value):
                     idx += 1
 
                 if len(temp):
-                    values.append(decode_value(temp))
+                    nodes.append(decode_value(temp))
                     temp.clear()
 
                 idx += 1
@@ -233,8 +259,14 @@ def decode_value(value):
             temp.append(value[idx])
             idx += 1
 
-        if len(tags) and len(values):
-            return " ".join(tags), values
+        if len(tags) and len(nodes):
+            node_set = {}
+            i = 0
+            for k, v in iterate((tags, nodes)):
+                node_set.update({k: nodes[i]})
+                i += 1
+
+            return node_set
 
         if len(temp) > 0:
             return temp.decode()

jargon_py/__init__.py

@@ -2,6 +2,7 @@
 
 from jargon_py import *
 from jargon_py.nodes import *
+from jargon_py.query import *
 
 
 def load(file):
@@ -87,14 +88,14 @@ def build_nodes(self, raw_nodes, parent=None):
         buffer = self.__fso.buffer
         length = len(buffer)
 
-        key_nodes = []
+        root = KeyNode('root', None)
         for n in raw_nodes:
             kn = KeyNode(n.name, parent)
 
             if n.nodes:
-                children = self.build_nodes(n.nodes, kn)
+                children = self.build_nodes(n.nodes, kn).nodes
                 for ch in children:
-                    kn.add_node(ch[1])
+                    kn.add_node(ch.node)
             else:
                 # no child nodes but value instead
                 idx = n.start
@@ -123,9 +124,10 @@ def build_nodes(self, raw_nodes, parent=None):
                 if len(value) > 0:
                     kn.set_value(decode_value(value))
 
-            key_nodes.append((kn.name, kn))
+            root.add_node(kn)
+            kn.parent = root
 
-        return key_nodes
+        return root
 
     def __scan(self, index=0, read_length=None):
         buffer = self.__fso.buffer
@@ -186,7 +188,7 @@ def __scan(self, index=0, read_length=None):
                     idx += 1
 
                 start = idx
-                while buffer[idx] != LINE_TERM:
+                while idx < length and buffer[idx] != LINE_TERM:
                     idx += 1
 
             raw_node.start = start

jargon_py/jargon.py

@@ -1,19 +1,8 @@
+from collections import namedtuple
 
-def get_nodes(collection, key):
-    results = filter(lambda r: r[0] == key, collection)
+from jargon_py.query import *
 
-    for k, n in results:
-        yield n
-
-
-def first(iterator):
-    item = None
-
-    for i in iterator:
-        item = i
-        break
-
-    return item
+Node = namedtuple("Node", "name node")
 
 
 class RawNode:
@@ -49,37 +38,60 @@ def name(self):
     def value(self):
         return self.__value
 
+    @property
+    def nodes(self):
+        return self.__nodes
+
     def __init__(self, key, parent):
         self.parent = parent
         self.__name = key
         self.__value = None
+        self.__nodes = NodeCollection()
 
     def add_node(self, node):
-        if not self.__value:
-            self.__value = []
-
-        self.__value.append((node.name, node))
+        self.__nodes.add(node)
 
     def set_value(self, value):
-        if isinstance(value, tuple):
-            from collections import namedtuple
-            attribs = value[0]
-            values = value[1]
-            val_cls = namedtuple(self.name, attribs)
+        self.__value = value
+
+    def __hash__(self):
+        return self.__value.__hash__()
 
-            value = val_cls(*values)
+    def __str__(self):
+        return '{name}'.format(name=self.__name)
 
-        if not self.__value:
-            self.__value = value
+    def __iter__(self):
+        return self.__nodes.__iter__()
 
     def __getitem__(self, item):
-        results = get_nodes(self.__value, item)
+        return self.__nodes[item]
 
-        for v in results:
-            yield v
 
-    def __hash__(self):
-        return self.__value.__hash__()
+class NodeCollection:
 
-    def __str__(self):
-        return '{name}'.format(name=self.__name)
+    def __init__(self):
+        self.__nodes = []
+
+    def add(self, node):
+        """
+        Add a KeyNode to Collection
+
+        :param node:    a key node object
+        :type node:     KeyNode
+
+        :return: void
+        """
+        self.__nodes.append(Node(node.name, node))
+
+    def __len__(self):
+        return len(self.__nodes)
+
+    def __iter__(self):
+        for n in self.__nodes:
+            yield n
+
+    def __getitem__(self, item):
+        results = get_nodes(self.__nodes, item)
+
+        for r in results:
+            yield r

jargon_py/nodes.py

@@ -0,0 +1,52 @@
+import types
+
+
+def get_nodes(collection, key):
+    results = filter(lambda r: r.name == key, collection)
+
+    for k, n in results:
+        yield n
+
+
+def first(iterator):
+    """
+    Returns the first occurrence from collection iterator
+
+    :param iterator:
+
+    :return:
+    """
+    item = None
+
+    for i in iterator:
+        item = i
+        break
+
+    return item
+
+
+def child_tags(collection):
+    if isinstance(collection, types.GeneratorType):
+        collection = list(collection)[0].nodes
+
+    return [n.name for n in collection]
+
+
+def one(iterator):
+    """
+    Returns one instance found in the collection; raises exception if more than one are found
+
+    :param iterator:
+
+    :return:
+    """
+    item = None
+
+    for i in iterator:
+        if item is not None:
+            raise Exception("expected only one instance but multiple exist")
+
+        item = i
+        break
+
+    return item