initial html conversion

5 files changed, 33 insertions, 335 deletions

diff --git a/py/__init__.py b/py/__init__.py
index f98310f..30aabac 100644
--- a/py/__init__.py
+++ b/py/__init__.py
@@ -26,342 +26,14 @@ __version__ = _convert_version(version_info)
 
 del _convert_version
 
-
-from ruamel.yaml.error import *
-
-from ruamel.yaml.tokens import *
-from ruamel.yaml.events import *
-from ruamel.yaml.nodes import *
-
-from ruamel.yaml.loader import *
-from ruamel.yaml.dumper import *
-from ruamel.yaml.compat import StringIO, BytesIO, with_metaclass, PY3
-
 try:
     from .cyaml import *
     __with_libyaml__ = True
 except ImportError:
     __with_libyaml__ = False
 
-import io
-
-
-def scan(stream, Loader=Loader):
-    """
-    Scan a YAML stream and produce scanning tokens.
-    """
-    loader = Loader(stream)
-    try:
-        while loader.check_token():
-            yield loader.get_token()
-    finally:
-        loader.dispose()
-
-
-def parse(stream, Loader=Loader):
-    """
-    Parse a YAML stream and produce parsing events.
-    """
-    loader = Loader(stream)
-    try:
-        while loader.check_event():
-            yield loader.get_event()
-    finally:
-        loader.dispose()
-
-
-def compose(stream, Loader=Loader):
-    """
-    Parse the first YAML document in a stream
-    and produce the corresponding representation tree.
-    """
-    loader = Loader(stream)
-    try:
-        return loader.get_single_node()
-    finally:
-        loader.dispose()
-
-
-def compose_all(stream, Loader=Loader):
-    """
-    Parse all YAML documents in a stream
-    and produce corresponding representation trees.
-    """
-    loader = Loader(stream)
-    try:
-        while loader.check_node():
-            yield loader.get_node()
-    finally:
-        loader.dispose()
-
-
-def load(stream, Loader=Loader):
-    """
-    Parse the first YAML document in a stream
-    and produce the corresponding Python object.
-    """
-    loader = Loader(stream)
-    try:
-        return loader.get_single_data()
-    finally:
-        loader.dispose()
-
-
-def load_all(stream, Loader=Loader):
-    """
-    Parse all YAML documents in a stream
-    and produce corresponding Python objects.
-    """
-    loader = Loader(stream)
-    try:
-        while loader.check_data():
-            yield loader.get_data()
-    finally:
-        loader.dispose()
-
-
-def safe_load(stream):
-    """
-    Parse the first YAML document in a stream
-    and produce the corresponding Python object.
-    Resolve only basic YAML tags.
-    """
-    return load(stream, SafeLoader)
-
-
-def safe_load_all(stream):
-    """
-    Parse all YAML documents in a stream
-    and produce corresponding Python objects.
-    Resolve only basic YAML tags.
-    """
-    return load_all(stream, SafeLoader)
-
-
-def emit(events, stream=None, Dumper=Dumper,
-         canonical=None, indent=None, width=None,
-         allow_unicode=None, line_break=None):
-    """
-    Emit YAML parsing events into a stream.
-    If stream is None, return the produced string instead.
-    """
-    getvalue = None
-    if stream is None:
-        stream = StringIO()
-        getvalue = stream.getvalue
-    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
-                    allow_unicode=allow_unicode, line_break=line_break)
-    try:
-        for event in events:
-            dumper.emit(event)
-    finally:
-        dumper.dispose()
-    if getvalue:
-        return getvalue()
-
-enc = None if PY3 else 'utf-8'
-
-
-def serialize_all(nodes, stream=None, Dumper=Dumper,
-                  canonical=None, indent=None, width=None,
-                  allow_unicode=None, line_break=None,
-                  encoding=enc, explicit_start=None, explicit_end=None,
-                  version=None, tags=None):
-    """
-    Serialize a sequence of representation trees into a YAML stream.
-    If stream is None, return the produced string instead.
-    """
-    getvalue = None
-    if stream is None:
-        if encoding is None:
-            stream = StringIO()
-        else:
-            stream = BytesIO()
-        getvalue = stream.getvalue
-    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
-                    allow_unicode=allow_unicode, line_break=line_break,
-                    encoding=encoding, version=version, tags=tags,
-                    explicit_start=explicit_start, explicit_end=explicit_end)
-    try:
-        dumper.open()
-        for node in nodes:
-            dumper.serialize(node)
-        dumper.close()
-    finally:
-        dumper.dispose()
-    if getvalue:
-        return getvalue()
-
-
-def serialize(node, stream=None, Dumper=Dumper, **kwds):
-    """
-    Serialize a representation tree into a YAML stream.
-    If stream is None, return the produced string instead.
-    """
-    return serialize_all([node], stream, Dumper=Dumper, **kwds)
-
-
-def dump_all(documents, stream=None, Dumper=Dumper,
-             default_style=None, default_flow_style=None,
-             canonical=None, indent=None, width=None,
-             allow_unicode=None, line_break=None,
-             encoding=enc, explicit_start=None, explicit_end=None,
-             version=None, tags=None):
-    """
-    Serialize a sequence of Python objects into a YAML stream.
-    If stream is None, return the produced string instead.
-    """
-    getvalue = None
-    if stream is None:
-        if encoding is None:
-            stream = StringIO()
-        else:
-            stream = BytesIO()
-        getvalue = stream.getvalue
-    dumper = Dumper(stream, default_style=default_style,
-                    default_flow_style=default_flow_style,
-                    canonical=canonical, indent=indent, width=width,
-                    allow_unicode=allow_unicode, line_break=line_break,
-                    encoding=encoding, version=version, tags=tags,
-                    explicit_start=explicit_start, explicit_end=explicit_end)
-    try:
-        dumper.open()
-        for data in documents:
-            dumper.represent(data)
-        dumper.close()
-    finally:
-        dumper.dispose()
-    if getvalue:
-        return getvalue()
-
-
-def dump(data, stream=None, Dumper=Dumper, **kwds):
-    """
-    Serialize a Python object into a YAML stream.
-    If stream is None, return the produced string instead.
-    """
-    return dump_all([data], stream, Dumper=Dumper, **kwds)
-
-
-def safe_dump_all(documents, stream=None, **kwds):
-    """
-    Serialize a sequence of Python objects into a YAML stream.
-    Produce only basic YAML tags.
-    If stream is None, return the produced string instead.
-    """
-    return dump_all(documents, stream, Dumper=SafeDumper, **kwds)
-
-
-def safe_dump(data, stream=None, **kwds):
-    """
-    Serialize a Python object into a YAML stream.
-    Produce only basic YAML tags.
-    If stream is None, return the produced string instead.
-    """
-    return dump_all([data], stream, Dumper=SafeDumper, **kwds)
-
-
-def add_implicit_resolver(tag, regexp, first=None,
-                          Loader=Loader, Dumper=Dumper):
-    """
-    Add an implicit scalar detector.
-    If an implicit scalar value matches the given regexp,
-    the corresponding tag is assigned to the scalar.
-    first is a sequence of possible initial characters or None.
-    """
-    Loader.add_implicit_resolver(tag, regexp, first)
-    Dumper.add_implicit_resolver(tag, regexp, first)
-
-
-def add_path_resolver(tag, path, kind=None, Loader=Loader, Dumper=Dumper):
-    """
-    Add a path based resolver for the given tag.
-    A path is a list of keys that forms a path
-    to a node in the representation tree.
-    Keys can be string values, integers, or None.
-    """
-    Loader.add_path_resolver(tag, path, kind)
-    Dumper.add_path_resolver(tag, path, kind)
-
-
-def add_constructor(tag, constructor, Loader=Loader):
-    """
-    Add a constructor for the given tag.
-    Constructor is a function that accepts a Loader instance
-    and a node object and produces the corresponding Python object.
-    """
-    Loader.add_constructor(tag, constructor)
-
-
-def add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader):
-    """
-    Add a multi-constructor for the given tag prefix.
-    Multi-constructor is called for a node if its tag starts with tag_prefix.
-    Multi-constructor accepts a Loader instance, a tag suffix,
-    and a node object and produces the corresponding Python object.
-    """
-    Loader.add_multi_constructor(tag_prefix, multi_constructor)
-
-
-def add_representer(data_type, representer, Dumper=Dumper):
-    """
-    Add a representer for the given type.
-    Representer is a function accepting a Dumper instance
-    and an instance of the given data type
-    and producing the corresponding representation node.
-    """
-    Dumper.add_representer(data_type, representer)
-
-
-def add_multi_representer(data_type, multi_representer, Dumper=Dumper):
-    """
-    Add a representer for the given type.
-    Multi-representer is a function accepting a Dumper instance
-    and an instance of the given data type or subtype
-    and producing the corresponding representation node.
-    """
-    Dumper.add_multi_representer(data_type, multi_representer)
-
-
-class YAMLObjectMetaclass(type):
-    """
-    The metaclass for YAMLObject.
-    """
-    def __init__(cls, name, bases, kwds):
-        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
-        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
-            cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
-            cls.yaml_dumper.add_representer(cls, cls.to_yaml)
-
-
-class YAMLObject(with_metaclass(YAMLObjectMetaclass)):
-    """
-    An object that can dump itself to a YAML stream
-    and load itself from a YAML stream.
-    """
-    __slots__ = ()  # no direct instantiation, so allow immutable subclasses
-
-    yaml_loader = Loader
-    yaml_dumper = Dumper
-
-    yaml_tag = None
-    yaml_flow_style = None
-
-    @classmethod
-    def from_yaml(cls, loader, node):
-        """
-        Convert a representation node to a Python object.
-        """
-        return loader.construct_yaml_object(node, cls)
-
-    @classmethod
-    def to_yaml(cls, dumper, data):
-        """
-        Convert a Python object to a representation node.
-        """
-        return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
-                                            flow_style=cls.yaml_flow_style)
-
+# body extracted to main.py
+from .main import *
 
 def main():
     # No direct import of yaml in order not to pollute namespace.
diff --git a/py/yaml.py b/py/yaml.py
index 6974108..fadc78d 100644
--- a/py/yaml.py
+++ b/py/yaml.py
@@ -5,6 +5,8 @@ this is the source for the yaml utility
 """
 
 from __future__ import print_function
+from __future__ import absolute_import
+
 
 import sys
 import os
@@ -192,7 +194,7 @@ class YAML:
             default_flow_style=self._args.flow))
         return 1 if errors else 0
 
-    def to_html(self):
+    def to_htmltable(self):
         def vals(x):
             if isinstance(x, list):
                 return x
@@ -220,6 +222,12 @@ class YAML:
             return
         print(yaml_to_html(code, levels))
 
+    def from_html(self):
+        from .convert.html import HTML2YAML
+        h2y = HTML2YAML(self._args)
+        with open(self._args.file) as fp:
+            print(h2y(fp.read()))
+
     def round_trip(self):
         errors = 0
         warnings = 0
@@ -341,7 +349,7 @@ class YAML_Cmd(ProgramBase):
         return self._yaml.from_ini()
 
     @sub_parser(
-        aliases=['to-html'],
+        #aliases=['to-html'],
         help='convert YAML to html tables',
         description="""convert YAML to html tables. If hierarchy is two deep (
         sequence/mapping over sequence/mapping) this is mapped to one table
@@ -353,8 +361,24 @@ class YAML_Cmd(ProgramBase):
     )
     @option("--level", action='store_true', help="print # levels and exit")
     @option('file')
-    def html(self):
-        return self._yaml.to_html()
+    def htmltable(self):
+        return self._yaml.to_htmltable()
+
+    @sub_parser('from-html',
+        help='convert HTML to YAML',
+        description="""convert HTML to YAML. Tags become keys with as
+        value a list. The first item in the list is a key value pair with
+        key ".attribute" if attributes are available followed by tag and string
+        segment items. Lists with one item are by default flattened.
+        """,
+    )
+    @option("--no-body", action='store_true',
+            help="drop top level html and body from HTML code segments")
+    @option("--strip", action='store_true',
+            help="strip whitespace surrounding strings")
+    @option('file')
+    def from_html(self):
+        return self._yaml.from_html()
 
     if 'test' in sys.argv:
         @sub_parser(
diff --git a/setup.py b/setup.py
index 7020476..d576a66 100644
--- a/setup.py
+++ b/setup.py
@@ -70,6 +70,7 @@ if __name__ == '__main__':
     # whl files that take precedence on Linux over source with compilable C
     if '--universal' in sys.argv:
         Distribution.is_pure = lambda *args: True
+    Distribution.is_pure = lambda *args: False
 
 
 
diff --git a/test/test_utiltohtml.py b/test/test_utiltohtml.py
index 0fad033..316a620 100644
--- a/test/test_utiltohtml.py
+++ b/test/test_utiltohtml.py
@@ -11,7 +11,7 @@ from test_util import check_output, call_util
 
 
 def to_html(s, file_name, mp, td, options=None):
-    cmd = ['yaml', 'to-html', file_name]
+    cmd = ['yaml', 'htmltable', file_name]
     if options:
         cmd.extend(options)
     return call_util(s, file_name, cmd, mp, td)
diff --git a/tox.ini b/tox.ini
index 02c9109..be490d8 100644
--- a/tox.ini
+++ b/tox.ini
@@ -7,6 +7,7 @@ commands =
 deps =
     pytest
     configobj
+    beautifulsoup4
 
 [pytest]
 norecursedirs = test/lib .tox