nixpkgs/pkgs/development/ruby-modules/gem-config/default.nix

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1193 lines
28 KiB
Nix
Raw Normal View History

# The standard set of gems in nixpkgs including potential fixes.
#
# The gemset is derived from two points of entry:
# - An attrset describing a gem, including version, source and dependencies
# This is just meta data, most probably automatically generated by a tool
# like Bundix (https://github.com/aflatter/bundix).
# {
# name = "bundler";
# version = "1.6.5";
# sha256 = "1s4x0f5by9xs2y24jk6krq5ky7ffkzmxgr4z1nhdykdmpsi2zd0l";
# dependencies = [ "rake" ];
# }
# - An optional derivation that may override how the gem is built. For popular
# gems that don't behave correctly, fixes are already provided in the form of
# derivations.
#
2022-12-17 19:39:44 -05:00
# This separates "what to build" (the exact gem versions) from "how to build"
# (to make gems behave if necessary).
{
lib,
fetchurl,
fetchpatch,
fetchpatch2,
writeScript,
ruby,
libkrb5,
libxml2,
libxslt,
python2,
stdenv,
which,
2024-11-23 23:36:23 +01:00
libiconv,
libpq,
nodejs,
clang,
sqlite,
zlib,
imagemagick,
lasem,
pkg-config,
ncurses,
xapian,
gpgme,
util-linux,
tzdata,
icu,
libffi,
cmake,
libssh2,
openssl,
openssl_1_1,
libmysqlclient,
git,
perl,
pcre2,
gecode_3,
curl,
libsodium,
snappy,
libossp_uuid,
lxc,
libpcap,
xorg,
gtk3,
lerc,
buildRubyGem,
cairo,
expat,
re2,
rake,
gobject-introspection,
gdk-pixbuf,
zeromq,
czmq,
graphicsmagick,
libcxx,
file,
libvirt,
glib,
vips,
taglib,
libopus,
linux-pam,
libidn,
protobuf,
fribidi,
harfbuzz,
bison,
flex,
pango,
python3,
patchelf,
binutils,
freetds,
wrapGAppsHook3,
atk,
bundler,
libsass,
dart-sass,
libexif,
libselinux,
libsepol,
shared-mime-info,
libthai,
libdatrie,
CoreServices,
DarwinTools,
cctools,
libtool,
discount,
exiv2,
libepoxy,
libxkbcommon,
libmaxminddb,
libyaml,
cargo,
rustc,
rustPlatform,
libsysprof-capture,
imlib2,
autoSignDarwinBinariesHook,
2016-09-21 14:29:12 +02:00
}@args:
let
rainbow_rake = buildRubyGem {
pname = "rake";
gemName = "rake";
source.sha256 = "01j8fc9bqjnrsxbppncai05h43315vmz9fwg28qdsgcjw9ck1d7n";
type = "gem";
version = "12.0.0";
};
2014-10-28 04:16:14 +00:00
in
2014-10-28 04:16:14 +00:00
{
2022-08-08 19:36:27 +00:00
ZenTest = attrs: {
meta.mainProgram = "zentest";
};
atk = attrs: {
dependencies = attrs.dependencies ++ [ "gobject-introspection" ];
2021-04-18 02:17:13 +09:00
nativeBuildInputs = [
rake
bundler
pkg-config
] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
propagatedBuildInputs = [
gobject-introspection
wrapGAppsHook3
atk
];
};
2017-05-18 09:47:45 +09:00
bundler =
attrs:
let
templates = "${attrs.ruby.gemPath}/gems/${attrs.gemName}-${attrs.version}/lib/bundler/templates/";
in
{
# patching shebangs would fail on the templates/Executable file, so we
# temporarily remove the executable flag.
preFixup = "chmod -x $out/${templates}/Executable";
postFixup = ''
chmod +x $out/${templates}/Executable
# Allows to load another bundler version
sed -i -e "s/activate_bin_path/bin_path/g" $out/bin/bundle
'';
};
2017-05-18 09:47:45 +09:00
cairo = attrs: {
2021-04-18 02:17:13 +09:00
nativeBuildInputs = [ pkg-config ] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
buildInputs = [
cairo
expat
glib
libsysprof-capture
pcre2
xorg.libpthreadstubs
xorg.libXdmcp
];
2017-05-18 09:47:45 +09:00
};
2017-10-31 13:33:52 +09:00
cairo-gobject = attrs: {
2021-04-18 02:17:13 +09:00
nativeBuildInputs = [ pkg-config ] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
buildInputs = [
cairo
expat
libsysprof-capture
pcre2
xorg.libpthreadstubs
xorg.libXdmcp
];
2017-10-31 13:33:52 +09:00
};
2015-01-25 16:01:48 -05:00
charlock_holmes = attrs: {
2015-04-15 19:24:04 -04:00
buildInputs = [
which
icu
zlib
];
2015-01-25 16:01:48 -05:00
};
2017-10-31 13:33:52 +09:00
2019-05-02 02:37:35 +02:00
cld3 = attrs: {
nativeBuildInputs = [ pkg-config ];
2019-05-02 02:37:35 +02:00
buildInputs = [ protobuf ];
};
cocoapods-acknowledgements = attrs: {
dependencies = attrs.dependencies ++ [ "cocoapods" ];
};
cocoapods-deploy = attrs: {
dependencies = [ "cocoapods" ];
};
cocoapods-disable-podfile-validations = attrs: {
dependencies = [ "cocoapods" ];
};
cocoapods-generate = attrs: {
dependencies = attrs.dependencies ++ [ "cocoapods" ];
};
cocoapods-git_url_rewriter = attrs: {
dependencies = [ "cocoapods" ];
};
cocoapods-keys = attrs: {
dependencies = attrs.dependencies ++ [ "cocoapods" ];
};
cocoapods-open = attrs: {
dependencies = [ "cocoapods" ];
};
cocoapods-try-release-fix = attrs: {
dependencies = [ "cocoapods" ];
};
2017-09-20 23:53:25 -07:00
curb = attrs: {
buildInputs = [ curl ];
};
2015-01-25 16:01:48 -05:00
2018-08-15 15:32:50 +02:00
curses = attrs: {
dontBuild = false;
2018-08-15 15:32:50 +02:00
buildInputs = [ ncurses ];
patches = lib.optionals (lib.versionOlder attrs.version "1.4.5") [
# Fixes incompatible function pointer type error with clang 16. Fixed in 1.4.5 and newer.
# Upstream issue: https://github.com/ruby/curses/issues/85
(fetchpatch2 {
url = "https://github.com/ruby/curses/commit/13e00d07c3aaed83d5f138cf268cc33c9f025d0e.patch?full_index=1";
hash = "sha256-ZJ2egqj3Uwmi4KrF79dtwczpwUqFCp52/xQYUymYDmc=";
})
];
2018-08-15 15:32:50 +02:00
};
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
dep-selector-libgecode = attrs: {
USE_SYSTEM_GECODE = true;
postInstall = ''
installPath=$(cat $out/nix-support/gem-meta/install-path)
sed -i $installPath/lib/dep-selector-libgecode.rb -e 's@VENDORED_GECODE_DIR =.*@VENDORED_GECODE_DIR = "${gecode_3}"@'
'';
};
2018-03-13 10:16:03 +00:00
digest-sha3 = attrs: {
hardeningDisable = [ "format" ];
};
rdiscount = attrs: {
# Use discount from nixpkgs instead of vendored version
dontBuild = false;
buildInputs = [ discount ];
patches = [
# Adapted from Debian:
# https://sources.debian.org/data/main/r/ruby-rdiscount/2.1.8-1/debian/patches/01_use-system-libmarkdown.patch
./rdiscount-use-nixpkgs-libmarkdown.patch
];
};
ethon = attrs: {
dontBuild = false;
postPatch = ''
substituteInPlace lib/ethon/curls/settings.rb \
2018-02-20 11:29:07 +01:00
--replace "libcurl" "${curl.out}/lib/libcurl${stdenv.hostPlatform.extensions.sharedLibrary}"
'';
2018-03-13 10:16:03 +00:00
};
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
exiv2 = attrs: {
buildFlags = [
"--with-exiv2-lib=${exiv2}/lib"
"--with-exiv2-include=${exiv2.dev}/include"
];
};
fog-dnsimple =
attrs:
lib.optionalAttrs (lib.versionOlder attrs.version "1.0.1") {
postInstall = ''
cd $(cat $out/nix-support/gem-meta/install-path)
rm {$out/bin,bin,../../bin}/{setup,console}
'';
};
redis-rack = attrs: {
dontBuild = false;
preBuild = ''
exec 3>&1
output="$(gem build $gemspec | tee >(cat - >&3))"
exec 3>&-
sed -i 's!"rake".freeze!!' $gemspec
'';
};
ffi-rzmq-core = attrs: {
postInstall = ''
installPath=$(cat $out/nix-support/gem-meta/install-path)
sed -i $installPath/lib/ffi-rzmq-core/libzmq.rb -e 's@inside_gem =.*@inside_gem = "${zeromq}/lib"@'
'';
};
2021-04-07 16:52:15 +02:00
mimemagic = attrs: {
FREEDESKTOP_MIME_TYPES_PATH = "${shared-mime-info}/share/mime/packages/freedesktop.org.xml";
};
mini_magick = attrs: {
postInstall = ''
installPath=$(cat $out/nix-support/gem-meta/install-path)
echo -e "\nENV['PATH'] += ':${graphicsmagick}/bin'\n" >> $installPath/lib/mini_magick/configuration.rb
'';
};
mini_racer = attrs: {
buildFlags = [
"--with-v8-dir=\"${nodejs.libv8}\""
];
dontBuild = false;
postPatch = ''
substituteInPlace ext/mini_racer_extension/extconf.rb \
--replace Libv8.configure_makefile '$CPPFLAGS += " -x c++"; Libv8.configure_makefile'
'';
};
2017-09-21 00:18:01 +02:00
do_sqlite3 = attrs: {
buildInputs = [ sqlite ];
};
eventmachine = attrs: {
dontBuild = false;
buildInputs = [ openssl ];
postPatch = ''
substituteInPlace ext/em.cpp \
--replace 'if (bind (' 'if (::bind ('
'';
};
2020-11-10 22:41:08 +03:00
exif = attrs: {
buildFlags = [ "--with-exif-dir=${libexif}" ];
buildInputs = [ libexif ];
};
2015-01-25 16:01:48 -05:00
ffi = attrs: {
nativeBuildInputs = [ pkg-config ];
buildInputs = [ libffi ];
2015-01-25 16:01:48 -05:00
};
fiddle = attrs: {
buildInputs = [ libffi ];
};
2017-10-31 13:33:52 +09:00
gdk_pixbuf2 = attrs: {
2021-04-18 02:17:13 +09:00
nativeBuildInputs = [
pkg-config
bundler
rake
] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
propagatedBuildInputs = [
gobject-introspection
wrapGAppsHook3
gdk-pixbuf
];
2017-10-31 13:33:52 +09:00
};
gdk3 = attrs: {
nativeBuildInputs = [
pkg-config
bundler
rake
] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
propagatedBuildInputs = [
gobject-introspection
wrapGAppsHook3
gdk-pixbuf
cairo
];
};
2015-01-21 20:33:19 -05:00
gpgme = attrs: {
buildInputs = [ gpgme ];
2023-02-25 00:00:00 +00:00
nativeBuildInputs = [ pkg-config ];
2019-09-10 14:05:19 +02:00
buildFlags = [ "--use-system-libraries" ];
2015-01-21 20:33:19 -05:00
};
gio2 = attrs: {
nativeBuildInputs = [
pkg-config
gobject-introspection
2021-04-18 02:17:13 +09:00
] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
buildInputs =
[
glib
libsysprof-capture
pcre2
]
++ lib.optionals stdenv.hostPlatform.isLinux [
util-linux
libselinux
libsepol
];
};
2017-05-18 09:47:45 +09:00
2017-09-03 15:38:28 +02:00
gitlab-markup = attrs: { meta.priority = 1; };
2021-02-17 22:55:14 +01:00
gitlab-pg_query =
attrs:
lib.optionalAttrs (attrs.version == "1.3.1") {
dontBuild = false;
postPatch = ''
2021-02-17 22:55:14 +01:00
sed -i "s;'https://codeload.github.com.*';'${
fetchurl {
url = "https://codeload.github.com/lfittl/libpg_query/tar.gz/10-1.0.3";
sha256 = "0jfij8apzxsdabl70j42xgd5f3ka1gdcrk764nccp66164gpcchk";
}
2021-02-17 22:55:14 +01:00
}';" ext/pg_query/extconf.rb
'';
};
2022-08-08 19:36:27 +00:00
parser = attrs: {
meta.mainProgram = "ruby-parse";
};
pg_query =
attrs:
lib.optionalAttrs (attrs.version == "2.0.2") {
dontBuild = false;
postPatch = ''
sed -i "s;'https://codeload.github.com.*';'${
fetchurl {
url = "https://codeload.github.com/lfittl/libpg_query/tar.gz/13-2.0.2";
sha256 = "0ms2s6hmy8qyzv4g1hj4i2p5fws1v8lrj73b2knwbp2ipd45yj7y";
}
}';" ext/pg_query/extconf.rb
'';
}
// lib.optionalAttrs (attrs.version == "1.3.0") {
# Needed for gitlab
2021-02-17 22:55:14 +01:00
dontBuild = false;
postPatch = ''
sed -i "s;'https://codeload.github.com.*';'${
fetchurl {
url = "https://codeload.github.com/lfittl/libpg_query/tar.gz/10-1.0.4";
sha256 = "0f0kshhai0pnkqj0w4kgz3fssnvwidllc31n1fysxjjzdqlr1k48";
}
2021-02-17 22:55:14 +01:00
}';" ext/pg_query/extconf.rb
'';
};
2022-08-08 19:36:27 +00:00
prettier = attrs: {
meta.mainProgram = "rbprettier";
};
prometheus-client-mmap =
attrs:
{
dontBuild = false;
postPatch =
let
getconf = if stdenv.hostPlatform.isGnu then stdenv.cc.libc else getconf;
in
''
substituteInPlace lib/prometheus/client/page_size.rb --replace "getconf" "${lib.getBin getconf}/bin/getconf"
'';
}
// lib.optionalAttrs (lib.versionAtLeast attrs.version "1.0") {
cargoDeps = rustPlatform.fetchCargoVendor {
src = stdenv.mkDerivation {
inherit (buildRubyGem { inherit (attrs) gemName version source; })
name
src
unpackPhase
nativeBuildInputs
;
dontBuilt = true;
installPhase = ''
cp -R ext/fast_mmaped_file_rs $out
cp Cargo.lock $out
'';
};
hash = "sha256-KVbmDAa9EFwTUTHPF/8ZzycbieMhAuiidiz5rqGIKOo=";
};
nativeBuildInputs = [
cargo
rustc
rustPlatform.cargoSetupHook
rustPlatform.bindgenHook
];
disallowedReferences = [
rustc.unwrapped
];
preInstall = ''
export CARGO_HOME="$PWD/../.cargo/"
'';
postInstall = ''
find $out -type f -name .rustc_info.json -delete
'';
};
glib2 = attrs: {
2021-04-18 02:17:13 +09:00
nativeBuildInputs = [ pkg-config ] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
buildInputs = [
glib
libsysprof-capture
pcre2
];
2017-05-18 09:47:45 +09:00
};
gtk3 = attrs: {
nativeBuildInputs =
[
binutils
pkg-config
]
++ lib.optionals stdenv.hostPlatform.isLinux [
util-linux
libselinux
libsepol
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
propagatedBuildInputs = [
atk
gdk-pixbuf
fribidi
gobject-introspection
gtk3
cairo
harfbuzz
lerc
libdatrie
libsysprof-capture
libthai
pcre2
xorg.libpthreadstubs
xorg.libXdmcp
xorg.libXtst
libxkbcommon
libepoxy
];
dontStrip = stdenv.hostPlatform.isDarwin;
};
2017-10-31 13:33:52 +09:00
gobject-introspection = attrs: {
2021-04-18 02:17:13 +09:00
nativeBuildInputs = [ pkg-config ] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
propagatedBuildInputs = [
gobject-introspection
wrapGAppsHook3
glib
pcre2
libsysprof-capture
];
2017-10-31 13:33:52 +09:00
};
2017-05-18 09:47:45 +09:00
gollum = attrs: {
dontBuild = false;
postPatch = ''
substituteInPlace bin/gollum \
--replace "/usr/bin/env -S ruby" "${ruby}/bin/ruby"
'';
};
google-protobuf =
attrs:
lib.optionalAttrs (lib.versionAtLeast attrs.version "3.25.0") {
# Fails on 3.25.0 with:
# convert.c:312:32: error: format string is not a string literal (potentially insecure) [-Werror,-Wformat-security]
hardeningDisable = [ "format" ];
};
2017-07-05 23:53:31 +02:00
grpc = attrs: {
2023-05-01 11:51:27 +03:00
nativeBuildInputs =
[ pkg-config ]
++ lib.optional stdenv.hostPlatform.isDarwin cctools
++ lib.optional (
lib.versionAtLeast attrs.version "1.53.0"
&& stdenv.hostPlatform.isDarwin
&& stdenv.hostPlatform.isAarch64
) autoSignDarwinBinariesHook;
buildInputs = [ openssl ];
hardeningDisable = [ "format" ];
env = lib.optionalAttrs (lib.versionOlder attrs.version "1.68.1") {
NIX_CFLAGS_COMPILE = "-Wno-error=incompatible-pointer-types";
};
patches = lib.optionals (lib.versionOlder attrs.version "1.65.0") [
(fetchpatch {
name = "gcc-14-fixes.patch";
url = "https://boringssl.googlesource.com/boringssl/+/c70190368c7040c37c1d655f0690bcde2b109a0d%5E%21/?format=TEXT";
decode = "base64 -d";
stripLen = 1;
extraPrefix = "third_party/boringssl-with-bazel/src/";
hash = "sha256-1QyQm5s55op268r72dfExNGV+UyV5Ty6boHa9DQq40U=";
})
2019-01-11 09:31:18 +01:00
];
dontBuild = false;
postPatch =
''
substituteInPlace Makefile \
--replace '-Wno-invalid-source-encoding' ""
2023-05-01 11:51:27 +03:00
''
+ lib.optionalString (lib.versionOlder attrs.version "1.53.0" && stdenv.hostPlatform.isDarwin) ''
# For < v1.48.0
2021-12-09 19:57:32 +01:00
substituteInPlace src/ruby/ext/grpc/extconf.rb \
--replace "ENV['AR'] = 'libtool -o' if RUBY_PLATFORM =~ /darwin/" ""
# For >= v1.48.0
substituteInPlace src/ruby/ext/grpc/extconf.rb \
--replace 'apple_toolchain = ' 'apple_toolchain = false && '
2019-01-11 09:31:18 +01:00
'';
2017-07-05 23:53:31 +02:00
};
2016-05-04 16:41:44 -06:00
hitimes = attrs: {
2021-04-18 02:17:13 +09:00
buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [ CoreServices ];
2016-05-04 16:41:44 -06:00
};
hpricot = attrs: {
dontBuild = false;
patches = [
# Fix incompatible function pointer conversion errors with clang 16
./hpricot-fix-incompatible-function-pointer-conversion.patch
];
};
2018-11-08 16:46:29 +00:00
iconv = attrs: {
buildFlags = lib.optionals stdenv.hostPlatform.isDarwin [
"--with-iconv-dir=${lib.getLib libiconv}"
"--with-iconv-include=${lib.getDev libiconv}/include"
];
2018-11-08 16:46:29 +00:00
};
2019-05-02 02:37:35 +02:00
idn-ruby = attrs: {
buildInputs = [ libidn ];
};
# disable bundle install as it can't install anything in addition to what is
# specified in pkgs/applications/misc/jekyll/Gemfile anyway. Also do chmod_R
# to compensate for read-only files in site_template in nix store.
jekyll = attrs: {
postInstall = ''
installPath=$(cat $out/nix-support/gem-meta/install-path)
sed -i $installPath/lib/jekyll/commands/new.rb \
-e 's@Exec.run("bundle", "install"@Exec.run("true"@' \
-e 's@FileUtils.cp_r site_template + "/.", path@FileUtils.cp_r site_template + "/.", path; FileUtils.chmod_R "u+w", path@'
'';
};
execjs = attrs: {
2024-05-30 11:53:55 +02:00
propagatedBuildInputs = [ nodejs.libv8 ];
};
2018-07-26 19:51:17 +02:00
libxml-ruby = attrs: {
buildFlags =
[
"--with-xml2-lib=${libxml2.out}/lib"
"--with-xml2-include=${libxml2.dev}/include/libxml2"
]
++ lib.optionals stdenv.hostPlatform.isDarwin [
"--with-iconv-dir=${lib.getLib libiconv}"
"--with-opt-include=${lib.getDev libiconv}/include"
2018-07-26 19:51:17 +02:00
];
};
mathematical = attrs: {
nativeBuildInputs = [
ruby
cmake
bison
flex
pkg-config
python3
patchelf
];
buildInputs = [
cairo
fribidi
2019-05-22 07:03:39 -04:00
gdk-pixbuf
glib
libxml2
pango
];
strictDeps = true;
# The ruby build script takes care of this
dontUseCmakeConfigure = true;
postInstall = ''
# Reduce output size by a lot, and remove some unnecessary references.
# The ext directory should only be required at build time, so
# can be deleted now.
rm -r $out/${ruby.gemPath}/gems/mathematical-${attrs.version}/ext \
$out/${ruby.gemPath}/extensions/*/*/mathematical-${attrs.version}/gem_make.out
'';
# For some reason 'mathematical.so' is missing cairo, glib, and
# lasem in its RPATH, add them explicitly here
postFixup =
lib.optionalString stdenv.hostPlatform.isLinux ''
soPath="$out/${ruby.gemPath}/gems/mathematical-${attrs.version}/lib/mathematical/mathematical.so"
rpath="$(patchelf --print-rpath "$soPath")"
patchelf --set-rpath "${
lib.makeLibraryPath [
lasem
glib
cairo
]
}:$rpath" "$soPath"
patchelf --replace-needed liblasem.so liblasem-0.4.so "$soPath"
''
+ lib.optionalString stdenv.hostPlatform.isDarwin ''
soPath="$out/${ruby.gemPath}/gems/mathematical-${attrs.version}/lib/mathematical/mathematical.bundle"
install_name_tool -add_rpath "${
lib.makeLibraryPath [
lasem
glib
cairo
]
}/lib" "$soPath"
install_name_tool -change @rpath/liblasem.dylib "${lib.getLib lasem}/lib/liblasem-0.4.dylib" "$soPath"
'';
};
2018-10-23 16:09:43 +02:00
magic = attrs: {
buildInputs = [ file ];
postInstall = ''
installPath=$(cat $out/nix-support/gem-meta/install-path)
sed -e 's@ENV\["MAGIC_LIB"\] ||@ENV\["MAGIC_LIB"\] || "${file}/lib/libmagic.so" ||@' -i $installPath/lib/magic/api.rb
'';
};
maxmind_geoip2 = attrs: {
buildFlags = [
"--with-maxminddb-lib=${libmaxminddb}/lib"
"--with-maxminddb-include=${libmaxminddb}/include"
];
};
metasploit-framework = attrs: {
preInstall = ''
export HOME=$TMPDIR
'';
};
mysql = attrs: {
buildInputs = [
libmysqlclient
zlib
openssl
];
};
2015-01-25 16:01:48 -05:00
mysql2 = attrs: {
buildInputs = [
libmysqlclient
zlib
openssl
];
2015-01-25 16:01:48 -05:00
};
2015-01-21 20:33:19 -05:00
ncursesw = attrs: {
buildInputs = [ ncurses ];
buildFlags = [
"--with-cflags=-I${ncurses.dev}/include"
"--with-ldflags=-L${ncurses.out}/lib"
2015-01-21 20:33:19 -05:00
];
2014-10-28 04:16:14 +00:00
};
nokogiri =
attrs:
(
{
2014-10-28 04:16:14 +00:00
buildFlags =
[
"--use-system-libraries"
"--with-zlib-lib=${zlib.out}/lib"
"--with-zlib-include=${zlib.dev}/include"
"--with-xml2-lib=${libxml2.out}/lib"
"--with-xml2-include=${libxml2.dev}/include/libxml2"
"--with-xslt-lib=${libxslt.out}/lib"
"--with-xslt-include=${libxslt.dev}/include"
"--with-exslt-lib=${libxslt.out}/lib"
"--with-exslt-include=${libxslt.dev}/include"
]
++ lib.optionals stdenv.hostPlatform.isDarwin [
"--with-iconv-dir=${libiconv}"
"--with-opt-include=${libiconv}/include"
];
}
// lib.optionalAttrs stdenv.hostPlatform.isDarwin {
buildInputs = [ libxml2 ];
# libxml 2.12 upgrade requires these fixes
# https://github.com/sparklemotion/nokogiri/pull/3032
# which don't trivially apply to older versions
meta.broken =
(lib.versionOlder attrs.version "1.16.0") && (lib.versionAtLeast libxml2.version "2.12");
}
);
2014-10-29 01:16:02 +00:00
openssl = attrs: {
2022-07-04 18:30:48 +02:00
# https://github.com/ruby/openssl/issues/369
buildInputs = [ (if (lib.versionAtLeast attrs.version "3.0.0") then openssl else openssl_1_1) ];
};
2019-04-07 15:09:15 +02:00
opus-ruby = attrs: {
dontBuild = false;
postPatch = ''
substituteInPlace lib/opus-ruby.rb \
--replace "ffi_lib 'opus'" \
"ffi_lib '${libopus}/lib/libopus${stdenv.hostPlatform.extensions.sharedLibrary}'"
'';
};
ovirt-engine-sdk = attrs: {
buildInputs = [
curl
libxml2
];
# https://github.com/oVirt/ovirt-engine-sdk-ruby/issues/13
env.NIX_CFLAGS_COMPILE = toString [
"-Wno-error=implicit-function-declaration"
"-Wno-error=incompatible-pointer-types"
"-Wno-int-conversion"
];
dontBuild = false;
meta.broken = stdenv.hostPlatform.isDarwin; # At least until releasing https://github.com/oVirt/ovirt-engine-sdk-ruby/pull/17
};
2017-05-18 09:47:45 +09:00
pango = attrs: {
nativeBuildInputs = [
pkg-config
2021-04-18 02:17:13 +09:00
] ++ lib.optionals stdenv.hostPlatform.isDarwin [ DarwinTools ];
buildInputs =
[
libdatrie
libthai
fribidi
harfbuzz
libsysprof-capture
pcre2
xorg.libpthreadstubs
xorg.libXdmcp
]
2021-04-18 02:17:13 +09:00
++ lib.optionals stdenv.hostPlatform.isLinux [
libselinux
libsepol
util-linux
];
propagatedBuildInputs = [
gobject-introspection
wrapGAppsHook3
];
2017-05-18 09:47:45 +09:00
};
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
patron = attrs: {
buildInputs = [ curl ];
};
2017-05-14 22:07:26 +01:00
pcaprub = attrs: {
buildInputs = [ libpcap ];
};
2014-10-29 01:16:02 +00:00
pg = attrs: {
# Force pkg-config lookup for libpq.
# See https://github.com/ged/ruby-pg/blob/6629dec6656f7ca27619e4675b45225d9e422112/ext/extconf.rb#L34-L55
#
# Note that setting --with-pg-config=${postgresql.pg_config}/bin/pg_config would add
# an unnecessary reference to the entire postgresql package.
buildFlags = [ "--with-pg-config=ignore" ];
nativeBuildInputs = [ pkg-config ];
2024-11-23 23:36:23 +01:00
buildInputs = [ libpq ];
2014-10-29 01:16:02 +00:00
};
rszr = attrs: {
buildInputs = [
imlib2
imlib2.dev
];
buildFlags = [ "--without-imlib2-config" ];
};
psych = attrs: {
buildInputs = [ libyaml ];
};
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
puma = attrs: {
buildInputs = [ openssl ];
};
"pygments.rb" = attrs: {
buildInputs = [ python3 ];
};
2022-08-08 19:36:27 +00:00
rack = attrs: {
meta.mainProgram = "rackup";
};
railties = attrs: {
meta.mainProgram = "rails";
};
rainbow = attrs: {
buildInputs = [ rainbow_rake ];
};
rbczmq =
{ ... }:
{
buildInputs = [
zeromq
czmq
];
buildFlags = [ "--with-system-libs" ];
};
2016-06-16 19:33:12 +02:00
rbnacl =
spec:
if lib.versionOlder spec.version "6.0.0" then
{
2019-01-31 10:12:42 +03:00
postInstall = ''
sed -i $(cat $out/nix-support/gem-meta/install-path)/lib/rbnacl.rb -e "2a \
RBNACL_LIBSODIUM_GEM_LIB_PATH = '${libsodium.out}/lib/libsodium${stdenv.hostPlatform.extensions.sharedLibrary}'
"
'';
}
else
{
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
dontBuild = false;
2015-01-21 20:33:19 -05:00
postPatch = ''
substituteInPlace lib/rbnacl/sodium.rb \
--replace 'ffi_lib ["sodium"' \
'ffi_lib ["${libsodium}/lib/libsodium${stdenv.hostPlatform.extensions.sharedLibrary}"'
'';
};
2017-08-06 16:27:54 +02:00
re2 = attrs: {
buildInputs = [ re2 ];
buildFlags = [
"--enable-system-libraries"
];
2017-08-06 16:27:54 +02:00
};
2022-08-08 19:36:27 +00:00
rest-client = attrs: {
meta.mainProgram = "restclient";
};
2014-10-29 01:16:02 +00:00
rmagick = attrs: {
nativeBuildInputs = [ pkg-config ];
buildInputs = [
imagemagick
which
];
2014-10-29 01:16:02 +00:00
};
2022-08-08 19:36:27 +00:00
rouge = attrs: {
meta.mainProgram = "rougify";
};
2019-05-02 02:37:35 +02:00
rpam2 = attrs: {
buildInputs = [ linux-pam ];
};
2022-08-08 19:36:27 +00:00
rspec-core = attrs: {
meta.mainProgram = "rspec";
};
ruby-libvirt = attrs: {
nativeBuildInputs = [ pkg-config ];
buildInputs = [ libvirt ];
buildFlags = [
"--with-libvirt-include=${libvirt}/include"
"--with-libvirt-lib=${libvirt}/lib"
];
};
ruby-lxc = attrs: {
buildInputs = [ lxc ];
};
ruby-terminfo = attrs: {
buildInputs = [ ncurses ];
buildFlags = [
"--with-cflags=-I${ncurses.dev}/include"
"--with-ldflags=-L${ncurses.out}/lib"
];
dontBuild = false;
postPatch = ''
substituteInPlace extconf.rb --replace 'rubyio.h' 'ruby/io.h'
substituteInPlace terminfo.c \
--replace 'rubyio.h' 'ruby/io.h' \
--replace 'rb_cData' 'rb_cObject'
'';
};
2019-01-31 10:12:42 +03:00
ruby-vips = attrs: {
postInstall = ''
cd "$(cat $out/nix-support/gem-meta/install-path)"
substituteInPlace lib/vips.rb \
2021-05-21 04:20:00 +00:00
--replace 'library_name("vips", 42)' '"${lib.getLib vips}/lib/libvips${stdenv.hostPlatform.extensions.sharedLibrary}"' \
--replace 'library_name("glib-2.0", 0)' '"${glib.out}/lib/libglib-2.0${stdenv.hostPlatform.extensions.sharedLibrary}"' \
--replace 'library_name("gobject-2.0", 0)' '"${glib.out}/lib/libgobject-2.0${stdenv.hostPlatform.extensions.sharedLibrary}"'
2019-01-31 10:12:42 +03:00
'';
};
2015-01-25 16:01:48 -05:00
rugged = attrs: {
2021-12-09 19:57:32 +01:00
nativeBuildInputs = [
cmake
pkg-config
which
] ++ lib.optional stdenv.hostPlatform.isDarwin libiconv;
buildInputs = [
openssl
libssh2
zlib
];
2018-03-10 12:59:06 +01:00
dontUseCmakeConfigure = true;
2015-01-25 16:01:48 -05:00
};
2018-10-11 21:04:29 +02:00
sassc = attrs: {
nativeBuildInputs = [ rake ];
dontBuild = false;
SASS_LIBSASS_PATH = toString libsass;
postPatch = ''
substituteInPlace lib/sassc/native.rb \
--replace 'gem_root = spec.gem_dir' 'gem_root = File.join(__dir__, "../../")'
'';
2024-07-17 23:10:56 -04:00
};
2018-10-11 21:04:29 +02:00
sass-embedded = attrs: {
# Patch the Rakefile to use our dart-sass and not try to fetch anything.
dontBuild = false;
postPatch = ''
substituteInPlace ext/sass/Rakefile \
--replace \'dart-sass/sass\' \'${dart-sass}/bin/sass\' \
--replace ' => %w[dart-sass]' ""
'';
};
scrypt =
attrs:
lib.optionalAttrs stdenv.hostPlatform.isDarwin {
dontBuild = false;
postPatch = ''
sed -i -e "s/-arch i386//" Rakefile ext/scrypt/Rakefile
'';
};
semian = attrs: {
buildInputs = [ openssl ];
};
sequel_pg = attrs: {
2024-11-23 23:36:23 +01:00
buildInputs = [ libpq ];
};
2016-09-21 14:29:12 +02:00
snappy = attrs: {
buildInputs = [ args.snappy ];
};
sqlite3 =
attrs:
if lib.versionAtLeast attrs.version "1.5.0" then
{
nativeBuildInputs = [ pkg-config ];
buildInputs = [ sqlite ];
buildFlags = [
"--enable-system-libraries"
];
}
else
{
2014-10-29 01:16:02 +00:00
buildFlags = [
2015-10-13 22:30:30 +02:00
"--with-sqlite3-include=${sqlite.dev}/include"
"--with-sqlite3-lib=${sqlite.out}/lib"
2014-10-28 04:16:14 +00:00
];
2024-12-31 09:33:50 +01:00
env.NIX_CFLAGS_COMPILE = toString [
"-Wno-error=incompatible-pointer-types"
"-Wno-error=int-conversion"
];
2014-10-28 04:16:14 +00:00
};
2017-05-14 22:13:55 +01:00
rb-readline = attrs: {
dontBuild = false;
postPatch = ''
substituteInPlace lib/rbreadline.rb \
--replace 'infocmp' '${ncurses}/bin/infocmp'
2017-05-14 22:13:55 +01:00
'';
};
taglib-ruby = attrs: {
buildInputs = [ taglib ];
};
2015-10-21 19:48:56 +02:00
timfel-krb5-auth = attrs: {
2021-03-14 17:11:48 +01:00
buildInputs = [ libkrb5 ];
2015-10-21 19:48:56 +02:00
};
tiny_tds = attrs: {
nativeBuildInputs = [
pkg-config
openssl
];
buildInputs = [ freetds ];
};
2022-08-08 19:36:27 +00:00
treetop = attrs: {
meta.mainProgram = "tt";
};
2016-06-16 11:43:21 +02:00
typhoeus = attrs: {
buildInputs = [ curl ];
};
tzinfo =
attrs:
lib.optionalAttrs (lib.versionAtLeast attrs.version "1.0") {
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
dontBuild = false;
postPatch =
let
path =
if lib.versionAtLeast attrs.version "2.0" then
"lib/tzinfo/data_sources/zoneinfo_data_source.rb"
else
"lib/tzinfo/zoneinfo_data_source.rb";
in
''
substituteInPlace ${path} \
--replace "/usr/share/zoneinfo" "${tzdata}/share/zoneinfo"
'';
2015-01-24 17:59:01 -05:00
};
2016-11-21 13:41:05 +01:00
uuid4r = attrs: {
buildInputs = [
which
libossp_uuid
];
};
2015-01-24 17:59:01 -05:00
2022-08-08 19:36:27 +00:00
whois = attrs: {
meta.mainProgram = "whoisrb";
};
2015-01-21 20:33:19 -05:00
xapian-ruby = attrs: {
# use the system xapian
ruby: new bundler infrastructure This improves our Bundler integration (i.e. `bundlerEnv`). Before describing the implementation differences, I'd like to point a breaking change: buildRubyGem now expects `gemName` and `version` as arguments, rather than a `name` attribute in the form of "<gem-name>-<version>". Now for the differences in implementation. The previous implementation installed all gems at once in a single derivation. This was made possible by using a set of monkey-patches to prevent Bundler from downloading gems impurely, and to help Bundler find and activate all required gems prior to installation. This had several downsides: * The patches were really hard to understand, and required subtle interaction with the rest of the build environment. * A single install failure would cause the entire derivation to fail. The new implementation takes a different approach: we install gems into separate derivations, and then present Bundler with a symlink forest thereof. This has a couple benefits over the existing approach: * Fewer patches are required, with less interplay with the rest of the build environment. * Changes to one gem no longer cause a rebuild of the entire dependency graph. * Builds take 20% less time (using gitlab as a reference). It's unfortunate that we still have to muck with Bundler's internals, though it's unavoidable with the way that Bundler is currently designed. There are a number improvements that could be made in Bundler that would simplify our packaging story: * Bundler requires all installed gems reside within the same prefix (GEM_HOME), unlike RubyGems which allows for multiple prefixes to be specified through GEM_PATH. It would be ideal if Bundler allowed for packages to be installed and sourced from multiple prefixes. * Bundler installs git sources very differently from how RubyGems installs gem packages, and, unlike RubyGems, it doesn't provide a public interface (CLI or programmatic) to guide the installation of a single gem. We are presented with the options of either reimplementing a considerable portion Bundler, or patch and use parts of its internals; I choose the latter. Ideally, there would be a way to install gems from git sources in a manner similar to how we drive `gem` to install gem packages. * When a bundled program is executed (via `bundle exec` or a binstub that does `require 'bundler/setup'`), the setup process reads the Gemfile.lock, activates the dependencies, re-serializes the lock file it read earlier, and then attempts to overwrite the Gemfile.lock if the contents aren't bit-identical. I think the reasoning is that by merely running an application with a newer version of Bundler, you'll automatically keep the Gemfile.lock up-to-date with any changes in the format. Unfortunately, that doesn't play well with any form of packaging, because bundler will immediately cause the application to abort when it attempts to write to the read-only Gemfile.lock in the store. We work around this by normalizing the Gemfile.lock with the version of Bundler that we'll use at runtime before we copy it into the store. This feels fragile, but it's the best we can do without changes upstream, or resorting to more delicate hacks. With all of the challenges in using Bundler, one might wonder why we can't just cut Bundler out of the picture and use RubyGems. After all, Nix provides most of the isolation that Bundler is used for anyway. The problem, however, is that almost every Rails application calls `Bundler::require` at startup (by way of the default project templates). Because bundler will then, by default, `require` each gem listed in the Gemfile, Rails applications are almost always written such that none of the source files explicitly require their dependencies. That leaves us with two options: support and use Bundler, or maintain massive patches for every Rails application that we package. Closes #8612
2015-11-14 21:17:29 -05:00
dontBuild = false;
nativeBuildInputs = [
rake
pkg-config
bundler
];
buildInputs = [
xapian
zlib
];
2015-01-21 20:33:19 -05:00
postPatch = ''
cp ${./xapian-Rakefile} Rakefile
'';
preInstall = ''
export XAPIAN_CONFIG=${xapian}/bin/xapian-config
2015-01-21 20:33:19 -05:00
'';
};
2016-04-17 22:36:40 +02:00
2019-05-08 17:41:13 +02:00
zlib = attrs: {
buildInputs = [ zlib ];
};
2019-05-08 17:40:53 +02:00
zookeeper = attrs: {
2021-04-18 02:17:13 +09:00
buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [ cctools ];
2019-05-08 17:40:53 +02:00
};
2014-10-28 04:16:14 +00:00
}