—

              
#!/usr/bin/perl
####################################################################################################
# sass (scss) compiler
####################################################################################################
use utf8;
use strict;
use warnings;
####################################################################################################
# dependencies
####################################################################################################
# parse options
use Pod::Usage;
use Getopt::Long;
# make the options case sensitive
Getopt::Long::Configure("bundling");
# load constants from libsass
use CSS::Sass qw(SASS_STYLE_EXPANDED);
use CSS::Sass qw(SASS_STYLE_NESTED);
use CSS::Sass qw(SASS_STYLE_COMPRESSED);
use CSS::Sass qw(SASS_STYLE_COMPACT);
use CSS::Sass::Watchdog qw(start_watchdog);
use CSS::Sass::Plugins qw(%plugins);
# setup encodings for std streams
# not sure why this is not default
binmode(STDIN, ":encoding(console_in)");
binmode(STDOUT, ":encoding(console_out)");
binmode(STDERR, ":encoding(console_out)");
####################################################################################################
# normalize command arguments to utf8
####################################################################################################
# get cmd arg encoding
use Encode::Locale qw();
# convert cmd args to utf8
use Encode qw(decode encode);
# now just decode every command arguments
@ARGV = map { decode(locale => $_, 1) } @ARGV;
####################################################################################################
# options variables
####################################################################################################
# init options
my $watchdog;
my $benchmark;
my $precision;
my $output_file;
my $output_style;
my $source_comments;
my $source_map_file;
my $source_map_root;
my $source_map_embed;
my $source_map_contents;
my $source_map_file_urls;
my $omit_source_map_url;
# paths arrays
my @plugin_paths;
my @include_paths;
# output styles
my $indent = "  ";
my $linefeed = "auto";
####################################################################################################
####################################################################################################
# define a sub to print out the version (mimic behaviour of node.js blessc)
# this script has it's own version numbering as it's not dependent on any libs
sub version {
        printf "psass %s (perl sass/scss compiler)\n", "0.5.0";
        printf "  libsass: %s\n", CSS::Sass::libsass_version();
        printf "  sass2scss: %s\n", CSS::Sass::sass2scss_version();
exit 0 };
sub list_plugins {
        foreach my $plugin (sort keys %plugins) {
                printf "--%s-plugin\n", $plugin;
        }
exit 0 };
####################################################################################################
####################################################################################################
my %options = (
        'help|h' => sub { pod2usage(1); },
        'watch|w!' => \ $watchdog,
        'version|v' => \ &version,
        'benchmark|b!' => \ $benchmark,
        'indent=s' => \ $indent,
        'linefeed=s' => \ $linefeed,
        'precision|p=s' => \ $precision,
        'output-file|o=s' => \ $output_file,
        'output-style|t=s' => \ $output_style,
        'line-numbers|c!' => \ $source_comments,
        'line-comments|c!' => \ $source_comments,
        'source-comments|c!' => \ $source_comments,
        'source-map-file|m=s' => \ $source_map_file,
        'source-map-root=s' => \ $source_map_root,
        'source-map-embed|e!' => \ $source_map_embed,
        'source-map-contents|s!' => \ $source_map_contents,
        'source-map-file-urls!' => \$source_map_file_urls,
        'no-source-map-url!' => \ $omit_source_map_url,
        'plugin-path|P|L=s' => sub { push @plugin_paths, $_[1] },
        'include-path|I=s' => sub { push @include_paths, $_[1] }
);
my %enable_plugins;
# add shortcuts for known plugins
foreach my $plugin (keys %plugins) {
        $enable_plugins{$plugin} = 0;
        $options{"${plugin}-plugin!"} =
                \ $enable_plugins{$plugin};
}
$options{'list-plugins'} = sub { list_plugins };
$options{'all-plugins'} = sub {
        foreach my $plugin (keys %plugins) {
                $enable_plugins{$plugin} = 1;
        }
};
# get options
GetOptions %options;
# register the enabled plugin paths
foreach my $plugin (keys %enable_plugins) {
        next unless $enable_plugins{$plugin};
        push @plugin_paths, $plugins{$plugin};
}
# set default if not configured
unless (defined $output_style)
{ $output_style = SASS_STYLE_NESTED }
# parse string to constant
elsif ($output_style =~ m/^n/i)
{ $output_style = SASS_STYLE_NESTED }
elsif ($output_style =~ m/^compa/i)
{ $output_style = SASS_STYLE_COMPACT }
elsif ($output_style =~ m/^compr/i)
{ $output_style = SASS_STYLE_COMPRESSED }
elsif ($output_style =~ m/^e/i)
{ $output_style = SASS_STYLE_EXPANDED }
# die with message if style is unknown
else { die "unknown output style: $output_style" }
# resolve linefeed options
if ($linefeed =~ m/^a/i)
{ $linefeed = undef; }
elsif ($linefeed =~ m/^w/i)
{ $linefeed = "\r\n"; }
elsif ($linefeed =~ m/^[u]/i)
{ $linefeed = "\n"; }
elsif ($linefeed =~ m/^[n]/i)
{ $linefeed = ""; }
# die with message if linefeed type is unknown
else { die "unknown linefeed type: $linefeed" }
# do we have output path in second arg?
if (defined $ARGV[1] && $ARGV[1] ne '-')
{ $output_file = $ARGV[1]; }
# check if the benchmark module is available
if ($benchmark && ! eval "use Benchmark; 1" )
{ die "Error loading Benchmark module\n", $@; }
####################################################################################################
# get sass standard option list
####################################################################################################
sub sass_options ()
{
        return (
                dont_die => $watchdog,
                indent => $indent,
                linefeed => $linefeed,
                precision => $precision,
                output_path => $output_file,
                output_style  => $output_style,
                plugin_paths => \ @plugin_paths,
                include_paths => \ @include_paths,
                source_comments => $source_comments,
                source_map_file => $source_map_file,
                source_map_root => $source_map_root,
                source_map_embed => $source_map_embed,
                source_map_contents => $source_map_contents,
                source_map_file_urls => $source_map_file_urls,
                omit_source_map_url => $omit_source_map_url,
        );
}
####################################################################################################
# implement our own safe File::Slurp::write_file
# since syswrite() is deprecated on :utf8 handles 
####################################################################################################
# To mark FILEHANDLE as UTF-8, use :utf8 or :encoding(UTF-8) . :utf8 just marks the
# data as UTF-8 without further checking, while :encoding(UTF-8) checks the data for
# actually being valid UTF-8. More details can be found in PerlIO::encoding.
sub write_file ($$)
{
        use Fcntl qw(:flock LOCK_EX);
        # my ($file, $content, $binmode) = @_; 
        # avoid arg copies and use @_ directly
        if (open (my $fh, ">", $_[0])) {
                unless (flock($fh, LOCK_EX)) {
                        Carp::croak "Error aquiring file lock!\n",
                                "Path: ", $_[0], "\n",
                                "Reason: ", $!, "\n";
                }
                unless (binmode($fh, $_[2] || ':utf8')) {
                        Carp::croak "Error setting file mode!\n",
                                "Path: ", $_[0], "\n",
                                "Reason: ", $!, "\n";
                }
                unless (print $fh $_[1]) {
                        Carp::croak "Error writing output!\n",
                                "Path: ", $_[0], "\n",
                                "Reason: ", $!, "\n";
                }
        }
        else {
                Carp::croak "Error opening writable file!\n",
                        "Path: ", $_[0], "\n",
                        "Reason: ", $!, "\n";
        }
}
####################################################################################################
use CSS::Sass qw(sass_compile_file sass_compile);
####################################################################################################
# first run we always want to die on error
# because we will not get any included files
our $error = sub { die @_ };
sub compile ()
{
        # variables
        my ($css, $err, $stats);
        # get benchmark stamp before compiling
        my $t0 = $benchmark ? Benchmark->new : 0;
        # open filehandle if path is given
        if (defined $ARGV[0] && $ARGV[0] ne '-')
        {
                ($css, $err, $stats) = sass_compile_file(
                        $ARGV[0], sass_options()
                );
        }
        # or use standard input
        else
        {
                ($css, $err, $stats) = sass_compile(
                        join('', <STDIN>), sass_options()
                );
        }
        # get benchmark stamp after compiling
        my $t1 = $benchmark ? Benchmark->new : 0;
        # only print benchmark result when module is available
        if ($benchmark) { warn timestr(timediff($t1, $t0), 'auto', '5.4f'), "\n"; }
        # process return status values
        if (defined $css)
        {
                # by default we just print to standard out
                unless (defined $output_file) { print $css; }
                # or if output_file is defined via options we write it there
                else { write_file($output_file, $css ); }
        }
        elsif (defined $err) { $error->($err); }
        else { $error->("fatal error - aborting"); }
        # output source-map
        if ($source_map_file)
        {
                my $smap = $stats->{'source_map_string'};
                unless ($smap) { $error->("source-map not generated <$source_map_file>") }
                else { write_file($source_map_file, $smap ); }
        }
        # return according to expected return type
        return wantarray ? ($css, $err, $stats) : $css;
}
####################################################################################################
# main program execution
####################################################################################################
my ($css, $err, $stats) = compile();
if ($watchdog)
{
        local $error = sub { warn @_ };
        start_watchdog($stats, \&compile);
}
####################################################################################################
####################################################################################################
__END__
HideShow 54 lines of Pod
=head1 NAME
psass - perl sass (scss) compiler
=head1 SYNOPSIS
psass [options] [ path_in | - ] [ path_out | - ]
 Options:
   -v, --version                 print version
   -h, --help                    print this help
   -w, --watch                   start watchdog mode
   -p, --precision=int           precision for float output
       --indent=string           set indent string used for output
       --linefeed=type           linefeed used for output [auto|unix|win|none]
   -o, --output-file=file        output file to write result to
   -t, --output-style=style      output style [expanded|nested|compressed|compact]
   -P, --plugin-path=path        plugin load path (repeatable)
   -I, --include-path=path       sass include path (repeatable)
   -c, --source-comments         enable source debug comments
   -l, --line-comments           synonym for --source-comments
       --line-numbers            synonym for --source-comments
   -e, --source-map-embed        embed source-map in mapping url
   -s, --source-map-contents     include original contents
   -m, --source-map-file=file    create and write source-map to file
       --source-map-file-urls    create file urls for source paths
       --source-map-root=.       specific root for relative paths
       --no-source-map-url       omit sourceMappingUrl from output
       --benchmark               print benchmark for compilation time
   Plugins may be pre-installed by CSS::Sass or from 3rd parties.
   There are some options available for each known plugin.
       --all-plugins             enables all known plugins
       --list-plugin             print list of all known plugins
       --[name]-plugin           enables the plugin with [name]
       --no-[name]-plugin        disabled the plugin with [name]
=head1 OPTIONS
=over 8
=item B<-help>
Print a brief help message with options and exits.
=back
=head1 DESCRIPTION
B<This program> is a sass (scss) compiler
=cut