NAME
   Inline::Module::LeanDist - Develop your module with Inline but
   distribute lean XS

SYNOPSIS
   In your module (say "Acme::Math::XS::LeanDist"):

       use Inline::Module::LeanDist C => 'DATA';

   This module forwards all its parameters to Inline.

   NOTE: Currently the entire use statement must be on one line! The DATA
   section is generally the best place to put your code (heredocs won't
   work).

   In "Makefile.PL":

       use ExtUtils::MakeMaker;

       use Inline::Module::LeanDist::MakefilePL;

       WriteMakefile(
           NAME => 'Acme::Math::XS::LeanDist',
           OBJECT => '',
           postamble => {
             inline => {
               file => 'lib/Acme/Math/XS/LeanDist.pm',
             },
           },
       );

   NOTE: The "postamble.inline.file" parameter should be the filename of
   your module that is using Inline, and you must have an "OBJECT"
   parameter in the "WriteMakefile" arguments.

DESCRIPTION
   This module is heavily inspired by Inline::Module. I wrote it because I
   wanted to be able to use Inline during development, but ship
   distributions that have no dependencies on it or any other module (for
   example Inline::Filters and its plugins). I wanted to ship distributions
   that were (from the user's perspective) identical to the XS dists I
   would have created by hand (without Inline).

   Essentially, Inline compiles your code as lazily as possible which means
   all compilation dependencies are required at run-time. Inline::Module
   pushes the compilation dependencies back to build time. However,
   Inline::Module::LeanDist goes yet one step futher and pushes back the
   compilation dependencies to distribution creation time (of course the
   normal XS tool-chain dependency is still required).

   The advantage of the Inline::Module approach over Inline is that
   start-up time is faster for your modules since the fairly heavy-weight
   Inline system isn't loaded, and a compiled version of your module is
   always available no matter the state of the current ".inline" directory
   (or which user is running the program, file-system permissions, etc).

   Inline::Module::LeanDist has all of these advantages as well as some
   additional ones: Downloading and installing Inline is not necessary to
   build the distribution. This also goes for any other dependencies (such
   as the "ragel" binary required by Inline::Filters::Ragel).

   With Inline::Module::LeanDist you don't need to worry about updates to
   Inline/Inline::Module/etc breaking your distribution, not that there is
   any more reason to expect "Inline::*" to break than say "MakeMaker" or
   "Test::*". Inline::Module recommends avoiding back-compat problems by
   bundling hundreds of KB of Inline and its dependencies along with every
   distribution. I recommend against that. Fortunately there is a C"bundle
   => 0" option in Inline::Module to stop the bundling. Just add the
   required modules to your distribution's build-time pre-requisites.

   Finally, with Inline::Module::LeanDist you don't need to mess around
   with Inline::Module's awkward "stub" packages.

   On the other hand, Inline::Module will likely work for more ILSMs: this
   module module has only been tested with Inline::C so far. Also, although
   it's a bit subjective, in my opinion Inline::Module is nicer to develop
   with over Inline since it always puts the ".so" files into "blib/" which
   is more "normal" than the ".inline" directory (and of course it's nice
   that running "make" actually, you know, compiles your code).

HOW DOES IT WORK?
   Basically it's all a huge hack. :)

   During development time, the Inline::Module::LeanDist forwards all its
   parameters to Inline so you develop with normal Inline practices.

   However, Inline::Module::LeanDist::MakefilePL modifies "Makefile.PL" so
   that at "make dist" time, it will comment out the "use
   Inline::Module::LeanDist::MakefilePL;" line in "Makefile.PL". It will
   also comment out the "use Inline::Module::LeanDist" line in your module
   and replace it with an XSLoader invocation. Finally, it copies the
   generated ".xs" file from the ".inline" directory into the distribution
   and adds this to the "OBJECT" parameter in "Makefile.PL" (as well as the
   dist's "MANIFEST").

   The consequence of all this hacking is that the created distributions
   are lean, XS-only distributions.

EXAMLES
   Acme::Math::XS::LeanDist - This is a very simple example in the style of
   Acme::Math::XS and co.

   Unicode::Truncate - This is an actually somewhat useful module that
   doubles as a proof of concept for Inline::Module::LeanDist and
   Inline::Filters::Ragel.

BUGS
   It really ought to be possible to have multiple separate files in a
   single dist that use Inline, but this is not yet supported.

   It should support "Build.PL" in addition to "Makefile.PL".

   It should support other ILSMs (C++ at least).

   "make" prints some annoying warning, need to figure out how to insert
   dist actions with MakeMaker:

       Makefile:884: warning: overriding commands for target `distdir'
       Makefile:632: warning: ignoring old commands for target `distdir'

SEE ALSO
   Inline-Module-LeanDist github repo
   <https://github.com/hoytech/Inline-Module-LeanDist>

   Inline::Module

AUTHOR
   Doug Hoyte, "<[email protected]>"

COPYRIGHT & LICENSE
   Copyright 2015 Doug Hoyte.

   This module is licensed under the same terms as perl itself.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.