Hello community,
here is the log from the commit of package perl-Types-Serialiser for
openSUSE:Factory checked in at 2014-06-01 19:40:13
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/perl-Types-Serialiser (Old)
and /work/SRC/openSUSE:Factory/.perl-Types-Serialiser.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "perl-Types-Serialiser"
Changes:
--------
---
/work/SRC/openSUSE:Factory/perl-Types-Serialiser/perl-Types-Serialiser.changes
2013-12-06 14:43:36.000000000 +0100
+++
/work/SRC/openSUSE:Factory/.perl-Types-Serialiser.new/perl-Types-Serialiser.changes
2014-06-01 19:40:16.000000000 +0200
@@ -1,0 +2,10 @@
+Tue May 27 07:14:53 UTC 2014 - [email protected]
+
+- checked license
+- updated to 1.0
+ - clarify that the second arg of FEEZE/THAW is the data
+ model/data format name, not the serialsier.
+ - clarify that FREEZE must not modify the data structure
+ to be serialised.
+
+-------------------------------------------------------------------
Old:
----
Types-Serialiser-0.03.tar.gz
New:
----
Types-Serialiser-1.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ perl-Types-Serialiser.spec ++++++
--- /var/tmp/diff_new_pack.lUkUjw/_old 2014-06-01 19:40:18.000000000 +0200
+++ /var/tmp/diff_new_pack.lUkUjw/_new 2014-06-01 19:40:18.000000000 +0200
@@ -1,7 +1,7 @@
#
# spec file for package perl-Types-Serialiser
#
-# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany.
+# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,11 +17,11 @@
Name: perl-Types-Serialiser
-Version: 0.03
+Version: 1.0
Release: 0
%define cpan_name Types-Serialiser
-Summary: simple data types for common serialisation formats
-License: GPL-1.0+ or Artistic-1.0
+Summary: Simple data types for common serialisation formats
+License: Artistic-1.0 or GPL-2.0+
Group: Development/Libraries/Perl
Url: http://search.cpan.org/dist/Types-Serialiser/
Source:
http://www.cpan.org/authors/id/M/ML/MLEHMANN/%{cpan_name}-%{version}.tar.gz
++++++ Types-Serialiser-0.03.tar.gz -> Types-Serialiser-1.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Types-Serialiser-0.03/Changes
new/Types-Serialiser-1.0/Changes
--- old/Types-Serialiser-0.03/Changes 2013-10-29 14:08:05.000000000 +0100
+++ new/Types-Serialiser-1.0/Changes 2013-11-30 19:33:28.000000000 +0100
@@ -1,12 +1,17 @@
Revision history for Perl extension Types::Serialiser
-0.03 Tue Oct 29 14:08:00 CET 2013
+1.0 Sat Nov 30 19:33:19 CET 2013
+ - clarify that the seocnd arg of FEEZE/THAW is the data
+ model/data format name, not the serialsier.
+ - clarify that FREEZE must not modify the data structure to be
serialised.
+
+0.03 Tue Oct 29 14:08:00 CET 2013
- work around an overloading bug in perls < 5.18 (reported by
Paul Howarth).
- remove Types::Serialiser::Boolean module, as it serves
no purpose anymore.
-0.02 Mon Oct 28 16:29:06 CET 2013
+0.02 Mon Oct 28 16:29:06 CET 2013
- document the Types::Serialisation protocol, in the hope
of other modules picking it up.
- alias JSON::PP::Boolean as class for booleans, without
@@ -16,6 +21,6 @@
- actually add a simple testcase.
- reintroduced common::sense to supprerss spurious warnings.
-0.01 Sun Oct 27 16:37:56 CET 2013
+0.01 Sun Oct 27 16:37:56 CET 2013
- original version; cloned from JSON-XS/CBOR-XS
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Types-Serialiser-0.03/MANIFEST
new/Types-Serialiser-1.0/MANIFEST
--- old/Types-Serialiser-0.03/MANIFEST 2013-10-29 14:08:25.000000000 +0100
+++ new/Types-Serialiser-1.0/MANIFEST 2013-11-30 19:33:35.000000000 +0100
@@ -8,3 +8,4 @@
t/00_load.t
t/51_types.t
META.yml Module meta-data (added by MakeMaker)
+META.json Module JSON meta-data (added by
MakeMaker)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Types-Serialiser-0.03/META.json
new/Types-Serialiser-1.0/META.json
--- old/Types-Serialiser-0.03/META.json 1970-01-01 01:00:00.000000000 +0100
+++ new/Types-Serialiser-1.0/META.json 2013-11-30 19:33:35.000000000 +0100
@@ -0,0 +1,41 @@
+{
+ "abstract" : "unknown",
+ "author" : [
+ "unknown"
+ ],
+ "dynamic_config" : 1,
+ "generated_by" : "ExtUtils::MakeMaker version 6.8, CPAN::Meta::Converter
version 2.120921",
+ "license" : [
+ "unknown"
+ ],
+ "meta-spec" : {
+ "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec";,
+ "version" : "2"
+ },
+ "name" : "Types-Serialiser",
+ "no_index" : {
+ "directory" : [
+ "t",
+ "inc"
+ ]
+ },
+ "prereqs" : {
+ "build" : {
+ "requires" : {
+ "ExtUtils::MakeMaker" : "0"
+ }
+ },
+ "configure" : {
+ "requires" : {
+ "ExtUtils::MakeMaker" : "0"
+ }
+ },
+ "runtime" : {
+ "requires" : {
+ "common::sense" : "0"
+ }
+ }
+ },
+ "release_status" : "stable",
+ "version" : "1.0"
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Types-Serialiser-0.03/META.yml
new/Types-Serialiser-1.0/META.yml
--- old/Types-Serialiser-0.03/META.yml 2013-10-29 14:08:25.000000000 +0100
+++ new/Types-Serialiser-1.0/META.yml 2013-11-30 19:33:35.000000000 +0100
@@ -1,11 +1,22 @@
-# http://module-build.sourceforge.net/META-spec.html
-#XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX#
-name: Types-Serialiser
-version: 0.03
-version_from: Serialiser.pm
-installdirs: site
+---
+abstract: unknown
+author:
+ - unknown
+build_requires:
+ ExtUtils::MakeMaker: 0
+configure_requires:
+ ExtUtils::MakeMaker: 0
+dynamic_config: 1
+generated_by: 'ExtUtils::MakeMaker version 6.8, CPAN::Meta::Converter version
2.120921'
+license: unknown
+meta-spec:
+ url: http://module-build.sourceforge.net/META-spec-v1.4.html
+ version: 1.4
+name: Types-Serialiser
+no_index:
+ directory:
+ - t
+ - inc
requires:
- common::sense: 0
-
-distribution_type: module
-generated_by: ExtUtils::MakeMaker version 6.17
+ common::sense: 0
+version: 1.0
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Types-Serialiser-0.03/README
new/Types-Serialiser-1.0/README
--- old/Types-Serialiser-0.03/README 2013-10-29 14:08:25.000000000 +0100
+++ new/Types-Serialiser-1.0/README 2013-11-30 19:33:35.000000000 +0100
@@ -79,7 +79,7 @@
pointers is faster and guaranteed to work.
For historical reasons, the "Types::Serialiser::Boolean" stash is just
- an alias for "JSON::PP::Boolean". When printed, the classname withh
+ an alias for "JSON::PP::Boolean". When printed, the classname with
usually be "JSON::PP::Boolean", but isa tests and stash pointer
comparison will normally work correctly (i.e. Types::Serialiser::true
ISA JSON::PP::Boolean, but also ISA Types::Serialiser::Boolean).
@@ -98,29 +98,42 @@
first attempt to use the special "TO_CBOR" serialisation protocol), it
will look up the "FREEZE" method on the object.
+ Note that the "FREEZE" method will normally be called *during* encoding,
+ and *MUST NOT* change the data structure that is being encoded in any
+ way, or it might cause memory corruption or worse.
+
If it exists, it will call it with two arguments: the object to
- serialise, and a constant string that indicates the name of the
- serialisationformat. For example CBOR::XS uses "CBOR", and JSON and
- JSON::XS (or any other JSON serialiser), would use "JSON" as second
+ serialise, and a constant string that indicates the name of the data
+ model. For example CBOR::XS uses "CBOR", and the JSON and JSON::XS
+ modules (or any other JSON serialiser), would use "JSON" as second
argument.
The "FREEZE" method can then return zero or more values to identify the
object instance. The serialiser is then supposed to encode the class
name and all of these return values (which must be encodable in the
- format) using the relevant form for perl objects. In CBOR for example,
+ format) using the relevant form for Perl objects. In CBOR for example,
there is a registered tag number for encoded perl objects.
The values that "FREEZE" returns must be serialisable with the
serialiser that calls it. Therefore, it is recommended to use simple
types such as strings and numbers, and maybe array references and hashes
(basically, the JSON data model). You can always use a more complex
- format for a specific serialiser by checking the second argument.
+ format for a specific data model by checking the second argument, the
+ data model.
+
+ The "data model" is not the same as the "data format" - the data model
+ indicates what types and kinds of return values can be returned from
+ "FREEZE". For example, in "CBOR" it is permissible to return tagged CBOR
+ values, while JSON does not support these at all, so "JSON" would be a
+ valid (but too limited) data model name for "CBOR::XS". similarly, a
+ serialising format that supports more or less the same data model as
+ JSON could use "JSON" as data model without losing anything.
DECODING
When the decoder then encounters such an encoded perl object, it should
look up the "THAW" method on the stored classname, and invoke it with
- the classname, the constant string to identify the format, and all the
- return values returned by "FREEZE".
+ the classname, the constant string to identify the data model/data
+ format, and all the return values returned by "FREEZE".
EXAMPLES
See the "OBJECT SERIALISATION" section in the CBOR::XS manpage for more
@@ -129,15 +142,15 @@
Here is an example "FREEZE"/"THAW" method pair:
sub My::Object::FREEZE {
- my ($self, $serialiser) = @_;
+ my ($self, $model) = @_;
($self->{type}, $self->{id}, $self->{variant})
}
sub My::Object::THAW {
- my ($class, $serialiser, $type, $id, $variant) = @_;
+ my ($class, $model, $type, $id, $variant) = @_;
- $class-<new (type => $type, id => $id, variant => $variant)
+ $class->new (type => $type, id => $id, variant => $variant)
}
BUGS
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Types-Serialiser-0.03/Serialiser.pm
new/Types-Serialiser-1.0/Serialiser.pm
--- old/Types-Serialiser-0.03/Serialiser.pm 2013-10-29 14:08:14.000000000
+0100
+++ new/Types-Serialiser-1.0/Serialiser.pm 2013-11-30 19:33:18.000000000
+0100
@@ -19,7 +19,7 @@
use common::sense; # required to suppress annoying warnings
-our $VERSION = 0.03;
+our $VERSION = '1.0';
=head1 SIMPLE SCALAR CONSTANTS
@@ -159,7 +159,7 @@
For historical reasons, the C<Types::Serialiser::Boolean> stash is
just an alias for C<JSON::PP::Boolean>. When printed, the classname
-withh usually be C<JSON::PP::Boolean>, but isa tests and stash pointer
+with usually be C<JSON::PP::Boolean>, but isa tests and stash pointer
comparison will normally work correctly (i.e. Types::Serialiser::true ISA
JSON::PP::Boolean, but also ISA Types::Serialiser::Boolean).
@@ -179,30 +179,41 @@
attempt to use the special C<TO_CBOR> serialisation protocol), it will
look up the C<FREEZE> method on the object.
-If it exists, it will call it with two arguments: the object to
-serialise, and a constant string that indicates the name of the
-serialisationformat. For example L<CBOR::XS> uses C<CBOR>, and L<JSON> and
-L<JSON::XS> (or any other JSON serialiser), would use C<JSON> as second
-argument.
+Note that the C<FREEZE> method will normally be called I<during> encoding,
+and I<MUST NOT> change the data structure that is being encoded in any
+way, or it might cause memory corruption or worse.
+
+If it exists, it will call it with two arguments: the object to serialise,
+and a constant string that indicates the name of the data model. For
+example L<CBOR::XS> uses C<CBOR>, and the L<JSON> and L<JSON::XS> modules
+(or any other JSON serialiser), would use C<JSON> as second argument.
The C<FREEZE> method can then return zero or more values to identify the
object instance. The serialiser is then supposed to encode the class name
and all of these return values (which must be encodable in the format)
-using the relevant form for perl objects. In CBOR for example, there is a
+using the relevant form for Perl objects. In CBOR for example, there is a
registered tag number for encoded perl objects.
The values that C<FREEZE> returns must be serialisable with the serialiser
that calls it. Therefore, it is recommended to use simple types such as
strings and numbers, and maybe array references and hashes (basically, the
JSON data model). You can always use a more complex format for a specific
-serialiser by checking the second argument.
+data model by checking the second argument, the data model.
+
+The "data model" is not the same as the "data format" - the data model
+indicates what types and kinds of return values can be returned from
+C<FREEZE>. For example, in C<CBOR> it is permissible to return tagged CBOR
+values, while JSON does not support these at all, so C<JSON> would be a
+valid (but too limited) data model name for C<CBOR::XS>. similarly, a
+serialising format that supports more or less the same data model as JSON
+could use C<JSON> as data model without losing anything.
=head2 DECODING
When the decoder then encounters such an encoded perl object, it should
look up the C<THAW> method on the stored classname, and invoke it with the
-classname, the constant string to identify the format, and all the return
-values returned by C<FREEZE>.
+classname, the constant string to identify the data model/data format, and
+all the return values returned by C<FREEZE>.
=head2 EXAMPLES
@@ -212,15 +223,15 @@
Here is an example C<FREEZE>/C<THAW> method pair:
sub My::Object::FREEZE {
- my ($self, $serialiser) = @_;
+ my ($self, $model) = @_;
($self->{type}, $self->{id}, $self->{variant})
}
sub My::Object::THAW {
- my ($class, $serialiser, $type, $id, $variant) = @_;
+ my ($class, $model, $type, $id, $variant) = @_;
- $class-<new (type => $type, id => $id, variant => $variant)
+ $class->new (type => $type, id => $id, variant => $variant)
}
=head1 BUGS
--
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
