File Coverage

blib/lib/Data/Edit/Xml/SDL.pm

Criterion	Covered	Total	%
statement	108	109	99.0
branch	13	20	65.0
condition			n/a
subroutine	25	25	100.0
pod	11	17	64.7
total	157	171	91.8

#!/usr/bin/perl -I/home/phil/z/perl/cpan/DataEditXmlLint/lib/ -I/home/phil/z/perl/cpan/DataEditXml/lib -I/home/phil/z/perl/cpan/DataTableText/lib
#-------------------------------------------------------------------------------
# Create SDL file map from a set of linted xml files
# Philip R Brenan at gmail dot com, Appa Apps Ltd, 2016
#-------------------------------------------------------------------------------
# podDocumentation

package Data::Edit::Xml::SDL;
require v5.16.0;
use warnings FATAL => qw(all);
use strict;
use Carp;
use Data::Edit::Xml::Lint;
use Data::Table::Text qw(:all);
our $VERSION = 20170809;

#1 Constructor                                                                  # Construct a new SDL file map creator

sub new                                                                         # Create a new SDL file map creator - call this method statically as in Data::Edit::Xml::Lint::new()
 {bless {sdlVersion=>'12.0.0.0', language=>(qq(en-US))}                         # Defaults that can be easily overridden
 }

#2 Attributes                                                                   # Attributes describing a lint

genLValueScalarMethods(qw(filePathFolder));                                     # Prefix this folder (if supplied) to the filepath
genLValueScalarMethods(qw(fileType));                                           # The fileType of the file to be processed
genLValueScalarMethods(qw(folderHasMixedContent));                              # folderHasMixedContent field
genLValueScalarMethods(qw(ishType));                                            # IshType field
genLValueScalarMethods(qw(imagePath));                                          # Image path relative to sourcebasepath
genLValueScalarMethods(qw(language));                                           # The language of the content, defaults to: 'en-US'
genLValueScalarMethods(qw(lint));                                               # The lint of the file to be processed
genLValueScalarMethods(qw(sdlVersion));                                         # Version of SDL we are using, defaults to: '12.0.0.0'
genLValueScalarMethods(qw(section));                                            # Sub folder for file on SDL: maps, topics
genLValueScalarMethods(qw(sourcebasepath));                                     # Path to source to be uploaded
genLValueScalarMethods(qw(targetFolder));                                       # The SDL target folder to be used
genLValueScalarMethods(qw(version));                                            # Version of the input content

#1 SDL File Map                                                                 # Generate an SDL file map

sub xmlLineOne                                                                  #P Line one of all xml files
 {''
 }

sub getFileMap                                                                  #P File map tag
 {my ($sdl) = @_;                                                               # Sdl file map creator
  my $s = $sdl->sourcebasepath;
  my $v = $sdl->sdlVersion;
  <
 ;
END
 }

sub getFile($$)                                                                 #P File tag
 {my ($sdl, $images) = @_;                                                      # Sdl file map creator, processing an image file or not
  my $targetFolder   = $sdl->targetFolder;
  my $ishType        = $sdl->ishType;
  my $section        = $sdl->section;
  my $imagePath      = $sdl->imagePath;
  my $lint           = $sdl->lint;
  my $project        = $lint->project;
  my $guid           = $lint->guid;
  my $file           = $lint->file;
  my $mixed          = ucfirst $sdl->folderHasMixedContent;
     $mixed =~ m/\A(True|False)\Z/s or
       confess "FolderhasMixedContent = (True|False) not $mixed";

  my $filePrefix = '';                                                          # File name prefix if any
  if ($images)                                                                  # The image file prefix if we are processing an image
   {defined($imagePath) or
      confess "Use SDL->imagePath() to supply a path for images";
    $filePrefix = filePathDir($imagePath);                                      # The image file prefix if we are processing an image
    $lint->file =~ s/\.xml\Z//gs;                                               # Remove trailing xml extension on image files
   }

  my (undef, $fileName, $fileExt) = parseFileName($lint->file);                 # Parse file name
  my $relFile = filePathExt($filePrefix, $fileName, $fileExt);
  <

END
 }

sub getIshObject                                                                #P IshObject tag
 {my ($sdl) = @_;                                                               # Sdl
  my $ishType = $sdl->ishType;
  my $lint    = $sdl->lint;
  my $guid    = $lint->guid;
  <

END
 }

sub getFTitle                                                                   #P FTITLE tag
 {my ($sdl) = @_;                                                               # Sdl
  my (undef, $fileName, $fileExt) = parseFileName($sdl->lint->file);            # Parse file name
  <
$fileName'
END
 }

sub getVersion                                                                  #P Version tag
 {my ($sdl) = @_;                                                               # Sdl
  my $v = $sdl->version;
  <
$v
END
 }

sub getDocLanguage                                                              #P DOC-LANGUAGE tag
 {my ($sdl) = @_;                                                               # Sdl
  my $l = $sdl->language;
  <
$l
END
 }

sub getAuthor                                                                   #P Author tag
 {my ($sdl) = @_;                                                               # Sdl
  my $lint  = $sdl->lint;
  my $a     = $lint->author;
  <
$a
END
 }

sub getResolution                                                               #P Resolution
 {my ($sdl) = @_;                                                               # Sdl
  <
High
END
 }

sub createSDLFileMap($@)                                                        # Generate an SDL file map for a selected set of files
 {my ($sdl, @foldersAndExtensions) = @_;                                        # Sdl, Directory tree search specification

  my @files = searchDirectoryTreesForMatchingFiles(@foldersAndExtensions);      # Find matching files

  my @map = (xmlLineOne, $sdl->getFileMap);                                     # The generated map

  for my $file(@files)                                                          # Each file contributing to the map
   {my $lint = Data::Edit::Xml::Lint::read($file);                              # Linter for the file
    $sdl->lint = $lint;

    my $ditaType = $lint->ditaType;
    $ditaType or confess "DitaType required for file:\n$file";

    if ($ditaType =~ m/bookmap/i)
     {$sdl->ishType = (qq(ISHMasterDoc));
      $sdl->section = (qq(maps));
      $sdl->folderHasMixedContent = (qq(true));
      push @map,
        $sdl->getFile,
        $sdl->getIshObject, <

END
        $sdl->getFTitle,
        $sdl->getVersion,
        $sdl->getDocLanguage,
        $sdl->getAuthor,
        <



END
     }

    elsif ($ditaType =~ m/concept|reference|task|troubleShooting/i)
     {$sdl->ishType = (qq(ISHModule));
      $sdl->section = (qq(topics));
      $sdl->folderHasMixedContent = (qq(true));
      push @map,
        $sdl->getFile,
        $sdl->getIshObject, <

END
        $sdl->getFTitle,
        $sdl->getVersion,
        $sdl->getDocLanguage,
        $sdl->getAuthor,
        <



END
     }

    elsif ($ditaType  =~ m/image/i)
     {$sdl->ishType   = qq(ISHIllustration);
      $sdl->section   = qq(images);
      $sdl->imagePath = qq(images);
      $sdl->folderHasMixedContent = qq(false);
      push @map,
        $sdl->getFile(1),
        $sdl->getIshObject, <

END
        $sdl->getFTitle,
        $sdl->getVersion,
        $sdl->getDocLanguage,
        $sdl->getResolution,
        $sdl->getAuthor,
        <



END
     }
    else {confess "Unrecognized ditaType $ditaType"}
   }
  my $T = dateTimeStamp;
  push @map, <


END
  join "", @map;
 } # createSDLFileMap

# podDocumentation

=pod

=encoding utf-8

=head1 Name

Data::Edit::Xml::SDL - Create SDL file map from a set of linted xml files
produced by L

=head1 Synopsis

Create an SDL file map from a set of linted xml files produced by
L

 my $s = Data::Edit::Xml::SDL::new();
    $s->sourcebasepath = 'C:\frame\batch1\out';
    $s->targetFolder   = qq(RyffineImportSGIfm);
    $s->imagePath      = qq(images);
    $s->version = 1;

 say STDERR $s->createSDLFileMap(qw(. xml));

Produces:


 ;



      bm_0003388-002'
      1
      en-US
      [e-mail]




etc.

=head1 Description

=head2 Constructor

Construct a new SDL file map creator

=head3 new()

Create a new SDL file map creator - call this method statically as in Data::Edit::Xml::Lint::new()


=head3 Attributes

Attributes describing a lint

=head4 filePathFolder :lvalue

Prefix this folder (if supplied) to the filepath


=head4 fileType :lvalue

The fileType of the file to be processed


=head4 folderHasMixedContent :lvalue

folderHasMixedContent field


=head4 ishType :lvalue

IshType field


=head4 imagePath :lvalue

Image path relative to sourcebasepath


=head4 language :lvalue

The language of the content, defaults to: 'en-US'


=head4 lint :lvalue

The lint of the file to be processed


=head4 sdlVersion :lvalue

Version of SDL we are using, defaults to: '12.0.0.0'


=head4 section :lvalue

Sub folder for file on SDL: maps, topics


=head4 sourcebasepath :lvalue

Path to source to be uploaded


=head4 targetFolder :lvalue

The SDL target folder to be used


=head4 version :lvalue

Version of the input content


=head2 SDL File Map

Generate an SDL file map

=head3 createSDLFileMap($@)

Generate an SDL file map for a selected set of files

  1  $sdl                   Sdl
  2  @foldersAndExtensions  Directory tree search specification


=head1 Private Methods

=head2 xmlLineOne()

Line one of all xml files


=head2 getFileMap()

File map tag


=head2 getFile($$)

File tag

  1  $sdl     Sdl file map creator
  2  $images  Processing an image file or not

=head2 getIshObject()

IshObject tag


=head2 getFTitle()

FTITLE tag


=head2 getVersion()

Version tag


=head2 getDocLanguage()

DOC-LANGUAGE tag


=head2 getAuthor()

Author tag


=head2 getResolution()

Resolution



=head1 Index


L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

L

=head1 Installation

This module is written in 100% Pure Perl and, thus, it is easy to read, use,
modify and install.

Standard Module::Build process for building and installing modules:

  perl Build.PL
  ./Build
  ./Build test
  ./Build install

=head1 Author

L

L

=head1 Copyright

Copyright (c) 2016-2017 Philip R Brenan.

This module is free software. It may be used, redistributed and/or modified
under the same terms as Perl itself.

=cut


# Tests and documentation

sub test
 {my $p = __PACKAGE__;
  return if eval "eof(${p}::DATA)";
  my $s = eval "join('', <${p}::DATA>)";
  $@ and die $@;
  eval $s;
  $@ and die $@;
 }

test unless caller;

1;
# podDocumentation

__DATA__