Free simplicity sewing patterns software for linux

Object::PerlDesignPatterns is a Perl architecture for structuring and refactoring large programs.

SYNOPSIS

lynx perldesignpatterns.html
perldoc Object::PerlDesignPatterns

ABSTRACT

Documentation: Ideas for keeping programs fun to hack on even after they grow large. Object, lambda, hybrid structures, Perl specific methods of refactoring, object tricks, anti-patterns, non-structural recurring code patterns.

PerlDesignPatterns is a free book sporting:

Ideas for keeping programs fun to hack on even after they grow large. Object, lambda, hybrid structures, Perl specific methods of refactoring, object tricks, anti-patterns, non-structural recurring code patterns.

Feel free to jump right in and make corrections, suggestions, ask questions, play editor, or just rant. Start in http://www.perldesignpatterns.com/?TinyWiki to learn about the TinyWiki software, make a page for yourself, play with editing that, perhaps make a link from the GuestLog to your page. The markup language is ASCII based - it couldnt be any easier.

This document is a snapshot of the current state of the Wiki, automatically compiled from hundreds of individual sections by a Perl script.

Pattern-lab is a pattern recognition program. Pattern-lab project is optimized for OCR, but not constrained to it. The method used is mainly pattern matching. Separation of merged patterns is one of the main goals. It is currently under development.
Enhancements:
- This release adds the Standardizing Transformation (ST) embedding IMage Euclidean Distance (IMED) in the preprocessing phase.
- Positive and negative effects of the new feature are explained in the manual.

CVSPermissions is a toolkit that will allow CVS administrators to set up directory level access control in CVS for multiple CVS users.
This toolkit is a collection of shell scripts and CVS configuration to achieve the access control functionality.
Enhancements:
- This release implements changes to all the grep patterns to accurately search for strings.

KMidiTracker is a MIDI Step Sequencer.
A Step Sequencer is a sequencer in witch the MIDI notes are delivered at regular time intervals, usually a 1/4th of a quarter note. As such it is not as versatile as a regular sequencer as [Rosegarden], but allows very easy creation of loops and sequences. The use of the [MIDI Clock] allows several sequencers communicate clock events, so it is possible to join several sequencers, with diverse focus, to make one single synchronized composition.
KMidiTracker is similar to trackers like [FastTracker], [ScreamTracker] or [Buzz], but only the Tracker; no actual sound is emmited. Only MIDI signals.
The Tracker divides songs in tracks, each one have several patterns that are arranged as sequences. Time advance in steps that depend on tempo, and in each time step a new MIDI note may sound, or a controller event may be sent. You can have several columns of notes and/or controllers for each pattern, and pattern length is configurable.
Main features:
- MIDI oriented Step Sequencer
- ALSA MIDI input/output
- MIDI thru
- Keyboard input
- Graphical Controller edition
- Controllers include MIDI Controllers, SysEx Controllers and PitchBend
- MIDI Master Clock (master and slave)
- Linux RTC timer or MMC if avaliable for perfect timing
- Tracks and columns in patterns muteable
- SysEx parameters. Can be loaded from binary file, manually inserted in hex, or captured from midi input.
- Variable Time Signature
- Load/Save
- KDE application: easy menu, toolbar and shortcuts changes
- Everything can be changed in realtime: notes, arrangement, loops, controllers, load/save, new tracks or patterns, delete tracks or patterns...
- [GPL] license

MP3::Tag::ParseData is a Perl module for parsing arbitrary data associated with music files.

SYNOPSIS

# parses the file name according to one of the patterns:
$mp3->config(parse_data, [i, %f, %t - %n - %a.%e, %t - %y.%e]);
$title = $mp3->title;

Array::PatternMatcher is a pattern matching for arrays.

SYNOPSIS

This section inlines the entire test suite. Please excuse the ok()s.

use Array::PatternMatcher;

Matching logical variables to input stream

# 1 - simple match of logical variable to input
my $pattern = AGE ;
my $input = 969 ;
my $result = pat_match ($pattern, $input, {} ) ;
ok($result->{AGE}, 969) ;

# 2 - if binding exists, it must equal the input
$input = 12;
my $new_result = pat_match ($pattern, $input, $result) ;
ok(!defined($new_result)) ;

# 3 - bind the pattern logical variables to the input list

$pattern = [qw(X Y)] ;
$input = [ 77, 45 ] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok($result->{X}, 77) ;
Matching segments (quantifying) portions of the input stream
# 1
{
my $pattern = [a, [qw(X *)], d] ;
my $input = [a, b, c, d] ;

my $result = pat_match ($pattern, $input, {} ) ;
ok ("@{$result->{X}}","b c") ;
}

# 2
{

my $pattern = [a, [qw(X *)], [qw(Y *)], d] ;
my $input = [a, b, c, d] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok ("@{$result->{Y}}","b c") ;

}
# 3
{
my $pattern = [a, [qw(X +)], d] ;
my $input = [a, b, c, d] ;
ok ("@{$result->{X}}","b c") ;
}
# 4
{
my $pattern = [ a, [qw(X ?)], c ] ;
my $input = [ a, b, c ] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok ("$result->{X}","b") ;
}
# 5
{
my $pattern = [ qw(X OP Y is Z),
[
sub { "($_->{X} $_->{OP} $_->{Y}) == $_->{Z}" },
IF?
]
] ;
my $input = [qw(3 + 4 is 7) ] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok ($result) ;
}
Single-matching:
Take a single input and a series of patterns and decide which pattern
matches the input:

# 1 - Here all input patterns must match the input

{
my @pattern ;
push @pattern, [ qw(X Y) ] ;
push @pattern, [ qw(22 Z ) ] ;
push @pattern, [ qw(M 33) ] ;

my $input = [ qw(22 33) ] ;

my $meta_pattern = [ AND?, @pattern ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($meta_pattern, $input, {} ) ;
ok ($result->{Z},33) ;
}

# 2 - Here, any one of the patterns must match the input

{
my @pattern ;
push @pattern, [ qw(99 22) ] ;
push @pattern, [ qw(33 22) ] ;
push @pattern, [ qw(44 3) ] ;
push @pattern, [ qw(22 Z) ] ;

my $input = [ qw(22 33) ] ;

my $meta_pattern = [ OR?, @pattern ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($meta_pattern, $input, {} ) ;
ok ($result->{Z},33) ;
}

# 3 - Here, none of the patterns must match the input

{
my @pattern ;
push @pattern, [ qw(99 22) ] ;
push @pattern, [ qw(33 22) ] ;
push @pattern, [ qw(44 3) ] ;
push @pattern, [ qw(22 Z) ] ;

my $input = [ qw(22 33) ] ;

my $meta_pattern = [ NOT?, @pattern ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($meta_pattern, $input, {} ) ;
ok (scalar keys %$result == 0) ;
}

# 4 - here the input must satisfy the predicate
{
sub numberp { $_[0] =~ /d+/ }

my $pattern = [ qw(X age), [qw(IS? N), νmberp] ] ;
my $input = [ qw(Mary age), thirty-four ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($pattern, $input, {} ) ;
ok (!defined($result));
}

# 5 - same thing, but this time a failing result ---
# not undef because it is the return val of numberp
{
sub numberp { $_[0] =~ /d+/ }

my $pattern = [ qw(X age), [qw(IS? N), νmberp] ] ;
my $input = [ qw(Mary age), 34 ] ;
my $result = pat_match ($pattern, $input, {} ) ;

ok ($result->{N},34) ;
}
Segment-matching:
Match a chunk of the input stream using *, +, ?

# 1 - * is greedy in this case, but not with 2 consecutve * patterns
{
my $pattern = [a, [qw(X *)], d] ;
my $input = [a, b, c, d] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "X*RETVAL: %s", Data::Dumper::Dumper($result) ;
ok ("@{$result->{X}}","b c") ;
}
# 2 - X* gets nothing, Y* gets all it can:
{

my $pattern = [a, [qw(X *)], [qw(Y *)], d] ;
my $input = [a, b, c, d] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "X*Y*RETVAL: %s", Data::Dumper::Dumper($result) ;
ok ("@{$result->{Y}}","b c") ;

}
# 3 - samething , but require at least one match for X
{
my $pattern = [a, [qw(X +)], d] ;
my $input = [a, b, c, d] ;

my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "RETVAL: @{$result->{X}}" ;
ok ("@{$result->{X}}","b c") ;
}
# 4 - require 0 or 1 match for X
{
my $pattern = [ a, [qw(X ?)], c ] ;
my $input = [ a, b, c ] ;


my $result = pat_match ($pattern, $input, {} ) ;

ok ("$result->{X}","b") ;
}
# 5 - evaluate a sub on the fly after match
{
my $pattern = [ qw(X OP Y is Z),
[
sub { "($_->{X} $_->{OP} $_->{Y}) == $_->{Z}" },
IF?
]
] ;
my $input = [qw(3 + 4 is 7) ] ;

my $result = pat_match ($pattern, $input, {} ) ;

ok ($result) ;
}
# --- 6 same thing, but fail
{
my $pattern = [ qw(X OP Y is Z),
[
sub { "($_->{X} $_->{OP} $_->{Y}) == $_->{Z}" },
IF?
]
] ;
my $input = [qw(3 + 4 is 8) ] ;

my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "IF_RETVAL2: *%s*", Data::Dumper::Dumper($result);
ok ($result eq ) ;
}

XML::PatAct::ToObjects is an action module for creating Perl objects.

SYNOPSIS

use XML::PatAct::ToObjects;

my $patterns = [ PATTERN => [ OPTIONS ],
PATTERN => "PERL-CODE",
... ];

my $matcher = XML::PatAct::ToObjects->new( Patterns => $patterns,
Matcher => $matcher,
CopyId => 1,
CopyAttributes => 1 );

XML::PatAct::ToObjects is a PerlSAX handler for applying pattern-action lists to XML parses or trees. XML::PatAct::ToObjects creates Perl objects of the types and contents of the action items you define.

New XML::PatAct::ToObject instances are creating by calling `new(). Parameters can be passed as a list of key, value pairs or a hash. `new() requires the Patterns and Matcher parameters, the rest are optional:

Patterns
The pattern-action list to apply.

Matcher
An instance of the pattern or query matching module.

CopyId
Causes the `ID attribute, if any, in a source XML element to be copied to an `ID attribute in newly created objects. Note that IDs may be lost of no pattern matches that element or an object is not created (-make) for that element.

CopyAttributes
Causes all attributes of the element to be copied to the newly created objects.

Each action can either be a list of options defined below or a string containing a fragment of Perl code. If the action is a string of Perl code then simple then some simple substitutions are made as described further below.