bookstack: 24.12.1 -> 25.05.1

{

  pkgs,

  stdenv,

  lib,

  fetchFromGitHub,

  php83,

  nixosTests,

  dataDir ? "/var/lib/bookstack",

}:

let

  package =

    (import ./composition.nix {

      inherit pkgs;

      inherit (stdenv.hostPlatform) system;

      noDev = true; # Disable development dependencies

    }).overrideAttrs

      (attrs: {

        installPhase =

          attrs.installPhase

          + ''

            rm -R $out/storage $out/public/uploads

            ln -s ${dataDir}/.env $out/.env

            ln -s ${dataDir}/storage $out/storage

            ln -s ${dataDir}/public/uploads $out/public/uploads

          '';

      });

in

package.override rec {

php83.buildComposerProject2 (finalAttrs: {

  pname = "bookstack";

  version = "24.12.1";

  version = "25.05.1";

  src = fetchFromGitHub {

    owner = "bookstackapp";

    repo = pname;

    rev = "v${version}";

    sha256 = "sha256-uuek56256NCIhvvLYTHgbRBea66SUg+9xnfcOsK5Bo0=";

    repo = "bookstack";

    tag = "v${finalAttrs.version}";

    hash = "sha256-wQ5i9A+uCD9srSuEnTWWgALzlbciPVwfYhy8ZKVsX7E=";

  };

  meta = with lib; {

  vendorHash = "sha256-ApLBU21CrmYVW1lOX1wFTo5UMWUEErWumn8x742iMT0=";

  passthru = {

    phpPackage = php83;

    tests = nixosTests.bookstack;

  };

  postInstall = ''

    chmod -R u+w $out/share

    mv $out/share/php/bookstack/* $out

    rm -R $out/share $out/storage $out/bootstrap/cache $out/public/uploads

    ln -s ${dataDir}/storage $out/storage

    ln -s ${dataDir}/cache $out/bootstrap/cache

    ln -s ${dataDir}/public/uploads $out/public/uploads

  '';

  meta = {

    description = "Platform to create documentation/wiki content built with PHP & Laravel";

    longDescription = ''

      A platform for storing and organising information and documentation.

      Details for BookStack can be found on the official website at https://www.bookstackapp.com/.

    '';

    homepage = "https://www.bookstackapp.com/";

    license = licenses.mit;

    maintainers = with maintainers; [ ymarkus ];

    platforms = platforms.linux;

    license = lib.licenses.mit;

    maintainers = with lib.maintainers; [

      ymarkus

      savyajha

    ];

    platforms = lib.platforms.linux;

  };

}

})

# This file originates from composer2nix

{

  stdenv,

  lib,

  writeTextFile,

  fetchurl,

  php,

  unzip,

  phpPackages,

}:

let

  inherit (phpPackages) composer;

  filterSrc =

    src:

    builtins.filterSource (

      path: type:

      type != "directory"

      || (baseNameOf path != ".git" && baseNameOf path != ".git" && baseNameOf path != ".svn")

    ) src;

  buildZipPackage =

    { name, src }:

    stdenv.mkDerivation {

      inherit name src;

      nativeBuildInputs = [ unzip ];

      buildCommand = ''

        shopt -s dotglob

        unzip $src

        baseDir=$(find . -type d -mindepth 1 -maxdepth 1)

        cd $baseDir

        mkdir -p $out

        mv * $out

      '';

    };

  buildPackage =

    {

      name,

      src,

      packages ? { },

      devPackages ? { },

      buildInputs ? [ ],

      symlinkDependencies ? false,

      executable ? false,

      removeComposerArtifacts ? false,

      postInstall ? "",

      noDev ? false,

      composerExtraArgs ? "",

      unpackPhase ? "true",

      buildPhase ? "true",

      ...

    }@args:

    let

      reconstructInstalled = writeTextFile {

        name = "reconstructinstalled.php";

        executable = true;

        text = ''

          #! ${php}/bin/php

          <?php

          if(file_exists($argv[1]))

          {

              $composerLockStr = file_get_contents($argv[1]);

              if($composerLockStr === false)

              {

                  fwrite(STDERR, "Cannot open composer.lock contents\n");

                  exit(1);

              }

              else

              {

                  $config = json_decode($composerLockStr, true);

                  if(array_key_exists("packages", $config))

                      $allPackages = $config["packages"];

                  else

                      $allPackages = array();

                  ${lib.optionalString (!noDev) ''

                    if(array_key_exists("packages-dev", $config))

                        $allPackages = array_merge($allPackages, $config["packages-dev"]);

                  ''}

                  $packagesStr = json_encode($allPackages, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);

                  print($packagesStr);

              }

          }

          else

              print("[]");

          ?>

        '';

      };

      constructBin = writeTextFile {

        name = "constructbin.php";

        executable = true;

        text = ''

          #! ${php}/bin/php

          <?php

          $composerJSONStr = file_get_contents($argv[1]);

          if($composerJSONStr === false)

          {

              fwrite(STDERR, "Cannot open composer.json contents\n");

              exit(1);

          }

          else

          {

              $config = json_decode($composerJSONStr, true);

              if(array_key_exists("bin-dir", $config))

                  $binDir = $config["bin-dir"];

              else

                  $binDir = "bin";

              if(array_key_exists("bin", $config))

              {

                  if(!file_exists("vendor/".$binDir))

                      mkdir("vendor/".$binDir);

                  foreach($config["bin"] as $bin)

                      symlink("../../".$bin, "vendor/".$binDir."/".basename($bin));

              }

          }

          ?>

        '';

      };

      bundleDependencies =

        dependencies:

        lib.concatMapStrings (

          dependencyName:

          let

            dependency = dependencies.${dependencyName};

          in

          ''

            ${

              if dependency.targetDir == "" then

                ''

                  vendorDir="$(dirname ${dependencyName})"

                  mkdir -p "$vendorDir"

                  ${

                    if symlinkDependencies then

                      ''ln -s "${dependency.src}" "$vendorDir/$(basename "${dependencyName}")"''

                    else

                      ''cp -av "${dependency.src}" "$vendorDir/$(basename "${dependencyName}")"''

                  }

                ''

              else

                ''

                  namespaceDir="${dependencyName}/$(dirname "${dependency.targetDir}")"

                  mkdir -p "$namespaceDir"

                  ${

                    if symlinkDependencies then

                      ''ln -s "${dependency.src}" "$namespaceDir/$(basename "${dependency.targetDir}")"''

                    else

                      ''cp -av "${dependency.src}" "$namespaceDir/$(basename "${dependency.targetDir}")"''

                  }

                ''

            }

          ''

        ) (builtins.attrNames dependencies);

      extraArgs = removeAttrs args [

        "packages"

        "devPackages"

        "buildInputs"

      ];

    in

    stdenv.mkDerivation (

      {

        buildInputs = [

          php

          composer

        ] ++ buildInputs;

        inherit unpackPhase buildPhase;

        installPhase = ''

          ${

            if executable then

              ''

                mkdir -p $out/share/php

                cp -av $src $out/share/php/$name

                chmod -R u+w $out/share/php/$name

                cd $out/share/php/$name

              ''

            else

              ''

                cp -av $src $out

                chmod -R u+w $out

                cd $out

              ''

          }

          # Remove unwanted files

          rm -f *.nix

          export HOME=$TMPDIR

          # Remove the provided vendor folder if it exists

          rm -Rf vendor

          # If there is no composer.lock file, compose a dummy file.

          # Otherwise, composer attempts to download the package.json file from

          # the registry which we do not want.

          if [ ! -f composer.lock ]

          then

              cat > composer.lock <<EOF

          {

              "packages": []

          }

          EOF

          fi

          # Reconstruct the installed.json file from the lock file

          mkdir -p vendor/composer

          ${php}/bin/php ${reconstructInstalled} composer.lock > vendor/composer/installed.json

          # Copy or symlink the provided dependencies

          cd vendor

          ${bundleDependencies packages}

          ${lib.optionalString (!noDev) (bundleDependencies devPackages)}

          cd ..

          # Reconstruct autoload scripts

          # We use the optimize feature because Nix packages cannot change after they have been built

          # Using the dynamic loader for a Nix package is useless since there is nothing to dynamically reload.

          composer dump-autoload --optimize ${lib.optionalString noDev "--no-dev"} ${composerExtraArgs}

          # Run the install step as a validation to confirm that everything works out as expected

          composer install --optimize-autoloader ${lib.optionalString noDev "--no-dev"} ${composerExtraArgs}

          ${lib.optionalString executable ''

            # Reconstruct the bin/ folder if we deploy an executable project

            ${php}/bin/php ${constructBin} composer.json

            ln -s $(pwd)/vendor/bin $out/bin

          ''}

          ${lib.optionalString (!symlinkDependencies) ''

            # Patch the shebangs if possible

            if [ -d $(pwd)/vendor/bin ]

            then

                # Look for all executables in bin/

                for i in $(pwd)/vendor/bin/*

                do

                    # Look for their location

                    realFile=$(readlink -f "$i")

                    # Restore write permissions

                    chmod u+wx "$(dirname "$realFile")"

                    chmod u+w "$realFile"

                    # Patch shebang

                    sed -e "s|#!/usr/bin/php|#!${php}/bin/php|" \

                        -e "s|#!/usr/bin/env php|#!${php}/bin/php|" \

                        "$realFile" > tmp

                    mv tmp "$realFile"

                    chmod u+x "$realFile"

                done

            fi

          ''}

          if [ "$removeComposerArtifacts" = "1" ]

          then

              # Remove composer stuff

              rm -f composer.json composer.lock

          fi

          # Execute post install hook

          runHook postInstall

        '';

      }

      // extraArgs

    );

in

{

  inherit filterSrc;

  composer = lib.makeOverridable composer;

  buildZipPackage = lib.makeOverridable buildZipPackage;

  buildPackage = lib.makeOverridable buildPackage;

}

{

  pkgs ? import <nixpkgs> { inherit system; },

  system ? builtins.currentSystem,

  noDev ? false,

  php ? pkgs.php,

  phpPackages ? pkgs.phpPackages,

}:

let

  composerEnv = import ./composer-env.nix {

    inherit (pkgs)

      stdenv

      lib

      writeTextFile

      fetchurl

      unzip

      ;

    inherit php phpPackages;

  };

in

import ./php-packages.nix {

  inherit composerEnv noDev;

  inherit (pkgs)

    fetchurl

    fetchgit

    fetchhg

    fetchsvn

    ;

}

#!/usr/bin/env nix-shell

#! nix-shell -i bash -p nix curl jq nix-update

# check if composer2nix is installed

if ! command -v composer2nix &> /dev/null; then

  echo "Please install composer2nix (https://github.com/svanderburg/composer2nix) to run this script."

  exit 1

fi

CURRENT_VERSION=$(nix eval -f ../../../.. --raw bookstack.version)

TARGET_VERSION_REMOTE=$(curl https://api.github.com/repos/bookstackapp/bookstack/releases/latest | jq -r ".tag_name")

TARGET_VERSION=${TARGET_VERSION_REMOTE:1}

BOOKSTACK=https://github.com/bookstackapp/bookstack/raw/$TARGET_VERSION_REMOTE

SHA256=$(nix-prefetch-url --unpack "https://github.com/bookstackapp/bookstack/archive/v$TARGET_VERSION/bookstack.tar.gz")

if [[ "$CURRENT_VERSION" == "$TARGET_VERSION" ]]; then

  echo "bookstack is up-to-date: ${CURRENT_VERSION}"

  exit 0

fi

curl -LO "$BOOKSTACK/composer.json"

curl -LO "$BOOKSTACK/composer.lock"

composer2nix --name "bookstack" \

  --composition=composition.nix \

  --no-dev

rm composer.json composer.lock

# change version number

sed -e "s/version =.*;/version = \"$TARGET_VERSION\";/g" \

    -e "s/sha256 =.*;/sha256 = \"$SHA256\";/g" \

    -i ./default.nix

# fix composer-env.nix

sed -e "s/stdenv\.lib/lib/g" \

    -e '3s/stdenv, writeTextFile/stdenv, lib, writeTextFile/' \

    -i ./composer-env.nix

# fix composition.nix

sed -e '7s/stdenv writeTextFile/stdenv lib writeTextFile/' \

    -i composition.nix

# fix missing newline

echo "" >> composition.nix

echo "" >> php-packages.nix

cd ../../../..

nix-build -A bookstack

exit $?