pmsetup

#!/usr/bin/env perl
use strict;
use warnings;
use ExtUtils::MakeMaker qw(prompt);
use File::Basename;
use File::Path;
use File::Spec;
use Text::Xslate;
use Time::Piece;
use YAML;

my $path   = File::Spec->catfile($ENV{HOME}, "/.pmsetuprc");
my $config = eval { YAML::LoadFile($path) } || {};

my $save;
while (! $config->{author}) {
    $config->{author} = prompt("Your name: ", '');
    $save++;
}

while (! $config->{email}) {
    $config->{email} = prompt("Your email: ", '');
    $save++;
}

my $modname = shift @ARGV or die "Usage: $0 module\n";
   $modname =~ s/-/::/g;

write_plugin_files($modname, $config);

END {
    YAML::DumpFile($path, $config) if $save;
}

sub write_plugin_files {
    my($module, $config) = @_;

    # $module = "Foo::Bar"
    # $dist   = "Foo-Bar"
    # $path   = "Foo/Bar.pm"
    my @pkg  = split /::/, $module;
    my $dist = join "-", @pkg;
    my $path = join("/", @pkg) . ".pm";

    mkdir $dist, 0777;
    chdir $dist;

    my @template = YAML::Load(join '', <DATA>);
    my $vars = {
        module => $module, dist => $dist, path => $path,
        config => $config, localtime => localtime()->ymd,
        year => (localtime)[5] + 1900
    };

    for my $tmpl (@template) {
        my $file = $tmpl->{file};
           $file =~ s/(\$\w+)/$1/eeg;
        write_file($file, $tmpl->{template}, $vars);
    }

    !system "perl Build.PL" or die $?;
    !system './Build manifest' or die $?;
    !system 'git init' or die $?;
    !system 'git add .' or die $?;
    !system 'git commit -m "init repos"' or die $?;
    !system 'git tag init' or die $?;
    !system './Build test' or die $?;
    !system './Build distclean' or die $?;
}

sub write_file {
    my($path, $template, $vars) = @_;

    if (-e $path) {
        my $ans = prompt("$path exists. Override? [yN] ", 'n');
        return if $ans !~ /[Yy]/;
    }

    my $dir = File::Basename::dirname($path);
    unless (-e $dir) {
        warn "Creating directory $dir\n";
        File::Path::mkpath($dir, 1, 0777);
    }

    my $tt = Text::Xslate->new;
    my $content = $tt->render_string($template, $vars);

    warn "Creating $path\n";
    open my $out, ">", $path or die "$path: $!";
    print $out $content;
    close $out;
}

__DATA__
---
file: Build.PL
template: |
  use strict;
  use warnings;
  use Module::Build::Pluggable (
      'CPANfile',
      'GithubMeta',
  );

  my $builder = Module::Build::Pluggable->new(
      dist_author => 'Syohei YOSHIDA<syohex@gmail.com>',
      license     => 'perl',
      no_index    => { 'directory' => [ 't', 'xt', 'inc', 'eg' ] },
      test_files  => ( -d '.git' || $ENV{RELEASE_TESTING} ) ? 't/ xt/' : 't/',

      name        => '<: $dist :>',
      module_name => '<: $module :>',

      create_readme  => 0,
      create_license => 0,
  );

  $builder->create_build_script();

---
file: cpanfile
template: |

  on test => sub {
      requires 'Test::More', '0.98';
  };

  on configure => sub  {
      requires 'Module::Build::Pluggable';
      requires 'Module::Build::Pluggable::GithubMeta';
      requires 'Module::Build::Pluggable::CPANfile';
  };

---
file: .travis.yml
template: |
  language: perl
  before_install:
    - "perlbrew -f install-cpanm"
    - "cpanm Module::Build::Pluggable"
  perl:
    - 5.16
    - 5.14

---
file: t/00_compile.t
template: |
  use strict;
  use Test::More tests => 1;

  BEGIN { use_ok '<: $module :>' }
---
file: xt/01_spelling.t
template: |
  use strict;
  use Test::More;
  eval q{ use Test::Spelling };
  plan skip_all => "Test::Spelling is not installed." if $@;

  my $spell_cmd;
  foreach my $path (split(/:/, $ENV{PATH})) {
      -x "$path/spell"  and $spell_cmd="spell", last;
      -x "$path/ispell" and $spell_cmd="ispell -l", last;
      -x "$path/aspell" and $spell_cmd="aspell list", last;
  }
  plan skip_all => "no spell/ispell/aspell" unless $spell_cmd;

  set_spell_cmd($spell_cmd);

  add_stopwords(map { split /[\s\:\-]/ } <DATA>);
  $ENV{LANG} = 'C';
  all_pod_files_spelling_ok('lib');

  __DATA__
  Syohei YOSHIDA
  syohex
  gmail
  <: $module :>
---
file: xt/02_perlcritic.t
template: |
  use strict;
  use Test::More;
  eval q{
      use Test::Perl::Critic 1.02 -exclude => [
          'Subroutines::ProhibitSubroutinePrototypes',
          'Subroutines::ProhibitExplicitReturnUndef',
          'TestingAndDebugging::ProhibitNoStrict',
          'ControlStructures::ProhibitMutatingListFunctions',
          'InputOutput::RequireEncodingWithUTF8Layer',
      ]
  };
  plan skip_all => "Test::Perl::Critic 1.02+ is not installed." if $@;
  all_critic_ok('lib');
---
file: xt/03_pod.t
template: |
  use Test::More;
  eval "use Test::Pod 1.00";
  plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
  all_pod_files_ok();
---
file: Changes
template: |
  Revision history for Perl extension <: $module :>

  0.01  <: $localtime :>
          - original version
---
file: lib/$path
template: |
  package <: $module :>;
  use strict;
  use warnings;
  use 5.008_001;

  our $VERSION = '0.01';

  1;
  __END__

  =encoding utf-8

  =for stopwords

  =head1 NAME

  <: $module :> -

  =head1 SYNOPSIS

    use <: $module :>;

  =head1 DESCRIPTION

  <: $module :> is

  =head1 AUTHOR

  <: $config.author :> E<lt><: $config.email :>E<gt>

  =head1 COPYRIGHT

  Copyright <: $year :>- <: $config.author :>

  =head1 LICENSE

  This library is free software; you can redistribute it and/or modify
  it under the same terms as Perl itself.

  =head1 SEE ALSO

  =cut
---
file: MANIFEST.SKIP
template: |
  \bRCS\b
  \bCVS\b
  \.svn/
  \.git/
  ^MANIFEST\.
  ^Makefile$
  ~$
  \.old$
  ^blib/
  ^pm_to_blib
  ^MakeMaker-\d
  \.gz$
  \.cvsignore
  \.shipit
  \.bs$
  Build
  _build/
  MYMETA
  ^README.md$
  ^README.pod$
  ^\.travis\.yml$

---
file: README
template: |
  This is Perl module <: $module :>.

  INSTALLATION

  <: $module :> installation is straightforward.
  If your CPAN shell is set up, you should just be able to do

      % cpan <: $module :>

  Download it, unpack it, then build it as per the usual:

      % perl Build.PL
      % ./Build && ./Build test

  Then install it:

      % ./Build install

  DOCUMENTATION

  <: $module :> documentation is available as in POD.
  So you can do:

      % perldoc <: $module :>

  to read the documentation online with your favorite pager.

  <: $config.author :>
---
file: .shipit
template: |
  steps = FindVersion, ChangeVersion, CheckChangeLog, DistTest, Commit, Tag, MakeDist, UploadCPAN
  git.push_to = origin
---
file: .gitignore
template: |
  META.yml
  MYMETA.yml
  MYMETA.json
  Makefile
  Makefile.old
  MANIFEST.bak
  blib/
  pm_to_blib
  Build
  _build/
  *~