pax_global_header 0000666 0000000 0000000 00000000064 14256061462 0014520 g ustar 00root root 0000000 0000000 52 comment=83d06d779c05e259bf1e020aca9b850d3c6f010b
Serpent-serpent-1.41/ 0000775 0000000 0000000 00000000000 14256061462 0014543 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/.github/ 0000775 0000000 0000000 00000000000 14256061462 0016103 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/.github/workflows/ 0000775 0000000 0000000 00000000000 14256061462 0020140 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/.github/workflows/main-ci.yml 0000664 0000000 0000000 00000003667 14256061462 0022214 0 ustar 00root root 0000000 0000000 # This workflow will install Python dependencies, run tests and lint with a single version of Python
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
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.7', '3.8', '3.9', '3.10']
steps:
- name: Checkout source
uses: actions/checkout@v2
- name: Set up Python
uses: actions/setup-python@v2
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@v2
- name: Install .Net
uses: actions/setup-dotnet@v1
with:
dotnet-version: '6.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@v3
- name: Set up JDK 8
uses: actions/setup-java@v3
with:
java-version: '8'
distribution: 'temurin'
- name: Build with Maven
run: mvn --batch-mode --update-snapshots -f java/pom.xml verify
Serpent-serpent-1.41/.gitignore 0000664 0000000 0000000 00000001514 14256061462 0016534 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.41/.pylintrc 0000664 0000000 0000000 00000000200 14256061462 0016400 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.41/LICENSE 0000664 0000000 0000000 00000002054 14256061462 0015551 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.41/MANIFEST.in 0000664 0000000 0000000 00000000465 14256061462 0016306 0 ustar 00root root 0000000 0000000 include LICENSE
include README.md
include tox.ini
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.41/Makefile 0000664 0000000 0000000 00000002073 14256061462 0016205 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:
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.41/README.md 0000664 0000000 0000000 00000007242 14256061462 0016027 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.41/dotnet/ 0000775 0000000 0000000 00000000000 14256061462 0016040 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/dotnet/Serpent/ 0000775 0000000 0000000 00000000000 14256061462 0017460 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/ 0000775 0000000 0000000 00000000000 14256061462 0023056 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/Ast.cs 0000664 0000000 0000000 00000022602 14256061462 0024136 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)
{
var cv = Value as IComparable;
var otherCv = other.Value as IComparable;
if (cv != null && otherCv != null)
return cv.CompareTo(otherCv);
return 0;
}
public override string ToString()
{
var s = Value as string;
if(s != null)
{
var sb=new StringBuilder();
sb.Append("'");
foreach(var 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 double) && !(Value is 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 NoneNode();
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 List();
public virtual char OpenChar => '?';
public virtual char CloseChar => '?';
public override int GetHashCode()
{
int hashCode = 0;
unchecked {
// ReSharper disable once NonReadonlyMemberInGetHashCode
foreach(var elt in Elements)
hashCode += 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 UnorderedSequenceNode))
return false;
var set1 = ElementsAsSet();
var set2 = ((UnorderedSequenceNode) obj).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.41/dotnet/Serpent/Razorvine.Serpent/ComplexNumber.cs 0000664 0000000 0000000 00000004240 14256061462 0026165 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()
{
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 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 ComplexNumber))
return false;
ComplexNumber other = (ComplexNumber) obj;
// 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.41/dotnet/Serpent/Razorvine.Serpent/DebugVisitor.cs 0000664 0000000 0000000 00000005337 14256061462 0026023 0 ustar 00root root 0000000 0000000 using System.Diagnostics.CodeAnalysis;
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 StringBuilder();
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 node in dict.Elements)
{
var kv = (Ast.KeyValueNode) node;
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(Ast.INode 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(Ast.INode 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(Ast.INode node in tuple.Elements)
{
Indent();
node.Accept(this);
_result.AppendLine(",");
}
_indent--;
Indent();
_result.Append(")");
}
}
}
Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/ObjectifyVisitor.cs 0000664 0000000 0000000 00000006300 14256061462 0026702 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Collections;
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 Stack();
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 node in dict.Elements)
{
var kv = (Ast.KeyValueNode) node;
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(Ast.INode 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(Ast.INode 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(Ast.INode node in tuple.Elements)
{
node.Accept(this);
array[index++] = _generated.Pop();
}
_generated.Push(array);
}
}
}
Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/ParseException.cs 0000664 0000000 0000000 00000000644 14256061462 0026342 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.41/dotnet/Serpent/Razorvine.Serpent/Parser.cs 0000664 0000000 0000000 00000046456 14256061462 0024660 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;
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)
{
Ast ast=new Ast();
if(string.IsNullOrEmpty(expression))
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.Message + " (at position "+sr.Bookmark()+"; '"+faultLocation+"')", x);
}
}
private string ExtractFaultLocation(SeekableStringReader sr)
{
string left, right;
sr.Context(-1, 20, out left, out 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") ? (Ast.INode) 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();
Ast.TupleNode tuple = new Ast.TupleNode();
if(sr.Peek() == ')')
{
sr.Read();
return tuple; // empty tuple
}
Ast.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.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 .
Ast.INode key = ParseExpr(sr);
if (!sr.HasMore() || sr.Peek() != ':') throw new ParseException("expected ':'");
sr.Read(); // :
Ast.INode 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();
Ast.SetNode 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();
Ast.ListNode 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();
Ast.DictNode 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 node in elts)
{
var kv = (Ast.KeyValueNode) node;
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);
var integerNode = integerPart as Ast.IntegerNode;
if (integerNode != null)
doubleValue = integerNode.Value;
else {
var longNode = integerPart as Ast.LongNode;
if (longNode != null)
doubleValue = longNode.Value;
else {
var decimalNode = integerPart as Ast.DecimalNode;
if (decimalNode != null)
doubleValue = Convert.ToDouble(decimalNode.Value);
else
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 "
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 '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) {
Hashtable hashtable = obj as Hashtable;
if(hashtable!=null)
{
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);
}
var dict = obj as IDictionary;
if(dict!=null)
{
string data;
string encoding;
bool hasData = dict.TryGetValue("data", out data);
bool hasEncoding = dict.TryGetValue("encoding", out encoding);
if(!hasData || !hasEncoding || encoding!="base64")
{
throw new ArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
return Convert.FromBase64String(data);
}
var dict2 = obj as IDictionary;
if(dict2!=null)
{
object dataobj;
object encodingobj;
bool hasData = dict2.TryGetValue("data", out dataobj);
bool hasEncoding = dict2.TryGetValue("encoding", out 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);
}
var bytearray = obj as byte[];
if(bytearray!=null)
{
return bytearray;
}
throw new ArgumentException("argument is neither bytearray nor serpent base64 encoded bytes dict");
}
}
}
Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/Razorvine.Serpent.csproj 0000664 0000000 0000000 00000003145 14256061462 0027701 0 ustar 00root root 0000000 0000000
netstandard2.0
6
Irmen de Jong
Serpent Python literal expression serialization
Razorvine.Serpent
1.40.0
1.40.0.0
1.40.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
assembly is now strong-name signed (so other strong-named assemblies can reference it, most notably, Razorvine.Pyrolite)
Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/SeekableStringReader.cs 0000664 0000000 0000000 00000010735 14256061462 0027440 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)
{
if(str==null)
throw new ArgumentNullException(nameof(str));
_str = 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))
{
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.41/dotnet/Serpent/Razorvine.Serpent/Serializer.cs 0000664 0000000 0000000 00000037033 14256061462 0025524 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.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 IllegalArgumentException 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(StringWriter 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
Type t = obj?.GetType();
if(obj==null)
{
tw.Write("None");
}
else if(obj is string)
{
Serialize_string((string)obj, tw, level);
}
else if(t.IsPrimitive)
{
Serialize_primitive(obj, tw, level);
}
else if(obj is decimal)
{
Serialize_decimal((decimal)obj, tw, level);
}
else if(obj is Enum)
{
Serialize_string(obj.ToString(), tw, level);
}
else if(obj is IDictionary)
{
Serialize_dict((IDictionary)obj, tw, level);
}
else if(t.IsGenericType && t.GetGenericTypeDefinition() == typeof(HashSet<>))
{
IEnumerable x = (IEnumerable) obj;
var list = new List();
foreach(object elt in x)
list.Add(elt);
var setvalues = list.ToArray();
Serialize_set(setvalues, tw, level);
}
else if(obj is byte[])
{
Serialize_bytes((byte[])obj, tw, level);
}
else if(obj is Array)
{
Serialize_tuple((ICollection) obj, tw, level);
}
else if(obj is ICollection)
{
Serialize_list((ICollection) obj, tw, level);
}
else if(obj is DateTimeOffset)
{
Serialize_datetimeoffset((DateTimeOffset)obj, tw, level);
}
else if(obj is DateTime)
{
Serialize_datetime((DateTime)obj, tw, level);
}
else if(obj is TimeSpan)
{
Serialize_timespan((TimeSpan)obj, tw, level);
}
else if(obj is Exception)
{
Serialize_exception((Exception)obj, tw, level);
}
else if(obj is Guid)
{
Serialize_guid((Guid) obj, tw, level);
}
else if(obj is ComplexNumber)
{
Serialize_complex((ComplexNumber) obj, tw, level);
}
else
{
Serialize_class(obj, tw, level);
}
}
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)
{
IComparable c1 = d1.Key as IComparable;
IComparable 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(DictionaryEntry 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(new object[0], 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.
StringBuilder 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;
Func converter;
ClassToDictRegistry.TryGetValue(exc.GetType(), out 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)
{
if(obj is float)
{
float f = (float)obj;
double d = f;
Serialize_primitive(d, tw, level);
}
else if(obj is double)
{
double d = (double) obj;
if(double.IsPositiveInfinity(d)) {
// output a literal expression that overflows the float and results in +/-INF
tw.Write("1e30000");
}
else if(double.IsNegativeInfinity(d)) {
tw.Write("-1e30000");
}
else if(double.IsNaN(d)) {
// there's no literal expression for a float NaN...
tw.Write("{'__class__':'float','value':'nan'}");
} else {
tw.Write(Convert.ToString(obj, CultureInfo.InvariantCulture));
}
}
else
{
tw.Write(Convert.ToString(obj, CultureInfo.InvariantCulture));
}
}
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)
{
Type 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)
{
Func converter;
if(ClassToDictRegistry.TryGetValue(obj_type, out 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.
foreach(var x in ClassToDictRegistry) {
if(x.Key.IsAssignableFrom(obj_type)) {
return x.Value;
}
}
return null;
}
}
}
Serpent-serpent-1.41/dotnet/Serpent/Razorvine.Serpent/Serpent.snk 0000664 0000000 0000000 00000001124 14256061462 0025211 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.41/dotnet/Serpent/Razorvine.Serpent/Version.cs 0000664 0000000 0000000 00000000550 14256061462 0025032 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.40";
}
}
Serpent-serpent-1.41/dotnet/Serpent/Serpent.sln 0000664 0000000 0000000 00000002365 14256061462 0021624 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.41/dotnet/Serpent/Tests/ 0000775 0000000 0000000 00000000000 14256061462 0020562 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/dotnet/Serpent/Tests/CycleTest.cs 0000664 0000000 0000000 00000006446 14256061462 0023022 0 ustar 00root root 0000000 0000000 using System;
using System.Collections;
using System.Collections.Generic;
using Xunit;
// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
namespace Razorvine.Serpent.Test
{
public class CycleTest
{
[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
{
ser.Serialize(d);
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.True(false, "should fail");
}
catch (ArgumentException x)
{
Assert.Contains("too deep", x.Message);
}
}
}
} Serpent-serpent-1.41/dotnet/Serpent/Tests/Example.cs 0000664 0000000 0000000 00000007121 14256061462 0022505 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;
// ReSharper disable CheckNamespace
namespace Razorvine.Serpent.Test
{
///
/// Example usage.
///
public class Example
{
[Fact(Skip = "this is an example")]
public void ExampleUsage()
{
Console.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
Console.WriteLine("Serialized:");
Console.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);
Console.WriteLine("\nParsed AST:");
Console.WriteLine(ast.Root.ToString());
// print debug representation
var dv = new DebugVisitor();
ast.Accept(dv);
Console.WriteLine("DEBUG string representation:");
Console.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
Console.WriteLine("PARSED results:");
Console.Write("tuple items: ");
var tuple = (object[]) dict["tuple"];
Console.WriteLine(string.Join(", ", tuple.Select(e => e.ToString()).ToArray()));
Console.WriteLine("date: {0}", dict["date"]);
Console.Write("set items: ");
var set = (HashSet) dict["set"];
Console.WriteLine(string.Join(", ", set.Select(e => e.ToString()).ToArray()));
Console.WriteLine("class attributes:");
var clazz = (IDictionary) dict["class"]; // custom classes are serialized as dicts
Console.WriteLine(" type: {0}", clazz["__class__"]);
Console.WriteLine(" name: {0}", clazz["name"]);
Console.WriteLine(" age: {0}", clazz["age"]);
Console.WriteLine("");
// parse and print the example file
ser = File.ReadAllBytes("testserpent.utf8.bin");
ast = parser.Parse(ser);
dv = new DebugVisitor();
ast.Accept(dv);
Console.WriteLine("DEBUG string representation of the test file:");
Console.WriteLine(dv.ToString());
}
[Serializable]
[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Local")]
private class SampleClass
{
public int Age { get; set; }
public string Name { get; set; }
}
}
} Serpent-serpent-1.41/dotnet/Serpent/Tests/ParserTest.cs 0000664 0000000 0000000 00000101323 14256061462 0023205 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(string.Format("{0} (seq)", node.GetType()));
foreach (var child in seq.Elements) Walk(child, sb);
}
else
{
sb.AppendLine(string.Format("{0} = {1}", 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.41/dotnet/Serpent/Tests/SerializeTest.cs 0000664 0000000 0000000 00000056047 14256061462 0023714 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 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()
{
Serializer 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()
{
Serializer 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()
{
Serializer ser = new Serializer();
var data = ser.Serialize(null);
data=strip_header(data);
Assert.Equal(B("None"),data);
}
[Fact]
public void TestStrings()
{
Serializer 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()
{
Serializer 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()
{
Serializer 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);
ComplexNumber 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()
{
Serializer 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()
{
Serializer 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()
{
Serializer serpent = new Serializer();
IList 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
Serializer 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()
{
Serializer serpent = new Serializer();
Parser 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[ser.Length-1]);
Assert.NotEqual((int)',', ser[ser.Length-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[ser.Length-1]);
Assert.Equal((int)'\n', ser[ser.Length-2]);
Assert.NotEqual((int)',', ser[ser.Length-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=="{2:'two',1:'one'}" || ser_str=="{1:'one',2:'two'}");
}
[Fact]
public void TestBytesDefault()
{
Serializer 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)));
Parser 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()
{
Serializer 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)));
Parser p = new Parser();
Ast.BytesNode 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);
Serializer 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} );
Serializer 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()
{
Serializer 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);
Serializer 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);
Serializer 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)
{
SerializeTestClass 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);
Serializer 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()
{
Serializer 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()
{
Serializer 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()
{
Serializer 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()
{
Serializer serpent = new Serializer();
DateTime 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));
TimeSpan timespan = new TimeSpan(1, 10, 20, 30, 999);
ser = strip_header(serpent.Serialize(timespan));
Assert.Equal("123630.999", S(ser));
}
[Fact]
public void TestDateTimeOffset()
{
Serializer serpent = new Serializer();
DateTimeOffset 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");
Serializer 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");
Serializer 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;
Serializer 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()
{
ConcreteSubClass c = new ConcreteSubClass();
Serializer 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()
{
BaseClassWithInterface b = new BaseClassWithInterface();
SubClassWithInterface sub = new SubClassWithInterface();
Serializer 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.41/dotnet/Serpent/Tests/SlowPerformanceTest.cs 0000664 0000000 0000000 00000003053 14256061462 0025060 0 ustar 00root root 0000000 0000000 using System;
using Xunit;
// ReSharper disable CheckNamespace
namespace Razorvine.Serpent.Test
{
public class SlowPerformanceTest {
// 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()
{
SeekableStringReader 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()
{
SeekableStringReader 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()
{
SeekableStringReader 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()
{
SeekableStringReader 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()
{
SeekableStringReader 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()
{
SeekableStringReader outer = new SeekableStringReader("hello!");
outer.Read(1);
SeekableStringReader inner1 = new SeekableStringReader(outer);
SeekableStringReader 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()
{
SeekableStringReader s = new SeekableStringReader("abcdefghijklmnopqrstuvwxyz");
s.Read(10);
string left, right;
s.Context(-1, 5, out left, out 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.41/dotnet/Serpent/Tests/Tests.csproj 0000664 0000000 0000000 00000001602 14256061462 0023105 0 ustar 00root root 0000000 0000000
net6.0
false
6
UnitTests
UnitTests
Library
PreserveNewest
Serpent-serpent-1.41/dotnet/Serpent/Tests/testserpent.utf8.bin 0000664 0000000 0000000 00000002236 14256061462 0024524 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.41/dotnet/nuget-pack.sh 0000775 0000000 0000000 00000000627 14256061462 0020442 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.41/dotnet/test.sh 0000775 0000000 0000000 00000000071 14256061462 0017354 0 ustar 00root root 0000000 0000000 #!/bin/sh
echo "Running tests"
dotnet test Serpent/Tests
Serpent-serpent-1.41/java/ 0000775 0000000 0000000 00000000000 14256061462 0015464 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/.gitignore 0000664 0000000 0000000 00000000105 14256061462 0017450 0 ustar 00root root 0000000 0000000 # intellij workspace info
.idea/workspace.xml
# java/maven
target/
Serpent-serpent-1.41/java/.idea/ 0000775 0000000 0000000 00000000000 14256061462 0016444 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/.idea/.name 0000664 0000000 0000000 00000000007 14256061462 0017362 0 ustar 00root root 0000000 0000000 Serpent Serpent-serpent-1.41/java/.idea/Serpent.iml 0000664 0000000 0000000 00000002007 14256061462 0020566 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/.idea/compiler.xml 0000664 0000000 0000000 00000001503 14256061462 0020777 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/.idea/encodings.xml 0000664 0000000 0000000 00000000362 14256061462 0021140 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/.idea/libraries/ 0000775 0000000 0000000 00000000000 14256061462 0020420 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/.idea/libraries/Maven__org_hamcrest_hamcrest_core_1_3.xml 0000664 0000000 0000000 00000001010 14256061462 0030434 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/.idea/misc.xml 0000664 0000000 0000000 00000000614 14256061462 0020122 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/.idea/modules.xml 0000664 0000000 0000000 00000000412 14256061462 0020633 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/.idea/vcs.xml 0000664 0000000 0000000 00000000267 14256061462 0017766 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/mvn-release-readme.txt 0000664 0000000 0000000 00000000617 14256061462 0021702 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.41/java/pom.xml 0000664 0000000 0000000 00000005661 14256061462 0017011 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.41/java/serpent.iml 0000664 0000000 0000000 00000001657 14256061462 0017660 0 ustar 00root root 0000000 0000000
Serpent-serpent-1.41/java/src/ 0000775 0000000 0000000 00000000000 14256061462 0016253 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/ 0000775 0000000 0000000 00000000000 14256061462 0017177 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/java/ 0000775 0000000 0000000 00000000000 14256061462 0020120 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/java/net/ 0000775 0000000 0000000 00000000000 14256061462 0020706 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/java/net/razorvine/ 0000775 0000000 0000000 00000000000 14256061462 0022725 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/java/net/razorvine/serpent/ 0000775 0000000 0000000 00000000000 14256061462 0024405 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/java/net/razorvine/serpent/ComplexNumber.java 0000664 0000000 0000000 00000004011 14256061462 0030024 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.41/java/src/main/java/net/razorvine/serpent/DebugVisitor.java 0000664 0000000 0000000 00000005356 14256061462 0027667 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.41/java/src/main/java/net/razorvine/serpent/IDictToInstance.java 0000664 0000000 0000000 00000001162 14256061462 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;
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.41/java/src/main/java/net/razorvine/serpent/LibraryVersion.java 0000664 0000000 0000000 00000000556 14256061462 0030230 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.41/java/src/main/java/net/razorvine/serpent/ObjectifyVisitor.java 0000664 0000000 0000000 00000006034 14256061462 0030551 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.41/java/src/main/java/net/razorvine/serpent/ParseException.java 0000664 0000000 0000000 00000001322 14256061462 0030177 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.41/java/src/main/java/net/razorvine/serpent/Parser.java 0000664 0000000 0000000 00000042076 14256061462 0026515 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.41/java/src/main/java/net/razorvine/serpent/SeekableStringReader.java 0000664 0000000 0000000 00000011323 14256061462 0031275 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.41/java/src/main/java/net/razorvine/serpent/Serializer.java 0000664 0000000 0000000 00000047060 14256061462 0027370 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.41/java/src/main/java/net/razorvine/serpent/ast/ 0000775 0000000 0000000 00000000000 14256061462 0025174 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/main/java/net/razorvine/serpent/ast/Ast.java 0000664 0000000 0000000 00000002444 14256061462 0026572 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.41/java/src/main/java/net/razorvine/serpent/ast/BigIntNode.java 0000664 0000000 0000000 00000000417 14256061462 0030023 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.41/java/src/main/java/net/razorvine/serpent/ast/BooleanNode.java 0000664 0000000 0000000 00000000355 14256061462 0030227 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.41/java/src/main/java/net/razorvine/serpent/ast/BytesNode.java 0000664 0000000 0000000 00000000650 14256061462 0027734 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.41/java/src/main/java/net/razorvine/serpent/ast/DictNode.java 0000664 0000000 0000000 00000000443 14256061462 0027531 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.41/java/src/main/java/net/razorvine/serpent/ast/DoubleNode.java 0000664 0000000 0000000 00000000350 14256061462 0030055 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.41/java/src/main/java/net/razorvine/serpent/ast/INode.java 0000664 0000000 0000000 00000000224 14256061462 0027033 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.41/java/src/main/java/net/razorvine/serpent/ast/INodeVisitor.java 0000664 0000000 0000000 00000000726 14256061462 0030422 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.41/java/src/main/java/net/razorvine/serpent/ast/IntegerNode.java 0000664 0000000 0000000 00000000350 14256061462 0030240 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.41/java/src/main/java/net/razorvine/serpent/ast/KeyValueNode.java 0000664 0000000 0000000 00000001366 14256061462 0030400 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.41/java/src/main/java/net/razorvine/serpent/ast/ListNode.java 0000664 0000000 0000000 00000000432 14256061462 0027557 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.41/java/src/main/java/net/razorvine/serpent/ast/LongNode.java 0000664 0000000 0000000 00000000341 14256061462 0027542 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.41/java/src/main/java/net/razorvine/serpent/ast/NoneNode.java 0000664 0000000 0000000 00000000427 14256061462 0027547 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.41/java/src/main/java/net/razorvine/serpent/ast/PrimitiveNode.java 0000664 0000000 0000000 00000003172 14256061462 0030620 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.41/java/src/main/java/net/razorvine/serpent/ast/SequenceNode.java 0000664 0000000 0000000 00000002013 14256061462 0030411 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.41/java/src/main/java/net/razorvine/serpent/ast/SetNode.java 0000664 0000000 0000000 00000000442 14256061462 0027400 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.41/java/src/main/java/net/razorvine/serpent/ast/StringNode.java 0000664 0000000 0000000 00000000350 14256061462 0030111 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.41/java/src/main/java/net/razorvine/serpent/ast/TupleNode.java 0000664 0000000 0000000 00000001212 14256061462 0027732 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.41/java/src/main/java/net/razorvine/serpent/ast/UnorderedSequenceNode.java 0000664 0000000 0000000 00000000733 14256061462 0032270 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.41/java/src/main/java/net/razorvine/serpent/package-info.java 0000664 0000000 0000000 00000000453 14256061462 0027576 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.41/java/src/test/ 0000775 0000000 0000000 00000000000 14256061462 0017232 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/test/java/ 0000775 0000000 0000000 00000000000 14256061462 0020153 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/test/java/SerpentExample.java 0000664 0000000 0000000 00000007500 14256061462 0023754 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.41/java/src/test/java/net/ 0000775 0000000 0000000 00000000000 14256061462 0020741 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/test/java/net/razorvine/ 0000775 0000000 0000000 00000000000 14256061462 0022760 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/test/java/net/razorvine/serpent/ 0000775 0000000 0000000 00000000000 14256061462 0024440 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/test/java/net/razorvine/serpent/test/ 0000775 0000000 0000000 00000000000 14256061462 0025417 5 ustar 00root root 0000000 0000000 Serpent-serpent-1.41/java/src/test/java/net/razorvine/serpent/test/CycleTest.java 0000664 0000000 0000000 00000005314 14256061462 0030164 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.41/java/src/test/java/net/razorvine/serpent/test/ParserTest.java 0000664 0000000 0000000 00000070450 14256061462 0030364 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.41/java/src/test/java/net/razorvine/serpent/test/SerializationHelperClass.java 0000664 0000000 0000000 00000001011 14256061462 0033216 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.41/java/src/test/java/net/razorvine/serpent/test/SerializeTest.java 0000664 0000000 0000000 00000057115 14256061462 0031062 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