App-Tarotplane

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    - tarotplane now depends on Perl 5.016.
    - CHANGELOG renamed to Changes, now follows traditional perl Changes format.
    - Switched to x.xx version number format.
  Added:
    - Tests.
    - -o option, allows you to order cards alphabetically by either terms or
      definitions.

0.3.0 Wed 2 Oct 2024
  Added:
    - Two new escape sequences:
      - \n: Force linebreak.
      - \\: Back slash.
    - Demo GIF.
  Changes:
    - Text::Wrap is now used for line wrapping.
    - Split words are no longer hyphenated.

0.2.0 Sat 17 Aug 2024
  Added:
    - '?' displays help message.

MANIFEST  view on Meta::CPAN

lib/App/Tarotplane.pm
lib/App/Tarotplane/Cards.pm
lib/App/Tarotplane/UI.pm
LICENSE
Makefile.PL
MANIFEST			This list of files
README.md
t/00_load.t
t/10_cards.t
t/20_tarotplane-init.t
t/data/escape.cards
t/data/multiline.cards
t/data/sort.cards
t/data/whitespace.cards
META.yml                                 Module YAML meta-data (added by MakeMaker)
META.json                                Module JSON meta-data (added by MakeMaker)

README.md  view on Meta::CPAN

### Card Files
A **tarotplane** card file is a text file that contains cards seperated by a
delimitting line, which is a line the contains nothing but a percentage (%)
sign. Each card must contain a term and a definition, seperated by a colon (:).
Terms precede the colon, definitions follow the colon.

Lines starting with a hash (#) are treated as comments and are ignored. Blank
lines are also ignored.

#### Escape Sequences
An escape sequence is a pair of characters, a forward slash (\\) and some other
character, that enables special behavior in **tarotplane** when
reading/displaying cards. Below is a list of all the escape sequences
**tarotplane** supports:

| Escape Sequence | Behavior                  |
| --------------- | ------------------------- |
| \\\\            | Single back slash (\\)    |
| \\:             | Colon (:)                 |
| \\n             | Force linebreak           |

### Controls

bin/tarotplane  view on Meta::CPAN

  %

B<tarotplane> will only read two cards, and ignore the two empty cards between
Term 1 and Term 2.

Lines starting with a hash (#) are treated as comments and are ignored. Blank
lines are also ignored.

=head3 Escape Sequences

An escape sequence is a pair of characters, a forward slash (\) and some other
character, that signals to B<tarotplane> to perform special behavior when
reading/displaying the card. Below is a list of all the escape sequences
B<tarotplane> supports:

=over 4

=item \\

Single back slash (\).

=item \:

lib/App/Tarotplane/Cards.pm  view on Meta::CPAN

                unless $state == CARD_DEF;

            # Trim leading/trailing whitespace
            $card->{Term}       =~ s/^\s+|\s+$//g;
            $card->{Definition} =~ s/^\s+|\s+$//g;

            # Truncate whitespace
            $card->{Term}       =~ s/\s+/ /g;
            $card->{Definition} =~ s/\s+/ /g;

            ## Now interpret some escape codes
            # '\:' -> ':'
            $card->{Term}       =~ s/\\:/:/g;
            $card->{Definition} =~ s/\\:/:/g;

            # '\n' -> line break
            $card->{Term}       =~ s/\\n/\n/g;
            $card->{Definition} =~ s/\\n/\n/g;

            # No longer need '\\' substitution null byte
            $card->{Term}       =~ s/\0//g;

lib/App/Tarotplane/Cards.pm  view on Meta::CPAN

            $cn++;

            next;

        }

        # Skip comments and blanks
        my $first = substr $l, 0, 1;
        next if $first eq '#' or $first eq "\n";

        # Substitute '\\' now so that '\\:' does not count as an escaped colon.
        # The null byte is added so that the subsequent substitutions do not
        # try to replace any '\\' escaped backslash.
        $l =~ s/\\\\/\\\0/g;

        if ($state == CARD_TERM) {
            # Does card contain non-escaped colon?
            if ($l =~ /(^|[^\\]):/) {
                my (undef,
                    $te,
                    $de
                ) = split(/(^.*[^\\]):/, $l, 2);
                $card->{Term}       .= $te || '';
                $card->{Definition} .= $de || '';
                $state = CARD_DEF;
            } else {
                $card->{Term} .= $l;

t/10_cards.t  view on Meta::CPAN

    {
        Term => '5',
        Def  => '6',
    },
    {
        Term => '7',
        Def  => '8',
    },
);

my $Escape_Test = File::Spec->catfile(qw(t data escape.cards));
my $Escape_Num = 4;
my @Escape = (
    {
        Term => ":)",
        Def  => "Happy :D",
    },
    {
        Term => ":-\\",
        Def  => "Concerned\\Confused",
    },

t/10_cards.t  view on Meta::CPAN

is($d2->get('CardNum'), $Whitespace_Num, "Correct number of cards read");

foreach my $i (0 .. $Whitespace_Num) {
    is($d2->card_side($i, 'Term'), $Whitespace[$i]->{Term},
        "Card #$i term is okay (w/ weird whitespace)");
    is($d2->card_side($i, 'Definition'), $Whitespace[$i]->{Def},
        "Card #$i definition is okay (w/ weird whitespace)");
}

# Test reading escape sequences
my $d3 = App::Tarotplane::Cards->new($Escape_Test);

is($d3->get('CardNum'), $Escape_Num, "Correct number of cards read");

foreach my $i (0 .. $Escape_Num - 1) {
    is($d3->card_side($i, 'Term'), $Escape[$i]->{Term},
        "Card #$i term is okay (w/ escape sequences)");
    is($d3->card_side($i, 'Definition'), $Escape[$i]->{Def},
        "Card #$i definition is okay (w/ escape sequences)");
}

# $d4 will test reading multiple files at once
my $d4 = App::Tarotplane::Cards->new(
    $Sort_Test, $Whitespace_Test, $Escape_Test
);

is($d4->get('CardNum'), $Sort_Num + $Whitespace_Num + $Escape_Num,
    "new() correctly read multiple files at once");

t/data/escape.cards  view on Meta::CPAN

# These cards test tarotplane's escape sequences
%
\:): Happy \:D
%
\:-\\: Concerned\\Confused
%
Line\nbreak: Broken\nline
%
\\\n\\\\\:\:: All together!
%