pax_global_header 0000666 0000000 0000000 00000000064 15077515333 0014523 g ustar 00root root 0000000 0000000 52 comment=f6cb65e4301bc424a3de2c894f88c7537190abba
Serpent-serpent-1.42/ 0000775 0000000 0000000 00000000000 15077515333 0014547 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/.github/ 0000775 0000000 0000000 00000000000 15077515333 0016107 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/.github/workflows/ 0000775 0000000 0000000 00000000000 15077515333 0020144 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/.github/workflows/main-ci.yml 0000664 0000000 0000000 00000003351 15077515333 0022206 0 ustar 00root root 0000000 0000000
name: Run CI Tests
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
# allow manual trigger
workflow_dispatch:
jobs:
test-python:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
steps:
- name: Checkout source
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: ${{ matrix.python-version }}
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install pytz attrs pytest
- name: build and install
run:
pip install .
- name: Test with pytest
run: |
pytest -v tests
test-dotnet:
name: build, pack, test .Net
runs-on: ubuntu-latest
env:
DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
DOTNET_CLI_TELEMETRY_OPTOUT: true
DOTNET_NOLOGO: true
NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
steps:
- uses: actions/checkout@v4
- name: Install .Net
uses: actions/setup-dotnet@v4
with:
dotnet-version: '9.0.x'
- name: Restore, Build, test, and pack
uses: Elskom/build-dotnet@main
with:
SOLUTION_FILE_PATH: 'dotnet/Serpent'
TEST: true
PACK: true
PUSH: false
test-java:
name: build, test Java
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up JDK 8
uses: actions/setup-java@v4
with:
java-version: '8'
distribution: 'temurin'
- name: Build with Maven
run: mvn --batch-mode --update-snapshots -f java/pom.xml verify
Serpent-serpent-1.42/.gitignore 0000664 0000000 0000000 00000001514 15077515333 0016540 0 ustar 00root root 0000000 0000000 *.py[cod]
# C extensions
*.so
# Packages
*.egg[s]
*.egg-info
dist
build
eggs
parts
bin
target
var
sdist
develop-eggs
.installed.cfg
lib
lib64
.idea/
# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
[Bb]in/
[Oo]bj/
build
target
# mstest test results
TestResults
TEST-*.xml
TestResult.xml
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.sln.docstates
# Build results
[Dd]ebug/
[Rr]elease/
x64/
*_i.c
*_p.c
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.log
*.vspscc
*.vssscc
.builds
*.nupkg
# Installer logs
pip-log.txt
# Unit test / coverage reports
.coverage
.tox
nosetests.xml
# Translations
*.mo
# Mr Developer
.mr.developer.cfg
.project
.pydevproject
# java
*.class
Serpent-serpent-1.42/.pylintrc 0000664 0000000 0000000 00000000200 15077515333 0016404 0 ustar 00root root 0000000 0000000 [MESSAGES CONTROL]
disable=missing-docstring
[BASIC]
include-naming-hint=yes
max-line-length=120
good-names=i,j,k,x,y,z,t,ex,_
Serpent-serpent-1.42/LICENSE 0000664 0000000 0000000 00000002054 15077515333 0015555 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) by Irmen de Jong
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Serpent-serpent-1.42/MANIFEST.in 0000664 0000000 0000000 00000000523 15077515333 0016305 0 ustar 00root root 0000000 0000000 include LICENSE
include README.md
include tox.ini
include test-requirements.txt
recursive-include tests *
global-exclude */.svn/*
global-exclude */.idea/*
global-exclude *.class
global-exclude *.pyc
global-exclude *.pyo
global-exclude *.coverage
global-exclude .git
global-exclude .gitignore
global-exclude .tox
global-exclude __pycache__
Serpent-serpent-1.42/Makefile 0000664 0000000 0000000 00000002110 15077515333 0016201 0 ustar 00root root 0000000 0000000 .PHONY: all dist install upload clean test check lint
all:
@echo "targets include dist, upload, install, clean, test, lint"
dist:
python setup.py sdist bdist_wheel
@echo "Look in the dist/ directory"
upload: dist
@echo "Uploading to Pypi using twine...."
twine upload dist/*
install:
python setup.py install
test:
PYTHONPATH=. pytest -v tests
lint:
pycodestyle
clean:
@echo "Cleaning up..."
find . -name __pycache__ -print0 | xargs -0 rm -rf
find . -name \*_log -print0 | xargs -0 rm -f
find . -name \*.log -print0 | xargs -0 rm -f
find . -name \*.pyo -print0 | xargs -0 rm -f
find . -name \*.pyc -print0 | xargs -0 rm -f
find . -name \*.class -print0 | xargs -0 rm -f
find . -name \*.DS_Store -print0 | xargs -0 rm -f
find . -name TEST-*.xml -print0 | xargs -0 rm -f
find . -name TestResult.xml -print0 | xargs -0 rm -f
rm -f MANIFEST
rm -rf build
rm -rf dotnet/Serpent/obj dotnet/Serpent.Test/obj
rm -rf dotnet/Serpent/bin dotnet/Serpent.Test/bin
find . -name '.#*' -print0 | xargs -0 rm -f
find . -name '#*#' -print0 | xargs -0 rm -f
@echo "clean!"
Serpent-serpent-1.42/README.md 0000664 0000000 0000000 00000007242 15077515333 0016033 0 ustar 00root root 0000000 0000000 Serpent serialization library (Python/.NET/Java)
================================================
[](https://pypi.python.org/pypi/Serpent/)
[](http://search.maven.org/#search|ga|1|g%3A%22net.razorvine%22%20AND%20a%3A%22serpent%22)
[](https://www.nuget.org/packages/Razorvine.Serpent/)
[](https://anaconda.org/conda-forge/serpent)
Serpent provides ast.literal_eval() compatible object tree serialization.
It serializes an object tree into bytes (utf-8 encoded string) that can be decoded and then
passed as-is to ast.literal_eval() to rebuild it as the original object tree.
As such it is safe to send serpent data to other machines over the network for instance
(because only 'safe' literals are encoded).
More info on Pypi: https://pypi.python.org/pypi/serpent
Source code is on Github: https://github.com/irmen/Serpent
Copyright by Irmen de Jong (irmen@razorvine.net)
This software is released under the MIT software license.
This license, including disclaimer, is available in the 'LICENSE' file.
PYTHON
------
Compatible with Python 3.7+ (use a serpent version before 1.30 for Python 2.7 support)
It can be found on Pypi as 'serpent': https://pypi.python.org/pypi/serpent
Example usage can be found in ./tests/example.py
C#/.NET
-------
Package is available on www.nuget.org as 'Razorvine.Serpent'.
Full source code can be found in ./dotnet/ directory.
Example usage can be found in ./dotnet/Serpent.Test/Example.cs
The project is a dotnet core project targeting NetStandard 2.0.
JAVA
----
Maven-artefact is available on maven central, groupid 'net.razorvine' artifactid 'serpent'.
Full source code can be found in ./java/ directory.
Example usage can be found in ./java/test/SerpentExample.java
Versions before 1.23 require Java 7 or Java 8 (JDK 1.7 or 1.8) to compile and run.
Version 1.23 and later require Java 8 (JDK 1.8) at a minimum to compile and run.
SOME MORE DETAILS
-----------------
Serpent handles several special Python types to make life easier:
- bytes, bytearrays, memoryview --> string, base-64 (or bytes-literal if selected)
(you'll have to manually un-base64. Can use serpent.tobytes function for that.)
- uuid.UUID, datetime.{datetime, date, time, timespan} --> appropriate string/number
- decimal.Decimal --> string (to not lose precision)
- array.array typecode 'u' --> string
- array.array other typecode --> list
- Exception --> dict with some fields of the exception (message, args)
- collections module types --> mostly equivalent primitive types or dict
- enums --> the value of the enum
- namedtuple --> treated as just a tuple
- attr dataclasses and python 3.7 native dataclasses: treated as just a class, so will become a dict
- all other types --> dict with the ``__getstate__`` or ``vars()`` of the object, and a ``__class__`` element with the name of the class
Notes:
The serializer is not thread-safe. Make sure you're not making changes
to the object tree that is being serialized, and don't use the same
serializer in different threads.
Because the serialized format is just valid Python source code, it can
contain comments. Serpent does not add comments by itself apart from the
single header line.
Floats +inf and -inf are handled via a trick, Float 'nan' cannot be handled
and is represented by the special value: ``{'__class__':'float','value':'nan'}``
We chose not to encode it as just the string 'NaN' because that could cause
memory issues when used in multiplications.
Serpent-serpent-1.42/dotnet/ 0000775 0000000 0000000 00000000000 15077515333 0016044 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/dotnet/Serpent/ 0000775 0000000 0000000 00000000000 15077515333 0017464 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/ 0000775 0000000 0000000 00000000000 15077515333 0023062 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/Ast.cs 0000664 0000000 0000000 00000022414 15077515333 0024143 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
using System.Linq;
// ReSharper disable MemberCanBeProtected.Global
// ReSharper disable UnusedParameter.Global
namespace Razorvine.Serpent
{
///
/// Abstract syntax tree for the literal expression. This is what the parser returns.
///
public class Ast
{
public INode Root;
public override string ToString()
{
return "# serpent utf-8 .net\n" + Root.ToString();
}
///
/// Get the actual parsed data as C# object(s).
///
public object GetData()
{
var visitor = new ObjectifyVisitor();
Root.Accept(visitor);
return visitor.GetObject();
}
///
/// Get the actual parsed data as C# object(s).
///
/// dictToInstance)
{
var visitor = new ObjectifyVisitor(dictToInstance);
Root.Accept(visitor);
return visitor.GetObject();
}
public interface INodeVisitor
{
void Visit(ComplexNumberNode complex);
void Visit(DictNode dict);
void Visit(ListNode list);
void Visit(NoneNode none);
void Visit(IntegerNode value);
void Visit(LongNode value);
void Visit(DoubleNode value);
void Visit(BooleanNode value);
void Visit(StringNode value);
void Visit(BytesNode value);
void Visit(DecimalNode value);
void Visit(SetNode setnode);
void Visit(TupleNode tuple);
}
///
/// Visitor pattern: visit all nodes in the Ast with the given visitor.
///
public void Accept(INodeVisitor visitor)
{
Root.Accept(visitor);
}
[SuppressMessage("ReSharper", "UnusedMember.Global")]
public interface INode
{
string ToString();
bool Equals(object obj);
void Accept(INodeVisitor visitor);
}
[SuppressMessage("ReSharper", "UnusedMember.Global")]
public abstract class PrimitiveNode : INode, IComparable>
{
public readonly T Value;
protected PrimitiveNode(T value)
{
Value=value;
}
public override int GetHashCode()
{
return Value!=null? Value.GetHashCode() : 0;
}
public override bool Equals(object obj)
{
var node = obj as PrimitiveNode;
return node != null && Equals(Value, node.Value);
}
public bool Equals(PrimitiveNode other)
{
return Equals(Value, other.Value);
}
public int CompareTo(PrimitiveNode other)
{
if (Value is IComparable cv && other.Value is IComparable otherCv)
return cv.CompareTo(otherCv);
return 0;
}
public override string ToString()
{
if(Value is string s)
{
var sb=new StringBuilder();
sb.Append("'");
foreach(char c in s)
{
switch(c)
{
case '\\':
sb.Append(@"\\");
break;
case '\'':
sb.Append("\\'");
break;
case '\a':
sb.Append("\\a");
break;
case '\b':
sb.Append("\\b");
break;
case '\f':
sb.Append("\\f");
break;
case '\n':
sb.Append("\\n");
break;
case '\r':
sb.Append("\\r");
break;
case '\t':
sb.Append("\\t");
break;
case '\v':
sb.Append("\\v");
break;
default:
sb.Append(c);
break;
}
}
sb.Append("'");
return sb.ToString();
}
if (Value is not double && Value is not float)
return Value.ToString();
var d = Convert.ToString(Value, CultureInfo.InvariantCulture);
if (d == null)
throw new ParseException("ast value is null");
if(d.IndexOfAny(new [] {'.', 'e', 'E'})<=0)
d+=".0";
return d;
}
public abstract void Accept(INodeVisitor visitor);
}
public class IntegerNode: PrimitiveNode
{
public IntegerNode(int value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class LongNode: PrimitiveNode
{
public LongNode(long value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class DoubleNode: PrimitiveNode
{
public DoubleNode(double value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class StringNode: PrimitiveNode
{
public StringNode(string value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class BytesNode: PrimitiveNode
{
public BytesNode(byte[] value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class DecimalNode: PrimitiveNode
{
public DecimalNode(decimal value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class BooleanNode: PrimitiveNode
{
public BooleanNode(bool value) : base(value)
{
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public struct ComplexNumberNode: INode
{
public double Real;
public double Imaginary;
public void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
public override string ToString()
{
string strReal = Real.ToString(CultureInfo.InvariantCulture);
string strImag = Imaginary.ToString(CultureInfo.InvariantCulture);
return string.Format(Imaginary>=0 ? "({0}+{1}j)" : "({0}{1}j)", strReal, strImag);
}
}
public class NoneNode: INode
{
public static readonly NoneNode Instance = new();
private NoneNode()
{
}
public override string ToString()
{
return "None";
}
public void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public abstract class SequenceNode: INode
{
public List Elements = new();
public virtual char OpenChar => '?';
public virtual char CloseChar => '?';
public override int GetHashCode()
{
int hashCode = 0;
unchecked
{
// ReSharper disable once NonReadonlyMemberInGetHashCode
hashCode += Elements.Sum(elt => 1000000007 * elt.GetHashCode());
}
return hashCode;
}
public override bool Equals(object obj)
{
var other = obj as SequenceNode;
return other != null && Elements.SequenceEqual(other.Elements);
}
public override string ToString()
{
var sb=new StringBuilder();
sb.Append(OpenChar);
if(Elements != null)
{
foreach(var elt in Elements)
{
sb.Append(elt.ToString());
sb.Append(',');
}
}
// ReSharper disable once PossibleNullReferenceException
if(Elements.Count>0)
sb.Remove(sb.Length-1, 1); // remove last comma
sb.Append(CloseChar);
return sb.ToString();
}
public abstract void Accept(INodeVisitor visitor);
}
public class TupleNode : SequenceNode
{
public override string ToString()
{
var sb=new StringBuilder();
sb.Append('(');
if(Elements != null)
{
foreach(var elt in Elements)
{
sb.Append(elt.ToString());
sb.Append(",");
}
if(Elements.Count>1)
sb.Remove(sb.Length-1, 1);
}
sb.Append(')');
return sb.ToString();
}
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class ListNode : SequenceNode
{
public override char OpenChar => '[';
public override char CloseChar => ']';
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public abstract class UnorderedSequenceNode : SequenceNode
{
public override bool Equals(object obj)
{
if(obj is not UnorderedSequenceNode node)
return false;
var set1 = ElementsAsSet();
var set2 = node.ElementsAsSet();
return set1.SetEquals(set2);
}
public override int GetHashCode()
{
return ElementsAsSet().GetHashCode();
}
public HashSet ElementsAsSet()
{
var set = new HashSet();
foreach(var kv in Elements)
set.Add(kv);
return set;
}
}
public class SetNode : UnorderedSequenceNode
{
public override char OpenChar => '{';
public override char CloseChar => '}';
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public class DictNode : UnorderedSequenceNode
{
public override char OpenChar => '{';
public override char CloseChar => '}';
public override void Accept(INodeVisitor visitor)
{
visitor.Visit(this);
}
}
public struct KeyValueNode : INode
{
public INode Key;
public INode Value;
public KeyValueNode(INode key, INode value)
{
Key = key;
Value = value;
}
public override string ToString()
{
return $"{Key}:{Value}";
}
public void Accept(INodeVisitor visitor)
{
throw new NotSupportedException("don't visit a keyvaluenode");
}
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/ComplexNumber.cs 0000664 0000000 0000000 00000004160 15077515333 0026172 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
// ReSharper disable UnusedMember.Global
namespace Razorvine.Serpent
{
///
/// A Complex Number class.
///
public class ComplexNumber {
public double Real {get; }
public double Imaginary {get; }
public ComplexNumber(double r, double i) {
Real=r;
Imaginary=i;
}
public override string ToString()
{
var sb=new StringBuilder();
sb.Append(Real);
if(Imaginary>0)
sb.Append('+');
return sb.Append(Imaginary).Append('i').ToString();
}
public double Magnitude() {
return Math.Sqrt(Real * Real + Imaginary * Imaginary);
}
public static ComplexNumber operator +(ComplexNumber c1, ComplexNumber c2) {
return new ComplexNumber(c1.Real + c2.Real, c1.Imaginary + c2.Imaginary);
}
public static ComplexNumber operator -(ComplexNumber c1, ComplexNumber c2) {
return new ComplexNumber(c1.Real - c2.Real, c1.Imaginary - c2.Imaginary);
}
public static ComplexNumber operator *(ComplexNumber c1, ComplexNumber c2) {
return new ComplexNumber(c1.Real * c2.Real - c1.Imaginary * c2.Imaginary, c1.Real * c2.Imaginary + c1.Imaginary * c2.Real);
}
public static ComplexNumber operator /(ComplexNumber c1, ComplexNumber c2) {
return new ComplexNumber((c1.Real * c2.Real + c1.Imaginary * c2.Imaginary) / (c2.Real * c2.Real + c2.Imaginary * c2.Imaginary), (c1.Imaginary * c2.Real - c1.Real * c2.Imaginary)
/ (c2.Real * c2.Real + c2.Imaginary * c2.Imaginary));
}
#region Equals and GetHashCode implementation
public override bool Equals(object obj)
{
if(obj is not ComplexNumber other)
return false;
// ReSharper disable CompareOfFloatsByEqualityOperator
return Real==other.Real && Imaginary==other.Imaginary;
}
public override int GetHashCode()
{
return Real.GetHashCode() ^ Imaginary.GetHashCode();
}
public static bool operator ==(ComplexNumber lhs, ComplexNumber rhs)
{
if (ReferenceEquals(lhs, rhs))
return true;
if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null))
return false;
return lhs.Equals(rhs);
}
public static bool operator !=(ComplexNumber lhs, ComplexNumber rhs)
{
return !(lhs == rhs);
}
#endregion
}
} Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/DebugVisitor.cs 0000664 0000000 0000000 00000005304 15077515333 0026021 0 ustar 00root root 0000000 0000000 using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;
namespace Razorvine.Serpent
{
///
/// Ast nodevisitor that prints out the Ast as a string for debugging purposes
///
[SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
public class DebugVisitor: Ast.INodeVisitor
{
private readonly StringBuilder _result = new();
private int _indent;
///
/// Get the debug string representation result.
///
public override string ToString()
{
return _result.ToString();
}
protected void Indent()
{
for(int i=0; i<_indent; ++i)
_result.Append(" ");
}
public void Visit(Ast.ComplexNumberNode complex)
{
_result.AppendFormat("complexnumber ({0}r,{1}i)", complex.Real, complex.Imaginary);
}
public void Visit(Ast.DictNode dict)
{
_result.AppendLine("(dict");
_indent++;
foreach (var kv in dict.Elements.Cast())
{
Indent();
kv.Key.Accept(this);
_result.Append(" = ");
kv.Value.Accept(this);
_result.AppendLine(",");
}
_indent--;
Indent();
_result.Append(")");
}
public void Visit(Ast.ListNode list)
{
_result.AppendLine("(list");
_indent++;
foreach(var node in list.Elements)
{
Indent();
node.Accept(this);
_result.AppendLine(",");
}
_indent--;
Indent();
_result.Append(")");
}
public void Visit(Ast.NoneNode none)
{
_result.Append("None");
}
public void Visit(Ast.IntegerNode value)
{
_result.AppendFormat("int {0}", value.Value);
}
public void Visit(Ast.LongNode value)
{
_result.AppendFormat("long {0}", value.Value);
}
public void Visit(Ast.DoubleNode value)
{
_result.AppendFormat("double {0}", value.Value);
}
public void Visit(Ast.BooleanNode value)
{
_result.AppendFormat("bool {0}", value.Value);
}
public void Visit(Ast.StringNode value)
{
_result.AppendFormat("string '{0}'", value.Value);
}
public void Visit(Ast.BytesNode value)
{
_result.AppendFormat("bytes {0}", value.Value);
}
public void Visit(Ast.DecimalNode value)
{
_result.AppendFormat("decimal {0}", value.Value);
}
public void Visit(Ast.SetNode setnode)
{
_result.AppendLine("(set");
_indent++;
foreach(var node in setnode.Elements)
{
Indent();
node.Accept(this);
_result.AppendLine(",");
}
_indent--;
Indent();
_result.Append(")");
}
public void Visit(Ast.TupleNode tuple)
{
_result.AppendLine("(tuple");
_indent++;
foreach(var node in tuple.Elements)
{
Indent();
node.Accept(this);
_result.AppendLine(",");
}
_indent--;
Indent();
_result.Append(")");
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/ObjectifyVisitor.cs 0000664 0000000 0000000 00000006245 15077515333 0026716 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
namespace Razorvine.Serpent
{
///
/// Ast nodevisitor that turns the AST into actual .NET objects (array, int, IDictionary, string, etc...)
///
public class ObjectifyVisitor: Ast.INodeVisitor
{
private readonly Stack _generated = new();
private readonly Func _dictToInstance;
///
/// Create the visitor that converts AST in actual objects.
///
public ObjectifyVisitor()
{
}
///
/// Create the visitor that converts AST in actual objects.
///
/// dictToInstance)
{
_dictToInstance = dictToInstance;
}
///
/// get the resulting object tree.
///
public object GetObject()
{
return _generated.Pop();
}
public void Visit(Ast.ComplexNumberNode complex)
{
_generated.Push(new ComplexNumber(complex.Real, complex.Imaginary));
}
public void Visit(Ast.DictNode dict)
{
IDictionary obj = new Dictionary(dict.Elements.Count);
foreach (var kv in dict.Elements.Cast())
{
kv.Key.Accept(this);
object key = _generated.Pop();
kv.Value.Accept(this);
object value = _generated.Pop();
obj[key] = value;
}
if(_dictToInstance==null || !obj.Contains("__class__"))
{
_generated.Push(obj);
}
else
{
object result = _dictToInstance(obj);
_generated.Push(result ?? obj);
}
}
public void Visit(Ast.ListNode list)
{
IList obj = new List(list.Elements.Count);
foreach(var node in list.Elements)
{
node.Accept(this);
obj.Add(_generated.Pop());
}
_generated.Push(obj);
}
public void Visit(Ast.NoneNode none)
{
_generated.Push(null);
}
public void Visit(Ast.IntegerNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.LongNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.DoubleNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.BooleanNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.StringNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.BytesNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.DecimalNode value)
{
_generated.Push(value.Value);
}
public void Visit(Ast.SetNode setnode)
{
var obj = new HashSet();
foreach(var node in setnode.Elements)
{
node.Accept(this);
obj.Add(_generated.Pop());
}
_generated.Push(obj);
}
public void Visit(Ast.TupleNode tuple)
{
var array = new object[tuple.Elements.Count];
int index=0;
foreach(var node in tuple.Elements)
{
node.Accept(this);
array[index++] = _generated.Pop();
}
_generated.Push(array);
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/ParseException.cs 0000664 0000000 0000000 00000000644 15077515333 0026346 0 ustar 00root root 0000000 0000000 using System;
// ReSharper disable once UnusedMember.Global
namespace Razorvine.Serpent
{
///
/// A problem occurred during parsing.
///
public class ParseException : Exception
{
public ParseException()
{
}
public ParseException(string message) : base(message)
{
}
public ParseException(string message, Exception innerException) : base(message, innerException)
{
}
}
} Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/Parser.cs 0000664 0000000 0000000 00000046035 15077515333 0024655 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
namespace Razorvine.Serpent
{
///
/// Parse a Python literal into an Ast (abstract syntax tree).
///
[SuppressMessage("ReSharper", "MemberCanBeMadeStatic.Local")]
public class Parser
{
///
/// Parse from a byte array (containing utf-8 encoded string with the Python literal expression in it)
///
public Ast Parse(byte[] serialized)
{
return Parse(Encoding.UTF8.GetString(serialized, 0, serialized.Length));
}
///
/// Parse from a string with the Python literal expression
///
public Ast Parse(string expression)
{
var ast=new Ast();
if(string.IsNullOrEmpty(expression))
return ast;
var sr = new SeekableStringReader(expression);
if(sr.Peek()=='#')
sr.ReadUntil('\n'); // skip comment line
try {
ast.Root = ParseExpr(sr);
sr.SkipWhitespace();
if(sr.HasMore())
throw new ParseException("garbage at end of expression");
return ast;
} catch (ParseException x) {
string faultLocation = ExtractFaultLocation(sr);
throw new ParseException(x.Message + " (at position "+sr.Bookmark()+"; '"+faultLocation+"')", x);
}
}
private string ExtractFaultLocation(SeekableStringReader sr)
{
sr.Context(-1, 20, out string left, out string right);
return $"...{left}>>><<<{right}...";
}
private Ast.INode ParseExpr(SeekableStringReader sr)
{
// expr = [ ] single | compound [ ] .
sr.SkipWhitespace();
if(!sr.HasMore())
throw new ParseException("unexpected end of line, missing expression or close/open character");
char c = sr.Peek();
Ast.INode node;
if(c=='{' || c=='[' || c=='(')
node = ParseCompound(sr);
else
node = ParseSingle(sr);
sr.SkipWhitespace();
return node;
}
private Ast.INode ParseCompound(SeekableStringReader sr)
{
// compound = tuple | dict | list | set .
sr.SkipWhitespace();
switch(sr.Peek())
{
case '[':
return ParseList(sr);
case '{':
{
int bm = sr.Bookmark();
try {
return ParseSet(sr);
} catch(ParseException) {
sr.FlipBack(bm);
return ParseDict(sr);
}
}
case '(':
// tricky case here, it can be a tuple but also a complex number:
// if the last character before the closing parenthesis is a 'j', it is a complex number
{
int bm = sr.Bookmark();
string betweenparens = sr.ReadUntil(')', '\n').TrimEnd();
sr.FlipBack(bm);
return betweenparens.EndsWith("j") ? ParseComplex(sr) : ParseTuple(sr);
}
default:
throw new ParseException("invalid sequencetype char");
}
}
private Ast.TupleNode ParseTuple(SeekableStringReader sr)
{
//tuple = tuple_empty | tuple_one | tuple_more
//tuple_empty = '()' .
//tuple_one = '(' expr ',' ')' .
//tuple_more = '(' expr_list trailing_comma ')' .
// trailing_comma = '' | ',' .
sr.Read(); // (
sr.SkipWhitespace();
var tuple = new Ast.TupleNode();
if(sr.Peek() == ')')
{
sr.Read();
return tuple; // empty tuple
}
var firstelement = ParseExpr(sr);
if(sr.Peek() == ',')
{
sr.Read();
sr.SkipWhitespace();
if(sr.Read() == ')')
{
// tuple with just a single element
tuple.Elements.Add(firstelement);
return tuple;
}
sr.Rewind(1); // undo the thing that wasn't a )
}
tuple.Elements = ParseExprList(sr);
tuple.Elements.Insert(0, firstelement);
// handle trailing comma if present
sr.SkipWhitespace();
if(!sr.HasMore())
throw new ParseException("missing ')'");
if(sr.Peek() == ',')
sr.Read();
if(!sr.HasMore())
throw new ParseException("missing ')'");
char closechar = sr.Read();
if(closechar==',')
closechar = sr.Read();
if(closechar!=')')
throw new ParseException("expected ')'");
return tuple;
}
private List ParseExprList(SeekableStringReader sr)
{
//expr_list = expr { ',' expr } .
var exprList = new List {ParseExpr(sr)};
while(sr.HasMore() && sr.Peek() == ',')
{
sr.Read();
try {
exprList.Add(ParseExpr(sr));
} catch (ParseException) {
sr.Rewind(1);
break;
}
}
return exprList;
}
private List ParseKeyValueList(SeekableStringReader sr)
{
//keyvalue_list = keyvalue { ',' keyvalue } .
var kvs = new List {ParseKeyValue(sr)};
while(sr.HasMore() && sr.Peek()==',')
{
sr.Read();
try {
kvs.Add(ParseKeyValue(sr));
} catch (ParseException) {
sr.Rewind(1);
break;
}
}
return kvs;
}
private Ast.KeyValueNode ParseKeyValue(SeekableStringReader sr)
{
//keyvalue = expr ':' expr .
var key = ParseExpr(sr);
if (!sr.HasMore() || sr.Peek() != ':') throw new ParseException("expected ':'");
sr.Read(); // :
var value = ParseExpr(sr);
return new Ast.KeyValueNode
{
Key = key,
Value = value
};
}
private Ast.SetNode ParseSet(SeekableStringReader sr)
{
// set = '{' expr_list trailing_comma '}' .
// trailing_comma = '' | ',' .
sr.Read(); // {
sr.SkipWhitespace();
var setnode = new Ast.SetNode();
var elts = ParseExprList(sr);
// handle trailing comma if present
sr.SkipWhitespace();
if(!sr.HasMore())
throw new ParseException("missing '}'");
if(sr.Peek() == ',')
sr.Read();
if(!sr.HasMore())
throw new ParseException("missing '}'");
char closechar = sr.Read();
if(closechar!='}')
throw new ParseException("expected '}'");
// make sure it has set semantics (remove duplicate elements)
var h = new HashSet(elts);
setnode.Elements = new List(h);
return setnode;
}
private Ast.ListNode ParseList(SeekableStringReader sr)
{
// list = list_empty | list_nonempty .
// list_empty = '[]' .
// list_nonempty = '[' expr_list trailing_comma ']' .
// trailing_comma = '' | ',' .
sr.Read(); // [
sr.SkipWhitespace();
var list = new Ast.ListNode();
if(sr.Peek() == ']')
{
sr.Read();
return list; // empty list
}
list.Elements = ParseExprList(sr);
// handle trailing comma if present
sr.SkipWhitespace();
if(!sr.HasMore())
throw new ParseException("missing ']'");
if(sr.Peek() == ',')
sr.Read();
if(!sr.HasMore())
throw new ParseException("missing ']'");
char closechar = sr.Read();
if(closechar!=']')
throw new ParseException("expected ']'");
return list;
}
private Ast.INode ParseDict(SeekableStringReader sr)
{
//dict = '{' keyvalue_list trailing_comma '}' .
//keyvalue_list = keyvalue { ',' keyvalue } .
//keyvalue = expr ':' expr .
// trailing_comma = '' | ',' .
sr.Read(); // {
sr.SkipWhitespace();
var dict = new Ast.DictNode();
if(sr.Peek() == '}')
{
sr.Read();
return dict; // empty dict
}
var elts = ParseKeyValueList(sr);
// handle trailing comma if present
sr.SkipWhitespace();
if(!sr.HasMore())
throw new ParseException("missing '}'");
if(sr.Peek() == ',')
sr.Read();
if(!sr.HasMore())
throw new ParseException("missing '}'");
char closechar = sr.Read();
if(closechar!='}')
throw new ParseException("expected '}'");
// make sure it has dict semantics (remove duplicate keys)
var fixedDict = new Dictionary(elts.Count);
foreach (var kv in elts.Cast())
{
fixedDict[kv.Key] = kv.Value;
}
foreach(var kv in fixedDict)
{
dict.Elements.Add(new Ast.KeyValueNode
{
Key=kv.Key,
Value=kv.Value
});
}
// SPECIAL CASE: {'__class__':'float','value':'nan'} ---> Double.NaN
if (dict.Elements.Count != 2) return dict;
if (!dict.Elements.Contains(new Ast.KeyValueNode(new Ast.StringNode("__class__"),
new Ast.StringNode("float")))) return dict;
if(dict.Elements.Contains(new Ast.KeyValueNode(new Ast.StringNode("value"), new Ast.StringNode("nan")))) {
return new Ast.DoubleNode(double.NaN);
}
return dict;
}
public Ast.INode ParseSingle(SeekableStringReader sr)
{
// single = int | float | complex | string | bool | none .
sr.SkipWhitespace();
switch(sr.Peek())
{
case 'N':
return ParseNone(sr);
case 'T':
case 'F':
return ParseBool(sr);
case '\'':
case '"':
return ParseString(sr);
case 'b':
return ParseBytes(sr);
}
// int or float or complex.
int bookmark = sr.Bookmark();
try {
return ParseComplex(sr);
} catch (ParseException) {
sr.FlipBack(bookmark);
try {
return ParseFloat(sr);
} catch (ParseException) {
sr.FlipBack(bookmark);
return ParseInt(sr);
}
}
}
private const string IntegerChars = "-0123456789";
private const string FloatChars = "-+.eE0123456789";
private Ast.INode ParseInt(SeekableStringReader sr)
{
// int = ['-'] digitnonzero {digit} .
string numberstr = sr.ReadWhile(IntegerChars);
if(numberstr.Length==0)
throw new ParseException("invalid int character");
try {
try {
return new Ast.IntegerNode(int.Parse(numberstr));
} catch (OverflowException) {
// try long
try {
return new Ast.LongNode(long.Parse(numberstr));
} catch (OverflowException) {
// try decimal, but it can still overflow because it's not arbitrary precision
try {
return new Ast.DecimalNode(decimal.Parse(numberstr));
} catch (OverflowException) {
throw new ParseException("number too large");
}
}
}
} catch (FormatException x) {
throw new ParseException("invalid integer format", x);
}
}
private Ast.PrimitiveNode ParseFloat(SeekableStringReader sr)
{
string numberstr = sr.ReadWhile(FloatChars);
if(numberstr.Length==0)
throw new ParseException("invalid float character");
// little bit of a hack:
// if the number doesn't contain a decimal point and no 'e'/'E', it is an integer instead.
// in that case, we need to reject it as a float.
if(numberstr.IndexOfAny(new [] {'.','e','E'}) < 0)
throw new ParseException("number is not a float (might be an integer though)");
try {
return new Ast.DoubleNode(ParseDouble(numberstr));
} catch (FormatException x) {
throw new ParseException("invalid float format", x);
}
}
private Ast.ComplexNumberNode ParseComplex(SeekableStringReader sr)
{
//complex = complextuple | imaginary .
//imaginary = ['+' | '-' ] ( float | int ) 'j' .
//complextuple = '(' ( float | int ) imaginary ')' .
if(sr.Peek()=='(')
{
// complextuple
sr.Read(); // (
string numberstr;
if(sr.Peek()=='-' || sr.Peek()=='+')
{
// starts with a sign, read that first otherwise the readuntil will return immediately
numberstr = sr.Read(1) + sr.ReadUntil('+', '-');
}
else
{
numberstr = sr.ReadUntil('+', '-');
}
sr.Rewind(1); // rewind the +/-
// because we're a bit more cautious here with reading chars than in the float parser,
// it can be that the parser now stopped directly after the 'e' in a number like "3.14e+20".
// ("3.14e20" is fine) So, check if the last char is 'e' and if so, continue reading 0..9.
if(numberstr.EndsWith("e", StringComparison.InvariantCultureIgnoreCase)) {
// if the next symbol is + or -, accept it, then read the exponent integer
if(sr.Peek()=='-' || sr.Peek()=='+')
numberstr+=sr.Read(1);
numberstr += sr.ReadWhile("0123456789");
}
sr.SkipWhitespace();
double realpart;
try {
realpart = ParseDouble(numberstr);
} catch (FormatException x) {
throw new ParseException("invalid float format", x);
}
double imaginarypart = ParseImaginaryPart(sr);
if(sr.Read()!=')')
throw new ParseException("expected ) to end a complex number");
return new Ast.ComplexNumberNode
{
Real = realpart,
Imaginary = imaginarypart
};
}
// imaginary
double imag = ParseImaginaryPart(sr);
return new Ast.ComplexNumberNode
{
Real=0,
Imaginary=imag
};
}
private double ParseImaginaryPart(SeekableStringReader sr)
{
//imaginary = ['+' | '-' ] ( float | int ) 'j' .
// string numberstr = sr.ReadUntil('j');
// try {
// return this.ParseDouble(numberstr);
// } catch(FormatException x) {
// throw new ParseException("invalid float format", x);
// }
if(!sr.HasMore())
throw new ParseException("unexpected end of input string");
char signOrDigit = sr.Peek();
if(signOrDigit=='+')
sr.Read(); // skip the '+'
// now an int or float follows.
double doubleValue;
int bookmark = sr.Bookmark();
try {
doubleValue = ParseFloat(sr).Value;
} catch (ParseException) {
sr.FlipBack(bookmark);
var integerPart = ParseInt(sr);
if (integerPart is Ast.IntegerNode integerNode)
doubleValue = integerNode.Value;
else
{
switch (integerPart)
{
case Ast.LongNode longNode:
doubleValue = longNode.Value;
break;
case Ast.DecimalNode decimalNode:
doubleValue = Convert.ToDouble(decimalNode.Value);
break;
default:
throw new ParseException("not an integer for the imaginary part");
}
}
}
// now a 'j' must follow!
sr.SkipWhitespace();
try {
if(sr.Read()!='j')
throw new ParseException("not an imaginary part");
} catch (IndexOutOfRangeException) {
throw new ParseException("not an imaginary part");
}
return doubleValue;
}
private Ast.PrimitiveNode ParseString(SeekableStringReader sr)
{
char quotechar = sr.Read(); // ' or "
var sb = new StringBuilder(10);
while(sr.HasMore())
{
char c = sr.Read();
if(c=='\\')
{
// backslash unescape
c = sr.Read();
switch(c)
{
case '\\':
sb.Append('\\');
break;
case '\'':
sb.Append('\'');
break;
case '"':
sb.Append('"');
break;
case 'a':
sb.Append('\a');
break;
case 'b':
sb.Append('\b');
break;
case 'f':
sb.Append('\f');
break;
case 'n':
sb.Append('\n');
break;
case 'r':
sb.Append('\r');
break;
case 't':
sb.Append('\t');
break;
case 'v':
sb.Append('\v');
break;
case 'x': // "\x00"
sb.Append((char)int.Parse(sr.Read(2), NumberStyles.HexNumber));
break;
case 'u': // "\u0000"
sb.Append((char)int.Parse(sr.Read(4), NumberStyles.HexNumber));
break;
default:
sb.Append(c);
break;
}
}
else if(c==quotechar)
{
// end of string
return new Ast.StringNode(sb.ToString());
}
else
{
sb.Append(c);
}
}
throw new ParseException("unclosed string");
}
private Ast.PrimitiveNode ParseBytes(SeekableStringReader sr)
{
sr.Read(); // skip the 'b'
char quotechar = sr.Read(); // ' or "
var bytes = new List();
while(sr.HasMore())
{
char c = sr.Read();
if(c=='\\')
{
// backslash unescape
c = sr.Read();
switch(c)
{
case '\\':
bytes.Add((byte)'\\');
break;
case '\'':
bytes.Add((byte)'\'');
break;
case '"':
bytes.Add((byte)'"');
break;
case 'a':
bytes.Add((byte)'\a');
break;
case 'b':
bytes.Add((byte)'\b');
break;
case 'f':
bytes.Add((byte)'\f');
break;
case 'n':
bytes.Add((byte)'\n');
break;
case 'r':
bytes.Add((byte)'\r');
break;
case 't':
bytes.Add((byte)'\t');
break;
case 'v':
bytes.Add((byte)'\v');
break;
case 'x': // "\x00"
bytes.Add(byte.Parse(sr.Read(2), NumberStyles.HexNumber));
break;
default:
bytes.Add((byte)c);
break;
}
}
else if(c==quotechar)
{
// end of bytes
return new Ast.BytesNode(bytes.ToArray());
}
else
{
bytes.Add((byte)c);
}
}
throw new ParseException("unclosed bytes");
}
private Ast.PrimitiveNode ParseBool(SeekableStringReader sr)
{
// True,False
string b = sr.ReadUntil('e');
switch (b)
{
case "Tru":
return new Ast.BooleanNode(true);
case "Fals":
return new Ast.BooleanNode(false);
}
throw new ParseException("expected bool, True or False");
}
private Ast.NoneNode ParseNone(SeekableStringReader sr)
{
// None
string n = sr.ReadUntil('e');
if(n=="Non")
return Ast.NoneNode.Instance;
throw new ParseException("expected None");
}
private double ParseDouble(string numberstr)
{
switch (numberstr)
{
// the number is possibly +Inf/-Inf, these are encoded as "1e30000" and "-1e30000"
case "1e30000":
return double.PositiveInfinity;
case "-1e30000":
return double.NegativeInfinity;
}
return double.Parse(numberstr, CultureInfo.InvariantCulture);
}
///
/// Utility function to convert obj back to actual bytes if it is a serpent-encoded bytes dictionary
/// (a IDictionary with base-64 encoded 'data' in it and 'encoding'='base64').
/// If obj is already a byte array, return obj unmodified.
/// If it is something else, throw an ArgumentException
///
public static byte[] ToBytes(object obj) {
switch (obj)
{
case Hashtable hashtable:
{
string data = null;
string encoding = null;
if(hashtable.Contains("data")) data = (string)hashtable["data"];
if(hashtable.Contains("encoding")) encoding = (string)hashtable["encoding"];
if(data==null || "base64"!=encoding)
{
throw new ArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
return Convert.FromBase64String(data);
}
case IDictionary dict:
{
bool hasData = dict.TryGetValue("data", out string data);
bool hasEncoding = dict.TryGetValue("encoding", out string encoding);
if(!hasData || !hasEncoding || encoding!="base64")
{
throw new ArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
return Convert.FromBase64String(data);
}
case IDictionary dict2:
{
bool hasData = dict2.TryGetValue("data", out object dataobj);
bool hasEncoding = dict2.TryGetValue("encoding", out object encodingobj);
string data = (string)dataobj;
string encoding = (string)encodingobj;
if(!hasData || !hasEncoding || encoding!="base64")
{
throw new ArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
return Convert.FromBase64String(data);
}
case byte[] bytearray:
return bytearray;
default:
throw new ArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/Razorvine.Serpent.csproj 0000664 0000000 0000000 00000003210 15077515333 0027676 0 ustar 00root root 0000000 0000000
netstandard2.0
9
Irmen de Jong
Serpent Python literal expression serialization
Razorvine.Serpent
1.43.0
1.43.0.0
1.43.0.0
true
false
Serpent.snk
Serpent provides Python ast.literal_eval() compatible object tree serialization.
Serpent provides Python ast.literal_eval() compatible object tree serialization.
It serializes an object tree into bytes that can be transferred to Python and
decoded there (using ast.literal_eval()). It can ofcourse also deserialize
such a Python expression itself, back into the equivalent .NET datatypes.
More info for the Python version is on Pypi: https://pypi.python.org/pypi/serpent
Copyright Irmen de Jong
MIT
https://github.com/irmen/serpent
https://github.com/irmen/Serpent.git
git
serialization python pyro
c# language level update with some refactorings
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/SeekableStringReader.cs 0000664 0000000 0000000 00000010714 15077515333 0027441 0 ustar 00root root 0000000 0000000 using System;
namespace Razorvine.Serpent
{
///
/// A special string reader that is suitable for the parser to read through
/// the expression string. You can rewind it, set bookmarks to flip back to, etc.
///
public class SeekableStringReader : IDisposable
{
// ReSharper disable RedundantDefaultMemberInitializer
private string _str;
private int _cursor = 0;
private int _bookmark = -1;
public SeekableStringReader(string str)
{
_str = str ?? throw new ArgumentNullException(nameof(str));
}
///
/// Make a nested reader with its own cursor and bookmark.
/// The cursor starts at the same position as the parent.
///
///
/// Is there more to read?
///
public bool HasMore()
{
return _cursor<_str.Length;
}
///
/// What is the next character?
///
public char Peek()
{
return _str[_cursor];
}
///
/// What are the next characters that will be read?
///
public string Peek(int count)
{
return _str.Substring(_cursor, Math.Min(count, _str.Length-_cursor));
}
///
/// Read a single character.
///
public char Read()
{
return _str[_cursor++];
}
///
/// Read a number of characters.
///
public string Read(int count)
{
if(count<0)
throw new ParseException("use Rewind to seek back");
int safecount = Math.Min(count, _str.Length-_cursor);
if(safecount==0 && count>0)
throw new ParseException("no more data");
string result = _str.Substring(_cursor, safecount);
_cursor += safecount;
return result;
}
///
/// Read everything until one of the sentinel(s), which must exist in the string.
/// Sentinel char is read but not returned in the result.
///
public string ReadUntil(params char[] sentinels)
{
int index = _str.IndexOfAny(sentinels, _cursor);
if (index < 0) throw new ParseException("terminator not found");
string result = _str.Substring(_cursor, index-_cursor);
_cursor = index+1;
return result;
}
///
/// Read everything as long as the char occurs in the accepted characters.
///
public string ReadWhile(string accepted)
{
int start = _cursor;
while(_cursor < _str.Length)
{
if(accepted.IndexOf(_str[_cursor])>=0)
++_cursor;
else
break;
}
return _str.Substring(start, _cursor-start);
}
///
/// Read away any whitespace.
/// If a comment follows ('# bla bla') read away that as well
///
public void SkipWhitespace()
{
while(HasMore())
{
char c=Read();
if(c=='#')
{
ReadUntil('\n');
return;
}
if (char.IsWhiteSpace(c))
continue;
Rewind(1);
return;
}
}
///
/// Returns the rest of the data until the end.
///
public string Rest()
{
if(_cursor>=_str.Length)
throw new ParseException("no more data");
string result=_str.Substring(_cursor);
_cursor = _str.Length;
return result;
}
///
/// Rewind a number of characters.
///
public void Rewind(int count)
{
_cursor = Math.Max(0, _cursor-count);
}
///
/// Return a bookmark to rewind to later.
///
public int Bookmark()
{
return _cursor;
}
///
/// Flip back to previously set bookmark.
///
public void FlipBack(int towhichbookmark)
{
_cursor = towhichbookmark;
}
///
/// Sync the position and bookmark with the current position in another reader.
///
public void Sync(SeekableStringReader inner)
{
_bookmark = inner._bookmark;
_cursor = inner._cursor;
}
///
/// Extract a piece of context around the current cursor (if you set cursor to -1)
/// or around a given position in the string (if you set cursor>=0).
///
public void Context(int crsr, int width, out string left, out string right)
{
if(crsr<0)
crsr=_cursor;
int leftStrt = Math.Max(0, crsr-width);
int leftLen = crsr-leftStrt;
int rightLen = Math.Min(width, _str.Length-crsr);
left = _str.Substring(leftStrt, leftLen);
right = _str.Substring(crsr, rightLen);
}
public void Dispose()
{
_str = null;
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/Serializer.cs 0000664 0000000 0000000 00000037134 15077515333 0025532 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Xml;
namespace Razorvine.Serpent
{
///
/// Serialize an object tree to a byte stream.
/// It is not thread-safe: make sure you're not making changes to the object tree that is being serialized.
///
[SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
[SuppressMessage("ReSharper", "UnusedParameter.Global")]
[SuppressMessage("ReSharper", "FieldCanBeMadeReadOnly.Global")]
[SuppressMessage("ReSharper", "MemberCanBeMadeStatic.Global")]
public class Serializer
{
///
/// indent output?
///
public bool Indent;
///
/// include namespace prefix for classes that are serialized to dict?
///
public bool NamespaceInClassName;
///
/// Use bytes literal representation instead of base-64 encoding?
///
public bool BytesRepr;
///
/// The maximum nesting level of the object graphs that you want to serialize.
/// This limit has been set to avoid troublesome stack overflow errors.
/// (If it is reached, an ArgumentException is thrown instead with a clear message)
///
public int MaximumLevel = 500; // avoids stackoverflow errors
private static readonly IDictionary> ClassToDictRegistry
= new Dictionary>();
///
/// Initialize the serializer.
///
///
/// Register a custom class-to-dict converter.
///
public static void RegisterClass(Type clazz, Func converter)
{
ClassToDictRegistry[clazz] = converter;
}
///
/// Serialize the object tree to bytes.
///
public byte[] Serialize(object obj)
{
using var tw = new StringWriter();
tw.Write("# serpent utf-8 python3.2\n");
Serialize(obj, tw, 0);
tw.Flush();
return Encoding.UTF8.GetBytes(tw.ToString());
}
protected void Serialize(object obj, TextWriter tw, int level)
{
if(level>MaximumLevel)
throw new ArgumentException("Object graph nesting too deep. Increase serializer.MaximumLevel if you think you need more.");
// null -> None
// hashtables/dictionaries -> dict
// hashset -> set
// array -> tuple
// byte arrays --> base64
// any other icollection --> list
// date/timespan/uuid/exception -> custom mapping
// random class --> public properties to dict
// primitive types --> simple mapping
var t = obj?.GetType();
switch (obj)
{
case null:
tw.Write("None");
break;
case string str:
Serialize_string(str, tw, level);
break;
default:
{
if(t.IsPrimitive)
{
Serialize_primitive(obj, tw, level);
}
else switch (obj)
{
case decimal dec:
Serialize_decimal(dec, tw, level);
break;
case Enum:
Serialize_string(obj.ToString(), tw, level);
break;
case IDictionary dict:
Serialize_dict(dict, tw, level);
break;
default:
{
if(t.IsGenericType && t.GetGenericTypeDefinition() == typeof(HashSet<>))
{
var x = (IEnumerable) obj;
object[] setValues = x.Cast().ToArray();
Serialize_set(setValues, tw, level);
}
else switch (obj)
{
case byte[] b:
Serialize_bytes(b, tw, level);
break;
case Array a:
Serialize_tuple(a, tw, level);
break;
case ICollection c:
Serialize_list(c, tw, level);
break;
case DateTimeOffset dto:
Serialize_datetimeoffset(dto, tw, level);
break;
case DateTime dt:
Serialize_datetime(dt, tw, level);
break;
case TimeSpan ts:
Serialize_timespan(ts, tw, level);
break;
case Exception ex:
Serialize_exception(ex, tw, level);
break;
case Guid guid:
Serialize_guid(guid, tw, level);
break;
case ComplexNumber cn:
Serialize_complex(cn, tw, level);
break;
default:
Serialize_class(obj, tw, level);
break;
}
break;
}
}
break;
}
}
}
protected void Serialize_tuple(ICollection array, TextWriter tw, int level)
{
tw.Write("(");
Serialize_sequence_elements(array, array.Count==1, tw, level+1);
if(Indent && array.Count>0)
tw.Write(string.Join(" ", new string[level+1]));
tw.Write(")");
}
protected void Serialize_list(ICollection list, TextWriter tw, int level)
{
tw.Write("[");
Serialize_sequence_elements(list, false, tw, level+1);
if(Indent && list.Count>0)
tw.Write(string.Join(" ", new string[level+1]));
tw.Write("]");
}
protected int DictentryCompare(DictionaryEntry d1, DictionaryEntry d2)
{
var c1 = d1.Key as IComparable;
var c2 = d2.Key as IComparable;
return c1?.CompareTo(c2) ?? 0;
}
protected void Serialize_dict(IDictionary dict, TextWriter tw, int level)
{
if(dict.Count==0)
{
tw.Write("{}");
return;
}
int counter=0;
if(Indent)
{
string innerIndent = string.Join(" ", new string[level+2]);
tw.Write("{\n");
var entries = new DictionaryEntry[dict.Count];
dict.CopyTo(entries, 0);
try {
Array.Sort(entries, DictentryCompare);
} catch (InvalidOperationException) {
// ignore sorting of incomparable elements
} catch (ArgumentException) {
// ignore sorting of incomparable elements
}
foreach(var x in entries)
{
tw.Write(innerIndent);
Serialize(x.Key, tw, level+1);
tw.Write(": ");
Serialize(x.Value, tw, level+1);
counter++;
if(counter0)
{
tw.Write("{");
if(Indent)
{
try {
Array.Sort(set);
} catch (InvalidOperationException) {
// ignore sorting of incomparable elements.
} catch (ArgumentException) {
// ignore sorting of incomparable elements.
}
}
Serialize_sequence_elements(set, false, tw, level+1);
if(Indent)
tw.Write(string.Join(" ", new string[level+1]));
tw.Write("}");
}
else
{
// empty set literal doesn't exist, replace with empty tuple
Serialize_tuple(Array.Empty(), tw, level+1);
}
}
protected void Serialize_sequence_elements(ICollection elements, bool trailingComma, TextWriter tw, int level)
{
if(elements.Count==0)
return;
int count=0;
if(Indent)
{
tw.Write("\n");
string innerIndent = string.Join(" ", new string[level+1]);
foreach(object e in elements)
{
tw.Write(innerIndent);
Serialize(e, tw, level);
count++;
if(count
{
{"data", str},
{"encoding", "base64"}
};
Serialize_dict(dict, tw, level);
}
}
private static void HandleQuotes(TextWriter tw, bool containsSingleQuote, StringBuilder b, bool containsQuote, bool isBytes)
{
if (!containsSingleQuote)
{
b.Insert(0, '\'');
b.Append('\'');
if(isBytes)
tw.Write('b');
tw.Write(b.ToString());
}
else if (!containsQuote)
{
b.Insert(0, '"');
b.Append('"');
if(isBytes)
tw.Write('b');
tw.Write(b.ToString());
}
else
{
string str2 = b.ToString();
str2 = str2.Replace("'", "\\'");
if(isBytes)
tw.Write('b');
tw.Write("'");
tw.Write(str2);
tw.Write("'");
}
}
// the repr translation table for characters 0x00-0xff
private static readonly string[] Repr255;
private static readonly string[] BytesRepr255;
static Serializer() {
Repr255=new string[256];
BytesRepr255=new string[256];
for(int c=0; c<32; ++c) {
Repr255[c] = "\\x"+c.ToString("x2");
BytesRepr255[c] = "\\x"+c.ToString("x2");
}
for(int c=0x20; c<0x7f; ++c) {
Repr255[c] = Convert.ToString((char)c);
BytesRepr255[c] = Convert.ToString((char)c);
}
for(int c=0x7f; c<=0xa0; ++c) {
Repr255[c] = "\\x"+c.ToString("x2");
}
for(int c=0xa1; c<=0xff; ++c) {
Repr255[c] = Convert.ToString((char)c);
}
for(int c=0x7f; c<=0xff; ++c) {
BytesRepr255[c] = "\\x"+c.ToString("x2");
}
// odd ones out:
Repr255['\t'] = "\\t";
Repr255['\n'] = "\\n";
Repr255['\r'] = "\\r";
Repr255['\\'] = @"\\";
Repr255[0xad] = "\\xad";
BytesRepr255['\t'] = "\\t";
BytesRepr255['\n'] = "\\n";
BytesRepr255['\r'] = "\\r";
BytesRepr255['\\'] = @"\\";
}
// ReSharper disable once UnusedParameter.Global
// ReSharper disable once MemberCanBePrivate.Global
protected void Serialize_string(string str, TextWriter tw, int level)
{
// create a 'repr' string representation following the same escaping rules as python 3.x repr() does.
var b=new StringBuilder(str.Length*2);
bool containsSingleQuote=false;
bool containsQuote=false;
foreach(char c in str)
{
containsSingleQuote |= c=='\'';
containsQuote |= c=='"';
if(c<256) {
// characters 0..255 via quick lookup table
b.Append(Repr255[c]);
} else {
if(char.IsLetterOrDigit(c) || char.IsNumber(c) || char.IsPunctuation(c) || char.IsSymbol(c)) {
b.Append(c);
} else {
b.Append("\\u");
b.Append(((int)c).ToString("x4"));
}
}
}
HandleQuotes(tw, containsSingleQuote, b, containsQuote, false);
}
protected void Serialize_datetime(DateTime dt, TextWriter tw, int level)
{
string s = dt.Millisecond == 0 ? XmlConvert.ToString(dt, "yyyy-MM-ddTHH:mm:ss") : XmlConvert.ToString(dt, "yyyy-MM-ddTHH:mm:ss.fff");
Serialize_string(s, tw, level);
}
protected void Serialize_datetimeoffset(DateTimeOffset dto, TextWriter tw, int level)
{
string s = XmlConvert.ToString(dto);
Serialize_string(s, tw, level);
}
protected void Serialize_timespan(TimeSpan span, TextWriter tw, int level)
{
Serialize_primitive(span.TotalSeconds, tw, level);
}
protected void Serialize_exception(Exception exc, TextWriter tw, int level)
{
IDictionary dict;
ClassToDictRegistry.TryGetValue(exc.GetType(), out var converter);
if(converter!=null)
{
// build a custom property dict from the object.
dict = converter(exc);
}
else
{
string className = NamespaceInClassName ? exc.GetType().FullName : exc.GetType().Name;
dict = new Dictionary {
{"__class__", className},
{"__exception__", true},
{"args", new []{exc.Message} },
{"attributes", exc.Data}
};
}
Serialize_dict(dict, tw, level);
}
protected void Serialize_guid(Guid guid, TextWriter tw, int level)
{
// simple string representation of the guid
Serialize_string(guid.ToString(), tw, level);
}
protected void Serialize_decimal(decimal dec, TextWriter tw, int level)
{
Serialize_string(dec.ToString(CultureInfo.InvariantCulture), tw, level);
}
protected void Serialize_primitive(object obj, TextWriter tw, int level)
{
switch (obj)
{
case float f:
{
double d = f;
// ReSharper disable once TailRecursiveCall
Serialize_primitive(d, tw, level);
break;
}
case double d when double.IsPositiveInfinity(d):
// output a literal expression that overflows the float and results in +/-INF
tw.Write("1e30000");
break;
case double d when double.IsNegativeInfinity(d):
tw.Write("-1e30000");
break;
case double.NaN:
// there's no literal expression for a float NaN...
tw.Write("{'__class__':'float','value':'nan'}");
break;
case double d:
tw.Write(Convert.ToString(d, CultureInfo.InvariantCulture));
break;
default:
tw.Write(Convert.ToString(obj, CultureInfo.InvariantCulture));
break;
}
}
protected void Serialize_complex(ComplexNumber cplx, TextWriter tw, int level)
{
tw.Write("(");
Serialize_primitive(cplx.Real, tw, level);
if(cplx.Imaginary>=0)
tw.Write("+");
Serialize_primitive(cplx.Imaginary, tw, level);
tw.Write("j)");
}
protected void Serialize_class(object obj, TextWriter tw, int level)
{
var objType = obj.GetType();
IDictionary dict;
var converter = GetCustomConverter(objType);
if(converter!=null)
{
// build a custom property dict from the object.
dict = converter(obj);
}
else
{
bool isAnonymousClass = objType.Name.StartsWith("<>");
dict = new Dictionary();
if(!isAnonymousClass) {
// only provide the class name when it is not an anonymous class
if(NamespaceInClassName)
dict["__class__"] = objType.FullName;
else
dict["__class__"] = objType.Name;
}
var properties=objType.GetProperties();
foreach(var propinfo in properties) {
if (!propinfo.CanRead) continue;
string name=propinfo.Name;
try {
dict[name]=propinfo.GetValue(obj, null);
} catch (Exception x) {
throw new SerializationException("cannot serialize a property:",x);
}
}
}
Serialize_dict(dict, tw, level);
}
// ReSharper disable once MemberCanBePrivate.Global
// ReSharper disable once MemberCanBeMadeStatic.Global
// ReSharper disable once InconsistentNaming
protected Func GetCustomConverter(Type obj_type)
{
if(ClassToDictRegistry.TryGetValue(obj_type, out var converter))
return converter; // exact match
// check if there's a custom converter registered for an interface or abstract base class
// that this object implements or inherits from.
// ReSharper disable once LoopCanBeConvertedToQuery
foreach(var x in ClassToDictRegistry) {
if(x.Key.IsAssignableFrom(obj_type)) {
return x.Value;
}
}
return null;
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/Serpent.snk 0000664 0000000 0000000 00000001124 15077515333 0025215 0 ustar 00root root 0000000 0000000 $ RSA2 ˤsW0 #yC۵ `/\k1G+wx k
2 6$ 2>y7]gV. ԕo@ȣܶ@sGE59 S9?O,f*ۅR'i=| VF߇u
uȺrV~nvN_0y\a{Z }NLӋM)ܗ M"5ߡH4w4,6kj Serpent-serpent-1.42/dotnet/Serpent/Razorvine.Serpent/Version.cs 0000664 0000000 0000000 00000000550 15077515333 0025036 0 ustar 00root root 0000000 0000000 /***
Serpent, a Python literal expression serializer/deserializer
(a.k.a. Python's ast.literal_eval in .NET)
Copyright: Irmen de Jong (irmen@razorvine.net)
Software license: "MIT software license". See http://opensource.org/licenses/MIT
***/
namespace Razorvine.Serpent
{
public static class LibraryVersion
{
public const string Version = "1.43";
}
}
Serpent-serpent-1.42/dotnet/Serpent/Serpent.sln 0000664 0000000 0000000 00000002365 15077515333 0021630 0 ustar 00root root 0000000 0000000
Microsoft Visual Studio Solution File, Format Version 12.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Razorvine.Serpent", "Razorvine.Serpent\Razorvine.Serpent.csproj", "{2FD56EEF-23E7-4CE8-94FA-92B0FC6E5CA4}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{10CAEE38-7E25-420D-AC29-98960E8785D2}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{2FD56EEF-23E7-4CE8-94FA-92B0FC6E5CA4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2FD56EEF-23E7-4CE8-94FA-92B0FC6E5CA4}.Debug|Any CPU.Build.0 = Debug|Any CPU
{2FD56EEF-23E7-4CE8-94FA-92B0FC6E5CA4}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2FD56EEF-23E7-4CE8-94FA-92B0FC6E5CA4}.Release|Any CPU.Build.0 = Release|Any CPU
{10CAEE38-7E25-420D-AC29-98960E8785D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{10CAEE38-7E25-420D-AC29-98960E8785D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
{10CAEE38-7E25-420D-AC29-98960E8785D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
{10CAEE38-7E25-420D-AC29-98960E8785D2}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobal
Serpent-serpent-1.42/dotnet/Serpent/Tests/ 0000775 0000000 0000000 00000000000 15077515333 0020566 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/dotnet/Serpent/Tests/CycleTest.cs 0000664 0000000 0000000 00000007264 15077515333 0023025 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using Xunit;
using Xunit.Abstractions;
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
namespace Razorvine.Serpent.Test
{
public class CycleTest
{
private readonly ITestOutputHelper _out;
public CycleTest(ITestOutputHelper testOutputHelper)
{
_out = testOutputHelper;
}
[Fact]
public void testTupleOk()
{
var ser = new Serializer();
var t = new[] {1, 2, 3};
var d = new object[] {t, t, t};
var data = ser.Serialize(d);
var parser = new Parser();
parser.Parse(data);
}
[Fact]
public void testListOk()
{
var ser = new Serializer();
var t = new List {1, 2, 3};
var d = new List {t, t, t};
var data = ser.Serialize(d);
var parser = new Parser();
parser.Parse(data);
}
[Fact]
public void testDictOk()
{
var ser = new Serializer();
var t = new Hashtable {["a"] = 1};
var d = new Hashtable
{
["x"] = t,
["y"] = t,
["z"] = t
};
var data = ser.Serialize(d);
var parser = new Parser();
parser.Parse(data);
}
[Fact]
public void testListCycle()
{
var ser = new Serializer();
var d = new List {1, 2};
d.Add(d);
Assert.Throws(() => ser.Serialize(d));
}
[Fact]
public void testDictCycle()
{
var ser = new Serializer();
var d = new Hashtable
{
["x"] = 1,
["y"] = 2
};
d["z"] = d;
Assert.Throws(() => ser.Serialize(d));
}
[Fact]
public void testClassCycle()
{
var ser = new Serializer();
var d = new SerializeTestClass
{
x = 42,
i = 99,
s = "hello"
};
d.obj = d; // make cycle
try
{
byte[] data = ser.Serialize(d);
_out.WriteLine("data: " + data.Length + " bytes");
_out.WriteLine("this object should hot have been serialized because it contains a circular object reference!");
throw new Exception("should not reach this");
}
catch (ArgumentException x)
{
Assert.Contains("nesting too deep", x.Message);
}
}
[Fact]
public void testMaxLevel()
{
var ser = new Serializer();
Assert.Equal(500, ser.MaximumLevel);
object[] array =
{
"level1",
new object[]
{
"level2",
new object[]
{
"level3",
new object[]
{
"level 4"
}
}
}
};
ser.MaximumLevel = 4;
ser.Serialize(array); // should work
ser.MaximumLevel = 3;
try
{
ser.Serialize(array);
Assert.Fail("should fail");
}
catch (ArgumentException x)
{
Assert.Contains("too deep", x.Message);
}
}
}
} Serpent-serpent-1.42/dotnet/Serpent/Tests/Example.cs 0000664 0000000 0000000 00000007774 15077515333 0022527 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Text;
using Xunit;
using Xunit.Abstractions;
// ReSharper disable CheckNamespace
namespace Razorvine.Serpent.Test
{
///
/// Example usage.
///
public class Example
{
private readonly ITestOutputHelper _testOutputHelper;
public Example(ITestOutputHelper testOutputHelper)
{
_testOutputHelper = testOutputHelper;
}
[Fact(Skip = "this is an example")]
public void ExampleUsage()
{
_testOutputHelper.WriteLine("using serpent library version {0}", LibraryVersion.Version);
var data = new Dictionary
{
{"tuple", new[] {1, 2, 3}},
{"date", DateTime.Now},
{"set", new HashSet {"a", "b", "c"}},
{
"class", new SampleClass
{
Name = "Sally",
Age = 26
}
}
};
// serialize data structure to bytes
var serpent = new Serializer(true);
var ser = serpent.Serialize(data);
// print it on the screen, but normally you'd store byte bytes in a file or transfer them across a network connection
_testOutputHelper.WriteLine("Serialized:");
_testOutputHelper.WriteLine(Encoding.UTF8.GetString(ser));
// parse the serialized bytes back into an abstract syntax tree of the datastructure
var parser = new Parser();
var ast = parser.Parse(ser);
_testOutputHelper.WriteLine("\nParsed AST:");
_testOutputHelper.WriteLine(ast.Root.ToString());
// print debug representation
var dv = new DebugVisitor();
ast.Accept(dv);
_testOutputHelper.WriteLine("DEBUG string representation:");
_testOutputHelper.WriteLine(dv.ToString());
// turn the Ast into regular .net objects
var dict = (IDictionary) ast.GetData();
// You can get the data out of the Ast manually as well, by using the supplied visitor:
// var visitor = new ObjectifyVisitor();
// ast.Accept(visitor);
// var dict = (IDictionary) visitor.GetObject();
// print the results
_testOutputHelper.WriteLine("PARSED results:");
_testOutputHelper.WriteLine("tuple items: ");
var tuple = (object[]) dict["tuple"];
_testOutputHelper.WriteLine(string.Join(", ", tuple.Select(e => e.ToString()).ToArray()));
_testOutputHelper.WriteLine("date: {0}", dict["date"]);
_testOutputHelper.WriteLine("set items: ");
var set = (HashSet) dict["set"];
_testOutputHelper.WriteLine(string.Join(", ", set.Select(e => e.ToString()).ToArray()));
_testOutputHelper.WriteLine("class attributes:");
var clazz = (IDictionary) dict["class"]; // custom classes are serialized as dicts
_testOutputHelper.WriteLine(" type: {0}", clazz["__class__"]);
_testOutputHelper.WriteLine(" name: {0}", clazz["name"]);
_testOutputHelper.WriteLine(" age: {0}", clazz["age"]);
_testOutputHelper.WriteLine("");
// parse and print the example file
ser = File.ReadAllBytes("testserpent.utf8.bin");
ast = parser.Parse(ser);
dv = new DebugVisitor();
ast.Accept(dv);
_testOutputHelper.WriteLine("DEBUG string representation of the test file:");
_testOutputHelper.WriteLine(dv.ToString());
}
[Serializable]
[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Local")]
private class SampleClass
{
public int Age { get; set; }
public string Name { get; set; }
}
}
} Serpent-serpent-1.42/dotnet/Serpent/Tests/ParserTest.cs 0000664 0000000 0000000 00000101252 15077515333 0023212 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Xunit;
// ReSharper disable CheckNamespace
// ReSharper disable SpecifyACultureInStringConversionExplicitly
// ReSharper disable RedundantAssignment
// ReSharper disable PossibleNullReferenceException
// ReSharper disable InconsistentNaming
// ReSharper disable MemberCanBeMadeStatic.Local
namespace Razorvine.Serpent.Test
{
public class ParserTest
{
[Fact]
public void TestBasic()
{
var p = new Parser();
Assert.Null(p.Parse((string) null).Root);
Assert.Null(p.Parse("").Root);
Assert.NotNull(p.Parse("# comment\n42\n").Root);
}
[Fact]
public void TestComments()
{
var p = new Parser();
var ast = p.Parse("[ 1, 2 ]"); // no header whatsoever
var visitor = new ObjectifyVisitor();
ast.Accept(visitor);
var obj = visitor.GetObject();
Assert.Equal(new[] {1, 2}, obj);
ast = p.Parse(@"# serpent utf-8 python2.7
[ 1, 2,
# some comments here
3, 4] # more here
# and here.
");
visitor = new ObjectifyVisitor();
ast.Accept(visitor);
obj = visitor.GetObject();
Assert.Equal(new[] {1, 2, 3, 4}, obj);
}
[Fact]
public void TestPrimitives()
{
var p = new Parser();
Assert.Equal(new Ast.IntegerNode(42), p.Parse("42").Root);
Assert.Equal(new Ast.IntegerNode(-42), p.Parse("-42").Root);
Assert.Equal(new Ast.DoubleNode(42.331), p.Parse("42.331").Root);
Assert.Equal(new Ast.DoubleNode(-42.331), p.Parse("-42.331").Root);
Assert.Equal(new Ast.DoubleNode(-1.2e19), p.Parse("-1.2e+19").Root);
Assert.Equal(new Ast.DoubleNode(-1.2e19), p.Parse("-1.2e19").Root);
Assert.Equal(new Ast.DoubleNode(0.0004), p.Parse("4e-4").Root);
Assert.Equal(new Ast.DoubleNode(40000), p.Parse("4e4").Root);
Assert.Equal(new Ast.BooleanNode(true), p.Parse("True").Root);
Assert.Equal(new Ast.BooleanNode(false), p.Parse("False").Root);
Assert.Equal(Ast.NoneNode.Instance, p.Parse("None").Root);
// long ints
Assert.Equal(new Ast.DecimalNode(123456789123456789123456789M),
p.Parse("123456789123456789123456789").Root);
Assert.NotEqual(new Ast.LongNode(52), p.Parse("52").Root);
Assert.Equal(new Ast.LongNode(123456789123456789L), p.Parse("123456789123456789").Root);
Assert.Throws(() => p.Parse("123456789123456789123456789123456789")); // overflow
}
[Fact]
public void TestWeirdFloats()
{
var p = new Parser();
var d = (Ast.DoubleNode) p.Parse("1e30000").Root;
Assert.True(double.IsPositiveInfinity(d.Value));
d = (Ast.DoubleNode) p.Parse("-1e30000").Root;
Assert.True(double.IsNegativeInfinity(d.Value));
var tuple = (Ast.TupleNode) p.Parse("(1e30000,-1e30000,{'__class__':'float','value':'nan'})").Root;
Assert.Equal(3, tuple.Elements.Count);
d = (Ast.DoubleNode) tuple.Elements[0];
Assert.True(double.IsPositiveInfinity(d.Value));
d = (Ast.DoubleNode) tuple.Elements[1];
Assert.True(double.IsNegativeInfinity(d.Value));
d = (Ast.DoubleNode) tuple.Elements[2];
Assert.True(double.IsNaN(d.Value));
var c = (Ast.ComplexNumberNode) p.Parse("(1e30000-1e30000j)").Root;
Assert.True(double.IsPositiveInfinity(c.Real));
Assert.True(double.IsNegativeInfinity(c.Imaginary));
}
[Fact]
public void TestFloatPrecision()
{
var p = new Parser();
var serpent = new Serializer();
var ser = serpent.Serialize(1.2345678987654321);
var dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.Equal(1.2345678987654321.ToString(), dv.Value.ToString());
ser = serpent.Serialize(5555.12345678987656);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.Equal(5555.12345678987656.ToString(), dv.Value.ToString());
ser = serpent.Serialize(98765432123456.12345678987656);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.Equal(98765432123456.12345678987656.ToString(), dv.Value.ToString());
ser = serpent.Serialize(98765432123456.12345678987656e+44);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.Equal(98765432123456.12345678987656e+44.ToString(), dv.Value.ToString());
ser = serpent.Serialize(-98765432123456.12345678987656e-44);
dv = (Ast.DoubleNode) p.Parse(ser).Root;
Assert.Equal((-98765432123456.12345678987656e-44).ToString(), dv.Value.ToString());
}
[Fact]
public void TestEquality()
{
Ast.INode n1 = new Ast.IntegerNode(42);
Ast.INode n2 = new Ast.IntegerNode(42);
Assert.Equal(n1, n2);
n2 = new Ast.IntegerNode(43);
Assert.NotEqual(n1, n2);
n1 = new Ast.StringNode("foo");
n2 = new Ast.StringNode("foo");
Assert.Equal(n1, n2);
n2 = new Ast.StringNode("bar");
Assert.NotEqual(n1, n2);
n1 = new Ast.ComplexNumberNode
{
Real = 1.1,
Imaginary = 2.2
};
n2 = new Ast.ComplexNumberNode
{
Real = 1.1,
Imaginary = 2.2
};
Assert.Equal(n1, n2);
n2 = new Ast.ComplexNumberNode
{
Real = 1.1,
Imaginary = 3.3
};
Assert.NotEqual(n1, n2);
n1 = new Ast.KeyValueNode
{
Key = new Ast.IntegerNode(42),
Value = new Ast.IntegerNode(42)
};
n2 = new Ast.KeyValueNode
{
Key = new Ast.IntegerNode(42),
Value = new Ast.IntegerNode(42)
};
Assert.Equal(n1, n2);
n1 = new Ast.KeyValueNode
{
Key = new Ast.IntegerNode(43),
Value = new Ast.IntegerNode(43)
};
Assert.NotEqual(n1, n2);
n1 = Ast.NoneNode.Instance;
n2 = Ast.NoneNode.Instance;
Assert.Equal(n1, n2);
n2 = new Ast.IntegerNode(42);
Assert.NotEqual(n1, n2);
n1 = new Ast.DictNode
{
Elements = new List
{
new Ast.KeyValueNode
{
Key = new Ast.IntegerNode(42),
Value = new Ast.IntegerNode(42)
}
}
};
n2 = new Ast.DictNode
{
Elements = new List
{
new Ast.KeyValueNode
{
Key = new Ast.IntegerNode(42),
Value = new Ast.IntegerNode(42)
}
}
};
Assert.Equal(n1, n2);
n2 = new Ast.DictNode
{
Elements = new List
{
new Ast.KeyValueNode
{
Key = new Ast.IntegerNode(42),
Value = new Ast.IntegerNode(43)
}
}
};
Assert.NotEqual(n1, n2);
n1 = new Ast.ListNode
{
Elements = new List
{
new Ast.IntegerNode(42)
}
};
n2 = new Ast.ListNode
{
Elements = new List
{
new Ast.IntegerNode(42)
}
};
Assert.Equal(n1, n2);
n2 = new Ast.ListNode
{
Elements = new List
{
new Ast.IntegerNode(43)
}
};
Assert.NotEqual(n1, n2);
n1 = new Ast.SetNode
{
Elements = new List
{
new Ast.IntegerNode(42)
}
};
n2 = new Ast.SetNode
{
Elements = new List
{
new Ast.IntegerNode(42)
}
};
Assert.Equal(n1, n2);
n2 = new Ast.SetNode
{
Elements = new List
{
new Ast.IntegerNode(43)
}
};
Assert.NotEqual(n1, n2);
n1 = new Ast.TupleNode
{
Elements = new List
{
new Ast.IntegerNode(42)
}
};
n2 = new Ast.TupleNode
{
Elements = new List
{
new Ast.IntegerNode(42)
}
};
Assert.Equal(n1, n2);
n2 = new Ast.TupleNode
{
Elements = new List
{
new Ast.IntegerNode(43)
}
};
Assert.NotEqual(n1, n2);
}
[Fact]
public void TestDictEquality()
{
var dict1 = new Ast.DictNode();
var kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key1"),
Value = new Ast.IntegerNode(42)
};
dict1.Elements.Add(kv);
kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key2"),
Value = new Ast.IntegerNode(43)
};
dict1.Elements.Add(kv);
kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key3"),
Value = new Ast.IntegerNode(44)
};
dict1.Elements.Add(kv);
var dict2 = new Ast.DictNode();
kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key2"),
Value = new Ast.IntegerNode(43)
};
dict2.Elements.Add(kv);
kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key3"),
Value = new Ast.IntegerNode(44)
};
dict2.Elements.Add(kv);
kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key1"),
Value = new Ast.IntegerNode(42)
};
dict2.Elements.Add(kv);
Assert.Equal(dict1, dict2);
kv = new Ast.KeyValueNode
{
Key = new Ast.StringNode("key4"),
Value = new Ast.IntegerNode(45)
};
dict2.Elements.Add(kv);
Assert.NotEqual(dict1, dict2);
}
[Fact]
public void TestSetEquality()
{
var set1 = new Ast.SetNode();
set1.Elements.Add(new Ast.IntegerNode(1));
set1.Elements.Add(new Ast.IntegerNode(2));
set1.Elements.Add(new Ast.IntegerNode(3));
var set2 = new Ast.SetNode();
set2.Elements.Add(new Ast.IntegerNode(2));
set2.Elements.Add(new Ast.IntegerNode(3));
set2.Elements.Add(new Ast.IntegerNode(1));
Assert.Equal(set1, set2);
set2.Elements.Add(new Ast.IntegerNode(0));
Assert.NotEqual(set1, set2);
}
[Fact]
public void TestPrintSingle()
{
var p = new Parser();
// primitives
Assert.Equal("42", p.Parse("42").Root.ToString());
Assert.Equal("-42.331", p.Parse("-42.331").Root.ToString());
Assert.Equal("-42.0", p.Parse("-42.0").Root.ToString());
Assert.Equal("-2E+20", p.Parse("-2E20").Root.ToString());
Assert.Equal("2.0", p.Parse("2.0").Root.ToString());
Assert.Equal("1.2E+19", p.Parse("1.2e19").Root.ToString());
Assert.Equal("True", p.Parse("True").Root.ToString());
Assert.Equal("'hello'", p.Parse("'hello'").Root.ToString());
Assert.Equal("'\\n'", p.Parse("'\n'").Root.ToString());
Assert.Equal("'\\''", p.Parse("'\\''").Root.ToString());
Assert.Equal("'\"'", p.Parse("'\\\"'").Root.ToString());
Assert.Equal("'\"'", p.Parse("'\"'").Root.ToString());
Assert.Equal(@"'\\'", p.Parse(@"'\\'").Root.ToString());
Assert.Equal("None", p.Parse("None").Root.ToString());
const string ustr = "'\u20ac\u2603'";
Assert.Equal(ustr, p.Parse(ustr).Root.ToString());
// complex
Assert.Equal("(0+2j)", p.Parse("2j").Root.ToString());
Assert.Equal("(-1.1-2.2j)", p.Parse("(-1.1-2.2j)").Root.ToString());
Assert.Equal("(1.1+2.2j)", p.Parse("(1.1+2.2j)").Root.ToString());
// long int
Assert.Equal("123456789123456789123456789", p.Parse("123456789123456789123456789").Root.ToString());
}
[Fact]
public void TestPrintSeq()
{
var p = new Parser();
//tuple
Assert.Equal("()", p.Parse("()").Root.ToString());
Assert.Equal("(42,)", p.Parse("(42,)").Root.ToString());
Assert.Equal("(42,43)", p.Parse("(42,43)").Root.ToString());
// list
Assert.Equal("[]", p.Parse("[]").Root.ToString());
Assert.Equal("[42]", p.Parse("[42]").Root.ToString());
Assert.Equal("[42,43]", p.Parse("[42,43]").Root.ToString());
// set
Assert.Equal("{42}", p.Parse("{42}").Root.ToString());
Assert.Equal("{42,43}", p.Parse("{42,43,43,43}").Root.ToString());
// dict
Assert.Equal("{}", p.Parse("{}").Root.ToString());
Assert.Equal("{'a':42}", p.Parse("{'a': 42}").Root.ToString());
Assert.Equal("{'a':42,'b':43}", p.Parse("{'a': 42, 'b': 43}").Root.ToString());
Assert.Equal("{'a':42,'b':45}", p.Parse("{'a': 42, 'b': 43, 'b': 44, 'b': 45}").Root.ToString());
}
[Fact]
public void TestInvalidPrimitives()
{
var p = new Parser();
Assert.Throws(() => p.Parse("1+2"));
Assert.Throws(() => p.Parse("1-2"));
Assert.Throws(() => p.Parse("1.1+2.2"));
Assert.Throws(() => p.Parse("1.1-2.2"));
Assert.Throws(() => p.Parse("True+2"));
Assert.Throws(() => p.Parse("False-2"));
Assert.Throws(() => p.Parse("3j+2"));
Assert.Throws(() => p.Parse("3j-2"));
Assert.Throws(() => p.Parse("None+2"));
Assert.Throws(() => p.Parse("None-2"));
}
[Fact]
public void TestComplex()
{
var p = new Parser();
var cplx = new Ast.ComplexNumberNode
{
Real = 4.2,
Imaginary = 3.2
};
var cplx2 = new Ast.ComplexNumberNode
{
Real = 4.2,
Imaginary = 99
};
Assert.NotEqual(cplx, cplx2);
cplx2.Imaginary = 3.2;
Assert.Equal(cplx, cplx2);
Assert.Equal(cplx, p.Parse("(4.2+3.2j)").Root);
cplx.Real = 0;
Assert.Equal(cplx, p.Parse("(0+3.2j)").Root);
Assert.Equal(cplx, p.Parse("3.2j").Root);
Assert.Equal(cplx, p.Parse("+3.2j").Root);
cplx.Imaginary = -3.2;
Assert.Equal(cplx, p.Parse("-3.2j").Root);
cplx.Real = -9.9;
Assert.Equal(cplx, p.Parse("(-9.9-3.2j)").Root);
cplx.Real = 2;
cplx.Imaginary = 3;
Assert.Equal(cplx, p.Parse("(2+3j)").Root);
cplx.Imaginary = -3;
Assert.Equal(cplx, p.Parse("(2-3j)").Root);
cplx.Real = 0;
Assert.Equal(cplx, p.Parse("-3j").Root);
cplx.Real = -3.2e32;
cplx.Imaginary = -9.9e44;
Assert.Equal(cplx, p.Parse("(-3.2e32 -9.9e44j)").Root);
Assert.Equal(cplx, p.Parse("(-3.2e+32 -9.9e+44j)").Root);
Assert.Equal(cplx, p.Parse("(-3.2e32-9.9e44j)").Root);
Assert.Equal(cplx, p.Parse("(-3.2e+32-9.9e+44j)").Root);
cplx.Imaginary = 9.9e44;
Assert.Equal(cplx, p.Parse("(-3.2e32+9.9e44j)").Root);
Assert.Equal(cplx, p.Parse("(-3.2e+32+9.9e+44j)").Root);
cplx.Real = -3.2e-32;
cplx.Imaginary = -9.9e-44;
Assert.Equal(cplx, p.Parse("(-3.2e-32-9.9e-44j)").Root);
}
[Fact]
public void TestComplexPrecision()
{
var p = new Parser();
var cv = (Ast.ComplexNumberNode) p.Parse("(98765432123456.12345678987656+665544332211.9998877665544j)")
.Root;
Assert.Equal(98765432123456.12345678987656, cv.Real);
Assert.Equal(665544332211.9998877665544, cv.Imaginary);
cv = (Ast.ComplexNumberNode) p.Parse("(98765432123456.12345678987656-665544332211.9998877665544j)").Root;
Assert.Equal(98765432123456.12345678987656, cv.Real);
Assert.Equal(-665544332211.9998877665544, cv.Imaginary);
cv = (Ast.ComplexNumberNode) p.Parse("(98765432123456.12345678987656e+33+665544332211.9998877665544e+44j)")
.Root;
Assert.Equal(98765432123456.12345678987656e+33, cv.Real);
Assert.Equal(665544332211.9998877665544e+44, cv.Imaginary);
cv = (Ast.ComplexNumberNode) p.Parse("(-98765432123456.12345678987656e+33-665544332211.9998877665544e+44j)")
.Root;
Assert.Equal(-98765432123456.12345678987656e+33, cv.Real);
Assert.Equal(-665544332211.9998877665544e+44, cv.Imaginary);
}
[Fact]
public void TestPrimitivesStuffAtEnd()
{
var p = new Parser();
Assert.Equal(new Ast.IntegerNode(42), p.ParseSingle(new SeekableStringReader("42@")));
Assert.Equal(new Ast.DoubleNode(42.331), p.ParseSingle(new SeekableStringReader("42.331@")));
Assert.Equal(new Ast.BooleanNode(true), p.ParseSingle(new SeekableStringReader("True@")));
Assert.Equal(Ast.NoneNode.Instance, p.ParseSingle(new SeekableStringReader("None@")));
var cplx = new Ast.ComplexNumberNode
{
Real = 4,
Imaginary = 3
};
Assert.Equal(cplx, p.ParseSingle(new SeekableStringReader("(4+3j)@")));
cplx.Real = 0;
Assert.Equal(cplx, p.ParseSingle(new SeekableStringReader("3j@")));
}
[Fact]
public void TestStrings()
{
var p = new Parser();
Assert.Equal(new Ast.StringNode("hello"), p.Parse("'hello'").Root);
Assert.Equal(new Ast.StringNode("hello"), p.Parse("\"hello\"").Root);
Assert.Equal(new Ast.StringNode("\\"), p.Parse(@"'\\'").Root);
Assert.Equal(new Ast.StringNode("\\"), p.Parse(@"""\\""").Root);
Assert.Equal(new Ast.StringNode("'"), p.Parse("\"'\"").Root);
Assert.Equal(new Ast.StringNode("\""), p.Parse("'\"'").Root);
Assert.Equal(new Ast.StringNode("tab\tnewline\n."), p.Parse("'tab\\tnewline\\n.'").Root);
}
[Fact]
public void TestUnicode()
{
var p = new Parser();
const string str = "'\u20ac\u2603'";
Assert.Equal(0x20ac, str[1]);
Assert.Equal(0x2603, str[2]);
var bytes = Encoding.UTF8.GetBytes(str);
const string value = "\u20ac\u2603";
Assert.Equal(new Ast.StringNode(value), p.Parse(str).Root);
Assert.Equal(new Ast.StringNode(value), p.Parse(bytes).Root);
}
[Fact]
public void TestLongUnicodeRoundtrip()
{
var chars64k = new char[65536];
for (var i = 0; i <= 65535; ++i)
chars64k[i] = (char) i;
var str64k = new string(chars64k);
var ser = new Serializer();
var data = ser.Serialize(str64k);
Assert.True(data.Length > chars64k.Length);
var p = new Parser();
var result = (string) p.Parse(data).GetData();
Assert.Equal(str64k, result);
}
[Fact]
public void TestWhitespace()
{
var p = new Parser();
Assert.Equal(new Ast.IntegerNode(42), p.Parse(" 42 ").Root);
Assert.Equal(new Ast.IntegerNode(42), p.Parse(" 42 ").Root);
Assert.Equal(new Ast.IntegerNode(42), p.Parse("\t42\r\n").Root);
Assert.Equal(new Ast.IntegerNode(42), p.Parse(" \t 42 \r \n ").Root);
Assert.Equal(new Ast.StringNode(" string value "), p.Parse(" ' string value ' ").Root);
Assert.Throws(() => p.Parse(" ( 42 , ( 'x', 'y' ) ")); // missing tuple close )
var ast = p.Parse(" ( 42 , ( 'x', 'y' ) ) ");
var tuple = (Ast.TupleNode) ast.Root;
Assert.Equal(new Ast.IntegerNode(42), tuple.Elements[0]);
tuple = (Ast.TupleNode) tuple.Elements[1];
Assert.Equal(new Ast.StringNode("x"), tuple.Elements[0]);
Assert.Equal(new Ast.StringNode("y"), tuple.Elements[1]);
p.Parse(" ( 52 , ) ");
p.Parse(" [ 52 ] ");
p.Parse(" { 'a' : 42 } ");
p.Parse(" { 52 } ");
}
[Fact]
public void TestTuple()
{
var p = new Parser();
var tuple = new Ast.TupleNode();
var tuple2 = new Ast.TupleNode();
Assert.Equal(tuple, tuple2);
tuple.Elements.Add(new Ast.IntegerNode(42));
tuple2.Elements.Add(new Ast.IntegerNode(99));
Assert.NotEqual(tuple, tuple2);
tuple2.Elements.Clear();
tuple2.Elements.Add(new Ast.IntegerNode(42));
Assert.Equal(tuple, tuple2);
tuple2.Elements.Add(new Ast.IntegerNode(43));
tuple2.Elements.Add(new Ast.IntegerNode(44));
Assert.NotEqual(tuple, tuple2);
Assert.Equal(new Ast.TupleNode(), p.Parse("()").Root);
Assert.Equal(tuple, p.Parse("(42,)").Root);
Assert.Equal(tuple2, p.Parse("( 42,43, 44 )").Root);
Assert.Throws(() => p.Parse("(42,43]"));
Assert.Throws(() => p.Parse("()@"));
Assert.Throws(() => p.Parse("(42,43)@"));
}
[Fact]
public void TestList()
{
var p = new Parser();
var list = new Ast.ListNode();
var list2 = new Ast.ListNode();
Assert.Equal(list, list2);
list.Elements.Add(new Ast.IntegerNode(42));
list2.Elements.Add(new Ast.IntegerNode(99));
Assert.NotEqual(list, list2);
list2.Elements.Clear();
list2.Elements.Add(new Ast.IntegerNode(42));
Assert.Equal(list, list2);
list2.Elements.Add(new Ast.IntegerNode(43));
list2.Elements.Add(new Ast.IntegerNode(44));
Assert.NotEqual(list, list2);
Assert.Equal(new Ast.ListNode(), p.Parse("[]").Root);
Assert.Equal(list, p.Parse("[42]").Root);
Assert.Equal(list2, p.Parse("[ 42,43, 44 ]").Root);
Assert.Throws(() => p.Parse("[42,43}"));
Assert.Throws(() => p.Parse("[]@"));
Assert.Throws(() => p.Parse("[42,43]@"));
}
[Fact]
public void TestSet()
{
var p = new Parser();
var set1 = new Ast.SetNode();
var set2 = new Ast.SetNode();
Assert.Equal(set1, set2);
set1.Elements.Add(new Ast.IntegerNode(42));
set2.Elements.Add(new Ast.IntegerNode(99));
Assert.NotEqual(set1, set2);
set2.Elements.Clear();
set2.Elements.Add(new Ast.IntegerNode(42));
Assert.Equal(set1, set2);
set2.Elements.Add(new Ast.IntegerNode(43));
set2.Elements.Add(new Ast.IntegerNode(44));
Assert.NotEqual(set1, set2);
Assert.Equal(set1, p.Parse("{42}").Root);
Assert.Equal(set2, p.Parse("{ 42,43, 44 }").Root);
Assert.Throws(() => p.Parse("{42,43]"));
Assert.Throws(() => p.Parse("{42,43}@"));
set1 =
p.Parse("{'first','second','third','fourth','fifth','second', 'first', 'third', 'third' }")
.Root as Ast.SetNode;
Assert.Equal("'first'", set1.Elements[0].ToString());
Assert.Equal("'second'", set1.Elements[1].ToString());
Assert.Equal("'third'", set1.Elements[2].ToString());
Assert.Equal("'fourth'", set1.Elements[3].ToString());
Assert.Equal("'fifth'", set1.Elements[4].ToString());
Assert.Equal(5, set1.Elements.Count);
}
[Fact]
public void TestDict()
{
var p = new Parser();
var dict1 = new Ast.DictNode();
var dict2 = new Ast.DictNode();
Assert.Equal(dict1, dict2);
var kv1 = new Ast.KeyValueNode {Key = new Ast.StringNode("key"), Value = new Ast.IntegerNode(42)};
var kv2 = new Ast.KeyValueNode {Key = new Ast.StringNode("key"), Value = new Ast.IntegerNode(99)};
Assert.NotEqual(kv1, kv2);
kv2.Value = new Ast.IntegerNode(42);
Assert.Equal(kv1, kv2);
dict1.Elements.Add(new Ast.KeyValueNode
{Key = new Ast.StringNode("key1"), Value = new Ast.IntegerNode(42)});
dict2.Elements.Add(new Ast.KeyValueNode
{Key = new Ast.StringNode("key1"), Value = new Ast.IntegerNode(99)});
Assert.NotEqual(dict1, dict2);
dict2.Elements.Clear();
dict2.Elements.Add(new Ast.KeyValueNode
{Key = new Ast.StringNode("key1"), Value = new Ast.IntegerNode(42)});
Assert.Equal(dict1, dict2);
dict2.Elements.Add(new Ast.KeyValueNode
{Key = new Ast.StringNode("key2"), Value = new Ast.IntegerNode(43)});
dict2.Elements.Add(new Ast.KeyValueNode
{Key = new Ast.StringNode("key3"), Value = new Ast.IntegerNode(44)});
Assert.NotEqual(dict1, dict2);
Assert.Equal(new Ast.DictNode(), p.Parse("{}").Root);
Assert.Equal(dict1, p.Parse("{'key1': 42}").Root);
Assert.Equal(dict2, p.Parse("{'key1': 42, 'key2': 43, 'key3':44}").Root);
Assert.Throws(() => p.Parse("{'key': 42]"));
Assert.Throws(() => p.Parse("{}@"));
Assert.Throws(() => p.Parse("{'key': 42}@"));
dict1 = p.Parse("{'a': 1, 'b': 2, 'c': 3, 'c': 4, 'c': 5, 'c': 6}").Root as Ast.DictNode;
Assert.Equal("'a':1", dict1.Elements[0].ToString());
Assert.Equal("'b':2", dict1.Elements[1].ToString());
Assert.Equal("'c':6", dict1.Elements[2].ToString());
Assert.Equal(3, dict1.Elements.Count);
}
[Fact]
public void TestFile()
{
var p = new Parser();
var ser = File.ReadAllBytes("testserpent.utf8.bin");
var ast = p.Parse(ser);
var expr = ast.ToString();
var ast2 = p.Parse(expr);
var expr2 = ast2.ToString();
Assert.Equal(expr, expr2);
var sb = new StringBuilder();
Walk(ast.Root, sb);
var walk1 = sb.ToString();
sb = new StringBuilder();
Walk(ast2.Root, sb);
var walk2 = sb.ToString();
Assert.Equal(walk1, walk2);
Assert.Equal(ast.Root, ast2.Root);
ast = p.Parse(expr2);
Assert.Equal(ast.Root, ast2.Root);
}
[Fact]
public void TestAstEquals()
{
var p = new Parser();
var ser = File.ReadAllBytes("testserpent.utf8.bin");
var ast = p.Parse(ser);
var ast2 = p.Parse(ser);
Assert.Equal(ast.Root, ast2.Root);
}
private void Walk(Ast.INode node, StringBuilder sb)
{
var seq = node as Ast.SequenceNode;
if (seq != null)
{
sb.AppendLine($"{node.GetType()} (seq)");
foreach (var child in seq.Elements) Walk(child, sb);
}
else
{
sb.AppendLine($"{node.GetType()} = {node.ToString()}");
}
}
[Fact]
public void TestTrailingCommas()
{
var p = new Parser();
var result = p.Parse("[1,2,3, ]").Root;
result = p.Parse("[1,2,3 , ]").Root;
result = p.Parse("[1,2,3,]").Root;
Assert.Equal("[1,2,3]", result.ToString());
result = p.Parse("(1,2,3, )").Root;
result = p.Parse("(1,2,3 , )").Root;
result = p.Parse("(1,2,3,)").Root;
Assert.Equal("(1,2,3)", result.ToString());
// for dict and set the asserts are a bit more complex
// we cannot simply convert to string because the order of elts is undefined.
result = p.Parse("{'a':1, 'b':2, 'c':3, }").Root;
result = p.Parse("{'a':1, 'b':2, 'c':3 , }").Root;
result = p.Parse("{'a':1, 'b':2, 'c':3,}").Root;
var dict = (Ast.DictNode) result;
var items = dict.ElementsAsSet();
Assert.Contains(new Ast.KeyValueNode(new Ast.StringNode("a"), new Ast.IntegerNode(1)), items);
Assert.Contains(new Ast.KeyValueNode(new Ast.StringNode("b"), new Ast.IntegerNode(2)), items);
Assert.Contains(new Ast.KeyValueNode(new Ast.StringNode("c"), new Ast.IntegerNode(3)), items);
result = p.Parse("{1,2,3, }").Root;
result = p.Parse("{1,2,3 , }").Root;
result = p.Parse("{1,2,3,}").Root;
var set = (Ast.SetNode) result;
items = set.ElementsAsSet();
Assert.Contains(new Ast.IntegerNode(1), items);
Assert.Contains(new Ast.IntegerNode(2), items);
Assert.Contains(new Ast.IntegerNode(3), items);
Assert.DoesNotContain(new Ast.IntegerNode(4), items);
}
}
public class VisitorTest
{
[Fact]
public void TestObjectify()
{
var p = new Parser();
var ser = File.ReadAllBytes("testserpent.utf8.bin");
var ast = p.Parse(ser);
var visitor = new ObjectifyVisitor();
ast.Accept(visitor);
var thing = visitor.GetObject();
var dict = (IDictionary) thing;
Assert.Equal(11, dict.Count);
var list = dict["numbers"] as IList;
Assert.Equal(4, list.Count);
Assert.Equal(999.1234, list[1]);
Assert.Equal(new ComplexNumber(-3, 8), list[3]);
var euro = dict["unicode"] as string;
Assert.Equal("\u20ac", euro);
var exc = (IDictionary) dict["exc"];
var args = (object[]) exc["args"];
Assert.Equal("fault", args[0]);
Assert.Equal("ZeroDivisionError", exc["__class__"]);
}
private object ZerodivisionFromDict(IDictionary dict)
{
var classname = (string) dict["__class__"];
if (classname != "ZeroDivisionError") return null;
var args = (object[]) dict["args"];
return new DivideByZeroException((string) args[0]);
}
[Fact]
public void TestObjectifyDictToClass()
{
var p = new Parser();
var ser = File.ReadAllBytes("testserpent.utf8.bin");
var ast = p.Parse(ser);
var visitor = new ObjectifyVisitor(ZerodivisionFromDict);
ast.Accept(visitor);
var thing = visitor.GetObject();
var dict = (IDictionary) thing;
Assert.Equal(11, dict.Count);
var ex = (DivideByZeroException) dict["exc"];
Assert.Equal("fault", ex.Message);
thing = ast.GetData(ZerodivisionFromDict);
dict = (IDictionary) thing;
Assert.Equal(11, dict.Count);
ex = (DivideByZeroException) dict["exc"];
Assert.Equal("fault", ex.Message);
}
}
} Serpent-serpent-1.42/dotnet/Serpent/Tests/SerializeTest.cs 0000664 0000000 0000000 00000055266 15077515333 0023722 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Text;
using Xunit;
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
// ReSharper disable MemberCanBeMadeStatic.Local
namespace Razorvine.Serpent.Test
{
public class SerializeTest
{
private static byte[] strip_header(byte[] data)
{
int start=Array.IndexOf(data, (byte)10); // the newline after the header
if(start<0)
throw new ArgumentException("need header in string");
start++;
var result = new byte[data.Length-start];
Array.Copy(data, start, result, 0, data.Length-start);
return result;
}
private byte[] B(string s)
{
return Encoding.UTF8.GetBytes(s);
}
private string S(byte[] b)
{
return Encoding.UTF8.GetString(b);
}
[Fact]
public void TestHeader()
{
var ser = new Serializer();
var data = ser.Serialize(null);
Assert.Equal(35, data[0]);
string strdata = S(data);
Assert.Equal("# serpent utf-8 python3.2", strdata.Split('\n')[0]);
data = B("# header\nfirst-line");
data = strip_header(data);
Assert.Equal(B("first-line"), data);
}
[Fact]
public void TestStuff()
{
var ser=new Serializer();
var result = ser.Serialize("blerp");
result= strip_header(result);
Assert.Equal(B("'blerp'"), result);
result = ser.Serialize(new Guid("f1f8d00e-49a5-4662-ac1d-d5f0426ed293"));
result= strip_header(result);
Assert.Equal(B("'f1f8d00e-49a5-4662-ac1d-d5f0426ed293'"), result);
result = ser.Serialize(123456789.987654321987654321987654321987654321m);
result= strip_header(result);
Assert.Equal(B("'123456789.98765432198765432199'"), result);
}
[Fact]
public void TestNull()
{
var ser = new Serializer();
var data = ser.Serialize(null);
data= strip_header(data);
Assert.Equal(B("None"),data);
}
[Fact]
public void TestStrings()
{
var serpent = new Serializer();
var ser = serpent.Serialize("hello");
var data = strip_header(ser);
Assert.Equal(B("'hello'"), data);
ser = serpent.Serialize("quotes'\"");
data = strip_header(ser);
Assert.Equal(B("'quotes\\'\"'"), data);
ser = serpent.Serialize("quotes2'");
data = strip_header(ser);
Assert.Equal(B("\"quotes2'\""), data);
}
[Fact]
public void TestUnicodeEscapes()
{
var serpent=new Serializer();
// regular escaped chars first
var ser = serpent.Serialize("\b\r\n\f\t \\");
var data = strip_header(ser);
// '\\x08\\r\\n\\x0c\\t \\\\'
Assert.Equal(new byte[] {39,
92, 120, 48, 56,
92, 114,
92, 110,
92, 120, 48, 99,
92, 116,
32,
92, 92,
39}, data);
// simple cases (chars < 0x80)
ser = serpent.Serialize("\u0000\u0001\u001f\u007f");
data = strip_header(ser);
// '\\x00\\x01\\x1f\\x7f'
Assert.Equal(new byte[] {39,
92, 120, 48, 48,
92, 120, 48, 49,
92, 120, 49, 102,
92, 120, 55, 102,
39 }, data);
// chars 0x80 .. 0xff
ser = serpent.Serialize("\u0080\u0081\u00ff");
data = strip_header(ser);
// '\\x80\\x81\xc3\xbf' (has some utf-8 encoded chars in it)
Assert.Equal(new byte[] {39,
92, 120, 56, 48,
92, 120, 56, 49,
195, 191,
39}, data);
// chars above 0xff
ser = serpent.Serialize("\u0100\u20ac\u8899");
data = strip_header(ser);
// '\xc4\x80\xe2\x82\xac\xe8\xa2\x99' (has some utf-8 encoded chars in it)
Assert.Equal(new byte[] {39, 196, 128, 226, 130, 172, 232, 162, 153, 39}, data);
// // some random high chars that are all printable in python and not escaped
// ser = serpent.Serialize("\u0377\u082d\u10c5\u135d\uac00");
// data = strip_header(ser);
// Console.WriteLine(S(data)); // XXX
// // '\xcd\xb7\xe0\xa0\xad\xe1\x83\x85\xe1\x8d\x9d\xea\xb0\x80' (only a bunch of utf-8 encoded chars)
// Assert.Equal(new byte[] {39, 205, 183, 224, 160, 173, 225, 131, 133, 225, 141, 157, 234, 176, 128, 39}, data);
// some random high chars that are all non-printable in python and that are escaped
ser = serpent.Serialize("\u0378\u082e\u10c6\u135c\uabff");
data = strip_header(ser);
// '\\u0378\\u082e\\u10c6\\u135c\\uabff'
Assert.Equal(new byte[] {39,
92, 117, 48, 51, 55, 56,
92, 117, 48, 56, 50, 101,
92, 117, 49, 48, 99, 54,
92, 117, 49, 51, 53, 99,
92, 117, 97, 98, 102, 102,
39}, data);
}
[Fact]
public void TestNumbers()
{
var serpent = new Serializer();
var ser = serpent.Serialize(12345);
var data = strip_header(ser);
Assert.Equal(B("12345"), data);
ser = serpent.Serialize((uint)12345);
data = strip_header(ser);
Assert.Equal(B("12345"), data);
ser = serpent.Serialize(-1234567891234567891L);
data = strip_header(ser);
Assert.Equal(B("-1234567891234567891"), data);
ser = serpent.Serialize(12345678912345678912L);
data = strip_header(ser);
Assert.Equal(B("12345678912345678912"), data);
ser = serpent.Serialize(99.1234);
data = strip_header(ser);
Assert.Equal(B("99.1234"), data);
ser = serpent.Serialize(1234.9999999999m);
data = strip_header(ser);
Assert.Equal(B("'1234.9999999999'"), data);
ser = serpent.Serialize(123456789.987654321987654321987654321987654321m);
data= strip_header(ser);
Assert.Equal(B("'123456789.98765432198765432199'"), data);
var cplx = new ComplexNumber(2.2, 3.3);
ser = serpent.Serialize(cplx);
data = strip_header(ser);
Assert.Equal(B("(2.2+3.3j)"), data);
cplx = new ComplexNumber(0, 3);
ser = serpent.Serialize(cplx);
data = strip_header(ser);
Assert.Equal(B("(0+3j)"), data);
cplx = new ComplexNumber(-2, -3);
ser = serpent.Serialize(cplx);
data = strip_header(ser);
Assert.Equal(B("(-2-3j)"), data);
}
[Fact]
public void TestDoubleNanInf()
{
var serpent = new Serializer();
var doubles = new object[] {double.PositiveInfinity, double.NegativeInfinity, double.NaN,
float.PositiveInfinity, float.NegativeInfinity, float.NaN,
new ComplexNumber(double.PositiveInfinity, 3.4)};
var ser = serpent.Serialize(doubles);
var data = strip_header(ser);
Assert.Equal("(1e30000,-1e30000,{'__class__':'float','value':'nan'},1e30000,-1e30000,{'__class__':'float','value':'nan'},(1e30000+3.4j))", S(data));
}
[Fact]
public void TestBool()
{
var serpent = new Serializer();
var ser = serpent.Serialize(true);
var data = strip_header(ser);
Assert.Equal(B("True"),data);
ser = serpent.Serialize(false);
data = strip_header(ser);
Assert.Equal(B("False"),data);
}
[Fact]
public void TestList()
{
var serpent = new Serializer();
var list = new List();
// test empty list
var ser = strip_header(serpent.Serialize(list));
Assert.Equal("[]", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(list));
Assert.Equal("[]", S(ser));
serpent.Indent=false;
// test nonempty list
list.Add(42);
list.Add("Sally");
list.Add(16.5);
ser = strip_header(serpent.Serialize(list));
Assert.Equal("[42,'Sally',16.5]", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(list));
Assert.Equal("[\n 42,\n 'Sally',\n 16.5\n]", S(ser));
}
[Fact]
public void TestSet()
{
// test with set literals
var serpent = new Serializer();
var set = new HashSet();
// test empty set
var ser = strip_header(serpent.Serialize(set));
Assert.Equal("()", S(ser)); // empty set is serialized as a tuple.
serpent.Indent=true;
ser = strip_header(serpent.Serialize(set));
Assert.Equal("()", S(ser)); // empty set is serialized as a tuple.
serpent.Indent=false;
// test nonempty set
set.Add(42);
set.Add("Sally");
set.Add(16.5);
ser = strip_header(serpent.Serialize(set));
Assert.Equal("{42,'Sally',16.5}", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(set));
Assert.Equal("{\n 42,\n 'Sally',\n 16.5\n}", S(ser));
}
[Fact]
public void TestDictionary()
{
var serpent = new Serializer();
var p = new Parser();
// test empty dict
IDictionary ht = new Hashtable();
var ser = serpent.Serialize(ht);
Assert.Equal(B("{}"), strip_header(ser));
string parsed = p.Parse(ser).Root.ToString();
Assert.Equal("{}", parsed);
// empty dict with indentation
serpent.Indent=true;
ser = serpent.Serialize(ht);
Assert.Equal(B("{}"), strip_header(ser));
parsed = p.Parse(ser).Root.ToString();
Assert.Equal("{}", parsed);
// test dict with values
serpent.Indent=false;
ht = new Hashtable
{
{42, "fortytwo"},
{"sixteen-and-half", 16.5},
{"name", "Sally"},
{"status", false}
};
ser = serpent.Serialize(ht);
Assert.Equal((int)'}', ser[^1]);
Assert.NotEqual((int)',', ser[^2]);
parsed = p.Parse(ser).Root.ToString();
Assert.Equal(69, parsed.Length);
// test indentation
serpent.Indent=true;
ser = serpent.Serialize(ht);
Assert.Equal((int)'}', ser[^1]);
Assert.Equal((int)'\n', ser[^2]);
Assert.NotEqual((int)',', ser[^3]);
string ser_str = S(strip_header(ser));
Assert.Contains("'name': 'Sally'", ser_str);
Assert.Contains("'status': False", ser_str);
Assert.Contains("42: 'fortytwo'", ser_str);
Assert.Contains("'sixteen-and-half': 16.5", ser_str);
parsed = p.Parse(ser).Root.ToString();
Assert.Equal(69, parsed.Length);
serpent.Indent=false;
// generic Dictionary test
IDictionary mydict = new Dictionary {
{ 1, "one" },
{ 2, "two" }
};
ser = serpent.Serialize(mydict);
ser_str = S(strip_header(ser));
Assert.True(ser_str is "{2:'two',1:'one'}" or "{1:'one',2:'two'}");
}
[Fact]
public void TestBytesDefault()
{
var serpent = new Serializer(true);
byte[] bytes = { 97, 98, 99, 100, 101, 102 }; // abcdef
var ser = serpent.Serialize(bytes);
Assert.Equal("{\n 'data': 'YWJjZGVm',\n 'encoding': 'base64'\n}", S(strip_header(ser)));
var p = new Parser();
string parsed = p.Parse(ser).Root.ToString();
Assert.Equal(39, parsed.Length);
var hashtable = new Hashtable {
{"data", "YWJjZGVm"},
{"encoding", "base64"}
};
var bytes2 = Parser.ToBytes(hashtable);
Assert.Equal(bytes, bytes2);
var dict = new Dictionary {
{"data", "YWJjZGVm"},
{"encoding", "base64"}
};
bytes2 = Parser.ToBytes(dict);
Assert.Equal(bytes, bytes2);
var dict2 = new Dictionary {
{"data", "YWJjZGVm"},
{"encoding", "base64"}
};
bytes2 = Parser.ToBytes(dict2);
Assert.Equal(bytes, bytes2);
dict["encoding"] = "base99";
Assert.Throws(()=>Parser.ToBytes(dict));
dict.Clear();
Assert.Throws(()=>Parser.ToBytes(dict));
dict.Clear();
dict["data"] = "YWJjZGVm";
Assert.Throws(()=>Parser.ToBytes(dict));
dict.Clear();
dict["encoding"] = "base64";
Assert.Throws(()=>Parser.ToBytes(dict));
Assert.Throws(()=>Parser.ToBytes(12345));
Assert.Throws(()=>Parser.ToBytes(null));
}
[Fact]
public void TestBytesRepr()
{
var serpent = new Serializer(indent: true, bytesRepr:true);
byte[] bytes = { 97, 98, 99, 100, 101, 102, 0, 255, (byte)'\'', (byte)'\"' }; // abcdef\x00\xff'"
var ser = serpent.Serialize(bytes);
Assert.Equal("b'abcdef\\x00\\xff\\'\"'", S(strip_header(ser)));
var p = new Parser();
var parsed = (Ast.BytesNode) p.Parse(ser).Root;
Assert.Equal(bytes, parsed.Value);
}
[Fact]
public void TestCollection()
{
ICollection intlist = new LinkedList();
intlist.Add(42);
intlist.Add(43);
var serpent = new Serializer();
var ser = serpent.Serialize(intlist);
ser = strip_header(ser);
Assert.Equal("[42,43]", S(ser));
ser= strip_header(serpent.Serialize(new [] {42}));
Assert.Equal("(42,)", S(ser));
ser= strip_header(serpent.Serialize(new [] {42, 43}));
Assert.Equal("(42,43)", S(ser));
serpent.Indent=true;
ser = strip_header(serpent.Serialize(intlist));
Assert.Equal("[\n 42,\n 43\n]", S(ser));
ser= strip_header(serpent.Serialize(new [] {42}));
Assert.Equal("(\n 42,\n)", S(ser));
ser= strip_header(serpent.Serialize(new [] {42, 43}));
Assert.Equal("(\n 42,\n 43\n)", S(ser));
}
[Fact]
public void TestIndentation()
{
var dict = new Dictionary();
var list = new List
{
1,
2,
new [] {"a", "b"}
};
dict.Add("first", list);
dict.Add("second", new Dictionary {
{1, false}
});
dict.Add("third", new HashSet { 3, 4} );
var serpent = new Serializer {Indent = true};
var ser = strip_header(serpent.Serialize(dict));
string txt=@"{
'first': [
1,
2,
(
'a',
'b'
)
],
'second': {
1: False
},
'third': {
3,
4
}
}";
// bit of trickery to deal with Windows/Unix line ending differences
txt = txt.Replace("\n","\r\n");
txt = txt.Replace("\r\r\n", "\r\n");
string ser_txt = S(ser);
ser_txt = ser_txt.Replace("\n", "\r\n");
ser_txt = ser_txt.Replace("\r\r\n", "\r\n");
Assert.Equal(txt, ser_txt);
}
[Fact]
public void TestSorting()
{
var serpent=new Serializer();
object data = new List { 3, 2, 1};
var ser = strip_header(serpent.Serialize(data));
Assert.Equal("[3,2,1]", S(ser));
data = new [] { 3,2,1 };
ser = strip_header(serpent.Serialize(data));
Assert.Equal("(3,2,1)", S(ser));
data = new HashSet {
42,
"hi"
};
serpent.Indent=true;
ser = strip_header(serpent.Serialize(data));
Assert.True(S(ser)=="{\n 42,\n 'hi'\n}" || S(ser)=="{\n 'hi',\n 42\n}");
data = new Dictionary {
{5, "five"},
{3, "three"},
{1, "one"},
{4, "four"},
{2, "two"}
};
serpent.Indent=true;
ser = strip_header(serpent.Serialize(data));
Assert.Equal("{\n 1: 'one',\n 2: 'two',\n 3: 'three',\n 4: 'four',\n 5: 'five'\n}", S(ser));
data = new HashSet {
"x",
"y",
"z",
"c",
"b",
"a"
};
serpent.Indent=true;
ser = strip_header(serpent.Serialize(data));
Assert.Equal("{\n 'a',\n 'b',\n 'c',\n 'x',\n 'y',\n 'z'\n}", S(ser));
}
[Fact]
public void TestClass()
{
Serializer.RegisterClass(typeof(SerializeTestClass), null);
var serpent = new Serializer(true);
var obj = new SerializeTestClass
{
i = 99,
s = "hi",
x = 42
};
var ser = strip_header(serpent.Serialize(obj));
Assert.Equal("{\n '__class__': 'SerializeTestClass',\n 'i': 99,\n 'obj': None,\n 's': 'hi'\n}", S(ser));
}
[Fact]
public void TestClass2()
{
Serializer.RegisterClass(typeof(SerializeTestClass), null);
var serpent = new Serializer(true, namespaceInClassName: true);
object obj = new SerializeTestClass
{
i = 99,
s = "hi",
x = 42
};
var ser = strip_header(serpent.Serialize(obj));
Assert.Equal("{\n '__class__': 'Razorvine.Serpent.Test.SerializeTestClass',\n 'i': 99,\n 'obj': None,\n 's': 'hi'\n}", S(ser));
}
private IDictionary testclassConverter(object obj)
{
var o = (SerializeTestClass) obj;
IDictionary result = new Hashtable();
result["__class@__"] = o.GetType().Name+"@";
result["i@"] = o.i;
result["s@"] = o.s;
result["x@"] = o.x;
return result;
}
[Fact]
public void TestCustomClassDict()
{
Serializer.RegisterClass(typeof(SerializeTestClass), testclassConverter);
var serpent = new Serializer(true);
var obj = new SerializeTestClass
{
i = 99,
s = "hi",
x = 42
};
var ser = strip_header(serpent.Serialize(obj));
Assert.Equal("{\n '__class@__': 'SerializeTestClass@',\n 'i@': 99,\n 's@': 'hi',\n 'x@': 42\n}", S(ser));
}
[Fact]
public void TestStruct()
{
var serpent = new Serializer(true);
var obj2 = new SerializeTestStruct
{
i = 99,
s = "hi",
x = 42
};
var ser = strip_header(serpent.Serialize(obj2));
Assert.Equal("{\n '__class__': 'SerializeTestStruct',\n 'i': 99,\n 's': 'hi'\n}", S(ser));
}
[Fact]
public void TestStruct2()
{
var serpent = new Serializer(true, namespaceInClassName: true);
var obj2 = new SerializeTestStruct
{
i = 99,
s = "hi",
x = 42
};
var ser = strip_header(serpent.Serialize(obj2));
Assert.Equal("{\n '__class__': 'Razorvine.Serpent.Test.SerializeTestStruct',\n 'i': 99,\n 's': 'hi'\n}", S(ser));
}
[Fact]
public void TestAnonymousClass()
{
var serpent = new Serializer(true);
object obj = new {
Name="Harry",
Age=33,
Country="NL"
};
var ser = strip_header(serpent.Serialize(obj));
Assert.Equal("{\n 'Age': 33,\n 'Country': 'NL',\n 'Name': 'Harry'\n}", S(ser));
}
[Fact]
public void TestDateTime()
{
var serpent = new Serializer();
var date = new DateTime(2013, 1, 20, 23, 59, 45, 999, DateTimeKind.Local);
var ser = strip_header(serpent.Serialize(date));
Assert.Equal("'2013-01-20T23:59:45.999'", S(ser));
date = new DateTime(2013, 1, 20, 23, 59, 45, 999, DateTimeKind.Utc);
ser = strip_header(serpent.Serialize(date));
Assert.Equal("'2013-01-20T23:59:45.999'", S(ser));
date = new DateTime(2013, 1, 20, 23, 59, 45, 999, DateTimeKind.Unspecified);
ser = strip_header(serpent.Serialize(date));
Assert.Equal("'2013-01-20T23:59:45.999'", S(ser));
date = new DateTime(2013, 1, 20, 23, 59, 45);
ser = strip_header(serpent.Serialize(date));
Assert.Equal("'2013-01-20T23:59:45'", S(ser));
var timespan = new TimeSpan(1, 10, 20, 30, 999);
ser = strip_header(serpent.Serialize(timespan));
Assert.Equal("123630.999", S(ser));
}
[Fact]
public void TestDateTimeOffset()
{
var serpent = new Serializer();
var date = new DateTimeOffset(2013, 1, 20, 23, 59, 45, 999, TimeSpan.FromHours(+2));
var ser = strip_header(serpent.Serialize(date));
Assert.Equal("'2013-01-20T23:59:45.999+02:00'", S(ser));
date = new DateTimeOffset(2013, 5, 10, 13, 59, 45, TimeSpan.FromHours(+2));
ser = strip_header(serpent.Serialize(date));
Assert.Equal("'2013-05-10T13:59:45+02:00'", S(ser));
}
[Fact]
public void TestException()
{
Exception x = new ApplicationException("errormessage");
var serpent = new Serializer(true);
var ser = strip_header(serpent.Serialize(x));
Assert.Equal("{\n '__class__': 'ApplicationException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {}\n}", S(ser));
x.Data["custom_attribute"]=999;
ser = strip_header(serpent.Serialize(x));
Assert.Equal("{\n '__class__': 'ApplicationException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {\n 'custom_attribute': 999\n }\n}", S(ser));
}
[Fact]
public void TestExceptionWithNamespace()
{
Exception x = new ApplicationException("errormessage");
var serpent = new Serializer(true, namespaceInClassName: true);
var ser = strip_header(serpent.Serialize(x));
Assert.Equal("{\n '__class__': 'System.ApplicationException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {}\n}", S(ser));
}
private enum FooType {
Jarjar
}
[Fact]
public void TestEnum()
{
const FooType e = FooType.Jarjar;
var serpent = new Serializer();
var ser = strip_header(serpent.Serialize(e));
Assert.Equal("'Jarjar'", S(ser));
}
private interface IBaseInterface {}
private interface ISubInterface : IBaseInterface {}
private class BaseClassWithInterface : IBaseInterface {}
private class SubClassWithInterface : BaseClassWithInterface, ISubInterface {}
private abstract class AbstractBaseClass {}
private class ConcreteSubClass : AbstractBaseClass {}
private IDictionary AnyClassSerializer(object arg)
{
IDictionary result = new Hashtable();
result["(SUB)CLASS"] = arg.GetType().Name;
return result;
}
[Fact]
public void testAbstractBaseClassHierarchyPickler()
{
var c = new ConcreteSubClass();
var serpent = new Serializer();
serpent.Serialize(c);
Serializer.RegisterClass(typeof(AbstractBaseClass), AnyClassSerializer);
var data = serpent.Serialize(c);
Assert.Equal("{'(SUB)CLASS':'ConcreteSubClass'}", S(strip_header(data)));
}
[Fact]
public void TestInterfaceHierarchyPickler()
{
var b = new BaseClassWithInterface();
var sub = new SubClassWithInterface();
var serpent = new Serializer();
serpent.Serialize(b);
serpent.Serialize(sub);
Serializer.RegisterClass(typeof(IBaseInterface), AnyClassSerializer);
var data = serpent.Serialize(b);
Assert.Equal("{'(SUB)CLASS':'BaseClassWithInterface'}", S(strip_header(data)));
data = serpent.Serialize(sub);
Assert.Equal("{'(SUB)CLASS':'SubClassWithInterface'}", S(strip_header(data)));
}
}
[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Local")]
[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]
public class SerializeTestClass
{
public int x;
public string s {get; set;}
public int i {get; set;}
public object obj {get; set;}
protected bool Equals(SerializeTestClass other)
{
return x == other.x && string.Equals(s, other.s) && i == other.i && Equals(obj, other.obj);
}
public override int GetHashCode()
{
unchecked
{
int hashCode = x;
hashCode = (hashCode * 397) ^ (s != null ? s.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ i;
hashCode = (hashCode * 397) ^ (obj != null ? obj.GetHashCode() : 0);
return hashCode;
}
}
}
[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Local")]
[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]
public struct SerializeTestStruct
{
// ReSharper disable once NotAccessedField.Global
public int x;
public string s {get; set;}
public int i {get; set;}
public bool Equals(SerializeTestStruct other)
{
return x == other.x && string.Equals(s, other.s) && i == other.i;
}
public override int GetHashCode()
{
unchecked
{
int hashCode = x;
hashCode = (hashCode * 397) ^ (s != null ? s.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ i;
return hashCode;
}
}
}
}
Serpent-serpent-1.42/dotnet/Serpent/Tests/SlowPerformanceTest.cs 0000664 0000000 0000000 00000003366 15077515333 0025073 0 ustar 00root root 0000000 0000000 using System;
using Xunit;
using Xunit.Abstractions;
// ReSharper disable CheckNamespace
namespace Razorvine.Serpent.Test
{
public class SlowPerformanceTest {
private readonly ITestOutputHelper _testOutputHelper;
public SlowPerformanceTest(ITestOutputHelper testOutputHelper)
{
_testOutputHelper = testOutputHelper;
}
// tests some performance regressions when they occur
[Fact(Skip="number parse performance in long lists has been resolved")]
public void TestManyFloats()
{
const int amount = 200000;
var array = new double[amount];
for(int i=0; i(()=>s2.Peek());
}
}
[Fact]
public void TestRead()
{
var s = new SeekableStringReader("hello");
Assert.Equal('h', s.Read());
Assert.Equal('e', s.Read());
Assert.Equal("l", s.Read(1));
Assert.Equal("lo", s.Read(2));
Assert.Throws(()=>s.Read());
}
[Fact]
public void TestRanges()
{
var s = new SeekableStringReader("hello");
Assert.Throws(()=>s.Read(-1));
Assert.Equal("hello", s.Read(999));
Assert.Throws(()=>s.Read(1));
s.Rewind(int.MaxValue);
Assert.True(s.HasMore());
Assert.Equal("hello", s.Peek(999));
Assert.True(s.HasMore());
}
[Fact]
public void TestReadUntil()
{
var s = new SeekableStringReader("hello there");
s.Read();
Assert.Equal("ello", s.ReadUntil(' '));
Assert.Equal('t', s.Peek());
Assert.Throws(()=>s.ReadUntil('x'));
Assert.Equal("there", s.Rest());
Assert.Throws(()=>s.Rest());
s.Rewind(int.MaxValue);
Assert.Equal("hell", s.ReadUntil('x', 'y', 'z', ' ', 'o'));
Assert.Throws(()=>s.ReadUntil('x', 'y', '@'));
}
[Fact]
public void TestReadWhile()
{
var s = new SeekableStringReader("123.456 foo");
Assert.Equal("123.456", s.ReadWhile("0123456789."));
Assert.Equal("", s.ReadWhile("@"));
Assert.Equal(" ", s.ReadWhile(" "));
Assert.Equal("foo", s.Rest());
}
[Fact]
public void TestBookmark()
{
var s = new SeekableStringReader("hello");
s.Read(2);
int bookmark = s.Bookmark();
Assert.Equal("ll", s.Read(2));
s.FlipBack(bookmark);
Assert.Equal("ll", s.Read(2));
Assert.Equal("o", s.Read(999));
}
[Fact]
public void TestNesting()
{
var outer = new SeekableStringReader("hello!");
outer.Read(1);
var inner1 = new SeekableStringReader(outer);
var inner2 = new SeekableStringReader(outer);
Assert.Equal("ell", inner1.Read(3));
Assert.Equal("el", inner2.Read(2));
Assert.Equal("o", inner1.Read(1));
Assert.Equal("l", inner2.Read(1));
Assert.Equal("e", outer.Read(1));
Assert.Equal("o", inner2.Read(1));
Assert.Equal("l", outer.Read(1));
outer.Sync(inner2);
Assert.Equal("!", outer.Read(1));
}
[Fact]
public void TestContext()
{
var s = new SeekableStringReader("abcdefghijklmnopqrstuvwxyz");
s.Read(10);
s.Context(-1, 5, out var left, out var right);
Assert.Equal("fghij", left);
Assert.Equal("klmno", right);
s.Context(-1, 12, out left, out right);
Assert.Equal("abcdefghij", left);
Assert.Equal("klmnopqrstuv", right);
s.Read(13);
s.Context(-1, 6, out left, out right);
Assert.Equal("rstuvw", left);
Assert.Equal("xyz", right);
s.Context(5,4, out left, out right);
Assert.Equal("bcde", left);
Assert.Equal("fghi", right);
}
}
} Serpent-serpent-1.42/dotnet/Serpent/Tests/Tests.csproj 0000664 0000000 0000000 00000002103 15077515333 0023106 0 ustar 00root root 0000000 0000000
net9.0
false
latestmajor
UnitTests
UnitTests
Library
all
runtime; build; native; contentfiles; analyzers; buildtransitive
PreserveNewest
Serpent-serpent-1.42/dotnet/Serpent/Tests/testserpent.utf8.bin 0000664 0000000 0000000 00000002236 15077515333 0024530 0 ustar 00root root 0000000 0000000 # serpent utf-8 python3.3
{
# serpent supports comments in the serialized data
'bytes': {
'data': 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==',
'encoding': 'base64'
},
'dates': [ # test some dates.
'2013-01-26T03:32:39.007001',
'23:59:45.999888',
500.0
],
'dict': {
0: '0000',
1: '1111',
2: '2222',
3: '3333',
4: '4444',
5: '5555',
6: '6666',
7: '7777',
8: '8888',
9: '9999'
},
'exc': {
'__class__': 'ZeroDivisionError',
'__exception__': True, # this is an exception
'args': (
'fault',
),
'attributes': {}
},
'list': [
1,
2,
3,
4,
5,
6,
7,
8
],
'numbers': [
12345678901234567890123456,
999.1234,
'1.99999999999999999991',
(-3+8j)
],
'set': {
1,
2,
3,
4,
5,
6,
7,
8,
9
},
'str': 'hello',
'tuple': (
1,
2,
3,
4,
5,
6,
7,
8
),
'unicode': '€', # the feared unicode!
'uuid': '57e12d82-511f-456b-ab65-f765144c6a90'
} Serpent-serpent-1.42/dotnet/Serpent/global.json 0000664 0000000 0000000 00000000151 15077515333 0021614 0 ustar 00root root 0000000 0000000 {
"sdk": {
"version": "9.0.0",
"rollForward": "latestMajor",
"allowPrerelease": false
}
} Serpent-serpent-1.42/dotnet/nuget-pack.sh 0000775 0000000 0000000 00000000627 15077515333 0020446 0 ustar 00root root 0000000 0000000 #!/bin/sh
set -e
echo "Building and testing..."
dotnet test -c Release Serpent/Tests
echo "\n\nCreating nuget release package..."
dotnet pack -c Release -o $(pwd)/dist Serpent
echo "\n\nPackage available in dist/ directory:"
ls -l dist
echo "\nIf this is allright, publish to nuget.org with:"
echo "dotnet nuget push dist/Razorvine.Serpent.xxxxx.nupkg -s https://www.nuget.org -k api_key_from_nuget_org"
Serpent-serpent-1.42/dotnet/test.sh 0000775 0000000 0000000 00000000071 15077515333 0017360 0 ustar 00root root 0000000 0000000 #!/bin/sh
echo "Running tests"
dotnet test Serpent/Tests
Serpent-serpent-1.42/java/ 0000775 0000000 0000000 00000000000 15077515333 0015470 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/.gitignore 0000664 0000000 0000000 00000000105 15077515333 0017454 0 ustar 00root root 0000000 0000000 # intellij workspace info
.idea/workspace.xml
# java/maven
target/
Serpent-serpent-1.42/java/.idea/ 0000775 0000000 0000000 00000000000 15077515333 0016450 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/.idea/.name 0000664 0000000 0000000 00000000007 15077515333 0017366 0 ustar 00root root 0000000 0000000 Serpent Serpent-serpent-1.42/java/.idea/Serpent.iml 0000664 0000000 0000000 00000002007 15077515333 0020572 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/.idea/compiler.xml 0000664 0000000 0000000 00000001503 15077515333 0021003 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/.idea/encodings.xml 0000664 0000000 0000000 00000000362 15077515333 0021144 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/.idea/libraries/ 0000775 0000000 0000000 00000000000 15077515333 0020424 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/.idea/libraries/Maven__org_hamcrest_hamcrest_core_1_3.xml 0000664 0000000 0000000 00000001010 15077515333 0030440 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/.idea/misc.xml 0000664 0000000 0000000 00000000614 15077515333 0020126 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/.idea/modules.xml 0000664 0000000 0000000 00000000412 15077515333 0020637 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/.idea/vcs.xml 0000664 0000000 0000000 00000000267 15077515333 0017772 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/mvn-release-readme.txt 0000664 0000000 0000000 00000000617 15077515333 0021706 0 ustar 00root root 0000000 0000000 Making a release to Sonatype Nexus/maven central:
$ mvn release:clean release:prepare release:perform
Requires version number in the pom.xml to be "x.y-SNAPSHOT".
Finalise and publish the release via https://oss.sonatype.org/#stagingRepositories
See also:
http://java.dzone.com/articles/deploy-maven-central
http://central.sonatype.org/pages/apache-maven.html#performing-a-release-deployment
Serpent-serpent-1.42/java/pom.xml 0000664 0000000 0000000 00000005661 15077515333 0017015 0 ustar 00root root 0000000 0000000
4.0.0
org.sonatype.oss
oss-parent
9
net.razorvine
serpent
1.41-SNAPSHOT
jar
serpent
https://github.com/irmen/Serpent
UTF-8
org.apache.maven.plugins
maven-compiler-plugin
3.8.0
-Xlint:all
1.8
1.8
org.apache.maven.plugins
maven-gpg-plugin
1.5
org.apache.maven.plugins
maven-release-plugin
2.5.2
org.apache.maven.plugins
maven-javadoc-plugin
none
junit
junit
4.13.1
test
Serpent serializes an object tree into a Python ast.literal_eval() compatible literal expression. It is safe to send serpent data to other machines over the network for instance
(because only 'safe' literals are encoded).
There is also a deserializer or parse provided that turns such a literal expression back into the appropriate Java object tree.
It is an alternative to JSON to provide easy data integration between Java and Python. Serpent is more expressive as JSON (it supports more data types).
https://github.com/irmen/Serpent
scm:git:https://github.com/irmen/Serpent.git
scm:git:https://github.com/irmen/Serpent.git
HEAD
Github
https://github.com/irmen/Serpent/issues
irmen
Irmen de Jong
irmen@razorvine.net
https://github.com/irmen
MIT License
http://www.opensource.org/licenses/mit-license.php
Serpent-serpent-1.42/java/serpent.iml 0000664 0000000 0000000 00000001657 15077515333 0017664 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.42/java/src/ 0000775 0000000 0000000 00000000000 15077515333 0016257 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/ 0000775 0000000 0000000 00000000000 15077515333 0017203 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/java/ 0000775 0000000 0000000 00000000000 15077515333 0020124 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/java/net/ 0000775 0000000 0000000 00000000000 15077515333 0020712 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/java/net/razorvine/ 0000775 0000000 0000000 00000000000 15077515333 0022731 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ 0000775 0000000 0000000 00000000000 15077515333 0024411 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ComplexNumber.java 0000664 0000000 0000000 00000004011 15077515333 0030030 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
import java.io.Serializable;
/**
* A complex number.
*/
public class ComplexNumber implements Serializable {
private static final long serialVersionUID = 5396759273405612137L;
public double real;
public double imaginary;
public ComplexNumber(double r, double i) {
real=r;
imaginary=i;
}
@Override
public String toString()
{
StringBuilder sb=new StringBuilder();
sb.append(real);
if(imaginary>0)
sb.append('+');
return sb.append(imaginary).append('i').toString();
}
public double Magnitude() {
return Math.sqrt(real * real + imaginary * imaginary);
}
public void add(ComplexNumber other)
{
real += other.real;
imaginary += other.imaginary;
}
public void subtract(ComplexNumber other)
{
real -= other.real;
imaginary -= other.imaginary;
}
public void multiply(ComplexNumber other)
{
double new_real = real * other.real - imaginary * other.imaginary;
double new_imaginary = real * other.imaginary + imaginary * other.real;
real = new_real;
imaginary = new_imaginary;
}
public void divide(ComplexNumber other)
{
double new_real = (real * other.real + imaginary * other.imaginary) / (other.real * other.real + other.imaginary * other.imaginary);
double new_imaginary = (imaginary * other.real - real * other.imaginary) / (other.real * other.real + other.imaginary * other.imaginary);
real = new_real;
imaginary = new_imaginary;
}
@Override
public boolean equals(Object obj)
{
if(!(obj instanceof ComplexNumber))
{
return false;
}
ComplexNumber other = (ComplexNumber) obj;
return real==other.real && imaginary==other.imaginary;
}
@Override
public int hashCode()
{
Double r = Double.valueOf(real);
Double i = Double.valueOf(imaginary);
return r.hashCode() ^ i.hashCode();
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/DebugVisitor.java 0000664 0000000 0000000 00000005356 15077515333 0027673 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
import net.razorvine.serpent.ast.*;
import java.util.Arrays;
/**
* Ast nodevisitor that prints out the Ast as a string for debugging purposes
*/
public class DebugVisitor implements INodeVisitor
{
private StringBuilder result = new StringBuilder();
private int indentlevel=0;
public DebugVisitor()
{
}
/**
* Get the debug string representation result.
*/
@Override
public String toString()
{
return result.toString();
}
protected void indent()
{
for(int i=0; i convert(Object obj);
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/IDictToInstance.java 0000664 0000000 0000000 00000001162 15077515333 0030240 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
import java.io.IOException;
import java.util.Map;
/**
* Customization interface for turning dicts back into specific objects.
*/
public interface IDictToInstance {
/**
* Convert the given dictionary to a specific object.
* Can return null to use the default behavior.
*/
Object convert(Map dict) throws IOException;
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/LibraryVersion.java 0000664 0000000 0000000 00000000556 15077515333 0030234 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
public final class LibraryVersion {
public static final String VERSION = "1.40";
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ObjectifyVisitor.java 0000664 0000000 0000000 00000006034 15077515333 0030555 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import net.razorvine.serpent.ast.*;
/**
* Ast nodevisitor that turns the AST into actual Java objects (array, int, IDictionary, string, etc...)
*/
public class ObjectifyVisitor implements INodeVisitor
{
Stack generated = new Stack();
protected IDictToInstance dictConverter = null;
public ObjectifyVisitor() {
}
public ObjectifyVisitor(IDictToInstance dictConverter) {
this.dictConverter = dictConverter;
}
/**
* get the resulting object tree.
*/
public Object getObject()
{
return generated.pop();
}
public void visit(ComplexNumberNode complex)
{
generated.push(new ComplexNumber(complex.real, complex.imaginary));
}
public void visit(DictNode dict)
{
Map obj = new HashMap(dict.elements.size());
for(INode e: dict.elements)
{
KeyValueNode kv = (KeyValueNode)e;
kv.key.accept(this);
Object key = generated.pop();
kv.value.accept(this);
Object value = generated.pop();
obj.put(key, value);
}
if(dictConverter==null || !obj.containsKey("__class__"))
{
generated.push(obj);
}
else
{
Object result;
try {
result = dictConverter.convert(obj);
} catch (IOException e) {
throw new RuntimeException("problem converting dict to class", e);
}
if(result==null)
generated.push(obj);
else
generated.push(result);
}
}
public void visit(ListNode list)
{
List obj = new ArrayList(list.elements.size());
for(INode node: list.elements)
{
node.accept(this);
obj.add(generated.pop());
}
generated.push(obj);
}
public void visit(NoneNode none)
{
generated.push(null);
}
public void visit(IntegerNode value)
{
generated.push(value.value);
}
public void visit(LongNode value)
{
generated.push(value.value);
}
public void visit(DoubleNode value)
{
generated.push(value.value);
}
public void visit(BooleanNode value)
{
generated.push(value.value);
}
public void visit(StringNode value)
{
generated.push(value.value);
}
public void visit(BytesNode value)
{
generated.push(value.value);
}
public void visit(BigIntNode value)
{
generated.push(value.value);
}
public void visit(SetNode setnode)
{
Set obj = new HashSet();
for(INode node: setnode.elements)
{
node.accept(this);
obj.add(generated.pop());
}
generated.push(obj);
}
public void visit(TupleNode tuple)
{
Object[] array = new Object[tuple.elements.size()];
int index=0;
for(INode node: tuple.elements)
{
node.accept(this);
array[index++] = generated.pop();
}
generated.push(array);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ParseException.java 0000664 0000000 0000000 00000001322 15077515333 0030203 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
/**
* Exception that is used when a serpent parsing error occurs.
*/
public class ParseException extends RuntimeException {
private static final long serialVersionUID = -667969719712045595L;
public ParseException() {
}
public ParseException(String message) {
super(message);
}
public ParseException(Throwable cause) {
super(cause);
}
public ParseException(String message, Throwable cause) {
super(message, cause);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/Parser.java 0000664 0000000 0000000 00000042076 15077515333 0026521 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Base64;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import net.razorvine.serpent.ast.*;
/**
* Parse a Python literal into an Ast (abstract syntax tree).
*/
public class Parser
{
/**
* Parse from a byte array (containing utf-8 encoded string with the Python literal expression in it)
*/
public Ast parse(byte[] serialized) throws ParseException
{
try {
return parse(new String(serialized, "utf-8"));
} catch (UnsupportedEncodingException e) {
throw new ParseException(e.toString());
}
}
/**
* Parse from a string with the Python literal expression
*/
public Ast parse(String expression)
{
Ast ast=new Ast();
if(expression==null || expression.length()==0)
return ast;
SeekableStringReader sr = new SeekableStringReader(expression);
if(sr.peek()=='#')
sr.readUntil('\n'); // skip comment line
try {
ast.root = parseExpr(sr);
sr.skipWhitespace();
if(sr.hasMore())
throw new ParseException("garbage at end of expression");
return ast;
} catch (ParseException x) {
String faultLocation = extractFaultLocation(sr);
throw new ParseException(x.getMessage() + " (at position "+sr.bookmark()+"; '"+faultLocation+"')", x);
}
}
String extractFaultLocation(SeekableStringReader sr)
{
SeekableStringReader.StringContext ctx = sr.context(-1, 20);
return String.format("...%s>>><<<%s...", ctx.left, ctx.right);
}
INode parseExpr(SeekableStringReader sr)
{
// expr = [ ] single | compound [ ] .
sr.skipWhitespace();
if(!sr.hasMore())
throw new ParseException("unexpected end of line, missing expression or close/open character");
char c = sr.peek();
INode node;
if(c=='{' || c=='[' || c=='(')
node = parseCompound(sr);
else
node = parseSingle(sr);
sr.skipWhitespace();
return node;
}
INode parseCompound(SeekableStringReader sr)
{
// compound = tuple | dict | list | set .
sr.skipWhitespace();
switch(sr.peek())
{
case '[':
return parseList(sr);
case '{':
{
int bm = sr.bookmark();
try {
return parseSet(sr);
} catch(ParseException x) {
sr.flipBack(bm);
return parseDict(sr);
}
}
case '(':
// tricky case here, it can be a tuple but also a complex number:
// if the last character before the closing parenthesis is a 'j', it is a complex number
{
int bm = sr.bookmark();
String betweenparens = sr.readUntil(")\n").trim();
sr.flipBack(bm);
return betweenparens.endsWith("j") ? parseComplex(sr) : parseTuple(sr);
}
default:
throw new ParseException("invalid sequencetype char");
}
}
TupleNode parseTuple(SeekableStringReader sr)
{
//tuple = tuple_empty | tuple_one | tuple_more
//tuple_empty = '()' .
//tuple_one = '(' expr ',' ')' .
//tuple_more = '(' expr_list trailing_comma ')' .
// trailing_comma = '' | ',' .
sr.read(); // (
sr.skipWhitespace();
TupleNode tuple = new TupleNode();
if(sr.peek() == ')')
{
sr.read();
return tuple; // empty tuple
}
INode firstelement = parseExpr(sr);
if(sr.peek() == ',')
{
sr.read();
sr.skipWhitespace();
if(sr.read() == ')')
{
// tuple with just a single element
tuple.elements.add(firstelement);
return tuple;
}
sr.rewind(1); // undo the thing that wasn't a )
}
tuple.elements = parseExprList(sr);
tuple.elements.add(0, firstelement);
// handle trailing comma if present
sr.skipWhitespace();
if(!sr.hasMore())
throw new ParseException("missing ')'");
if(sr.peek() == ',')
sr.read();
if(!sr.hasMore())
throw new ParseException("missing ')'");
char closechar = sr.read();
if(closechar==',')
closechar = sr.read();
if(closechar!=')')
throw new ParseException("expected ')'");
return tuple;
}
List parseExprList(SeekableStringReader sr)
{
//expr_list = expr { ',' expr } .
List exprList = new ArrayList();
exprList.add(parseExpr(sr));
while(sr.hasMore() && sr.peek() == ',')
{
sr.read();
try {
exprList.add(parseExpr(sr));
} catch (ParseException x) {
sr.rewind(1);
break;
}
}
return exprList;
}
List parseKeyValueList(SeekableStringReader sr)
{
//keyvalue_list = keyvalue { ',' keyvalue } .
List kvs = new ArrayList();
kvs.add(parseKeyValue(sr));
while(sr.hasMore() && sr.peek()==',')
{
sr.read();
try {
kvs.add(parseKeyValue(sr));
} catch (ParseException x) {
sr.rewind(1);
break;
}
}
return kvs;
}
KeyValueNode parseKeyValue(SeekableStringReader sr)
{
//keyvalue = expr ':' expr .
INode key = parseExpr(sr);
if(sr.hasMore() && sr.peek()==':')
{
sr.read(); // :
INode value = parseExpr(sr);
KeyValueNode kv = new KeyValueNode();
kv.key = key;
kv.value = value;
return kv;
}
throw new ParseException("expected ':'");
}
SetNode parseSet(SeekableStringReader sr)
{
// set = '{' expr_list trailing_comma '}' .
// trailing_comma = '' | ',' .
sr.read(); // {
sr.skipWhitespace();
SetNode setnode = new SetNode();
List elts = parseExprList(sr);
// handle trailing comma if present
sr.skipWhitespace();
if(!sr.hasMore())
throw new ParseException("missing '}'");
if(sr.peek() == ',')
sr.read();
if(!sr.hasMore())
throw new ParseException("missing '}'");
char closechar = sr.read();
if(closechar!='}')
throw new ParseException("expected '}'");
// make sure it has set semantics (remove duplicate elements)
Set h = new HashSet(elts);
setnode.elements = new ArrayList(h);
return setnode;
}
ListNode parseList(SeekableStringReader sr)
{
// list = list_empty | list_nonempty .
// list_empty = '[]' .
// list_nonempty = '[' expr_list trailing_comma ']' .
// trailing_comma = '' | ',' .
sr.read(); // [
sr.skipWhitespace();
ListNode list = new ListNode();
if(sr.peek() == ']')
{
sr.read();
return list; // empty list
}
list.elements = parseExprList(sr);
// handle trailing comma if present
sr.skipWhitespace();
if(!sr.hasMore())
throw new ParseException("missing ']'");
if(sr.peek() == ',')
sr.read();
if(!sr.hasMore())
throw new ParseException("missing ']'");
char closechar = sr.read();
if(closechar!=']')
throw new ParseException("expected ']'");
return list;
}
INode parseDict(SeekableStringReader sr)
{
//dict = '{' keyvalue_list trailing_comma '}' .
//keyvalue_list = keyvalue { ',' keyvalue } .
//keyvalue = expr ':' expr .
// trailing_comma = '' | ',' .
sr.read(); // {
sr.skipWhitespace();
DictNode dict = new DictNode();
if(sr.peek() == '}')
{
sr.read();
return dict; // empty dict
}
List elts = parseKeyValueList(sr);
// handle trailing comma if present
sr.skipWhitespace();
if(!sr.hasMore())
throw new ParseException("missing '}'");
if(sr.peek() == ',')
sr.read();
if(!sr.hasMore())
throw new ParseException("missing '}'");
char closechar = sr.read();
if(closechar!='}')
throw new ParseException("expected '}'");
// make sure it has dict semantics (remove duplicate keys)
Map fixedDict = new HashMap(elts.size());
for(INode e: elts)
{
KeyValueNode kv = (KeyValueNode)e;
fixedDict.put(kv.key, kv.value);
}
for(Map.Entry e: fixedDict.entrySet())
{
KeyValueNode kvnode = new KeyValueNode();
kvnode.key = e.getKey();
kvnode.value = e.getValue();
dict.elements.add(kvnode);
}
// SPECIAL CASE: {'__class__':'float','value':'nan'} ---> Double.NaN
if(dict.elements.size()==2) {
if(dict.elements.contains(new KeyValueNode(new StringNode("__class__"), new StringNode("float")))) {
if(dict.elements.contains(new KeyValueNode(new StringNode("value"), new StringNode("nan")))) {
return new DoubleNode(Double.NaN);
}
}
}
return dict;
}
public INode parseSingle(SeekableStringReader sr)
{
// single = int | float | complex | string | bool | none .
sr.skipWhitespace();
switch(sr.peek())
{
case 'N':
return parseNone(sr);
case 'T':
case 'F':
return parseBool(sr);
case '\'':
case '"':
return parseString(sr);
case 'b':
return parseBytes(sr);
}
// int or float or complex.
int bookmark = sr.bookmark();
try {
return parseComplex(sr);
} catch (ParseException x1) {
sr.flipBack(bookmark);
try {
return parseFloat(sr);
} catch (ParseException x2) {
sr.flipBack(bookmark);
return parseInt(sr);
}
}
}
final String FloatCharacters = "-+.eE0123456789";
final String IntCharacters = "-0123456789";
INode parseInt(SeekableStringReader sr)
{
// int = ['-'] digitnonzero {digit} .
String numberstr = sr.readWhile(IntCharacters);
if(numberstr.length()==0)
throw new ParseException("invalid int character");
try {
try {
return new IntegerNode(Integer.parseInt(numberstr));
} catch (NumberFormatException x1) {
// try long
try {
return new LongNode(Long.parseLong(numberstr));
} catch (NumberFormatException x2) {
// try bigint, but it can still overflow because it's not arbitrary precision
try {
return new BigIntNode(new BigInteger(numberstr));
} catch (NumberFormatException x3) {
throw new ParseException("number too large or invalid");
}
}
}
} catch (NumberFormatException x) {
throw new ParseException("invalid integer format", x);
}
}
PrimitiveNode parseFloat(SeekableStringReader sr)
{
String numberstr = sr.readWhile(FloatCharacters);
if(numberstr.length()==0)
throw new ParseException("invalid float character");
// little bit of a hack:
// if the number doesn't contain a decimal point and no 'e'/'E', it is an integer instead.
// in that case, we need to reject it as a float.
if(numberstr.indexOf('.')<0 && numberstr.indexOf('e')<0 && numberstr.indexOf('E')<0)
throw new ParseException("number is not a float (might be an integer though)");
try {
return new DoubleNode(Double.parseDouble(numberstr));
} catch (NumberFormatException x) {
throw new ParseException("invalid float format", x);
}
}
ComplexNumberNode parseComplex(SeekableStringReader sr)
{
//complex = complextuple | imaginary .
//imaginary = ['+' | '-' ] ( float | int ) 'j' .
//complextuple = '(' ( float | int ) imaginary ')' .
if(sr.peek()=='(')
{
// complextuple
sr.read(); // (
String numberstr;
if(sr.peek()=='-' || sr.peek()=='+')
{
// starts with a sign, read that first otherwise the readuntil will return immediately
numberstr = sr.read(1) + sr.readUntil("+-");
}
else
{
numberstr = sr.readUntil("+-");
}
sr.rewind(1); // rewind the +/-
// because we're a bit more cautious here with reading chars than in the float parser,
// it can be that the parser now stopped directly after the 'e' in a number like "3.14e+20".
// ("3.14e20" is fine) So, check if the last char is 'e' and if so, continue reading 0..9.
if(numberstr.endsWith("e")||numberstr.endsWith("E")) {
// if the next symbol is + or -, accept it, then read the exponent integer
if(sr.peek()=='-' || sr.peek()=='+')
numberstr+=sr.read(1);
numberstr += sr.readWhile("0123456789");
}
sr.skipWhitespace();
double real;
try {
real = Double.parseDouble(numberstr);
} catch (NumberFormatException x) {
throw new ParseException("invalid float format", x);
}
double imaginarypart = parseImaginaryPart(sr);
if(sr.read()!=')')
throw new ParseException("expected ) to end a complex number");
ComplexNumberNode c = new ComplexNumberNode();
c.real = real;
c.imaginary = imaginarypart;
return c;
}
else
{
// imaginary
double imag = parseImaginaryPart(sr);
ComplexNumberNode c = new ComplexNumberNode();
c.real = 0;
c.imaginary = imag;
return c;
}
}
double parseImaginaryPart(SeekableStringReader sr)
{
//imaginary = ['+' | '-' ] ( float | int ) 'j' .
if(!sr.hasMore())
throw new ParseException("unexpected end of input string");
char sign_or_digit = sr.peek();
if(sign_or_digit=='+')
sr.read(); // skip the '+'
// now an int or float follows.
double double_value;
int bookmark = sr.bookmark();
try {
PrimitiveNode float_part = parseFloat(sr);
double_value = float_part.value;
} catch (ParseException x1) {
sr.flipBack(bookmark);
INode integer_part = parseInt(sr);
if(integer_part instanceof IntegerNode) {
double_value = ((IntegerNode)integer_part).value;
}
else if(integer_part instanceof LongNode) {
double_value = ((LongNode)integer_part).value;
}
else if(integer_part instanceof BigIntNode) {
double_value = ((BigIntNode)integer_part).value.doubleValue();
}
else {
throw new ParseException("not an integer for the imaginary part");
}
}
// now a 'j' must follow!
sr.skipWhitespace();
try {
char j_char = sr.read();
if(j_char!='j')
throw new ParseException("not an imaginary part");
} catch (IndexOutOfBoundsException x) {
throw new ParseException("not an imaginary part");
}
return double_value;
}
PrimitiveNode parseString(SeekableStringReader sr)
{
char quotechar = sr.read(); // ' or "
StringBuilder sb = new StringBuilder(10);
while(sr.hasMore())
{
char c = sr.read();
if(c=='\\')
{
// backslash unescape
c = sr.read();
switch(c)
{
case '\\':
sb.append('\\');
break;
case '\'':
sb.append('\'');
break;
case '"':
sb.append('"');
break;
case 'b':
sb.append('\b');
break;
case 'f':
sb.append('\f');
break;
case 'n':
sb.append('\n');
break;
case 'r':
sb.append('\r');
break;
case 't':
sb.append('\t');
break;
case 'x': // "\x00"
sb.append((char)Integer.parseInt(sr.read(2), 16));
break;
case 'u': // "\u0000"
sb.append((char)Integer.parseInt(sr.read(4), 16));
break;
default:
sb.append(c);
break;
}
}
else if(c==quotechar)
{
// end of string
return new StringNode(sb.toString());
}
else
{
sb.append(c);
}
}
throw new ParseException("unclosed string");
}
PrimitiveNode> parseBytes(SeekableStringReader sr)
{
sr.read(); // skip the 'b'
char quotechar = sr.read(); // ' or "
List bytes = new ArrayList();
while(sr.hasMore())
{
char c = sr.read();
if(c=='\\')
{
// backslash unescape
c = sr.read();
switch(c)
{
case '\\':
bytes.add((byte) '\\');
break;
case '\'':
bytes.add((byte)'\'');
break;
case '"':
bytes.add((byte)'"');
break;
case 'b':
bytes.add((byte)'\b');
break;
case 'f':
bytes.add((byte)'\f');
break;
case 'n':
bytes.add((byte)'\n');
break;
case 'r':
bytes.add((byte)'\r');
break;
case 't':
bytes.add((byte)'\t');
break;
case 'x': // "\x00"
bytes.add((byte) Integer.parseInt(sr.read(2), 16));
break;
default:
bytes.add((byte)c);
break;
}
}
else if(c==quotechar)
{
// end of bytes
return new BytesNode(bytes);
}
else
{
bytes.add((byte)c);
}
}
throw new ParseException("unclosed bytes");
}
PrimitiveNode parseBool(SeekableStringReader sr)
{
// True,False
String b = sr.readUntil('e');
if(b.equals("Tru"))
return new BooleanNode(true);
if(b.equals("Fals"))
return new BooleanNode(false);
throw new ParseException("expected bool, True or False");
}
NoneNode parseNone(SeekableStringReader sr)
{
// None
String n = sr.readUntil('e');
if(n.equals("Non"))
return NoneNode.Instance;
throw new ParseException("expected None");
}
/**
* Utility function to convert obj back to actual bytes if it is a serpent-encoded bytes dictionary
* (a IDictionary with base-64 encoded 'data' in it and 'encoding'='base64').
* If obj is already a byte array, return obj unmodified.
* If it is something else, throw an IllegalArgumentException
*/
public static byte[] toBytes(Object obj) {
if(obj instanceof Map)
{
@SuppressWarnings("unchecked")
Map dict = (Map)obj;
String data = dict.get("data");
String encoding = dict.get("encoding");
if(data==null || encoding==null || !encoding.equals("base64"))
{
throw new IllegalArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
return Base64.getDecoder().decode(data);
}
if(obj instanceof byte[])
{
return (byte[]) obj;
}
throw new IllegalArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/SeekableStringReader.java 0000664 0000000 0000000 00000011323 15077515333 0031301 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
/**
* A special string reader that is suitable for the parser to read through
* the expression string. You can rewind it, set bookmarks to flip back to, etc.
*/
public class SeekableStringReader
{
private String str;
private int cursor = 0;
private int bookmark = -1;
public SeekableStringReader(String str)
{
if(str==null)
throw new IllegalArgumentException("str may not be null");
this.str = str;
}
/**
* Make a nested reader with its own cursor and bookmark.
* The cursor starts at the same position as the parent.
*/
public SeekableStringReader(SeekableStringReader parent)
{
str = parent.str;
cursor = parent.cursor;
}
/**
* Is tehre more to read?
*/
public boolean hasMore()
{
return cursor0)
throw new ParseException("no more data");
String result = str.substring(cursor, cursor+safecount);
cursor += safecount;
return result;
}
/**
* Read everything until one the sentinel, which must exist in the string.
* Sentinel char is read but not returned in the result.
*/
public String readUntil(char sentinel)
{
int i = str.indexOf(sentinel, cursor);
if(i>=0) {
int from = cursor;
cursor = i+1;
return str.substring(from, i);
}
throw new ParseException("terminator not found");
}
/**
* Read everything until one of the sentinel(s), which must exist in the string.
* Sentinel char is read but not returned in the result.
*/
public String readUntil(String sentinels)
{
int index=Integer.MAX_VALUE;
for(char s: sentinels.toCharArray())
{
int i = str.indexOf(s, cursor);
if(i>=0)
index = Math.min(i, index);
}
if(index>=0 && index=0)
++cursor;
else
break;
}
return str.substring(start, cursor);
}
/**
* Read away any whitespace.
* If a comment follows ('# bla bla') read away that as well
*/
public void skipWhitespace()
{
while(hasMore())
{
char c=read();
if(c=='#')
{
readUntil('\n');
return;
}
if(!Character.isWhitespace(c))
{
rewind(1);
return;
}
}
}
/**
* Returns the rest of the data until the end.
*/
public String rest()
{
if(cursor>=str.length())
throw new ParseException("no more data");
String result=str.substring(cursor);
cursor = str.length();
return result;
}
/**
* Rewind a number of characters.
*/
public void rewind(int count)
{
cursor = Math.max(0, cursor-count);
}
/**
* Return a bookmark to rewind to later.
*/
public int bookmark()
{
return cursor;
}
/**
* Flip back to previously set bookmark.
*/
public void flipBack(int bookmark)
{
cursor = bookmark;
}
/**
* Sync the position and bookmark with the current position in another reader.
*/
public void sync(SeekableStringReader inner)
{
bookmark = inner.bookmark;
cursor = inner.cursor;
}
/**
* Extract a piece of context around the current cursor (if you set cursor to -1)
* or around a given position in the string (if you set cursor greater or equal to 0).
*/
public class StringContext
{
public String left;
public String right;
}
public StringContext context(int crsr, int width)
{
if(crsr<0)
crsr=this.cursor;
int leftStrt = Math.max(0, crsr-width);
int leftLen = crsr-leftStrt;
int rightLen = Math.min(width, str.length()-crsr);
StringContext result = new StringContext();
result.left = str.substring(leftStrt, leftStrt+leftLen);
result.right = str.substring(crsr, crsr+rightLen);
return result;
}
public void close()
{
this.str = null;
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/Serializer.java 0000664 0000000 0000000 00000047060 15077515333 0027374 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent;
import java.io.IOException;
import java.io.Serializable;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
/**
* Serialize an object tree to a byte stream.
* It is not thread-safe: make sure you're not making changes to the object tree that is being serialized.
*/
public class Serializer
{
/**
* The maximum nesting level of the object graphs that you want to serialize.
* This limit has been set to avoid troublesome stack overflow errors.
* (If it is reached, an IllegalArgumentException is thrown instead with a clear message)
*/
public int maximumLevel = 500; // to avoid stack overflow errors
/**
* Indent the resulting serpent serialization text?
*/
public boolean indent = false;
/**
* Include package name in class name, for classes that are serialized to dicts?
*/
public boolean packageInClassName = false;
/**
* Use bytes literal representation instead of base-64 encoding?
*/
public boolean bytesRepr = false;
private static Map, IClassSerializer> classToDictRegistry = new HashMap, IClassSerializer>();
/**
* Create a Serpent serializer with default options.
*/
public Serializer()
{
}
/**
* Create a Serpent serializer with custom options.
* @param indent should the output be indented to make it more readable?
* @param packageInClassName should the package name be included with the class name for classes that are serialized to dict?
*/
public Serializer(boolean indent, boolean packageInClassName)
{
this.indent = indent;
this.packageInClassName = packageInClassName;
}
/**
* Create a Serpent serializer with custom options.
* @param indent should the output be indented to make it more readable?
* @param packageInClassName should the package name be included with the class name for classes that are serialized to dict?
* @param bytesRepr use bytes literal representation instead of base-64 encoding for bytes types?
*/
public Serializer(boolean indent, boolean packageInClassName, boolean bytesRepr)
{
this.indent = indent;
this.packageInClassName = packageInClassName;
this.bytesRepr = bytesRepr;
}
/**
* Register a custom class serializer, if you want to tweak the serialization of classes that Serpent doesn't know about yet.
*/
public static void registerClass(Class clazz, IClassSerializer converter)
{
classToDictRegistry.put(clazz, converter);
}
/**
* Serialize an object graph to a serpent serialized form.
*/
public byte[] serialize(Object obj)
{
StringWriter sw = new StringWriter();
sw.write("# serpent utf-8 python3.2\n");
serialize(obj, sw, 0);
sw.flush();
final String ser = sw.toString();
try {
sw.close();
return ser.getBytes("utf-8");
} catch (IOException x) {
throw new IllegalArgumentException("error creating output bytes: "+x);
}
}
protected void serialize(Object obj, StringWriter sw, int level)
{
if(level>maximumLevel)
throw new IllegalArgumentException("Object graph nesting too deep. Increase serializer.maximumLevel if you think you need more.");
if(obj!=null && obj.getClass().getName().startsWith("org.python."))
obj = convertJythonObject(obj);
// null -> None
// hashtables/dictionaries -> dict
// hashset -> set
// array -> tuple
// byte arrays --> base64 or bytes literal
// any other collection --> list
// date//uuid/exception -> custom mapping
// random class --> public javabean properties to dictionary
// primitive types --> simple mapping
Class type = obj==null? null : obj.getClass();
Class componentType = type==null? null : type.getComponentType();
// primitive array?
if(componentType!=null)
{
// byte array? encode as base-64 or bytes literal
if(componentType==Byte.TYPE)
{
serialize_bytes((byte[])obj, sw, level);
return;
}
else
{
serialize_primitive_array(obj, sw, level);
}
return;
}
if(obj==null)
{
sw.write("None");
}
else if(obj instanceof String)
{
serialize_string((String)obj, sw, level);
}
else if(type.isPrimitive() || isBoxed(type))
{
serialize_primitive(obj, sw, level);
}
else if(obj instanceof Enum)
{
serialize_string(obj.toString(), sw, level);
}
else if(obj instanceof BigDecimal)
{
serialize_bigdecimal((BigDecimal)obj, sw, level);
}
else if(obj instanceof Number)
{
serialize_primitive(obj, sw, level);
}
else if(obj instanceof Date)
{
serialize_date((Date)obj, sw, level);
}
else if(obj instanceof Calendar)
{
serialize_calendar((Calendar)obj, sw, level);
}
else if(obj instanceof UUID)
{
serialize_uuid((UUID)obj, sw, level);
}
else if(obj instanceof Set)
{
serialize_set((Set)obj, sw, level);
}
else if(obj instanceof Map)
{
serialize_dict((Map)obj, sw, level);
}
else if(obj instanceof Collection)
{
serialize_collection((Collection)obj, sw, level);
}
else if(obj instanceof ComplexNumber)
{
serialize_complex((ComplexNumber)obj, sw, level);
}
else if(obj instanceof Exception)
{
serialize_exception((Exception)obj, sw, level);
}
else if(obj instanceof Serializable)
{
serialize_class(obj, sw, level);
}
else
{
throw new IllegalArgumentException("cannot serialize object of type "+type);
}
}
/**
* When used from Jython directly, it sometimes passes some Jython specific
* classes to the serializer (such as org.python.core.PyComplex for a complex number).
* Due to the way these are constructed, Serpent is greatly confused, and will often
* end up in an endless loop eventually crashing with too deep nesting.
* For the know cases, we convert them here to appropriate representations.
*/
protected Object convertJythonObject(Object obj)
{
final Class clazz = obj.getClass();
final String classname = clazz.getName();
try
{
// use reflection because I don't want to have a compiler dependency on Jython.
switch (classname) {
case "org.python.core.PyTuple":
return clazz.getMethod("toArray").invoke(obj);
case "org.python.core.PyComplex":
Object pyImag = clazz.getMethod("getImag").invoke(obj);
Object pyReal = clazz.getMethod("getReal").invoke(obj);
Double imag = (Double) pyImag.getClass().getMethod("getValue").invoke(pyImag);
Double real = (Double) pyReal.getClass().getMethod("getValue").invoke(pyReal);
return new ComplexNumber(real, imag);
case "org.python.core.PyByteArray":
Object pyStr = clazz.getMethod("__str__").invoke(obj);
return pyStr.getClass().getMethod("toBytes").invoke(pyStr);
case "org.python.core.PyMemoryView":
Object pyBytes = clazz.getMethod("tobytes").invoke(obj);
return pyBytes.getClass().getMethod("toBytes").invoke(pyBytes);
}
} catch (ReflectiveOperationException e) {
throw new IllegalArgumentException("cannot serialize Jython object of type "+clazz, e);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("cannot serialize Jython object of type "+clazz, e);
} catch (SecurityException e) {
throw new IllegalArgumentException("cannot serialize Jython object of type "+clazz, e);
}
// instead of an endless nesting loop, report a proper exception
throw new IllegalArgumentException("cannot serialize Jython object of type "+obj.getClass());
}
protected void serialize_collection(Collection collection, StringWriter sw, int level)
{
// output a list
sw.write("[");
serialize_sequence_elements(collection, false, sw, level+1);
if(this.indent && collection.size()>0)
{
for(int i=0; i elts, boolean trailingComma, StringWriter sw, int level)
{
if(elts.size()==0)
return;
int count=0;
if(this.indent)
{
sw.write("\n");
String innerindent = "";
for(int i=0; i set, StringWriter sw, int level)
{
if(set.size()>0)
{
sw.write("{");
Collection output = set;
if(this.indent)
{
// try to sort the set
Set outputset = set;
try {
outputset = new TreeSet(set);
} catch (ClassCastException x) {
// ignore unsortable elements
}
output = outputset;
}
serialize_sequence_elements(output, false, sw, level+1);
if(this.indent)
{
for(int i=0; i items = new ArrayList(length);
for(int i=0; i items, StringWriter sw, int level)
{
sw.write("(");
serialize_sequence_elements(items, items.size()==1, sw, level+1);
if(this.indent && items.size()>0)
{
for(int i=0; i dict = new HashMap();
dict.put("data", str);
dict.put("encoding", "base64");
serialize_dict(dict, sw, level);
}
}
private void handleQuotes(StringWriter sw, StringBuilder b, boolean containsSingleQuote, boolean containsQuote, boolean isBytes) {
if(!containsSingleQuote) {
b.insert(0, '\'');
b.append('\'');
if(isBytes)
sw.write('b');
sw.write(b.toString());
} else if (!containsQuote) {
b.insert(0, '"');
b.append('"');
if(isBytes)
sw.write('b');
sw.write(b.toString());
} else {
String str2 = b.toString();
str2 = str2.replace("'", "\\'");
if(isBytes)
sw.write('b');
sw.write("'");
sw.write(str2);
sw.write("'");
}
}
protected void serialize_dict(Map dict, StringWriter sw,int level)
{
if(dict.size()==0)
{
sw.write("{}");
return;
}
int counter=0;
if(this.indent)
{
String innerindent = " ";
for(int i=0; i outputdict = dict;
try {
outputdict = new TreeMap(dict);
} catch (ClassCastException x) {
// ignore unsortable keys
}
for(Map.Entry e: outputdict.entrySet())
{
sw.write(innerindent);
serialize(e.getKey(), sw, level+1);
sw.write(": ");
serialize(e.getValue(), sw, level+1);
counter++;
if(counter e: dict.entrySet())
{
serialize(e.getKey(), sw, level+1);
sw.write(":");
serialize(e.getValue(), sw, level+1);
counter++;
if(counter0) {
// we have millis
df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS"+tzformat);
} else {
// no millis
df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"+tzformat);
}
df.setTimeZone(cal.getTimeZone());
serialize_string(df.format(cal.getTime()), sw, level);
}
protected void serialize_date(Date date, StringWriter sw, int level)
{
DateFormat df;
if((date.getTime() % 1000) != 0) {
// we have millis
df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
} else {
// no millis
df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
}
df.setTimeZone(TimeZone.getTimeZone("UTC"));
serialize_string(df.format(date), sw, level);
}
protected void serialize_complex(ComplexNumber cplx, StringWriter sw, int level)
{
sw.write("(");
serialize_primitive(cplx.real, sw, level);
if(cplx.imaginary>=0)
sw.write("+");
serialize_primitive(cplx.imaginary, sw, level);
sw.write("j)");
}
protected void serialize_uuid(UUID obj, StringWriter sw, int level)
{
serialize_string(obj.toString(), sw, level);
}
protected void serialize_bigdecimal(BigDecimal decimal, StringWriter sw, int level)
{
serialize_string(decimal.toEngineeringString(), sw, level);
}
private static final HashSet> boxedTypes;
static {
boxedTypes = new HashSet>();
boxedTypes.add(Boolean.class);
boxedTypes.add(Character.class);
boxedTypes.add(Byte.class);
boxedTypes.add(Short.class);
boxedTypes.add(Integer.class);
boxedTypes.add(Long.class);
boxedTypes.add(Float.class);
boxedTypes.add(Double.class);
}
protected boolean isBoxed(Class type)
{
return boxedTypes.contains(type);
}
protected void serialize_class(Object obj, StringWriter sw, int level)
{
Map map;
IClassSerializer converter=getCustomConverter(obj.getClass());
if(null!=converter)
{
map = converter.convert(obj);
}
else
{
map=new HashMap();
try {
// note: don't use the java.bean api, because that is not available on Android.
for(Method m: obj.getClass().getMethods()) {
int modifiers = m.getModifiers();
if((modifiers & Modifier.PUBLIC)!=0 && (modifiers & Modifier.STATIC)==0) {
String methodname = m.getName();
int prefixlen = 0;
if(methodname.equals("getClass")) continue;
if(methodname.startsWith("get")) prefixlen=3;
else if(methodname.startsWith("is")) prefixlen=2;
else continue;
Object value = m.invoke(obj);
String name = methodname.substring(prefixlen);
if(name.length()==1) {
name = name.toLowerCase();
} else {
if(!Character.isUpperCase(name.charAt(1))) {
name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
}
}
map.put(name, value);
}
}
if(this.packageInClassName)
map.put("__class__", obj.getClass().getName());
else
map.put("__class__", obj.getClass().getSimpleName());
} catch (IllegalAccessException e) {
throw new IllegalArgumentException("couldn't introspect javabean: "+e);
} catch (InvocationTargetException e) {
throw new IllegalArgumentException("couldn't introspect javabean: "+e);
}
}
serialize_dict(map, sw, level);
}
protected IClassSerializer getCustomConverter(Class type) {
IClassSerializer converter = classToDictRegistry.get(type.getClass());
if(converter!=null) {
return converter; // exact match
}
// check if there's a custom pickler registered for an interface or abstract base class
// that this object implements or inherits from.
for(Entry, IClassSerializer> x: classToDictRegistry.entrySet()) {
if(x.getKey().isAssignableFrom(type)) {
return x.getValue();
}
}
return null;
}
protected void serialize_primitive(Object obj, StringWriter sw, int level)
{
if(obj instanceof Boolean || obj.getClass()==Boolean.TYPE)
{
sw.write(obj.equals(Boolean.TRUE)? "True": "False");
}
else if (obj instanceof Float || obj.getClass()==Float.TYPE)
{
Float f = (Float)obj;
serialize_primitive(f.doubleValue(), sw, level);
}
else if (obj instanceof Double || obj.getClass()==Double.TYPE)
{
Double d = (Double) obj;
if(d.isInfinite()) {
// output a literal expression that overflows the float and results in +/-INF
if(d>0.0) {
sw.write("1e30000");
} else {
sw.write("-1e30000");
}
}
else if(d.isNaN()) {
// there's no literal expression for a float NaN...
sw.write("{'__class__':'float','value':'nan'}");
} else {
sw.write(d.toString());
}
}
else
{
sw.write(obj.toString());
}
}
// the repr translation table for characters 0x00-0xff
private final static String[] repr_255;
private final static String[] bytesrepr_255;
static {
repr_255=new String[256];
bytesrepr_255=new String[256];
for(int c=0; c<32; ++c) {
repr_255[c] = String.format("\\x%02x",c);
bytesrepr_255[c] = String.format("\\x%02x",c);
}
for(char c=0x20; c<0x7f; ++c) {
repr_255[c] = String.valueOf(c);
bytesrepr_255[c] = String.valueOf(c);
}
for(int c=0x7f; c<=0xa0; ++c) {
repr_255[c] = String.format("\\x%02x", c);
}
for(char c=0xa1; c<=0xff; ++c) {
repr_255[c] = String.valueOf(c);
}
for(int c=0x7f; c<=0xff; ++c) {
bytesrepr_255[c] = String.format("\\x%02x", c);
}
// odd ones out:
repr_255['\t'] = "\\t";
repr_255['\n'] = "\\n";
repr_255['\r'] = "\\r";
repr_255['\\'] = "\\\\";
repr_255[0xad] = "\\xad";
bytesrepr_255['\t'] = "\\t";
bytesrepr_255['\n'] = "\\n";
bytesrepr_255['\r'] = "\\r";
bytesrepr_255['\\'] = "\\\\";
}
protected void serialize_string(String str, StringWriter sw, int level)
{
// create a 'repr' string representation following the same escaping rules as python 3.x repr() does.
StringBuilder b=new StringBuilder(str.length()*2);
boolean containsSingleQuote=false;
boolean containsQuote=false;
for(int i=0; i dict;
IClassSerializer converter=classToDictRegistry.get(ex.getClass());
if(null!=converter)
{
dict = converter.convert(ex);
}
else
{
dict = new HashMap();
if(this.packageInClassName)
dict.put("__class__", ex.getClass().getName());
else
dict.put("__class__", ex.getClass().getSimpleName());
dict.put("__exception__", true);
dict.put("args", new String[]{ex.getMessage()});
dict.put("attributes", java.util.Collections.EMPTY_MAP);
}
serialize_dict(dict, sw, level);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/ 0000775 0000000 0000000 00000000000 15077515333 0025200 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/Ast.java 0000664 0000000 0000000 00000002444 15077515333 0026576 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent.ast;
import net.razorvine.serpent.IDictToInstance;
import net.razorvine.serpent.ObjectifyVisitor;
/**
* Abstract syntax tree for the literal expression. This is what the parser returns.
*/
public class Ast
{
public INode root;
@Override
public String toString()
{
return "# serpent utf-8 .net\n" + root.toString();
}
/**
* get the actual data as Java objects.
*/
public Object getData()
{
ObjectifyVisitor v = new ObjectifyVisitor();
this.accept(v);
return v.getObject();
}
/**
* get the actual data as Java objects.
* @param dictConverter object to convert dicts to actual instances for a class,
* instead of leaving them as dictionaries. Requires the __class__ key to be present
* in the dict node. If it returns null, the normal processing is done.
*/
public Object getData(IDictToInstance dictConverter)
{
ObjectifyVisitor v = new ObjectifyVisitor(dictConverter);
this.accept(v);
return v.getObject();
}
public void accept(INodeVisitor visitor)
{
root.accept(visitor);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/BigIntNode.java 0000664 0000000 0000000 00000000417 15077515333 0030027 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
import java.math.BigInteger;
public class BigIntNode extends PrimitiveNode {
public BigIntNode(BigInteger value) {
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/BooleanNode.java 0000664 0000000 0000000 00000000355 15077515333 0030233 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class BooleanNode extends PrimitiveNode
{
public BooleanNode(boolean value)
{
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/BytesNode.java 0000664 0000000 0000000 00000000650 15077515333 0027740 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
import java.util.List;
public class BytesNode extends PrimitiveNode>
{
public BytesNode(List value)
{
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
public byte[] toByteArray() {
byte[] bytes = new byte[value.size()];
for(int i=0; i=0)
return String.format("(%s+%sj)", strReal, strImag);
return String.format("(%s%sj)", strReal, strImag);
}
@Override
public boolean equals(Object obj)
{
if(!(obj instanceof ComplexNumberNode))
return false;
ComplexNumberNode other = (ComplexNumberNode) obj;
return real==other.real && imaginary==other.imaginary;
}
@Override
public int hashCode() {
return new Double(real).hashCode() ^ new Double(imaginary).hashCode();
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/DictNode.java 0000664 0000000 0000000 00000000443 15077515333 0027535 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class DictNode extends UnorderedSequenceNode
{
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
@Override
public char getOpenChar() {
return '{';
}
@Override
public char getCloseChar() {
return '}';
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/DoubleNode.java 0000664 0000000 0000000 00000000350 15077515333 0030061 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class DoubleNode extends PrimitiveNode
{
public DoubleNode(double value)
{
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/INode.java 0000664 0000000 0000000 00000000224 15077515333 0027037 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public interface INode
{
String toString();
boolean equals(Object obj);
void accept(INodeVisitor visitor);
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/INodeVisitor.java 0000664 0000000 0000000 00000000726 15077515333 0030426 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public interface INodeVisitor
{
void visit(ComplexNumberNode complex);
void visit(DictNode dict);
void visit(ListNode list);
void visit(NoneNode none);
void visit(IntegerNode value);
void visit(LongNode value);
void visit(DoubleNode value);
void visit(BooleanNode value);
void visit(StringNode value);
void visit(BytesNode value);
void visit(SetNode setnode);
void visit(TupleNode tuple);
void visit(BigIntNode value);
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/IntegerNode.java 0000664 0000000 0000000 00000000350 15077515333 0030244 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class IntegerNode extends PrimitiveNode
{
public IntegerNode(int value)
{
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/KeyValueNode.java 0000664 0000000 0000000 00000001366 15077515333 0030404 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class KeyValueNode implements INode
{
public INode key;
public INode value;
public KeyValueNode()
{}
public KeyValueNode(INode key, INode value)
{
this.key = key;
this.value = value;
}
@Override
public String toString()
{
return String.format("%s:%s", key, value);
}
public void accept(INodeVisitor visitor)
{
throw new NoSuchMethodError("don't visit a keyvaluenode");
}
@Override
public boolean equals(Object obj)
{
if(!(obj instanceof KeyValueNode))
return false;
KeyValueNode other = (KeyValueNode) obj;
return key.equals(other.key) && value.equals(other.value);
}
@Override
public int hashCode()
{
return key.hashCode() ^ (1000000007 * value.hashCode());
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/ListNode.java 0000664 0000000 0000000 00000000432 15077515333 0027563 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class ListNode extends SequenceNode
{
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
@Override
public char getOpenChar() {
return '[';
}
@Override
public char getCloseChar() {
return ']';
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/LongNode.java 0000664 0000000 0000000 00000000341 15077515333 0027546 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class LongNode extends PrimitiveNode
{
public LongNode(long value)
{
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/NoneNode.java 0000664 0000000 0000000 00000000427 15077515333 0027553 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class NoneNode implements INode
{
public static NoneNode Instance = new NoneNode();
private NoneNode()
{
}
public String toString()
{
return "None";
}
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/PrimitiveNode.java 0000664 0000000 0000000 00000003172 15077515333 0030624 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public abstract class PrimitiveNode implements INode, Comparable
{
public T value;
public PrimitiveNode(T value)
{
this.value=value;
}
@Override
public int hashCode()
{
return value!=null? value.hashCode() : 0;
}
@Override
public boolean equals(Object obj)
{
return (obj instanceof PrimitiveNode) && value.equals(((PrimitiveNode)obj).value);
}
public int compareTo(T other)
{
return 0;
}
public boolean equals(PrimitiveNode other)
{
return this.value.equals(other.value);
}
@Override
public String toString()
{
if(value instanceof String)
{
StringBuilder sb=new StringBuilder();
sb.append("'");
String strValue = (String)value;
for(char c: strValue.toCharArray())
{
switch(c)
{
case '\\':
sb.append("\\\\");
break;
case '\'':
sb.append("\\'");
break;
case '\b':
sb.append("\\b");
break;
case '\f':
sb.append("\\f");
break;
case '\n':
sb.append("\\n");
break;
case '\r':
sb.append("\\r");
break;
case '\t':
sb.append("\\t");
break;
default:
sb.append(c);
break;
}
}
sb.append("'");
return sb.toString();
}
else if(value instanceof Boolean)
{
return value.equals(Boolean.TRUE)? "True": "False";
}
else if(value instanceof Float || value instanceof Double)
{
String d = value.toString();
if(d.indexOf('.')<=0 && d.indexOf('e')<=0 && d.indexOf('E')<=0)
d+=".0";
return d;
}
else return value.toString();
}
public abstract void accept(INodeVisitor visitor);
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/SequenceNode.java 0000664 0000000 0000000 00000002013 15077515333 0030415 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
import java.util.ArrayList;
import java.util.List;
public abstract class SequenceNode implements INode
{
public List elements = new ArrayList();
public abstract char getOpenChar();
public abstract char getCloseChar();
@Override
public int hashCode()
{
int hashCode = 0;
for(INode elt: elements)
hashCode += 1000000007 * elt.hashCode();
return hashCode;
}
@Override
public boolean equals(Object obj)
{
if(!(obj instanceof SequenceNode))
return false;
SequenceNode other = (SequenceNode)obj;
return elements.equals(other.elements);
}
@Override
public String toString()
{
StringBuilder sb=new StringBuilder();
sb.append(getOpenChar());
if(elements != null)
{
for(INode elt: elements)
{
sb.append(elt.toString());
sb.append(',');
}
}
if(elements.size()>0)
sb.deleteCharAt(sb.length()-1); // remove last comma
sb.append(getCloseChar());
return sb.toString();
}
public abstract void accept(INodeVisitor visitor);
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/SetNode.java 0000664 0000000 0000000 00000000442 15077515333 0027404 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class SetNode extends UnorderedSequenceNode
{
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
@Override
public char getOpenChar() {
return '{';
}
@Override
public char getCloseChar() {
return '}';
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/StringNode.java 0000664 0000000 0000000 00000000350 15077515333 0030115 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class StringNode extends PrimitiveNode
{
public StringNode(String value)
{
super(value);
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/TupleNode.java 0000664 0000000 0000000 00000001212 15077515333 0027736 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
public class TupleNode extends SequenceNode
{
@Override
public String toString()
{
StringBuilder sb=new StringBuilder();
sb.append(getOpenChar());
if(elements != null)
{
for(INode elt: elements)
{
sb.append(elt.toString());
sb.append(",");
}
}
if(elements.size()>1)
sb.deleteCharAt(sb.length()-1); // remove last comma
sb.append(getCloseChar());
return sb.toString();
}
@Override
public void accept(INodeVisitor visitor)
{
visitor.visit(this);
}
@Override
public char getOpenChar() {
return '(';
}
@Override
public char getCloseChar() {
return ')';
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/ast/UnorderedSequenceNode.java 0000664 0000000 0000000 00000000733 15077515333 0032274 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.ast;
import java.util.HashSet;
import java.util.Set;
abstract class UnorderedSequenceNode extends SequenceNode {
@Override
public boolean equals(Object obj)
{
if(!(obj instanceof UnorderedSequenceNode))
return false;
Set set1 = elementsAsSet();
Set set2 = ((UnorderedSequenceNode)obj).elementsAsSet();
return set1.equals(set2);
}
public Set elementsAsSet()
{
return new HashSet(elements);
}
}
Serpent-serpent-1.42/java/src/main/java/net/razorvine/serpent/package-info.java 0000664 0000000 0000000 00000000453 15077515333 0027602 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
* @version 1.40
*/
package net.razorvine.serpent;
Serpent-serpent-1.42/java/src/test/ 0000775 0000000 0000000 00000000000 15077515333 0017236 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/test/java/ 0000775 0000000 0000000 00000000000 15077515333 0020157 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/test/java/SerpentExample.java 0000664 0000000 0000000 00000007500 15077515333 0023760 0 ustar 00root root 0000000 0000000
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import net.razorvine.serpent.DebugVisitor;
import net.razorvine.serpent.LibraryVersion;
import net.razorvine.serpent.Parser;
import net.razorvine.serpent.Serializer;
import net.razorvine.serpent.ast.Ast;
public class SerpentExample {
enum Foo {
Foobar,
Jarjar
}
public static void main(String[] args) {
SerpentExample t=new SerpentExample();
try {
t.run();
} catch (IOException e) {
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
public void run() throws IOException
{
// some example use of Serpent
System.out.println("Using serpent library version "+LibraryVersion.VERSION);
Map data = new HashMap();
data.put("tuple", new int[] { 1,2,3 });
data.put("date", new java.util.Date());
Set set = new HashSet();
set.add("c");
set.add("b");
set.add("a");
data.put("set", set);
data.put("class", new SampleClass("Sally", 26));
// serialize data structure to bytes
Serializer serpent = new Serializer(true, false);
byte[] ser = serpent.serialize(data);
// print it on the screen, but normally you'd store byte bytes in a file or transfer them across a network connection
System.out.println("Serialized:");
System.out.println(new String(ser, "utf-8"));
// parse the serialized bytes back into an abstract syntax tree of the datastructure
Parser parser = new Parser();
Ast ast = parser.parse(ser);
System.out.println("\nParsed AST:");
System.out.println(ast.root.toString());
// print debug representation
DebugVisitor dv = new DebugVisitor();
ast.accept(dv);
System.out.println("DEBUG string representation:");
System.out.println(dv.toString());
// turn the Ast into regular Java objects
Map dict = (Map)ast.getData();
// You can get the data out of the Ast manually as well, by using the supplied visitor:
// ObjectifyVisitor visitor = new ObjectifyVisitor();
// ast.accept(visitor);
// Map dict = (Map) visitor.getObject();
// print the results
System.out.println("PARSED results:");
System.out.print("tuple items: ");
Object[] tuple = (Object[]) dict.get("tuple");
for(Object o: tuple)
System.out.print(" "+o.toString()+",");
System.out.println("");
System.out.println("date: "+dict.get("date"));
System.out.print("set items: ");
Set set2 = (Set) dict.get("set");
for(Object o: set2)
System.out.print(" "+o.toString()+",");
System.out.println("");
System.out.println("class attributes:");
Map clazz = (Map) dict.get("class"); // custom classes are serialized as dicts
System.out.println(" type: "+clazz.get("__class__"));
System.out.println(" name: "+clazz.get("name"));
System.out.println(" age: "+clazz.get("age"));
System.out.println("");
// parse and print the example file
File testdatafile = new File("src/test/java/testserpent.utf8.bin");
ser = new byte[(int) testdatafile.length()];
FileInputStream fis=new FileInputStream(testdatafile);
DataInputStream dis = new DataInputStream(fis);
dis.readFully(ser);
dis.close();
fis.close();
ast = parser.parse(ser);
dv = new DebugVisitor();
ast.accept(dv);
System.out.println("DEBUG string representation of the test file:");
System.out.println(dv.toString());
}
public class SampleClass implements Serializable
{
private static final long serialVersionUID = -782424804184940436L;
int a;
String n;
public SampleClass(String name, int age)
{
a=age;
n=name;
}
public int getAge()
{
return a;
}
public String getName()
{
return n;
}
}
}
Serpent-serpent-1.42/java/src/test/java/net/ 0000775 0000000 0000000 00000000000 15077515333 0020745 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/test/java/net/razorvine/ 0000775 0000000 0000000 00000000000 15077515333 0022764 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/test/java/net/razorvine/serpent/ 0000775 0000000 0000000 00000000000 15077515333 0024444 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/test/java/net/razorvine/serpent/test/ 0000775 0000000 0000000 00000000000 15077515333 0025423 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.42/java/src/test/java/net/razorvine/serpent/test/CycleTest.java 0000664 0000000 0000000 00000005314 15077515333 0030170 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent.test;
import java.util.HashMap;
import java.util.LinkedList;
import net.razorvine.serpent.Parser;
import net.razorvine.serpent.Serializer;
import org.junit.Test;
import static org.junit.Assert.*;
public class CycleTest
{
@Test
public void testTupleOk()
{
Serializer ser = new Serializer();
int[] t = new int[] {1,2,3};
Object[] d = new Object[] {t,t,t};
byte[] data = ser.serialize(d);
Parser parser = new Parser();
parser.parse(data);
}
@Test
public void testListOk()
{
Serializer ser = new Serializer();
LinkedList t = new LinkedList();
t.add(1);
t.add(2);
t.add(3);
LinkedList d = new LinkedList();
d.add(t);
d.add(t);
d.add(t);
byte[] data = ser.serialize(d);
Parser parser = new Parser();
parser.parse(data);
}
@Test
public void testDictOk()
{
Serializer ser = new Serializer();
HashMap t = new HashMap();
t.put("a", 1);
HashMap d = new HashMap();
d.put("x", t);
d.put("y", t);
d.put("z", t);
byte[] data = ser.serialize(d);
Parser parser = new Parser();
parser.parse(data);
}
@Test(expected=IllegalArgumentException.class)
public void testListCycle()
{
Serializer ser = new Serializer();
LinkedList d = new LinkedList();
d.add(1);
d.add(2);
d.add(d);
ser.serialize(d);
}
@Test(expected=IllegalArgumentException.class)
public void testDictCycle()
{
Serializer ser = new Serializer();
HashMap d = new HashMap();
d.put("x", 1);
d.put("y", 2);
d.put("z", d);
ser.serialize(d);
}
@Test(expected=IllegalArgumentException.class)
public void testClassCycle()
{
Serializer ser = new Serializer();
SerializationHelperClass thing = new SerializationHelperClass();
thing.i = 42;
thing.s = "hello";
thing.x = 99;
thing.obj = thing;
ser.serialize(thing);
}
@Test
public void testMaxLevel()
{
Serializer ser = new Serializer();
assertEquals(500, ser.maximumLevel);
Object[] array = new Object[] {
"level1",
new Object[] {
"level2",
new Object[] {
"level3",
new Object[] {
"level 4"
}
}
}
};
ser.maximumLevel = 4;
ser.serialize(array); // should work
ser.maximumLevel = 3;
try {
ser.serialize(array);
fail("should fail");
} catch(IllegalArgumentException x) {
assertTrue(x.getMessage().contains("too deep"));
}
}
}
Serpent-serpent-1.42/java/src/test/java/net/razorvine/serpent/test/ParserTest.java 0000664 0000000 0000000 00000070450 15077515333 0030370 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent.test;
import static org.junit.Assert.*;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import net.razorvine.serpent.ObjectifyVisitor;
import net.razorvine.serpent.ParseException;
import net.razorvine.serpent.Parser;
import net.razorvine.serpent.SeekableStringReader;
import net.razorvine.serpent.Serializer;
import net.razorvine.serpent.ast.*;
import org.junit.Ignore;
import org.junit.Test;
public class ParserTest
{
@Test
public void TestBasic()
{
Parser p = new Parser();
assertNull(p.parse((String)null).root);
assertNull(p.parse("").root);
assertNotNull(p.parse("# comment\n42\n").root);
}
@Test
public void TestComments()
{
Parser p = new Parser();
Ast ast = p.parse("[ 1, 2 ]"); // no header whatsoever
ObjectifyVisitor visitor = new ObjectifyVisitor();
ast.accept(visitor);
Object obj = visitor.getObject();
List expected = new ArrayList();
expected.add(1);
expected.add(2);
assertEquals(expected, obj);
expected = new LinkedList();
expected.add(1);
expected.add(2);
assertEquals(expected, obj);
ast = p.parse("# serpent utf-8 python2.7\n"+
"[ 1, 2,\n"+
" # some comments here\n"+
" 3, 4] # more here\n"+
"# and here.\n");
visitor = new ObjectifyVisitor();
ast.accept(visitor);
obj = visitor.getObject();
expected = new LinkedList();
expected.add(1);
expected.add(2);
expected.add(3);
expected.add(4);
assertEquals(expected, obj);
}
@Test
public void TestPrimitives()
{
Parser p = new Parser();
assertEquals(new IntegerNode(42), p.parse("42").root);
assertEquals(new IntegerNode(-42), p.parse("-42").root);
assertEquals(new DoubleNode(42.331), p.parse("42.331").root);
assertEquals(new DoubleNode(-42.331), p.parse("-42.331").root);
assertEquals(new DoubleNode(-1.2e19), p.parse("-1.2e+19").root);
assertEquals(new DoubleNode(-1.2e-19), p.parse("-1.2e-19").root);
assertEquals(new DoubleNode(0.0004), p.parse("4e-4").root);
assertEquals(new DoubleNode(40000), p.parse("4e4").root);
assertEquals(new BooleanNode(true), p.parse("True").root);
assertEquals(new BooleanNode(false), p.parse("False").root);
assertEquals(NoneNode.Instance, p.parse("None").root);
// long ints
assertEquals(new BigIntNode(new BigInteger("123456789123456789123456789")), p.parse("123456789123456789123456789").root);
assertFalse(new LongNode(52).equals(p.parse("52").root));
assertEquals(new LongNode(123456789123456789L), p.parse("123456789123456789").root);
assertEquals(BigIntNode.class, p.parse("12345678912345678912345678912345678978571892375798273578927389758378467693485903859038593453475897349587348957893457983475983475893475893785732957398475").root.getClass());
}
@Test
public void TestWeirdFloats()
{
Parser p = new Parser();
DoubleNode d = (DoubleNode) p.parse("1e30000").root;
assertTrue(Double.isInfinite(d.value));
assertTrue(d.value > 0.0);
d = (DoubleNode) p.parse("-1e30000").root;
assertTrue(Double.isInfinite(d.value));
assertTrue(d.value < 0.0);
TupleNode tuple = (TupleNode) p.parse("(1e30000,-1e30000,{'__class__':'float','value':'nan'})").root;
assertEquals(3, tuple.elements.size());
d = (DoubleNode) tuple.elements.get(0);
assertTrue(Double.isInfinite(d.value));
d = (DoubleNode) tuple.elements.get(1);
assertTrue(Double.isInfinite(d.value));
assertTrue(d.value < 0.0);
d = (DoubleNode) tuple.elements.get(2);
assertTrue(Double.isNaN(d.value));
ComplexNumberNode c = (ComplexNumberNode) p.parse("(1e30000-1e30000j)").root;
assertTrue(Double.isInfinite(c.real));
assertTrue(c.real>0.0);
assertTrue(Double.isInfinite(c.imaginary));
assertTrue(c.imaginary<0.0);
}
@Test
public void TestFloatPrecision()
{
Parser p = new Parser();
Serializer serpent = new Serializer();
byte[] ser = serpent.serialize(1.2345678987654321);
DoubleNode dv = (DoubleNode) p.parse(ser).root;
assertEquals(Double.valueOf(1.2345678987654321), dv.value);
ser = serpent.serialize(5555.12345678987656);
dv = (DoubleNode) p.parse(ser).root;
assertEquals(Double.valueOf(5555.12345678987656), dv.value);
ser = serpent.serialize(98765432123456.12345678987656);
dv = (DoubleNode) p.parse(ser).root;
assertEquals(Double.valueOf(98765432123456.12345678987656), dv.value);
ser = serpent.serialize(98765432123456.12345678987656e+44);
dv = (DoubleNode) p.parse(ser).root;
assertEquals(Double.valueOf(98765432123456.12345678987656e+44), dv.value);
ser = serpent.serialize(-98765432123456.12345678987656e-44);
dv = (DoubleNode) p.parse(ser).root;
assertEquals(Double.valueOf(-98765432123456.12345678987656e-44), dv.value);
}
@Test
public void TestEquality()
{
INode n1, n2;
n1 = new IntegerNode(42);
n2 = new IntegerNode(42);
assertEquals(n1, n2);
n2 = new IntegerNode(43);
assertFalse(n1.equals(n2));
n1 = new StringNode("foo");
n2 = new StringNode("foo");
assertEquals(n1, n2);
n2 = new StringNode("bar");
assertFalse(n1.equals(n2));
ComplexNumberNode cn1 = new ComplexNumberNode();
cn1.real=1.1; cn1.imaginary=2.2;
ComplexNumberNode cn2 = new ComplexNumberNode();
cn2.real=1.1; cn2.imaginary=2.2;
assertEquals(cn1, cn2);
cn2 = new ComplexNumberNode();
cn2.real=1.1; cn2.imaginary=3.3;
assertFalse(cn1.equals(cn2));
KeyValueNode kvn1=new KeyValueNode();
kvn1.key = new IntegerNode(42);
kvn1.value = new IntegerNode(42);
KeyValueNode kvn2=new KeyValueNode();
kvn2.key=new IntegerNode(42);
kvn2.value=new IntegerNode(42);
assertEquals(kvn1, kvn2);
kvn1=new KeyValueNode();
kvn1.key=new IntegerNode(43);
kvn1.value=new IntegerNode(43);
assertFalse(kvn1.equals(kvn2));
n1=NoneNode.Instance;
n2=NoneNode.Instance;
assertEquals(n1, n2);
n2=new IntegerNode(42);
assertFalse(n1.equals(n2));
DictNode dn1 = new DictNode();
kvn1 = new KeyValueNode();
kvn1.key = new IntegerNode(42);
kvn1.value = new IntegerNode(42);
dn1.elements.add(kvn1);
DictNode dn2=new DictNode();
kvn1 = new KeyValueNode();
kvn1.key =new IntegerNode(42);
kvn1.value = new IntegerNode(42);
dn2.elements.add(kvn1);
assertEquals(dn1, dn2);
dn2=new DictNode();
kvn1 = new KeyValueNode();
kvn1.key = new IntegerNode(42);
kvn1.value = new IntegerNode(43);
dn2.elements.add(kvn1);
assertFalse(dn1.equals(dn2));
ListNode ln1=new ListNode();
ln1.elements.add(new IntegerNode(42));
ListNode ln2=new ListNode();
ln2.elements.add(new IntegerNode(42));
assertEquals(ln1,ln2);
ln2=new ListNode();
ln2.elements.add(new IntegerNode(43));
assertFalse(ln1.equals(ln2));
SetNode sn1=new SetNode();
sn1.elements.add(new IntegerNode(42));
SetNode sn2=new SetNode();
sn2.elements.add(new IntegerNode(42));
assertEquals(sn1,sn2);
sn2=new SetNode();
sn2.elements.add(new IntegerNode(43));
assertFalse(sn1.equals(sn2));
TupleNode tn1=new TupleNode();
tn1.elements.add(new IntegerNode(42));
TupleNode tn2=new TupleNode();
tn2.elements.add(new IntegerNode(42));
assertEquals(tn1,tn2);
tn2=new TupleNode();
tn2.elements.add(new IntegerNode(43));
assertFalse(tn1.equals(tn2));
}
@Test
public void TestPrintSingle()
{
Parser p = new Parser();
// primitives
assertEquals("42", p.parse("42").root.toString());
assertEquals("-42.331", p.parse("-42.331").root.toString());
assertEquals("-42.0", p.parse("-42.0").root.toString());
assertEquals("-2.0E20", p.parse("-2E20").root.toString());
assertEquals("2.0", p.parse("2.0").root.toString());
assertEquals("1.2E19", p.parse("1.2e19").root.toString());
assertEquals("True", p.parse("True").root.toString());
assertEquals("'hello'", p.parse("'hello'").root.toString());
assertEquals("'\\n'", p.parse("'\n'").root.toString());
assertEquals("'\\''", p.parse("'\\''").root.toString());
assertEquals("'\"'", p.parse("'\\\"'").root.toString());
assertEquals("'\"'", p.parse("'\"'").root.toString());
assertEquals("'\\\\'", p.parse("'\\\\'").root.toString());
assertEquals("None", p.parse("None").root.toString());
String ustr = "'\u20ac\u2603'";
assertEquals(ustr, p.parse(ustr).root.toString());
// complex
assertEquals("(0.0+2.0j)", p.parse("2j").root.toString());
assertEquals("(-1.1-2.2j)", p.parse("(-1.1-2.2j)").root.toString());
assertEquals("(1.1+2.2j)", p.parse("(1.1+2.2j)").root.toString());
// long int
assertEquals("123456789123456789123456789", p.parse("123456789123456789123456789").root.toString());
}
@Test
public void TestPrintSeq()
{
Parser p=new Parser();
//tuple
assertEquals("()", p.parse("()").root.toString());
assertEquals("(42,)", p.parse("(42,)").root.toString());
assertEquals("(42,43)", p.parse("(42,43)").root.toString());
// list
assertEquals("[]", p.parse("[]").root.toString());
assertEquals("[42]", p.parse("[42]").root.toString());
assertEquals("[42,43]", p.parse("[42,43]").root.toString());
// set
assertEquals("{42}", p.parse("{42}").root.toString());
assertEquals("{42,43}", p.parse("{42,43,43,43}").root.toString());
// dict
assertEquals("{}", p.parse("{}").root.toString());
assertEquals("{'a':42}", p.parse("{'a': 42}").root.toString());
String result = p.parse("{'a': 42, 'b': 43}").root.toString();
assertTrue(result.equals("{'a':42,'b':43}") || result.equals("{'b':43,'a':42}"));
result = p.parse("{'a': 42, 'b': 43, 'b': 44, 'b': 45}").root.toString();
assertTrue(result.equals("{'a':42,'b':45}") || result.equals("{'b':45,'a':42}"));
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive1()
{
new Parser().parse("1+2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive2()
{
new Parser().parse("1-2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive3()
{
new Parser().parse("1.1+2.2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive4()
{
new Parser().parse("1.1-2.2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive5()
{
new Parser().parse("True+2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive6()
{
new Parser().parse("False-2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive7()
{
new Parser().parse("3j+2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive8()
{
new Parser().parse("3j-2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive9()
{
new Parser().parse("None+2");
}
@Test(expected=ParseException.class)
public void TestInvalidPrimitive10()
{
new Parser().parse("None-2");
}
@Test(expected=ParseException.class)
public void TestInvalidTuple1()
{
new Parser().parse("(42,43]");
}
@Test(expected=ParseException.class)
public void TestInvalidTuple2()
{
new Parser().parse("()@");
}
@Test(expected=ParseException.class)
public void TestInvalidTuple3()
{
new Parser().parse("(42,43)@");
}
@Test(expected=ParseException.class)
public void TestInvalidList2()
{
new Parser().parse("[42,43}");
}
@Test(expected=ParseException.class)
public void TestInvalidList3()
{
new Parser().parse("[]@");
}
@Test(expected=ParseException.class)
public void TestInvalidList4()
{
new Parser().parse("[42,43]@");
}
@Test(expected=ParseException.class)
public void TestInvalidSet2()
{
new Parser().parse("{42,43]");
}
@Test(expected=ParseException.class)
public void TestInvalidSet3()
{
new Parser().parse("{42,43}@");
}
@Test(expected=ParseException.class)
public void TestInvalidDict2()
{
new Parser().parse("{'key': 42]");
}
@Test(expected=ParseException.class)
public void TestInvalidDict3()
{
new Parser().parse("{}@");
}
@Test(expected=ParseException.class)
public void TestInvalidDict4()
{
new Parser().parse("{'key': 42}@");
}
@Test
public void TestComplex()
{
Parser p = new Parser();
ComplexNumberNode cplx = new ComplexNumberNode();
cplx.real = 4.2;
cplx.imaginary = 3.2;
ComplexNumberNode cplx2 = new ComplexNumberNode();
cplx2.real = 4.2;
cplx2.imaginary = 99;
assertFalse(cplx.equals(cplx2));
cplx2.imaginary = 3.2;
assertEquals(cplx, cplx2);
assertEquals(cplx, p.parse("(4.2+3.2j)").root);
cplx.real = 0;
assertEquals(cplx, p.parse("(0+3.2j)").root);
assertEquals(cplx, p.parse("3.2j").root);
assertEquals(cplx, p.parse("+3.2j").root);
cplx.imaginary = -3.2;
assertEquals(cplx, p.parse("-3.2j").root);
cplx.real = -9.9;
assertEquals(cplx, p.parse("(-9.9-3.2j)").root);
cplx.real = 2;
cplx.imaginary = 3;
assertEquals(cplx, p.parse("(2+3j)").root);
cplx.imaginary = -3;
assertEquals(cplx, p.parse("(2-3j)").root);
cplx.real = 0;
assertEquals(cplx, p.parse("-3j").root);
cplx.real = -3.2e32;
cplx.imaginary = -9.9e44;
assertEquals(cplx, p.parse("(-3.2e32-9.9e44j)").root);
assertEquals(cplx, p.parse("(-3.2e+32-9.9e+44j)").root);
assertEquals(cplx, p.parse("(-3.2e32 -9.9e44j)").root);
assertEquals(cplx, p.parse("(-3.2e+32 -9.9e+44j)").root);
cplx.imaginary = 9.9e44;
assertEquals(cplx, p.parse("(-3.2e32+9.9e44j)").root);
assertEquals(cplx, p.parse("(-3.2e+32+9.9e+44j)").root);
cplx.real = -3.2e-32;
cplx.imaginary = -9.9e-44;
assertEquals(cplx, p.parse("(-3.2e-32-9.9e-44j)").root);
}
@Test
public void TestComplexPrecision()
{
Parser p = new Parser();
ComplexNumberNode cv = (ComplexNumberNode)p.parse("(98765432123456.12345678987656+665544332211.9998877665544j)").root;
assertEquals(Double.valueOf(98765432123456.12345678987656), cv.real, 0);
assertEquals(Double.valueOf(665544332211.9998877665544), cv.imaginary, 0);
cv = (ComplexNumberNode)p.parse("(98765432123456.12345678987656-665544332211.9998877665544j)").root;
assertEquals(Double.valueOf(98765432123456.12345678987656), cv.real, 0);
assertEquals(Double.valueOf(-665544332211.9998877665544), cv.imaginary, 0);
cv = (ComplexNumberNode)p.parse("(98765432123456.12345678987656e+33+665544332211.9998877665544e+44j)").root;
assertEquals(Double.valueOf(98765432123456.12345678987656e+33), cv.real, 0);
assertEquals(Double.valueOf(665544332211.9998877665544e+44), cv.imaginary, 0);
cv = (ComplexNumberNode)p.parse("(-98765432123456.12345678987656e+33-665544332211.9998877665544e+44j)").root;
assertEquals(Double.valueOf(-98765432123456.12345678987656e+33), cv.real, 0);
assertEquals(Double.valueOf(-665544332211.9998877665544e+44), cv.imaginary, 0);
}
@Test
public void TestPrimitivesStuffAtEnd()
{
Parser p = new Parser();
assertEquals(new IntegerNode(42), p.parseSingle(new SeekableStringReader("42@")));
assertEquals(new DoubleNode(42.331), p.parseSingle(new SeekableStringReader("42.331@")));
assertEquals(new BooleanNode(true), p.parseSingle(new SeekableStringReader("True@")));
assertEquals(NoneNode.Instance, p.parseSingle(new SeekableStringReader("None@")));
ComplexNumberNode cplx = new ComplexNumberNode();
cplx.real=4;
cplx.imaginary=3;
assertEquals(cplx, p.parseSingle(new SeekableStringReader("(4+3j)@")));
cplx.real=0;
assertEquals(cplx, p.parseSingle(new SeekableStringReader("3j@")));
}
@Test
public void TestStrings()
{
Parser p = new Parser();
assertEquals(new StringNode("hello"), p.parse("'hello'").root);
assertEquals(new StringNode("hello"), p.parse("\"hello\"").root);
assertEquals(new StringNode("\\"), p.parse("'\\\\'").root);
assertEquals(new StringNode("\\"), p.parse("\"\\\\\"").root);
assertEquals(new StringNode("'"), p.parse("\"'\"").root);
assertEquals(new StringNode("\""), p.parse("'\"'").root);
assertEquals(new StringNode("tab\tnewline\n."), p.parse("'tab\\tnewline\\n.'").root);
}
@Test
public void TestUnicode() throws UnsupportedEncodingException
{
Parser p = new Parser();
String str = "'\u20ac\u2603'";
assertEquals(0x20ac, str.charAt(1));
assertEquals(0x2603, str.charAt(2));
byte[] bytes = str.getBytes("utf-8");
String value = "\u20ac\u2603";
assertEquals(new StringNode(value), p.parse(str).root);
assertEquals(new StringNode(value), p.parse(bytes).root);
}
@Test
public void testLongUnicodeRoundtrip()
{
char[] chars64k = new char[65536];
for(int i=0; i<=65535; ++i)
chars64k[i]=(char)i;
String str64k= new String(chars64k);
Serializer ser=new Serializer();
byte[] data = ser.serialize(str64k);
assertTrue(data.length > chars64k.length);
Parser p=new Parser();
String result = (String)p.parse(data).getData();
assertEquals(str64k, result);
}
@Test
public void TestWhitespace()
{
Parser p = new Parser();
assertEquals(new IntegerNode(42), p.parse(" 42 ").root);
assertEquals(new IntegerNode(42), p.parse(" 42 ").root);
assertEquals(new IntegerNode(42), p.parse("\t42\r\n").root);
assertEquals(new IntegerNode(42), p.parse(" \t 42 \r \n ").root);
assertEquals(new StringNode(" string value "), p.parse(" ' string value ' ").root);
try {
p.parse(" ( 42 , 43 , "); // missing tuple close )
fail("expected parse error");
} catch (ParseException x) {
//ok
}
try {
p.parse(" [ 42 , 43 , "); // missing list close )
fail("expected parse error");
} catch (ParseException x) {
//ok
}
try {
p.parse(" { 42 , 43 , "); // missing set close )
fail("expected parse error");
} catch (ParseException x) {
//ok
}
try {
p.parse(" { 'a' : 4 2 , "); // missing dict close )
fail("expected parse error");
} catch (ParseException x) {
//ok
}
Ast ast = p.parse(" ( 42 , ( 'x', 'y' ) ) ");
TupleNode tuple = (TupleNode) ast.root;
assertEquals(new IntegerNode(42), tuple.elements.get(0));
tuple = (TupleNode) tuple.elements.get(1);
assertEquals(new StringNode("x"), tuple.elements.get(0));
assertEquals(new StringNode("y"), tuple.elements.get(1));
p.parse(" ( 52 , ) ");
p.parse(" [ 52 ] ");
p.parse(" { 'a' : 42 } ");
p.parse(" { 52 } ");
}
@Test
public void TestTuple()
{
Parser p = new Parser();
TupleNode tuple = new TupleNode();
TupleNode tuple2 = new TupleNode();
assertEquals(tuple, tuple2);
tuple.elements.add(new IntegerNode(42));
tuple2.elements.add(new IntegerNode(99));
assertFalse(tuple.equals(tuple2));
tuple2.elements.clear();
tuple2.elements.add(new IntegerNode(42));
assertEquals(tuple, tuple2);
tuple2.elements.add(new IntegerNode(43));
tuple2.elements.add(new IntegerNode(44));
assertFalse(tuple.equals(tuple2));
assertEquals(new TupleNode(), p.parse("()").root);
assertEquals(tuple, p.parse("(42,)").root);
assertEquals(tuple2, p.parse("( 42,43, 44 )").root);
}
@Test
public void TestList()
{
Parser p = new Parser();
ListNode list = new ListNode();
ListNode list2 = new ListNode();
assertEquals(list, list2);
list.elements.add(new IntegerNode(42));
list2.elements.add(new IntegerNode(99));
assertFalse(list.equals(list2));
list2.elements.clear();
list2.elements.add(new IntegerNode(42));
assertEquals(list, list2);
list2.elements.add(new IntegerNode(43));
list2.elements.add(new IntegerNode(44));
assertFalse(list.equals(list2));
assertEquals(new ListNode(), p.parse("[]").root);
assertEquals(list, p.parse("[42]").root);
assertEquals(list2, p.parse("[ 42,43, 44 ]").root);
}
@Test
public void TestSet()
{
Parser p = new Parser();
SetNode set1 = new SetNode();
SetNode set2 = new SetNode();
assertEquals(set1, set2);
set1.elements.add(new IntegerNode(42));
set2.elements.add(new IntegerNode(99));
assertFalse(set1.equals(set2));
set2.elements.clear();
set2.elements.add(new IntegerNode(42));
assertEquals(set1, set2);
set2.elements.add(new IntegerNode(43));
set2.elements.add(new IntegerNode(44));
assertFalse(set1.equals(set2));
assertEquals(set1, p.parse("{42}").root);
assertEquals(set2, p.parse("{ 42,43, 44 }").root);
set1 = (SetNode) p.parse("{'first','second','third','fourth','fifth','second', 'first', 'third', 'third' }").root;
assertTrue(set1.elements.contains(new StringNode("first")));
assertTrue(set1.elements.contains(new StringNode("second")));
assertTrue(set1.elements.contains(new StringNode("third")));
assertTrue(set1.elements.contains(new StringNode("fourth")));
assertTrue(set1.elements.contains(new StringNode("fifth")));
assertEquals(5, set1.elements.size());
}
@Test
public void TestDict()
{
Parser p = new Parser();
DictNode dict1 = new DictNode();
DictNode dict2 = new DictNode();
assertEquals(dict1, dict2);
KeyValueNode kv1 = new KeyValueNode();
kv1.key = new StringNode("key");
kv1.value = new IntegerNode(42);
KeyValueNode kv2 = new KeyValueNode();
kv2.key=new StringNode("key");
kv2.value=new IntegerNode(99);
assertFalse(kv1.equals(kv2));
kv2.value = new IntegerNode(42);
assertEquals(kv1, kv2);
kv1=new KeyValueNode();
kv1.key=new StringNode("key1");
kv1.value=new IntegerNode(42);
dict1.elements.add(kv1);
kv1=new KeyValueNode();
kv1.key=new StringNode("key1");
kv1.value=new IntegerNode(99);
dict2.elements.add(kv1);
assertFalse(dict1.equals(dict2));
dict2.elements.clear();
kv1=new KeyValueNode();
kv1.key=new StringNode("key1");
kv1.value=new IntegerNode(42);
dict2.elements.add(kv1);
assertEquals(dict1, dict2);
kv1=new KeyValueNode();
kv1.key=new StringNode("key2");
kv1.value=new IntegerNode(43);
dict2.elements.add(kv1);
kv1=new KeyValueNode();
kv1.key=new StringNode("key3");
kv1.value=new IntegerNode(44);
dict2.elements.add(kv1);
assertFalse(dict1.equals(dict2));
assertEquals(new DictNode(), p.parse("{}").root);
assertEquals(dict1, p.parse("{'key1': 42}").root);
assertEquals(dict2, p.parse("{'key1': 42, 'key2': 43, 'key3':44}").root);
dict1 = (DictNode) p.parse("{'a': 1, 'b': 2, 'c': 3, 'c': 4, 'c': 5, 'c': 6}").root;
kv1 = new KeyValueNode();
kv1.key=new StringNode("c");
kv1.value=new IntegerNode(6);
assertTrue(dict1.elements.contains(kv1));
assertEquals(3, dict1.elements.size());
}
@Test
public void TestKeyValueEquality()
{
KeyValueNode kv1=new KeyValueNode();
kv1.key=new StringNode("key1");
kv1.value=new IntegerNode(42);
KeyValueNode kv2=new KeyValueNode();
kv2.key=new StringNode("key1");
kv2.value=new IntegerNode(42);
assertEquals(kv1, kv2);
kv2.value=new IntegerNode(43);
assertFalse(kv1.equals(kv2));
}
@Test
public void TestDictEquality()
{
DictNode dict1 = new DictNode();
KeyValueNode kv=new KeyValueNode();
kv.key=new StringNode("key1");
kv.value=new IntegerNode(42);
dict1.elements.add(kv);
DictNode dict2 = new DictNode();
kv=new KeyValueNode();
kv.key=new StringNode("key1");
kv.value=new IntegerNode(42);
dict2.elements.add(kv);
assertEquals(dict1, dict2);
kv=new KeyValueNode();
kv.key=new StringNode("key2");
kv.value=new IntegerNode(43);
dict1.elements.add(kv);
kv=new KeyValueNode();
kv.key=new StringNode("key3");
kv.value=new IntegerNode(44);
dict1.elements.add(kv);
dict2 = new DictNode();
kv=new KeyValueNode();
kv.key=new StringNode("key2");
kv.value=new IntegerNode(43);
dict2.elements.add(kv);
kv=new KeyValueNode();
kv.key=new StringNode("key3");
kv.value=new IntegerNode(44);
dict2.elements.add(kv);
kv=new KeyValueNode();
kv.key=new StringNode("key1");
kv.value=new IntegerNode(42);
dict2.elements.add(kv);
assertTrue(dict1.equals(dict2));
assertEquals(dict1, dict2);
kv=new KeyValueNode();
kv.key=new StringNode("key4");
kv.value=new IntegerNode(45);
dict2.elements.add(kv);
assertFalse(dict1.equals(dict2));
}
@Test
public void TestSetEquality()
{
SetNode set1 = new SetNode();
set1.elements.add(new IntegerNode(1));
set1.elements.add(new IntegerNode(2));
set1.elements.add(new IntegerNode(3));
SetNode set2 = new SetNode();
set2.elements.add(new IntegerNode(2));
set2.elements.add(new IntegerNode(3));
set2.elements.add(new IntegerNode(1));
assertEquals(set1, set2);
set2.elements.add(new IntegerNode(0));
assertFalse(set1.equals(set2));
}
@Test
public void TestFile() throws IOException
{
Parser p = new Parser();
File testdatafile = new File("src/test/java/testserpent.utf8.bin");
byte[] ser = new byte[(int) testdatafile.length()];
FileInputStream fis=new FileInputStream(testdatafile);
DataInputStream dis = new DataInputStream(fis);
dis.readFully(ser);
dis.close();
fis.close();
Ast ast = p.parse(ser);
String expr = ast.toString();
Ast ast2 = p.parse(expr);
String expr2 = ast2.toString();
assertEquals(expr.length(), expr2.length());
StringBuilder sb= new StringBuilder();
Walk(ast.root, sb);
String walk1 = sb.toString();
sb= new StringBuilder();
Walk(ast2.root, sb);
String walk2 = sb.toString();
assertEquals(walk1.length(), walk2.length());
// TODO assertEquals(ast.root, ast2.root);
ast = p.parse(expr2);
// TODO assertEquals(ast.root, ast2.root);
}
@Test
public void TestTrailingCommas() throws IOException
{
Parser p = new Parser();
INode result;
result = p.parse("[1,2,3, ]").root;
result = p.parse("[1,2,3 , ]").root;
result = p.parse("[1,2,3,]").root;
assertEquals("[1,2,3]", result.toString());
result = p.parse("(1,2,3, )").root;
result = p.parse("(1,2,3 , )").root;
result = p.parse("(1,2,3,)").root;
assertEquals("(1,2,3)", result.toString());
// for dict and set the asserts are a bit more complex
// we cannot simply convert to string because the order of elts is undefined.
result = p.parse("{'a':1, 'b':2, 'c':3, }").root;
result = p.parse("{'a':1, 'b':2, 'c':3 , }").root;
result = p.parse("{'a':1, 'b':2, 'c':3,}").root;
DictNode dict = (DictNode) result;
assertEquals(3, dict.elements.size());
Set elts = dict.elementsAsSet();
assertTrue(elts.contains(new KeyValueNode(new StringNode("a"), new IntegerNode(1))));
assertTrue(elts.contains(new KeyValueNode(new StringNode("b"), new IntegerNode(2))));
assertTrue(elts.contains(new KeyValueNode(new StringNode("c"), new IntegerNode(3))));
result = p.parse("{1,2,3, }").root;
result = p.parse("{1,2,3 , }").root;
result = p.parse("{1,2,3,}").root;
SetNode set = (SetNode) result;
assertEquals(3, set.elements.size());
elts = set.elementsAsSet();
assertTrue(elts.contains(new IntegerNode(1)));
assertTrue(elts.contains(new IntegerNode(2)));
assertTrue(elts.contains(new IntegerNode(3)));
}
@Test
@Ignore("can't get the ast compare to succeed :(")
public void TestAstEquals() throws IOException
{
Parser p = new Parser();
File testdatafile = new File("test/testserpent.utf8.bin");
byte[] ser = new byte[(int) testdatafile.length()];
FileInputStream fis=new FileInputStream(testdatafile);
DataInputStream dis = new DataInputStream(fis);
dis.readFully(ser);
dis.close();
fis.close();
Ast ast = p.parse(ser);
Ast ast2 = p.parse(ser);
assertEquals(ast.root, ast2.root); // TODO this fails :(
}
public void Walk(INode node, StringBuilder sb)
{
if(node instanceof SequenceNode)
{
sb.append(String.format("%s (seq)\n", node.getClass()));
SequenceNode seq = (SequenceNode)node;
for(INode child: seq.elements) {
Walk(child, sb);
}
}
else
sb.append(String.format(" %s\n", node.toString()));
}
}
Serpent-serpent-1.42/java/src/test/java/net/razorvine/serpent/test/SerializationHelperClass.java 0000664 0000000 0000000 00000001011 15077515333 0033222 0 ustar 00root root 0000000 0000000 package net.razorvine.serpent.test;
import java.io.Serializable;
public class SerializationHelperClass implements Serializable
{
private static final long serialVersionUID = 5151254868567404093L;
public int x;
public String s;
public int i;
public Object obj;
public String getTheString() { return s; }
public int getTheInteger() { return i; }
public boolean isThingy() { return true; }
public int getNUMBER() { return 42; }
public String getX() { return "X"; }
public Object getObject() { return obj; }
} Serpent-serpent-1.42/java/src/test/java/net/razorvine/serpent/test/SerializeTest.java 0000664 0000000 0000000 00000057115 15077515333 0031066 0 ustar 00root root 0000000 0000000 /**
* Serpent, a Python literal expression serializer/deserializer
* (a.k.a. Python's ast.literal_eval in Java)
* Software license: "MIT software license". See http://opensource.org/licenses/MIT
* @author Irmen de Jong (irmen@razorvine.net)
*/
package net.razorvine.serpent.test;
import static org.junit.Assert.*;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import net.razorvine.serpent.ComplexNumber;
import net.razorvine.serpent.IClassSerializer;
import net.razorvine.serpent.Parser;
import net.razorvine.serpent.Serializer;
import net.razorvine.serpent.ast.BytesNode;
import org.junit.Test;
public class SerializeTest {
public byte[] strip_header(byte[] data)
{
int start;
for(start=0; start=data.length)
{
throw new IllegalArgumentException("need header in string");
}
start++;
byte[] result = new byte[data.length-start];
System.arraycopy(data, start, result, 0, data.length-start);
return result;
}
public byte[] B(String s)
{
try {
return s.getBytes("utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return null;
}
}
public String S(byte[] b)
{
try {
return new String(b, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return null;
}
}
@Test
public void testHeader()
{
Serializer ser = new Serializer();
byte[] data = ser.serialize(null);
assertEquals(35, data[0]);
String strdata = S(data);
assertEquals("# serpent utf-8 python3.2", strdata.split("\n")[0]);
data = B("# header\nfirst-line");
data = strip_header(data);
assertEquals("first-line", S(data));
}
@Test
public void testException()
{
Serializer.registerClass(IllegalArgumentException.class, null);
Exception x = new IllegalArgumentException("errormessage");
Serializer serpent = new Serializer(true, false);
byte[] ser = strip_header(serpent.serialize(x));
assertEquals("{\n '__class__': 'IllegalArgumentException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {}\n}", S(ser));
}
@Test
public void testExceptionPackage()
{
Serializer.registerClass(IllegalArgumentException.class, null);
Exception x = new IllegalArgumentException("errormessage");
Serializer serpent = new Serializer(true, true);
byte[] ser = strip_header(serpent.serialize(x));
assertEquals("{\n '__class__': 'java.lang.IllegalArgumentException',\n '__exception__': True,\n 'args': (\n 'errormessage',\n ),\n 'attributes': {}\n}", S(ser));
}
@Test
public void testStuff()
{
Serializer ser=new Serializer();
byte[] result = ser.serialize("blerp");
result=strip_header(result);
assertEquals("'blerp'", S(result));
result = ser.serialize("\\");
result=strip_header(result);
assertEquals("'\\\\'", S(result));
result = ser.serialize(UUID.fromString("f1f8d00e-49a5-4662-ac1d-d5f0426ed293"));
result=strip_header(result);
assertEquals("'f1f8d00e-49a5-4662-ac1d-d5f0426ed293'", S(result));
result = ser.serialize(new BigDecimal("123456789.987654321987654321987654321987654321"));
result=strip_header(result);
assertEquals("'123456789.987654321987654321987654321987654321'", S(result));
}
@Test
public void testNull()
{
Serializer ser = new Serializer();
byte[] data = ser.serialize(null);
data=strip_header(data);
assertEquals("None", S(data));
}
@Test
public void testStrings()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.serialize("hello");
byte[] data = strip_header(ser);
assertEquals("'hello'", S(data));
ser = serpent.serialize("quotes'\"");
data = strip_header(ser);
assertEquals("'quotes\\'\"'", S(data));
ser = serpent.serialize("quotes2'");
data = strip_header(ser);
assertEquals("\"quotes2'\"", S(data));
}
@Test
public void testUnicodeEscapes()
{
Serializer serpent=new Serializer();
// regular escaped chars first
byte[] ser = serpent.serialize("\b\r\n\f\t \\");
byte[] data = strip_header(ser);
// '\\x08\\r\\n\\x0c\\t \\\\'
assertArrayEquals(new byte[] {39,
92, 120, 48, 56,
92, 114,
92, 110,
92, 120, 48, 99,
92, 116,
32,
92, 92,
39}, data);
// simple cases (chars < 0x80)
ser = serpent.serialize("\u0000\u0001\u001f\u007f");
data = strip_header(ser);
// '\\x00\\x01\\x1f\\x7f'
assertArrayEquals(new byte[] {39,
92, 120, 48, 48,
92, 120, 48, 49,
92, 120, 49, 102,
92, 120, 55, 102,
39 }, data);
// chars 0x80 .. 0xff
ser = serpent.serialize("\u0080\u0081\u00ff");
data = strip_header(ser);
// '\\x80\\x81\xc3\xbf' (has some utf-8 encoded chars in it)
assertArrayEquals(new byte[] {39,
92, 120, 56, 48,
92, 120, 56, 49,
-61, -65,
39}, data);
// chars above 0xff
ser = serpent.serialize("\u0100\u20ac\u8899");
data = strip_header(ser);
// '\xc4\x80\xe2\x82\xac\xe8\xa2\x99' (has some utf-8 encoded chars in it)
assertArrayEquals(new byte[] {39, -60, -128, -30, -126, -84, -24, -94, -103, 39}, data);
// some random high chars that are all printable in python and not escaped
ser = serpent.serialize("\u0377\u082d\u10c5\u135d\uac00");
data = strip_header(ser);
// '\xcd\xb7\xe0\xa0\xad\xe1\x83\x85\xe1\x8d\x9d\xea\xb0\x80' (only a bunch of utf-8 encoded chars)
assertArrayEquals(new byte[] {39, -51, -73, -32, -96, -83, -31, -125, -123, -31, -115, -99, -22, -80, -128, 39}, data);
// some random high chars that are all non-printable in python and that are escaped
ser = serpent.serialize("\u0378\u082e\u10c6\u135c\uabff");
data = strip_header(ser);
// '\\u0378\\u082e\\u10c6\\u135c\\uabff'
assertArrayEquals(new byte[] {39,
92, 117, 48, 51, 55, 56,
92, 117, 48, 56, 50, 101,
92, 117, 49, 48, 99, 54,
92, 117, 49, 51, 53, 99,
92, 117, 97, 98, 102, 102,
39}, data);
}
@Test
public void testNullByte()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.serialize("null\u0000byte");
byte[] data = strip_header(ser);
assertEquals("'null\\x00byte'", new String(data));
for(byte b: ser) {
if(b==0)
fail("serialized data may not contain 0-bytes");
}
}
@Test
public void testBool()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.serialize(true);
byte[] data = strip_header(ser);
assertEquals("True", S(data));
ser = serpent.serialize(false);
data = strip_header(ser);
assertEquals("False", S(data));
}
@Test
public void testBytesDefault()
{
Serializer serpent = new Serializer(true, false);
byte[] bytes = new byte[] { 97, 98, 99, 100, 101, 102 }; // abcdef
byte[] ser = serpent.serialize(bytes);
assertEquals("{\n 'data': 'YWJjZGVm',\n 'encoding': 'base64'\n}", S(strip_header(ser)));
Parser p = new Parser();
String parsed = p.parse(ser).root.toString();
assertEquals(39, parsed.length());
Map dict = new HashMap();
dict.put("data", "YWJjZGVm");
dict.put("encoding", "base64");
byte[] bytes2 = Parser.toBytes(dict);
assertArrayEquals(bytes, bytes2);
dict.put("encoding", "base99");
try {
Parser.toBytes(dict);
fail("error expected");
} catch (IllegalArgumentException x) {
//
}
dict.clear();
try {
Parser.toBytes(dict);
fail("error expected");
} catch (IllegalArgumentException x) {
//
}
dict.clear();
dict.put("data", "YWJjZGVm");
try {
Parser.toBytes(dict);
fail("error expected");
} catch (IllegalArgumentException x) {
//
}
dict.clear();
dict.put("encoding", "base64");
try {
Parser.toBytes(dict);
fail("error expected");
} catch (IllegalArgumentException x) {
//
}
try {
Parser.toBytes(12345);
fail("error expected");
} catch (IllegalArgumentException x) {
//
}
try {
Parser.toBytes(null);
fail("error expected");
} catch (IllegalArgumentException x) {
//
}
}
@Test
public void testBytesRepr()
{
Serializer serpent = new Serializer(true, false, true);
byte[] bytes = new byte[] { 97, 98, 99, 100, 101, 102, 0, -1, '\'', '\"' }; // abcdef\x00\xff'"
byte[] ser = serpent.serialize(bytes);
assertEquals("b'abcdef\\x00\\xff\\'\"'", S(strip_header(ser)));
Parser p = new Parser();
BytesNode parsed = (BytesNode) p.parse(ser).root;
assertArrayEquals(bytes, parsed.toByteArray());
}
@Test
public void testDateTime()
{
Serializer serpent = new Serializer();
Calendar cal = new GregorianCalendar(2013, 0, 20, 23, 59, 45);
cal.set(Calendar.MILLISECOND, 999);
cal.setTimeZone(TimeZone.getTimeZone("GMT+0"));
byte[] ser = strip_header(serpent.serialize(cal));
assertEquals("'2013-01-20T23:59:45.999Z'", S(ser));
Date date = cal.getTime();
ser = strip_header(serpent.serialize(date));
assertEquals("'2013-01-20T23:59:45.999Z'", S(ser));
ser = strip_header(serpent.serialize(date));
assertEquals("'2013-01-20T23:59:45.999Z'", S(ser));
cal.set(Calendar.MILLISECOND, 0);
ser = strip_header(serpent.serialize(cal));
assertEquals("'2013-01-20T23:59:45Z'", S(ser));
date = cal.getTime();
ser = strip_header(serpent.serialize(date));
assertEquals("'2013-01-20T23:59:45Z'", S(ser));
}
@Test
public void testDateTimeWithTimezone()
{
Serializer serpent = new Serializer();
Calendar cal = new GregorianCalendar(2013, 0, 20, 23, 59, 45);
cal.set(Calendar.MILLISECOND, 999);
cal.setTimeZone(TimeZone.getTimeZone("Europe/Amsterdam"));
byte[] ser = strip_header(serpent.serialize(cal));
assertEquals("'2013-01-20T23:59:45.999+0100'", S(ser)); // normal time
cal = new GregorianCalendar(2013, 4, 10, 13, 59, 45);
cal.set(Calendar.MILLISECOND, 999);
cal.setTimeZone(TimeZone.getTimeZone("Europe/Amsterdam"));
ser = strip_header(serpent.serialize(cal));
assertEquals("'2013-05-10T13:59:45.999+0200'", S(ser)); // daylight saving time
Date date=cal.getTime();
ser = strip_header(serpent.serialize(date));
assertEquals("'2013-05-10T11:59:45.999Z'", S(ser)); // the date and time in UTC
cal.set(Calendar.MILLISECOND, 0);
date=cal.getTime();
ser = strip_header(serpent.serialize(date));
assertEquals("'2013-05-10T11:59:45Z'", S(ser)); // the date and time in UTC
}
@Test
public void testNumbers()
{
Serializer serpent = new Serializer();
byte[] ser = serpent.serialize(12345);
byte[] data = strip_header(ser);
assertEquals("12345", S(data));
ser = serpent.serialize(1234567891234567891L);
data = strip_header(ser);
assertEquals("1234567891234567891", S(data));
ser = serpent.serialize(99.1234);
data = strip_header(ser);
assertEquals("99.1234", S(data));
ser = serpent.serialize(new BigInteger("1234999999999912345678901234567890"));
data = strip_header(ser);
assertEquals("1234999999999912345678901234567890", S(data));
ser = serpent.serialize(new BigDecimal("123456789.987654321987654321987654321987654321"));
data=strip_header(ser);
assertEquals("'123456789.987654321987654321987654321987654321'", S(data));
ComplexNumber cplx = new ComplexNumber(2.2, 3.3);
ser = serpent.serialize(cplx);
data = strip_header(ser);
assertEquals("(2.2+3.3j)", S(data));
cplx = new ComplexNumber(0, 3);
ser = serpent.serialize(cplx);
data = strip_header(ser);
assertEquals("(0.0+3.0j)", S(data));
cplx = new ComplexNumber(-2, -3);
ser = serpent.serialize(cplx);
data = strip_header(ser);
assertEquals("(-2.0-3.0j)", S(data));
cplx = new ComplexNumber(-2.5, -3.9);
ser = serpent.serialize(cplx);
data = strip_header(ser);
assertEquals("(-2.5-3.9j)", S(data));
}
@Test
public void testDoubleNanInf()
{
Serializer serpent = new Serializer();
Object[] doubles = new Object[] {Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.NaN,
Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NaN,
new ComplexNumber(Double.POSITIVE_INFINITY, 3.3)};
byte[] ser = serpent.serialize(doubles);
byte[] data = strip_header(ser);
assertEquals("(1e30000,-1e30000,{'__class__':'float','value':'nan'},1e30000,-1e30000,{'__class__':'float','value':'nan'},(1e30000+3.3j))", S(data));
}
@Test
public void testList()
{
Serializer serpent = new Serializer();
List list = new LinkedList();
// test empty list
byte[] ser = strip_header(serpent.serialize(list));
assertEquals("[]", S(ser));
serpent.indent=true;
ser = strip_header(serpent.serialize(list));
assertEquals("[]", S(ser));
serpent.indent=false;
// test nonempty list
list.add(42);
list.add("Sally");
list.add(16.5);
ser = strip_header(serpent.serialize(list));
assertEquals("[42,'Sally',16.5]", S(ser));
serpent.indent=true;
ser = strip_header(serpent.serialize(list));
assertEquals("[\n 42,\n 'Sally',\n 16.5\n]", S(ser));
}
public class UnserializableClass
{
}
@Test(expected = IllegalArgumentException.class)
public void testClassFail()
{
Serializer serpent = new Serializer(true, false);
Object obj = new UnserializableClass();
serpent.serialize(obj);
}
@Test
public void testClassOk()
{
Serializer.registerClass(SerializationHelperClass.class, null);
Serializer serpent = new Serializer(true, false);
SerializationHelperClass obj = new SerializationHelperClass();
obj.i=99;
obj.s="hi";
obj.x=42;
byte[] ser = strip_header(serpent.serialize(obj));
assertEquals("{\n 'NUMBER': 42,\n '__class__': 'SerializationHelperClass',\n 'object': None,\n 'theInteger': 99,\n 'theString': 'hi',\n 'thingy': True,\n 'x': 'X'\n}", S(ser));
}
@Test
public void testClassPackageOk()
{
Serializer.registerClass(SerializationHelperClass.class, null);
Serializer serpent = new Serializer(true, true);
SerializationHelperClass obj = new SerializationHelperClass();
obj.i=99;
obj.s="hi";
obj.x=42;
byte[] ser = strip_header(serpent.serialize(obj));
assertEquals("{\n 'NUMBER': 42,\n '__class__': 'net.razorvine.serpent.test.SerializationHelperClass',\n 'object': None,\n 'theInteger': 99,\n 'theString': 'hi',\n 'thingy': True,\n 'x': 'X'\n}", S(ser));
}
class TestclassConverter implements IClassSerializer
{
@Override
public Map convert(Object obj) {
SerializationHelperClass o = (SerializationHelperClass) obj;
Map result = new HashMap();
result.put("__class@__", o.getClass().getSimpleName()+"@");
result.put("i@", o.i);
result.put("s@", o.s);
result.put("x@", o.x);
return result;
}
}
class ExceptionConverter implements IClassSerializer
{
@Override
public Map convert(Object obj) {
IllegalArgumentException e = (IllegalArgumentException) obj;
Map result = new HashMap();
result.put("__class@__", e.getClass().getSimpleName());
result.put("msg@", e.getMessage());
return result;
}
}
@Test
public void testCustomClassDict()
{
Serializer.registerClass(SerializationHelperClass.class, new TestclassConverter());
Serializer serpent = new Serializer(true, false);
SerializationHelperClass obj = new SerializationHelperClass();
obj.i=99;
obj.s="hi";
obj.x=42;
byte[] ser = strip_header(serpent.serialize(obj));
assertEquals("{\n '__class@__': 'SerializationHelperClass@',\n 'i@': 99,\n 's@': 'hi',\n 'x@': 42\n}", S(ser));
}
@Test
public void testCustomExceptionDict()
{
Serializer.registerClass(IllegalArgumentException.class, new ExceptionConverter());
Serializer serpent = new Serializer(true, false);
Exception x = new IllegalArgumentException("errormessage");
byte[] ser = strip_header(serpent.serialize(x));
assertEquals("{\n '__class@__': 'IllegalArgumentException',\n 'msg@': 'errormessage'\n}", S(ser));
}
@Test
public void testSet()
{
Serializer serpent = new Serializer();
Set set = new HashSet();
// test empty set
byte[] ser = strip_header(serpent.serialize(set));
assertEquals("()", S(ser)); // empty set is serialized as a tuple.
serpent.indent=true;
ser = strip_header(serpent.serialize(set));
assertEquals("()", S(ser)); // empty set is serialized as a tuple.
serpent.indent=false;
// test nonempty set
set.add("X");
set.add("Sally");
set.add("Y");
ser = strip_header(serpent.serialize(set));
assertEquals(17, ser.length);
assertTrue(S(ser).contains("'Sally'"));
assertTrue(S(ser).contains("'X'"));
assertTrue(S(ser).contains("'Y'"));
serpent.indent=true;
ser = strip_header(serpent.serialize(set));
assertEquals("{\n 'Sally',\n 'X',\n 'Y'\n}", S(ser));
}
@Test
public void testCollection()
{
Collection intlist = new LinkedList();
intlist.add(42);
intlist.add(43);
Serializer serpent = new Serializer();
byte[] ser = serpent.serialize(intlist);
ser = strip_header(ser);
assertEquals("[42,43]", S(ser));
ser=strip_header(serpent.serialize(new int[] {42}));
assertEquals("(42,)", S(ser));
ser=strip_header(serpent.serialize(new int[] {42, 43}));
assertEquals("(42,43)", S(ser));
serpent.indent=true;
ser = strip_header(serpent.serialize(intlist));
assertEquals("[\n 42,\n 43\n]", S(ser));
ser=strip_header(serpent.serialize(new int[] {42}));
assertEquals("(\n 42,\n)", S(ser));
ser=strip_header(serpent.serialize(new int[] {42, 43}));
assertEquals("(\n 42,\n 43\n)", S(ser));
}
@Test
public void testDictionary()
{
Serializer serpent = new Serializer();
Parser p = new Parser();
// test empty dict
Hashtable ht = new Hashtable();
byte[] ser = serpent.serialize(ht);
assertEquals("{}", S(strip_header(ser)));
String parsed = p.parse(ser).root.toString();
assertEquals("{}", parsed);
//empty dict with indentation
serpent.indent=true;
ser = serpent.serialize(ht);
assertEquals("{}", S(strip_header(ser)));
parsed = p.parse(ser).root.toString();
assertEquals("{}", parsed);
// test dict with values
serpent.indent=false;
ht = new Hashtable();
ht.put(42, "fortytwo");
ht.put("sixteen-and-half", 16.5);
ht.put("name", "Sally");
ht.put("status", false);
ser = serpent.serialize(ht);
assertEquals('}', ser[ser.length-1]);
assertTrue(ser[ser.length-2]!=',');
parsed = p.parse(ser).root.toString();
assertEquals(69, parsed.length());
// test indentation
serpent.indent=true;
ser = serpent.serialize(ht);
assertEquals('}', ser[ser.length-1]);
assertEquals('\n', ser[ser.length-2]);
assertTrue(ser[ser.length-3]!=',');
String ser_str = S(strip_header(ser));
assertTrue(ser_str.contains("'name': 'Sally'"));
assertTrue(ser_str.contains("'status': False"));
assertTrue(ser_str.contains("42: 'fortytwo'"));
assertTrue(ser_str.contains("'sixteen-and-half': 16.5"));
parsed = p.parse(ser).root.toString();
assertEquals(69, parsed.length());
serpent.indent=false;
// generic Dictionary test
Map mydict = new HashMap