Metadata-Version: 1.1
Name: collective.recipe.nix
Version: 0.15.1
Summary: Buildout recipe for creating Nix expressions from eggs list
Home-page: https://github.com/datakurre/collective.recipe.nix/
Author: Asko Soukka
Author-email: asko.soukka@iki.fi
License: GPL
Description: collective.recipe.nix
        =====================
        
        This is an experimental buildout recipe for creating nix expression from
        a buildout eggs list. This is work in progress. Please, contribute_.
        
        .. _contribute: https://github.com/datakurre/collective.recipe.nix
        
        The minimal buildout part should include ``recipe`` and ``eggs``:
        
        .. code:: ini
        
           [releaser]
           recipe = collective.recipe.nix
           eggs = zest.releaser[recommended]
        
        The recipe generates three kind of expressions:
        
        * mkDerivation based [name].nix usable with nix-shell and nix-build
        * buildEnv based [name]-env.nix usable with nix-build
        * buildPythonPackage based [name]-[package].nix usable with nix-env -i -f
        
        **Note:** For large projects like Plone, it's recommended to use a local
        mirrored package ``index`` / ``find-links`` to avoid connection issues when
        recipe is resolving each package fetchurl information. Possible remedies
        include setting ``allow-from-cache`` to ``true`` to allow recipe to use
        configured buildout download cache (and create ``file://`` urls), or just
        running the buildout again with help of recipe created cumulative cache
        (``[~/][.]collective.recipe.nix.cfg``).
        
        
        Recipe options
        --------------
        
        **eggs**
          list of packages to generate expressions for
        
        **name**
          string to define the used based filename in generated outputs (defaults to
          part name)
        
        **version**
          version string write into mkDerivation based expression (defaults to 1.0.0)
        
        **prefix**
          string to set prefix (or path) for generated outputs (defaults to working
          directory)
        
        **parts**
          list of existing buildout sections to install in mkDerivation based expression
          (defaults to all but the current section)
        
        **outputs**
          list of full generated expression filenames to filter outputs to be generated
          (defaults to nothing to generate all)
        
        **allow-from-cache**
          boolean (``true``) to allow generated expression to use package  from
          buildout download cache (defaults to ``false``)
        
        **build-inputs**
          list of additional build-inputs from nixpkgs for generated expressions (to be
          available in nix-shell environment) or list of ``package=nixpkgsPackage``
          mappings to inject build-inputs for each package's
          ``buildPythonPackage``-expression
        
        **propagated-build-inputs**
          list of ``package=other.package`` mappings to inject additional
          requirements for packages (usually to enable some additional features)
        
        **nixpkgs**
          list of ``package=pythonPackages.package`` mappings to use existing packages
          from nixpkgs instead of generating custom ``buildPythonPackage`` (useful with
          package like Pillow, which need additional care to get built properly)
        
        **urls**
          list of ``package=url#md5=hash`` mappings to explicitly define package
          download URL and MD5 checksum for cases where the recipe fails to resolve
          it automatically
        
        `See the project repository for configuration examples.`__
        
        __ https://github.com/datakurre/collective.recipe.nix/tree/master/examples
        
        
        Example of generic use
        ----------------------
        
        At first, define ``./default.nix`` with buildout::
        
            with import <nixpkgs> {}; {
              myEnv = stdenv.mkDerivation {
                name = "myEnv";
                buildInputs = [
                  libxml2
                  libxslt
                  pythonPackages.ldap
                  pythonPackages.pillow
                  pythonPackages.readline
                  pythonPackages.zc_buildout_nix
                ];
                shellHook = ''
                  export SSL_CERT_FILE=~/.nix-profile/etc/ca-bundle.crt
                '';
              };
            }
        
        And example ``./buildout.cfg``:
        
        .. code:: cfg
        
            [buildout]
            parts = releaser
        
            [releaser]
            recipe = collective.recipe.nix
            eggs = zest.releaser[recommended]
        
        Run the buildout:
        
        .. code:: bash
        
           $ nix-shell --run buildout-nix
        
        Now you should be able to run zest.releaser with recommended plugins with:
        
        .. code:: bash
        
           $ nix-shell releaser.nix --run fullrelease
        
        Or install zest.releaser into your current Nix profile with:
        
        .. code:: bash
        
           $ nix-env -i -f releaser-zest_releaser.nix
        
        `See the project repository for more configuration examples.`__
        
        __ https://github.com/datakurre/collective.recipe.nix/tree/master/examples
        
        
        Example of building Plone
        -------------------------
        
        Together with nixpkgs optimized buildout version (available in nixpkgs), this
        recipe can be used to build a Nix derivation using buildout install as in Nix
        derivation builder (see the generated mkDerivation based expression for
        current example implementation):
        
        .. code:: ini
        
           [buildout]
           extends = https://dist.plone.org/release/4-latest/versions.cfg
           parts = plone
           versions = versions
        
           [instance]
           recipe = plone.recipe.zope2instance
           eggs =
               Plone
               plone.app.ldap
           user = admin:admin
           var = /tmp
        
           [plone]
           recipe = collective.recipe.nix
           parts = instance
           eggs = ${instance:eggs}
           outputs = plone.nix
        
           [versions]
           zc.buildout =
           setuptools =
           Pillow =
        
        .. code:: bash
        
           $ nix-shell --run "buildout-nix plone:allow-from-cache=true"
           $ nix-build plone.nix
           $ results/bin/instance fg
        
        **Note:** Currently buildout extends are not cached into Nix expression making
        the expression not completely pure.
        
        
        Changelog
        =========
        
        0.15.1 (2015-07-25)
        -------------------
        
        - Cleanup generated expression
          [datakurre]
        
        0.15.0 (2015-07-25)
        -------------------
        
        - Fix to cache resolved fetchurl details between builds into
          [~/][.]collective.recipe.nix.cfg to ease creating expressions for
          large projects
          [datakurre]
        - Add support for Python 3
          [datakurre]
        
        0.14.1 (2015-07-24)
        -------------------
        
        - Fix issue where buildout provided propagatedBuildInputs were not always included
          [datakurre]
        
        0.14.0 (2015-07-24)
        -------------------
        
        - Remove default nixpkgs mapping for lxml to allow custom lxml versions by
          default
          [datakurre]
        
        0.13.2 (2015-07-24)
        -------------------
        
        - Fix regression where Nix-installed packages where thought to be developed
          packages
          [datakurre]
        
        0.13.1 (2015-07-23)
        -------------------
        
        - Fix issue where generated expression was missing $src
          [datakurre]
        
        0.13.0 (2015-07-23)
        -------------------
        
        - Fix to exclude developed packages from created expressions
          [datakurre]
        - Add zc.buildout -> zc_buildout_nix to default nixpkgs mapping
          [datakurre]
        
        0.12.1 (2015-07-23)
        -------------------
        
        - Cleanup generated [name].nix expression
          [datakurre]
        
        0.12.0 (2015-07-23)
        -------------------
        
        - Add support for installing the configured buildout with nix
          in the generated [name].nix expression
          [datakurre]
        
        0.11.0 (2015-07-23)
        -------------------
        
        - Change package lookup to use setuptools package index
          [datakurre]
        - Add allow-from-cache option to distributions from from download-cache
          [datakurre]
        - Add prefix option to control output paths
          [datakurre]
        - Add outputs option to filter generated outputs
          [datakurre]
        - Fix issue where nixpkgs mapping lookup failed because of non-normalize
          preconfigured mappings
          [datakurre]
        
        0.10.1 (2015-07-23)
        -------------------
        
        - Fix typo
          [datakurre]
        
        0.10.0 (2015-07-22)
        -------------------
        
        - Fix issue where nixpkgs mappings lookup failed because of non-normalized
          lookup
          [datakurre]
        - Add support for name option to change the base name for created expressions
          [datakurre]
        
        0.9.3 (2015-07-22)
        ------------------
        
        - Fix a few more issues where package was not found at PyPI
          [datakurre]
        
        0.9.2 (2015-07-12)
        ------------------
        
        - Fix a few issues where package was not found at PyPI
          [datakurre]
        
        0.9.1 (2015-07-11)
        ------------------
        
        - Fix issue where package requirement in wrong case caused error
        - Fix issue where buildout propagated-build-inputs did not support
          cyclic requirements (required for injecting 'add-on' packages)
          [datakurre]
        
        0.9.0 (2015-07-10)
        ------------------
        
        - Refactor to handle properly setuptools requires extras
          [datakurre]
        
        0.8.0 (2015-07-10)
        ------------------
        
        - Add support for comma separated list for inline build-inputs,
          propagated-build-inputs and nixpkgs
          [datakurre]
        
        0.7.0 (2015-07-10)
        ------------------
        
        - Add option to inject propagatedBuildInputs to enable extra package-dependent
          additional features
          [datakurre]
        
        0.6.0 (2015-07-10)
        ------------------
        
        - Add to create installable python package expression for each listed egg
          [datakurre]
        
        0.5.0 (2015-07-09)
        ------------------
        
        - Fix to resolve cyclic dependencies by letting the first seen dependency win
          and persist into resulting expression
          [datakurre]
        
        0.4.0 (2015-07-09)
        ------------------
        
        - Change to produce {name}-env.nix instead of {name}.env.nix as buildable
          derivations
          [datakurre]
        
        0.3.0 (2015-07-08)
        ------------------
        
        - Change resulting derivation to be buildEnv with python.buildEnv to make it
          also nix-buildable
          [datakurre]
        
        0.2.0 (2015-07-08)
        ------------------
        
        - Add buildout-based configuration
          [datakurre]
        - Back to development: 0.1.2
          [datakurre]
        
        0.1.1 (2015-07-08)
        ------------------
        
        - Add support for plone.app.ldap
          [datakurre]
        
        0.1.0 (2015-07-08)
        ------------------
        
        - Proof of concept release.
        
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Framework :: Buildout :: Recipe
Classifier: Framework :: Buildout
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python
