Split modules into v1 and v2 packages

* Moved the old parser to the "v1" package
* Renamed "deserialize" to "v2"
* Use enum in constants to sanitize everything (seems to introduce some bugs)
* Split the old parser into different modules to reduce
  its size a bit (to be continued)
* Moved some v1 methods to the shared utils
* Updated the tests to use the v1 package (still failing)

See #32 and #34

Author: tcalmant

javaobj/__init__.py

@@ -34,7 +34,9 @@
 """
 
 # Imports giving access to what the javaobj module provides
-from javaobj.core import *
+from javaobj.v1.beans import *
+from javaobj.v1.core import *
+from javaobj.v1.transformers import *
 
 # ------------------------------------------------------------------------------
 

javaobj/constants.py

@@ -24,52 +24,142 @@
     limitations under the License.
 """
 
-STREAM_MAGIC = 0xACED
-STREAM_VERSION = 0x05
-
-BASE_REFERENCE_IDX = 0x7E0000
-
-TC_NULL = 0x70
-TC_REFERENCE = 0x71
-TC_CLASSDESC = 0x72
-TC_OBJECT = 0x73
-TC_STRING = 0x74
-TC_ARRAY = 0x75
-TC_CLASS = 0x76
-TC_BLOCKDATA = 0x77
-TC_ENDBLOCKDATA = 0x78
-TC_RESET = 0x79
-TC_BLOCKDATALONG = 0x7A
-TC_EXCEPTION = 0x7B
-TC_LONGSTRING = 0x7C
-TC_PROXYCLASSDESC = 0x7D
-TC_ENUM = 0x7E
-
-SC_WRITE_METHOD = 0x01  # if SC_SERIALIZABLE
-SC_BLOCK_DATA = 0x08  # if SC_EXTERNALIZABLE
-SC_SERIALIZABLE = 0x02
-SC_EXTERNALIZABLE = 0x04
-SC_ENUM = 0x10
-
-# type definition chars (typecode)
-TYPE_BYTE = ord("B")  # 0x42
-TYPE_CHAR = ord("C")  # 0x43
-TYPE_DOUBLE = ord("D")  # 0x44
-TYPE_FLOAT = ord("F")  # 0x46
-TYPE_INTEGER = ord("I")  # 0x49
-TYPE_LONG = ord("J")  # 0x4A
-TYPE_SHORT = ord("S")  # 0x53
-TYPE_BOOLEAN = ord("Z")  # 0x5A
-TYPE_OBJECT = ord("L")  # 0x4C
-TYPE_ARRAY = ord("[")  # 0x5B
+import enum
 
+
+__all__ = (
+    "PRIMITIVE_TYPES",
+    "StreamConstants",
+    "TerminalCode",
+    "ClassDescFlags",
+    "TypeCode",
+    "StreamCodeDebug",
+)
+
+
+class StreamConstants(enum.IntEnum):
+    """
+    Basic constants of the stream protocol
+    """
+
+    # Magic bytes of any serialized files
+    STREAM_MAGIC = 0xACED
+
+    # Only protocol version supported by javaobj
+    STREAM_VERSION = 0x05
+
+    # Base index for handles
+    BASE_REFERENCE_IDX = 0x7E0000
+
+
+class TerminalCode(enum.IntEnum):
+    """
+    Stream type Codes
+    """
+
+    TC_NULL = 0x70
+    TC_REFERENCE = 0x71
+    TC_CLASSDESC = 0x72
+    TC_OBJECT = 0x73
+    TC_STRING = 0x74
+    TC_ARRAY = 0x75
+    TC_CLASS = 0x76
+    TC_BLOCKDATA = 0x77
+    TC_ENDBLOCKDATA = 0x78
+    TC_RESET = 0x79
+    TC_BLOCKDATALONG = 0x7A
+    TC_EXCEPTION = 0x7B
+    TC_LONGSTRING = 0x7C
+    TC_PROXYCLASSDESC = 0x7D
+    TC_ENUM = 0x7E
+    # Ignore TC_MAX: we don't use it and it messes with TC_ENUM
+    # TC_MAX = 0x7E
+
+
+class ClassDescFlags(enum.IntFlag):
+    """
+    Class description flags
+    """
+
+    SC_WRITE_METHOD = 0x01  # if SC_SERIALIZABLE
+    SC_BLOCK_DATA = 0x08  # if SC_EXTERNALIZABLE
+    SC_SERIALIZABLE = 0x02
+    SC_EXTERNALIZABLE = 0x04
+    SC_ENUM = 0x10
+
+
+class TypeCode(enum.IntEnum):
+    """
+    Type definition chars (typecode)
+    """
+
+    # Primitive types
+    TYPE_BYTE = ord("B")  # 0x42
+    TYPE_CHAR = ord("C")  # 0x43
+    TYPE_DOUBLE = ord("D")  # 0x44
+    TYPE_FLOAT = ord("F")  # 0x46
+    TYPE_INTEGER = ord("I")  # 0x49
+    TYPE_LONG = ord("J")  # 0x4A
+    TYPE_SHORT = ord("S")  # 0x53
+    TYPE_BOOLEAN = ord("Z")  # 0x5A
+    # Object types
+    TYPE_OBJECT = ord("L")  # 0x4C
+    TYPE_ARRAY = ord("[")  # 0x5B
+
+
+# List of the types defined as primitive
 PRIMITIVE_TYPES = (
-    TYPE_BYTE,
-    TYPE_CHAR,
-    TYPE_DOUBLE,
-    TYPE_FLOAT,
-    TYPE_INTEGER,
-    TYPE_LONG,
-    TYPE_SHORT,
-    TYPE_BOOLEAN,
+    TypeCode.TYPE_BYTE,
+    TypeCode.TYPE_CHAR,
+    TypeCode.TYPE_DOUBLE,
+    TypeCode.TYPE_FLOAT,
+    TypeCode.TYPE_INTEGER,
+    TypeCode.TYPE_LONG,
+    TypeCode.TYPE_SHORT,
+    TypeCode.TYPE_BOOLEAN,
 )
+
+
+class StreamCodeDebug:
+    """
+    Codes utility methods
+    """
+
+    @staticmethod
+    def op_id(op_id):
+        # type: (int) -> str
+        """
+        Returns the name of the given OP Code
+        :param op_id: OP Code
+        :return: Name of the OP Code
+        """
+        try:
+            return TerminalCode(op_id).name
+        except ValueError:
+            return "<unknown TC:{0}>".format(op_id)
+
+    @staticmethod
+    def type_code(type_id):
+        # type: (int) -> str
+        """
+        Returns the name of the given Type Code
+        :param type_id: Type code
+        :return: Name of the type code
+        """
+        try:
+            return TypeCode(type_id).name
+        except ValueError:
+            return "<unknown TypeCode:{0}>".format(type_id)
+
+    @staticmethod
+    def flags(flags):
+        # type: (int) -> str
+        """
+        Returns the names of the class description flags found in the given
+        integer
+
+        :param flags: A class description flag entry
+        :return: The flags names as a single string
+        """
+        names = sorted(key.name for key in ClassDescFlags if key & flags)
+        return ", ".join(names)

javaobj/utils.py

@@ -27,12 +27,15 @@
     limitations under the License.
 """
 
+from __future__ import absolute_import
+
 # Standard library
 import logging
+import struct
 import sys
 
 # Modified UTF-8 parser
-from javaobj.modifiedutf8 import decode_modified_utf8
+from .modifiedutf8 import decode_modified_utf8
 
 # ------------------------------------------------------------------------------
 
@@ -71,6 +74,69 @@ def log_error(message, ident=0):
 
 # ------------------------------------------------------------------------------
 
+
+def read_struct(data, fmt_str):
+    # type: (bytes, str) -> list
+    """
+    Reads input bytes and extract the given structure. Returns both the read
+    elements and the remaining data
+
+    :param data: Data as bytes
+    :param fmt_str: Struct unpack format string
+    :return: A tuple (results as tuple, remaining data)
+    """
+    size = struct.calcsize(fmt_str)
+    return struct.unpack(fmt_str, data[:size]), data[size:]
+
+
+def read_string(data, length_fmt="H"):
+    # type: (bytes, str) -> UNICODE_TYPE
+    """
+    Reads a serialized string
+
+    :param data: Bytes where to read the string from
+    :param length_fmt: Structure format of the string length (H or Q)
+    :return: The deserialized string
+    """
+    (length,), data = read_struct(data, ">{0}".format(length_fmt))
+    ba, data = data[:length], data[length:]
+    return to_unicode(ba), data
+
+
+# ------------------------------------------------------------------------------
+
+
+def hexdump(src, start_offset=0, length=16):
+    # type: (str, int, int) -> str
+    """
+    Prepares an hexadecimal dump string
+
+    :param src: A string containing binary data
+    :param start_offset: The start offset of the source
+    :param length: Length of a dump line
+    :return: A dump string
+    """
+    FILTER = "".join(
+        (len(repr(chr(x))) == 3) and chr(x) or "." for x in range(256)
+    )
+    pattern = "{{0:04X}}   {{1:<{0}}}  {{2}}\n".format(length * 3)
+
+    # Convert raw data to str (Python 3 compatibility)
+    src = to_str(src, "latin-1")
+
+    result = []
+    for i in range(0, len(src), length):
+        s = src[i : i + length]
+        hexa = " ".join("{0:02X}".format(ord(x)) for x in s)
+        printable = s.translate(FILTER)
+        result.append(pattern.format(i + start_offset, hexa, printable))
+
+    return "".join(result)
+
+
+# ------------------------------------------------------------------------------
+
+
 if sys.version_info[0] >= 3:
     UNICODE_TYPE = str
     unicode_char = chr
@@ -118,8 +184,8 @@ def read_to_str(data):
 
 
 else:
-    UNICODE_TYPE = unicode
-    unicode_char = unichr
+    UNICODE_TYPE = unicode  # pylint:disable=undefined-variable
+    unicode_char = unichr  # pylint:disable=undefined-variable
 
     # Python 2 interpreter : str & unicode
     def to_str(data, encoding="UTF-8"):
@@ -149,7 +215,7 @@ def to_unicode(data, encoding="UTF-8"):
         :param encoding: The encoding of data
         :return: The corresponding string
         """
-        if type(data) is unicode:
+        if type(data) is UNICODE_TYPE:
             # Nothing to do
             return data
         try:

javaobj/v1/__init__.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+"""
+First version of the un-marshalling process of javaobj.
+
+:authors: Thomas Calmant
+:license: Apache License 2.0
+:version: 0.4.0
+:status: Alpha
+
+..
+
+    Copyright 2019 Thomas Calmant
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
+
+from . import beans, core, transformers
+from .core import (
+    load,
+    loads,
+    dumps,
+    JavaObjectMarshaller,
+    JavaObjectUnmarshaller,
+)
+from .transformers import DefaultObjectTransformer