Free data software for linux

Data::SimplePassword provides a simple random password generator.

SYNOPSIS

use Data::SimplePassword;

my $sp = Data::SimplePassword->new;
$sp->chars( 0..9, a..z, A..Z ); # optional

my $password = $sp->make_password( 8 ); # length

Its a very easy-to-use but a bit strong random password generator.

Data::ENAML is a Perl extension for ENAML data representation.

SYNOPSIS

use Data::ENAML qw (serialize deserialize);

print serialize(login => {nick => Schop,
email => ariel@atheist.org.il,
tagline => If I had no modem I would not lose Regina});

$struct = deserialize(bad-nick: {nick: "c00l dewd" text: "spaces not allowed"});

ENAML stands for ENAML is Not A Markup Language. (And as we all know, Gnu is Not UNIX, Pine Is Not Email, Wine Is Not Emulator, Lame Aint Mp3 Encoder and so on).

ENAML was defined by Robey Pointer for use in Say2, check http://www.lag.net/say2.

Data.FormValidators aim is to bring all the benefits of the perl module Data::FormValidator over to javascript, using the same input profiles (they can be dumped into javascript objects using the perl module Data::JavaScript.
Data.FormValidator library lets you define profiles which declare the required and optional fields and any constraints they might have.
The results are provided as an object which makes it easy to handle missing and invalid results, return error messages about which constraints failed, or process the resulting valid data.
IMPORTANT NOTE: JavaScript form validation is NOT a replacement for data validation in your backend scripts. This is the primary reason this module was written... so that it would be easy to share the same validation profile for both the frontend (via Data.FormValidator.js) and backend (via Data::FormValidator.pm).
Enhancements:
- A problem where some functions were not terminated by a semi-colon, so JavaScript compactors would end up creating broken code was fixed.

Data::PropertyList is a Perl module that can convert arbitrary objects to/from strings.

SYNOPSIS

use Data::PropertyList qw(astext fromtext);

$hash_ref = { items => [ 7 .. 11 ], key => value };
$string = astext($hash_ref);
# ...
$hash_ref = fromtext($string);
print $hash_ref->{items}[0];

$array_ref = [ 1, { key => value }, Omega ];
$string = astext($array_ref);
# ...
$array_ref = fromtext($string, -array=>1 );
print $array_ref->[1]{key};

Data::Propertylist provides functions that turn data structures with nested references into NeXTs Property List text format and back again.

You may find this useful for saving and loading application information in text files, or perhaps for generating error messages while debugging.

astext( $reference ) : $propertylist_string;

Writes out a nested Perl data structure in NeXT property list format.

fromtext( $propertylist_string ) : $hash_ref

fromtext( $propertylist_string, -array=>1 ) : $array_ref

Reconstructs a Perl data structure of nested references and scalars from a NeXT property list. Use the -array flag if the string encodes an array rather than a hash.

Data::Secs2 is a Perl module to pack, unpack, format, transform from Perl data SEMI E5-94 nested data.

SYNOPSIS

#####
# Subroutine interface
#
use Data::Secs2 qw(arrayify config listify neuterify numberify perlify
perl_typify secsify secs_elementify stringify textify transify);

@array = arrayify($ref, @options);

$old_value = config( $option );
$old_value = config( $option => $new_value);

$body = secs_elementify($format, $cells, @options);

@secs_obj = listify(@vars);

@secs_obj = neuterify($binary_secs, @options);

@vars = perlify(@secs_obj, @options);

$ref = perl_typify(@array, @options);

$ascii_secs = secsify( @secs_obj, @options);
$binary_secs = secsify( @secs_obj, type => binary);

$string = stringify(@arg, [@options]);

@secs_obj = transify($acsii_secs, @options);

#####
# Class, Object interface
#
# For class interface, use Data::Secs2 instead of $self
# use Data::Secs2;
#
$secs2 = Data::Secs2 # uses built-in config object

$secs2 = new Data::Secs2( @options );

@array = secs2->arrayify( $ref, @options );

$old_value = secs2->secs_config( $option);
$old_value = secs2->secs_config( $option => $new_value);

$body = secs2->secs_elementify($format, $cells, @options);

@secs_obj = secs2->listify(@vars, @options);

@secs_obj = secs2->neuterify($binary_secs, @options);

@vars = secs2->perlify(@secs_obj, @options);

$ref = secs2->perl_typify(@array, @options);

$ascii_secs = secs2->secsify( @secs_obj, @options);
$binary_secs = secs2->secsify( @secs_obj, type => binary);

$body = secs2->stringify( @arg );

@secs_obj = secs2->transify($acsii_secs, @options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

Data::Serializer package contains modules that serialize data structures.

SYNOPSIS

use Data::Serializer;

$obj = Data::Serializer->new();

$obj = Data::Serializer->new(
serializer => Storable,
digester => MD5,
cipher => DES,
secret => my secret,
compress => 1,
);

$serialized = $obj->serialize({a => [1,2,3],b => 5});
$deserialized = $obj->deserialize($serialized);
print "$deserialized->{b}n";

Provides a unified interface to the various serializing modules currently available. Adds the functionality of both compression and encryption.

EXAMPLES

Please see Data::Serializer::Cookbook(3)

METHODS

new - constructor
$obj = Data::Serializer->new();


$obj = Data::Serializer->new(
serializer => Data::Dumper,
digester => SHA-256,
cipher => Blowfish,
secret => undef,
portable => 1,
compress => 0,
serializer_token => 1,
options => {},
);

new is the constructor object for Data::Serializer objects.

The default serializer is Data::Dumper
The default digester is SHA-256
The default cipher is Blowfish
The default secret is undef
The default portable is 1
The default encoding is hex
The default compress is 0
The default compressor is Compress::Zlib
The default serializer_token is 1
The default options is {} (pass nothing on to serializer)
serialize - serialize reference

$serialized = $obj->serialize({a => [1,2,3],b => 5});

Serializes the reference specified.
Will compress if compress is a true value.
Will encrypt if secret is defined.
deserialize - deserialize reference

$deserialized = $obj->deserialize($serialized);

Reverses the process of serialization and returns a copy of the original serialized reference.

freeze - synonym for serialize
$serialized = $obj->freeze({a => [1,2,3],b => 5});

thaw - synonym for deserialize
$deserialized = $obj->thaw($serialized);

raw_serialize - serialize reference in raw form
$serialized = $obj->raw_serialize({a => [1,2,3],b => 5});

This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)

raw_deserialize - deserialize reference in raw form
$deserialized = $obj->raw_deserialize($serialized);

This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)

secret - specify secret for use with encryption
$obj->secret(mysecret);

Changes setting of secret for the Data::Serializer object. Can also be set in the constructor. If specified than the object will utilize encryption.

portable - encodes/decodes serialized data

Uses encoding method to ascii armor serialized data

Aids in the portability of serialized data.

compress - compression of data

Compresses serialized data. Default is not to use it. Will compress if set to a true value $obj->compress(1);

serializer - change the serializer

Currently have 8 supported serializers: Storable, FreezeThaw, Data::Denter, Config::General, YAML, PHP::Serialization, XML::Dumper, and Data::Dumper.
Default is to use Data::Dumper.

Each serializer has its own caveats about usage especially when dealing with cyclical data structures or CODE references. Please see the appropriate documentation in those modules for further information.

cipher - change the cipher method

Utilizes Crypt::CBC and can support any cipher method that it supports.

digester - change digesting method

Uses Digest so can support any digesting method that it supports. Digesting function is used internally by the encryption routine as part of data verification.

compressor - changes compresing module

This method is included for possible future inclusion of alternate compression method Currently Compress::Zlib is the only supported compressor.

encoding - change encoding method

Encodes data structure in ascii friendly manner. Currently the only valid options are hex, or b64.

The b64 option uses Base64 encoding provided by MIME::Base64, but strips out newlines.

serializer_token - add usage hint to data

Data::Serializer prepends a token that identifies what was used to process its data. This is used internally to allow runtime determination of how to extract Serialized data. Disabling this feature is not recommended.

options - pass options through to underlying serializer

Currently is only supported by Config::General, and XML::Dumper.

my $obj = Data::Serializer->new(serializer => Config::General,
options => {
-LowerCaseNames => 1,
-UseApacheInclude => 1,
-MergeDuplicateBlocks => 1,
-AutoTrue => 1,
-InterPolateVars => 1
},
) or die "$!n";

or

my $obj = Data::Serializer->new(serializer => XML::Dumper,
options => { dtd => 1, }
) or die "$!n";
store - serialize data and write it to a file (or file handle)
$obj->store({a => [1,2,3],b => 5},$file, [$mode, $perm]);

or

$obj->store({a => [1,2,3],b => 5},$fh);

Serializes the reference specified using the serialize method and writes it out to the specified file or filehandle.

If a file path is specified you may specify an optional mode and permission as the next two arguments. See IO::File for examples.

Trips an exception if it is unable to write to the specified file.

retrieve - read data from file (or file handle) and return it after deserialization

my $ref = $obj->retrieve($file);

or

my $ref = $obj->retrieve($fh);

Reads first line of supplied file or filehandle and returns it deserialized.

Data::BenchmarkResults is a Perl extension for averaging and comparing multiple benchmark runs.

SYNOPSIS

use Data::BenchmarkResults;
$conditionA_results = new Data::BenchmarkResults;
$conditionB_results = new Data::BenchmarkResults;

#Load test result runs for the first condition
$conditionA_results->add_result_set("test1","run1",@data1);
$conditionA_results->add_result_set("test2","run1",@data2);
$conditionA_results->add_result_set("test1","run2",@data3);
$conditionA_results->add_result_set("test2","run2",@data4);

#Load test result runs for the second condition
$conditionB_results->add_result_set("test1","run1",@data5);
$conditionB_results->add_result_set("test2","run2",@data6);
$conditionB_results->add_result_set("test1","run1",@data7);
$conditionB_results->add_result_set("test2","run2",@data8);

#Average (mean average) the results of all the the runs of test1
# w/o tossing the highest and lowest values (replace the 0 with 1to
# toss the highest and lowest values

my $computed = $conditionA_results->process_result_set("test1","mean",0);
my $computed2 = $conditionB_results->process_result_set("test1","mean",0);

#OR process all of the tests at once (tossing the highest and lowest value) :

$conditionA_results->process_all_result_sets("mean",1);
$conditionB_results->process_all_result_sets("mean",1);


#Print out all of the processed test results
print "Condition A results.... nn"
$conditionA_results->print_calculated_sets;
print "Condition B results.... nn"
$conditionB_results->print_calculated_sets;


#Compare results of test1 of condition B against those with condition A
# as a percentage change from A to B

my $compared = $conditionB_results->compare_result_set($conditionA_results,"test1");

#OR compare all the processed test results from one condition to those of another
my $total_comparison = $conditionB_results->compare_all_result_sets($conditionA_results);