commit 093e7390f1399c01f82645c1cd4320b22cb52228 · pyrox.dev/nixpkgs

+72 -67
pkgs/development/interpreters/elixir/generic-builder.nix
···

       1
       1
        
       {

     

       2
       2
       +
         config,

     

       2
       3
        
         lib,

     

       3
       4
        
         stdenv,

     

       4
       5
        
         fetchFromGitHub,

     
···

       57
       58
        
             true

     

       58
       59
        
           else

     

       59
       60
        
             versionOlder (versions.major (getVersion erlang)) maxShiftMajor;

     

       61
       61
       +
         minAssert = versionAtLeast (getVersion erlang) minimumOTPVersion;

     

       62
       62
       +
         bothAssert = minAssert && maxAssert;

     

       60
       63
        
       

     

       61
       64
        
         elixirShebang =

     

       62
       65
        
           if stdenv.hostPlatform.isDarwin then

     
···

       70
       73
        
       

     

       71
       74
        
         erlc_opts = [ "deterministic" ] ++ optionals debugInfo [ "debug_info" ];

     

       72
       75
        
       in

     

       73
       73
       -
       assert assertMsg (versionAtLeast (getVersion erlang) minimumOTPVersion) compatibilityMsg;

     

       74
       74
       -
       assert assertMsg maxAssert compatibilityMsg;

     

       76
       76
       +
       if !config.allowAliases && !bothAssert then

     

       77
       77
       +
         # Don't throw without aliases to not break CI.

     

       78
       78
       +
         null

     

       79
       79
       +
       else

     

       80
       80
       +
         assert assertMsg bothAssert compatibilityMsg;

     

       81
       81
       +
         stdenv.mkDerivation {

     

       82
       82
       +
           pname = "${baseName}";

     

       75
       83
        
       

     

       76
       76
       -
       stdenv.mkDerivation {

     

       77
       77
       -
         pname = "${baseName}";

     

       84
       84
       +
           inherit src version debugInfo;

     

       78
       85
        
       

     

       79
       79
       -
         inherit src version debugInfo;

     

       86
       86
       +
           nativeBuildInputs = [ makeWrapper ];

     

       87
       87
       +
           buildInputs = [ erlang ];

     

       80
       88
        
       

     

       81
       81
       -
         nativeBuildInputs = [ makeWrapper ];

     

       82
       82
       -
         buildInputs = [ erlang ];

     

       89
       89
       +
           env = {

     

       90
       90
       +
             LANG = "C.UTF-8";

     

       91
       91
       +
             LC_TYPE = "C.UTF-8";

     

       92
       92
       +
             DESTDIR = placeholder "out";

     

       93
       93
       +
             PREFIX = "/";

     

       94
       94
       +
             ERL_COMPILER_OPTIONS = "[${concatStringsSep "," erlc_opts}]";

     

       95
       95
       +
           };

     

       83
       96
        
       

     

       84
       84
       -
         env = {

     

       85
       85
       -
           LANG = "C.UTF-8";

     

       86
       86
       -
           LC_TYPE = "C.UTF-8";

     

       87
       87
       -
           DESTDIR = placeholder "out";

     

       88
       88
       -
           PREFIX = "/";

     

       89
       89
       -
           ERL_COMPILER_OPTIONS = "[${concatStringsSep "," erlc_opts}]";

     

       90
       90
       -
         };

     

       97
       97
       +
           preBuild = ''

     

       98
       98
       +
             patchShebangs ${escriptPath} || true

     

       99
       99
       +
           '';

     

       91
       100
        
       

     

       92
       92
       -
         preBuild = ''

     

       93
       93
       -
           patchShebangs ${escriptPath} || true

     

       94
       94
       -
         '';

     

       101
       101
       +
           # copy stdlib source files for LSP access

     

       102
       102
       +
           postInstall = ''

     

       103
       103
       +
             for d in lib/*; do

     

       104
       104
       +
               cp -R "$d/lib" "$out/lib/elixir/$d"

     

       105
       105
       +
             done

     

       106
       106
       +
           '';

     

       95
       107
        
       

     

       96
       96
       -
         # copy stdlib source files for LSP access

     

       97
       97
       -
         postInstall = ''

     

       98
       98
       -
           for d in lib/*; do

     

       99
       99
       -
             cp -R "$d/lib" "$out/lib/elixir/$d"

     

       100
       100
       -
           done

     

       101
       101
       -
         '';

     

       108
       108
       +
           postFixup = ''

     

       109
       109
       +
             # Elixir binaries are shell scripts which run erl. Add some stuff

     

       110
       110
       +
             # to PATH so the scripts can run without problems.

     

       102
       111
        
       

     

       103
       103
       -
         postFixup = ''

     

       104
       104
       -
           # Elixir binaries are shell scripts which run erl. Add some stuff

     

       105
       105
       -
           # to PATH so the scripts can run without problems.

     

       112
       112
       +
             for f in $out/bin/*; do

     

       113
       113
       +
               b=$(basename $f)

     

       114
       114
       +
               if [ "$b" = mix ]; then continue; fi

     

       115
       115
       +
               wrapProgram $f \

     

       116
       116
       +
                 --prefix PATH ":" "${

     

       117
       117
       +
                   lib.makeBinPath [

     

       118
       118
       +
                     erlang

     

       119
       119
       +
                     coreutils

     

       120
       120
       +
                     curl

     

       121
       121
       +
                     bash

     

       122
       122
       +
                   ]

     

       123
       123
       +
                 }"

     

       124
       124
       +
             done

     

       106
       125
        
       

     

       107
       107
       -
           for f in $out/bin/*; do

     

       108
       108
       -
             b=$(basename $f)

     

       109
       109
       -
             if [ "$b" = mix ]; then continue; fi

     

       110
       110
       -
             wrapProgram $f \

     

       111
       111
       -
               --prefix PATH ":" "${

     

       112
       112
       -
                 lib.makeBinPath [

     

       113
       113
       -
                   erlang

     

       114
       114
       -
                   coreutils

     

       115
       115
       -
                   curl

     

       116
       116
       -
                   bash

     

       117
       117
       -
                 ]

     

       118
       118
       -
               }"

     

       119
       119
       -
           done

     

       126
       126
       +
             substituteInPlace $out/bin/mix \

     

       127
       127
       +
               --replace "/usr/bin/env elixir" "${elixirShebang}"

     

       128
       128
       +
           '';

     

       120
       129
        
       

     

       121
       121
       -
           substituteInPlace $out/bin/mix \

     

       122
       122
       -
             --replace "/usr/bin/env elixir" "${elixirShebang}"

     

       123
       123
       -
         '';

     

       130
       130
       +
           passthru.updateScript = nix-update-script {

     

       131
       131
       +
             extraArgs = [

     

       132
       132
       +
               "--version-regex"

     

       133
       133
       +
               "v(${lib.versions.major version}\\.${lib.versions.minor version}\\.[0-9\\-rc.]+)"

     

       134
       134
       +
               "--override-filename"

     

       135
       135
       +
               "pkgs/development/interpreters/elixir/${lib.versions.major version}.${lib.versions.minor version}.nix"

     

       136
       136
       +
             ];

     

       137
       137
       +
           };

     

       124
       138
        
       

     

       125
       125
       -
         passthru.updateScript = nix-update-script {

     

       126
       126
       -
           extraArgs = [

     

       127
       127
       -
             "--version-regex"

     

       128
       128
       -
             "v(${lib.versions.major version}\\.${lib.versions.minor version}\\.[0-9\\-rc.]+)"

     

       129
       129
       -
             "--override-filename"

     

       130
       130
       -
             "pkgs/development/interpreters/elixir/${lib.versions.major version}.${lib.versions.minor version}.nix"

     

       131
       131
       -
           ];

     

       132
       132
       -
         };

     

       139
       139
       +
           pos = builtins.unsafeGetAttrPos "sha256" args;

     

       140
       140
       +
           meta = with lib; {

     

       141
       141
       +
             homepage = "https://elixir-lang.org/";

     

       142
       142
       +
             description = "Functional, meta-programming aware language built on top of the Erlang VM";

     

       133
       143
        
       

     

       134
       134
       -
         pos = builtins.unsafeGetAttrPos "sha256" args;

     

       135
       135
       -
         meta = with lib; {

     

       136
       136
       -
           homepage = "https://elixir-lang.org/";

     

       137
       137
       -
           description = "Functional, meta-programming aware language built on top of the Erlang VM";

     

       138
       138
       -
       

     

       139
       139
       -
           longDescription = ''

     

       140
       140
       -
             Elixir is a functional, meta-programming aware language built on

     

       141
       141
       -
             top of the Erlang VM. It is a dynamic language with flexible

     

       142
       142
       -
             syntax and macro support that leverages Erlang's abilities to

     

       143
       143
       -
             build concurrent, distributed and fault-tolerant applications

     

       144
       144
       -
             with hot code upgrades.

     

       145
       145
       -
           '';

     

       144
       144
       +
             longDescription = ''

     

       145
       145
       +
               Elixir is a functional, meta-programming aware language built on

     

       146
       146
       +
               top of the Erlang VM. It is a dynamic language with flexible

     

       147
       147
       +
               syntax and macro support that leverages Erlang's abilities to

     

       148
       148
       +
               build concurrent, distributed and fault-tolerant applications

     

       149
       149
       +
               with hot code upgrades.

     

       150
       150
       +
             '';

     

       146
       151
        
       

     

       147
       147
       -
           license = licenses.asl20;

     

       148
       148
       -
           platforms = platforms.unix;

     

       149
       149
       -
           teams = [ teams.beam ];

     

       150
       150
       -
         };

     

       151
       151
       -
       }

     

       152
       152
       +
             license = licenses.asl20;

     

       153
       153
       +
             platforms = platforms.unix;

     

       154
       154
       +
             teams = [ teams.beam ];

     

       155
       155
       +
           };

     

       156
       156
       +
         }