File Coverage

blib/lib/Anki/Import.pm

Criterion	Covered	Total	%
statement	183	189	96.8
branch	52	62	83.8
condition	19	26	73.0
subroutine	13	13	100.0
pod	1	6	16.6
total	268	296	90.5

package Anki::Import ;
$Anki::Import::VERSION = '0.030';
use strict;
use warnings;
use Cwd;
use Getopt::Args;
use Log::Log4perl::Shortcuts 0.021 qw(:all);
use Exporter qw(import);
our @EXPORT = qw(anki_import);

# change log config to test for development for fine-tuned control over log output
set_log_config('anki-import.cfg');
#set_log_config('test.cfg', __PACKAGE__);

# set up variables
my @lines;                # lines from source file
my $line_count = 0;       # count processed lines to give more helpful error msg
my $cline      = '';      # current line getting processed
my $lline      = '';      # last (previous) line processed
my $ntype      = 'Basic'; # default note type
my @notes      = ();      # array for storing notes
my @autotags   = ();      # for storing automated tags

# argument processing
arg file => (
  isa => 'Str',
  required => 1,
  comment => 'the name of the source file'
);
arg parent_dir => (
  isa => 'Str',
  default => cwd,
  comment => 'optional directory to save output files, defaults to current directory',
);
opt quiet  => (
  isa => 'Bool',
  alias => 'q',
  default => 1,
  comment => 'On by default. Use --quiet to override this setting to suppress'
             . ' the success message after a successful execution of the command.'
);
opt verbose => (
  isa => 'Bool',
  alias => 'v',
  comment => 'provide details on progress of Anki::Import'
);
opt vverbose => (
  isa => 'Bool',
  alias => 'V',
  comment => 'verbose information plus debug info'
);

# start here
sub anki_import {
  my $args = optargs( @_ );

  my $file = $args->{file};
  if (!$file) {
    logf('Aborting: No file passed to Anki::Import.');
  }

  # set parent directory
  my $pd = $args->{parent_dir};

  # set log level as appropriate
  if ($args->{verbose}) {
    set_log_level('info');
  } elsif ($args->{vverbose}) {
    set_log_level('debug');
  } else {
    set_log_level('error');
  }
  logi('Log level set');

  # get and load the source file
  logi('Loading file');
  my $path  = File::Spec->catfile($file); logd($path);
  if (! -e $path) {
    logf("Aborting: Source file named '$path' does not exist.");
  };
  open (my $handle, "<:encoding(UTF-8)", $path) or logf("Could not open $path");;
  chomp(@lines = <$handle>);
  close $handle;
  logi('Source file loaded.');

  # pad data with a blank line to make it easier to process
  push @lines, '';

  # do the stuff we came here for
  validate_src_file(); logd(\@notes);
  generate_importable_files($pd);

  # print a success message
  unless ($args->{'quiet'}) {
    set_log_level('info');
    logi("Success! Your import files are in the $pd"
      . '/anki_import_files directory');
  }

  # fin
}

# functions for first pass parsing of source data
sub validate_src_file {
  logi('Validating source file');

  # throw error if file is empty
  logf('Source data file is empty.') if !$lines[0];

  # outer loop for parsing notes
  my %fields;  # keeps track of number of fields for each type of note
  while (next_line()) {

    # ignore blank lines
    next if ($cline =~ /^$|^\s+$/);

    if ($cline =~ /^#\s*(\S+)/) {
      $ntype = $1;
      logi("Found note type");
      logd($ntype);
      next;
    }

    logi('Processing new note');
    # get the note
    my $note = slurp_note();
    logd($note);

    logi('Checking number of note fields');
    # validaate that notes of the same type have the same number of fields
    if (my $number_of_fields = $fields{$ntype}) {
      if (scalar (@$note) != $number_of_fields) {
        my $field_count = scalar(@$note);
        logf("A(n) $ntype note ending on line $line_count"
        . " has $field_count fields, a different amount than previous '$ntype' note types."
        . " Notes of the same note type must have the same number of fields. One common reason"
        . " for this error is that you did not indicate that you wanted to leave a field blank. To leave a field blank,"
        . " place a single '`' (backtick) on the line by itself in the source file. You may also"
        . " have failed to separate notes with two or more blank lines."
        . " Check your source file to ensure it is properly formatted.\n\n\tRefer to the"
        . " Anki::Import documentation for more help with formatting your source file."
        );
      }
    } else {
      $fields{$ntype} = scalar @$note;
    }

    logi('Storing note');
    push @notes, {ntype => $ntype, note => $note};
  }

}

sub slurp_note {
  my @current_field;
  my @note;
  push @current_field, $cline;

  # loop over lines in the note
  while (next_line()) {
    logd($cline, 'cline');
    if ($cline =~ /^$|^\s+$/) {
      my @all_fields = @current_field;
      push (@note, \@all_fields) if @current_field;
      @current_field = ();
      if ($lline =~ /^$|^\s+$/) {
        last;
      }
    } else {
      push @current_field, $cline;
    }
  }
  return \@note;
}

sub next_line {
  return 0 if !@lines; # last line in file was made blank
  $lline = $cline;
  $cline = (shift @lines || '');

  # do some cleanup
  chomp $cline;
  $cline =~ s/\t/    /g; # replace tabs with spaces

  ++$line_count;
}

# functions for second pass parsing and formatting of source data
# and creation of import files
sub generate_importable_files {
  my $pd = shift; logi('Generating files for import');

  my %filenames;

  # loop over notes
  foreach my $note (@notes) {
    logi('Looping over notes');

    my $line = process_note($note->{note});

    # add our processed note to our data
    my $filename = $note->{ntype} . '_notes_import.txt';
    $filenames{$filename}{content} .= $line;
  }

  logi('Writing notes out to file');
  foreach my $file ( keys %filenames ) {
    my $dir = File::Spec->catfile($pd, 'anki_import_files');
    mkdir $dir || logf("Could not make directory: $dir, $!");
    logd($dir);
    my $out_path = File::Spec->catfile($dir, $file);
    open (my $handle, ">>:encoding(UTF-8)", $out_path) or logf("Could not create file: $out_path");
    chomp $filenames{$file}{content};
    print $handle $filenames{$file}{content};
    close $handle;
  }
}

# the meat of the matter
# TODO: break up into shorter functions for readability
sub process_note {
  my $note = shift; logd($note, 'note_2b_processed');

  my @fields = ();
  my $new_autotags = 0; # flag raised if autotag line found

  # loop over note fields
  foreach my $field (@$note) {
    my $ws_mode = 0;   # tracks if we are preserving whitespace
    my $field_out = '';

    # loop over lines in field and process accordingly
    my @lines = (''); # can't take a reference to nothing
    foreach my $line (@$field) {
      my $last_line = \$lines[-1]; # just to make it easier to type

      # detect autotags
      logd($line);
      if ($line =~ /^\+\s*$/ && !$ws_mode) {
        push @autotags, split (/\s+/, $$last_line);
        $new_autotags = 1;
      }
      if ($line =~ /^\^\s*$/ && !$ws_mode) {
        @autotags = split (/\s+/, $$last_line);
        $new_autotags = 1;
        next;
      }

      # blanks lines not in non-whitespace mode
      if ($line =~ /^`\s*$/ && !$ws_mode) {
        if ($$last_line && $$last_line !~ /^+$/) {
          $$last_line .= '';
        }
        next;
      }

      # enter whitespace mode and adding appropriate HTML
      if ($line =~ /^`{3,3}$/ && !$ws_mode) {
        $ws_mode = 1;

        # add a couple of blank lines to previous line
        if ($$last_line) {
          $$last_line .= '';
        }

        $$last_line .= '';
        next;
      }

      # exit whitespace mode, close out HTML, add blank lines
      if ($line =~ /^`{3,3}$/ && $ws_mode) {
        $ws_mode = 0;
        $$last_line .= "";
        next;
      }

      # handle lines differently based on if we are preserving whitespace
      if ($ws_mode) {
        # escape characters in preserved text
        if ($line =~ /^`\s*$/) {
          $$last_line .= '';
          next;
        }
        $line =~ s/(?
        $line =~ s/(?
        $line =~ s/(?
        $$last_line .= $line . "";
      } else {
        push @lines, $line;
      }
    }
    logf('A set of backticks (```) is unmatched or you failed to backtick a'
         . ' blank line inside of a backtick set. Please correct the source'
         . ' file and try again. Run "perldoc Anki::Import" for more help.') if $ws_mode;

    logd($field_out, 'field_out');

    shift @lines if !$lines[0];
    my $field = join ' ', @lines;

    # clean up dangling breaks
    $field =~ s/<\/div>/<\/div>/g;

    # handle formatting codes in text, preserve escaped characters

    # preserve angle brackets between backticks
    my $parts = [ split /[^\\]`|^`/, $field, -1];

    my $count = 0;
    foreach my $part (@$parts) {
      $count++;
      next if ($count % 2);  # only substitute on odd number array items
      $part =~ s/
    }

    $field = join '`', @$parts;

    # backticked characters
    $field =~ s/(?$1<\/span>/gm;
    $field =~ s/\\`/`/g;

    # bold
    $field =~ s/(?$1<\/span>/gm;
    $field =~ s/\\\*/*/g;

    # unordered lists
    $field =~ s'(?" . join ("", (split (/,\s*/, $1))) . "<\/ul>"'gme;
    $field =~ s/\\%/%/g;

    $field =~ s/()+$//;
    push @fields, $field;

  }

  # generate tag field
  if (@autotags && !$new_autotags) {

    # get tags from tag field
    my @note_tags = split (/\s+/, $fields[-1]); logd(\@note_tags, 'raw_note_tags');
    my @new_tags = ();

    # add tags from tag field
    foreach my $note_tag (@note_tags) {
      my $in_autotags = grep { $_ eq $note_tag } @autotags;
      push @new_tags, $note_tag unless $in_autotags;
    }

    # add autotags
    foreach my $autotag (@autotags) {
      my $discard_autotag = grep { $_ eq $autotag } @note_tags;
      push @new_tags, $autotag if !$discard_autotag;
    }

    # add combined tags as a field
    logd(\@new_tags, 'new_tags');
    my $new_tags = join (' ', @new_tags);
    $fields[-1] = $new_tags;
  }
  $new_autotags = 0;

  my $out = join ("\t", @fields);

  # create cloze fields
  my $cloze_count = 1;
  # TODO: should probably handle escaped braces just in case
  while ($out =~ /\{\{\{(.*?)}}}/) {
    $out =~ s/\{\{\{(.*?)}}}/{{c${cloze_count}::$1}}/s;
    $cloze_count++;
  }
  logd($out, 'out');

  $out .= "\n";
}

1; # Magic true value
# ABSTRACT: Anki note generation made easy.

__END__