commit 26ac257e4fecc050f28da30399afdfee83d98836 · pyrox.dev/nixpkgs

+1 -1

doc/functions.xml

···

       10
       10
        
        <xi:include href="functions/generators.xml" />

     

       11
       11
        
        <xi:include href="functions/debug.xml" />

     

       12
       12
        
        <xi:include href="functions/prefer-remote-fetch.xml" />

     

       13
       13
       -
        <xi:include href="functions/nix-gitignore.xml" />

     

       13
       13
       +
        <xi:include href="functions/nix-gitignore.section.xml" />

     

       14
       14
        
       </chapter>

+49

doc/functions/nix-gitignore.section.md

···

       1
       1
       +
       # pkgs.nix-gitignore {#sec-pkgs-nix-gitignore}

     

       2
       2
       +
       

     

       3
       3
       +
       `pkgs.nix-gitignore` is a function that acts similarly to `builtins.filterSource` but also allows filtering with the help of the gitignore format.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Usage {#sec-pkgs-nix-gitignore-usage}

     

       6
       6
       +
       

     

       7
       7
       +
       `pkgs.nix-gitignore` exports a number of functions, but you\'ll most likely need either `gitignoreSource` or `gitignoreSourcePure`. As their first argument, they both accept either 1. a file with gitignore lines or 2. a string with gitignore lines, or 3. a list of either of the two. They will be concatenated into a single big string.

     

       8
       8
       +
       

     

       9
       9
       +
       ```nix

     

       10
       10
       +
       { pkgs ? import <nixpkgs> {} }:

     

       11
       11
       +
       

     

       12
       12
       +
        nix-gitignore.gitignoreSource [] ./source

     

       13
       13
       +
            # Simplest version

     

       14
       14
       +
       

     

       15
       15
       +
        nix-gitignore.gitignoreSource "supplemental-ignores\n" ./source

     

       16
       16
       +
            # This one reads the ./source/.gitignore and concats the auxiliary ignores

     

       17
       17
       +
       

     

       18
       18
       +
        nix-gitignore.gitignoreSourcePure "ignore-this\nignore-that\n" ./source

     

       19
       19
       +
            # Use this string as gitignore, don't read ./source/.gitignore.

     

       20
       20
       +
       

     

       21
       21
       +
        nix-gitignore.gitignoreSourcePure ["ignore-this\nignore-that\n", ~/.gitignore] ./source

     

       22
       22
       +
            # It also accepts a list (of strings and paths) that will be concatenated

     

       23
       23
       +
            # once the paths are turned to strings via readFile.

     

       24
       24
       +
       ```

     

       25
       25
       +
       

     

       26
       26
       +
       These functions are derived from the `Filter` functions by setting the first filter argument to `(_: _: true)`:

     

       27
       27
       +
       

     

       28
       28
       +
       ```nix

     

       29
       29
       +
       gitignoreSourcePure = gitignoreFilterSourcePure (_: _: true);

     

       30
       30
       +
       gitignoreSource = gitignoreFilterSource (_: _: true);

     

       31
       31
       +
       ```

     

       32
       32
       +
       

     

       33
       33
       +
       Those filter functions accept the same arguments the `builtins.filterSource` function would pass to its filters, thus `fn: gitignoreFilterSourcePure fn ""` should be extensionally equivalent to `filterSource`. The file is blacklisted if it\'s blacklisted by either your filter or the gitignoreFilter.

     

       34
       34
       +
       

     

       35
       35
       +
       If you want to make your own filter from scratch, you may use

     

       36
       36
       +
       

     

       37
       37
       +
       ```nix

     

       38
       38
       +
       gitignoreFilter = ign: root: filterPattern (gitignoreToPatterns ign) root;

     

       39
       39
       +
       ```

     

       40
       40
       +
       

     

       41
       41
       +
       ## gitignore files in subdirectories {#sec-pkgs-nix-gitignore-usage-recursive}

     

       42
       42
       +
       

     

       43
       43
       +
       If you wish to use a filter that would search for .gitignore files in subdirectories, just like git does by default, use this function:

     

       44
       44
       +
       

     

       45
       45
       +
       ```nix

     

       46
       46
       +
       gitignoreFilterRecursiveSource = filter: patterns: root:

     

       47
       47
       +
       # OR

     

       48
       48
       +
       gitignoreRecursiveSource = gitignoreFilterSourcePure (_: _: true);

     

       49
       49
       +
       ```

-70

doc/functions/nix-gitignore.xml

···

       1
       1
       -
       <section xmlns="http://docbook.org/ns/docbook"

     

       2
       2
       -
                xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       3
       -
                xmlns:xi="http://www.w3.org/2001/XInclude"

     

       4
       4
       -
                xml:id="sec-pkgs-nix-gitignore">

     

       5
       5
       -
        <title>pkgs.nix-gitignore</title>

     

       6
       6
       -
       

     

       7
       7
       -
        <para>

     

       8
       8
       -
         <function>pkgs.nix-gitignore</function> is a function that acts similarly to <literal>builtins.filterSource</literal> but also allows filtering with the help of the gitignore format.

     

       9
       9
       -
        </para>

     

       10
       10
       -
       

     

       11
       11
       -
        <section xml:id="sec-pkgs-nix-gitignore-usage">

     

       12
       12
       -
         <title>Usage</title>

     

       13
       13
       -
       

     

       14
       14
       -
         <para>

     

       15
       15
       -
          <literal>pkgs.nix-gitignore</literal> exports a number of functions, but you'll most likely need either <literal>gitignoreSource</literal> or <literal>gitignoreSourcePure</literal>. As their first argument, they both accept either 1. a file with gitignore lines or 2. a string with gitignore lines, or 3. a list of either of the two. They will be concatenated into a single big string.

     

       16
       16
       -
         </para>

     

       17
       17
       -
       

     

       18
       18
       -
       <programlisting><![CDATA[

     

       19
       19
       -
       { pkgs ? import <nixpkgs> {} }:

     

       20
       20
       -
       

     

       21
       21
       -
        nix-gitignore.gitignoreSource [] ./source

     

       22
       22
       -
            # Simplest version

     

       23
       23
       -
       

     

       24
       24
       -
        nix-gitignore.gitignoreSource "supplemental-ignores\n" ./source

     

       25
       25
       -
            # This one reads the ./source/.gitignore and concats the auxiliary ignores

     

       26
       26
       -
       

     

       27
       27
       -
        nix-gitignore.gitignoreSourcePure "ignore-this\nignore-that\n" ./source

     

       28
       28
       -
            # Use this string as gitignore, don't read ./source/.gitignore.

     

       29
       29
       -
       

     

       30
       30
       -
        nix-gitignore.gitignoreSourcePure ["ignore-this\nignore-that\n", ~/.gitignore] ./source

     

       31
       31
       -
            # It also accepts a list (of strings and paths) that will be concatenated

     

       32
       32
       -
            # once the paths are turned to strings via readFile.

     

       33
       33
       -
         ]]></programlisting>

     

       34
       34
       -
       

     

       35
       35
       -
         <para>

     

       36
       36
       -
          These functions are derived from the <literal>Filter</literal> functions by setting the first filter argument to <literal>(_: _: true)</literal>:

     

       37
       37
       -
         </para>

     

       38
       38
       -
       

     

       39
       39
       -
       <programlisting><![CDATA[

     

       40
       40
       -
       gitignoreSourcePure = gitignoreFilterSourcePure (_: _: true);

     

       41
       41
       -
       gitignoreSource = gitignoreFilterSource (_: _: true);

     

       42
       42
       -
         ]]></programlisting>

     

       43
       43
       -
       

     

       44
       44
       -
         <para>

     

       45
       45
       -
          Those filter functions accept the same arguments the <literal>builtins.filterSource</literal> function would pass to its filters, thus <literal>fn: gitignoreFilterSourcePure fn ""</literal> should be extensionally equivalent to <literal>filterSource</literal>. The file is blacklisted iff it's blacklisted by either your filter or the gitignoreFilter.

     

       46
       46
       -
         </para>

     

       47
       47
       -
       

     

       48
       48
       -
         <para>

     

       49
       49
       -
          If you want to make your own filter from scratch, you may use

     

       50
       50
       -
         </para>

     

       51
       51
       -
       

     

       52
       52
       -
       <programlisting><![CDATA[

     

       53
       53
       -
       gitignoreFilter = ign: root: filterPattern (gitignoreToPatterns ign) root;

     

       54
       54
       -
         ]]></programlisting>

     

       55
       55
       -
        </section>

     

       56
       56
       -
       

     

       57
       57
       -
        <section xml:id="sec-pkgs-nix-gitignore-usage-recursive">

     

       58
       58
       -
         <title>gitignore files in subdirectories</title>

     

       59
       59
       -
       

     

       60
       60
       -
         <para>

     

       61
       61
       -
          If you wish to use a filter that would search for .gitignore files in subdirectories, just like git does by default, use this function:

     

       62
       62
       -
         </para>

     

       63
       63
       -
       

     

       64
       64
       -
       <programlisting><![CDATA[

     

       65
       65
       -
       gitignoreFilterRecursiveSource = filter: patterns: root:

     

       66
       66
       -
       # OR

     

       67
       67
       -
       gitignoreRecursiveSource = gitignoreFilterSourcePure (_: _: true);

     

       68
       68
       -
         ]]></programlisting>

     

       69
       69
       -
        </section>

     

       70
       70
       -
       </section>