diff options
Diffstat (limited to 'posts/2015-08-30-ruby-on-guix.skr')
| -rw-r--r-- | posts/2015-08-30-ruby-on-guix.skr | 578 |
1 files changed, 0 insertions, 578 deletions
diff --git a/posts/2015-08-30-ruby-on-guix.skr b/posts/2015-08-30-ruby-on-guix.skr deleted file mode 100644 index 5da4ab4..0000000 --- a/posts/2015-08-30-ruby-on-guix.skr +++ /dev/null @@ -1,578 +0,0 @@ -(post - :title "Ruby on Guix" - :date (make-date* 2015 08 30) - :tags '("gnu" "guix" "scheme" "guile" "ruby" "wsu") - :summary "How to use Guix + some elbow grease to replace RVM and -Bundler on GNU/Linux" - - (p [I’ve been working with Ruby professionally for over 3 years now -and I’ve grown frustrated with two of its most popular development -tools: RVM and Bundler. For those that may not know, RVM is the Ruby -version manager and it allows unprivileged users to download, compile, -install, and manage many versions of Ruby instead of being stuck with -the one that is installed globally by your distro’s package manager. -Bundler is the tool that allows developers to keep a version -controlled “Gemfile” that specifies all of the project’s dependencies -and provides utilities to install and update those gems. These tools -are crucial because Ruby developers often work with many applications -that use different versions of Ruby and/or different versions of gems -such as Rails. Traditional GNU/Linux distributions install packages -to the global ,(code [/usr]) directory, limiting users to a single -version of Ruby and associated gems, if they are packaged at all. -Traditional package management fails to meet the needs of a lot of -users, so many niche package managers have been developed to -supplement them.]) - - (source-code - (scheme-source - ";;; guile-syntax-highlight --- General-purpose syntax highlighter -;;; Copyright © 2015 David Thompson <davet@gnu.org> -;;; -;;; Guile-syntax-highlight is free software; you can redistribute it -;;; and/or modify it under the terms of the GNU Lesser General Public -;;; License as published by the Free Software Foundation; either -;;; version 3 of the License, or (at your option) any later version. -;;; -;;; Guile-syntax-highlight is distributed in the hope that it will be -;;; useful, but WITHOUT ANY WARRANTY; without even the implied -;;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -;;; See the GNU Lesser General Public License for more details. -;;; -;;; You should have received a copy of the GNU Lesser General Public -;;; License along with guile-syntax-highlight. If not, see -;;; <http://www.gnu.org/licenses/>. - -;;; Commentary: -;; -;; Lexing utilities. -;; -;;; Code: - -(define-module (syntax-highlight lexers) - #:use-module (ice-9 match) - #:use-module (ice-9 regex) - #:use-module (srfi srfi-1) - #:use-module (srfi srfi-9) - #:use-module (srfi srfi-11) - #:use-module (srfi srfi-26) - #:export (make-cursor - cursor? - cursor-text - cursor-position - cursor-end? - move-cursor - move-cursor-by - - lex-fail - lex-bind - lex-return - lex-lift - lex-map - lex-filter - lex-any* - lex-any - lex-all* - lex-all - lex-consume - lex-regexp - lex-string - lex-char-set - lex-delimited - lex-tag)) - -(define (string-prefix?* s1 s2 start-s2) - (string-prefix? s1 s2 0 (string-length s1) start-s2)) - - -;;; -;;; Cursor -;;; - -(define-record-type <cursor> - (make-cursor text position) - cursor? - (text cursor-text) - (position cursor-position)) - -(define (cursor-end? cursor) - \"Return #t if the cursor is at the end of the text.\" - (>= (cursor-position cursor) (string-length (cursor-text cursor)))) - -(define (move-cursor cursor position) - \"Move CURSOR to the character at POSITION.\" - (make-cursor (cursor-text cursor) position)) - -(define (move-cursor-by cursor offset) - \"Move CURSOR by OFFSET characters relative to its current -position.\" - (move-cursor cursor (+ (cursor-position cursor) offset))) - - -;;; -;;; Lexers -;;; - -(define (lex-fail cursor) - \"Always fail to lex STR without consuming any of it.\" - (values #f cursor)) - -(define (lex-bind proc lexer) - \"Return a lexer that applies the result of LEXER to PROC, a -procedure that returns a lexer, and then applies that new lexer.\" - (lambda (cursor) - (let-values (((result remainder) (lexer cursor))) - (if result - ((proc result) remainder) - (lex-fail cursor))))) - -(define (lex-return x) - \"Return a lexer that always yields X as the lex result.\" - (lambda (cursor) - (values x cursor))) - -(define (lex-lift proc) - \"Return a procedure that wraps the result of PROC in a lexer.\" - (lambda args - (lex-return (apply proc args)))) - -(define (lex-map proc lexer) - \"Return a lexer that applies PROC to result of LEXER.\" - (lex-bind (lex-lift proc) lexer)) - -(define (lex-any* lexers) - \"Return a lexer that succeeds with the result of the first -successful lexer in LEXERS or fails if all lexers fail.\" - (define (either a b) - (lambda (cursor) - (let-values (((result remainder) (a cursor))) - (if result - (values result remainder) - (b cursor))))) - - (fold-right either lex-fail lexers)) - -(define (lex-any . lexers) - \"Return a lexer that succeeds with the result of the first -successful lexer in LEXERS or fails if all lexers fail.\" - (lex-any* lexers)) - -(define (lex-all* lexers) - \"Return a lexer that succeeds with the results of all LEXERS in -order, or fails if any lexer fails.\" - (define (both a b) - (lambda (cursor) - (let-values (((result-a remainder-a) (a cursor))) - (if result-a - (let-values (((result-b remainder-b) (b remainder-a))) - (if result-b - (values (cons result-a result-b) remainder-b) - (lex-fail cursor))) - (lex-fail cursor))))) - - (fold-right both (lex-return '()) lexers)) - -(define (lex-all . lexers) - \"Return a lexer that succeeds with the results of all LEXERS in -order, or fails if any lexer fails.\" - (lex-all* lexers)) - -(define (lex-consume lexer) - \"Return a lexer that always succeeds with a list of as many -consecutive successful applications of LEXER as possible, consuming -the entire input text. Sections of text that could not be lexed are -returned as plain strings.\" - (define (substring* cursor start) - (substring (cursor-text cursor) start (cursor-position cursor))) - - (lambda (cursor) - (let loop ((cursor cursor) - (memo '()) - (fail-start #f)) - (if (cursor-end? cursor) - (values (reverse memo) cursor) - (let-values (((result remainder) (lexer cursor))) - (cond - ;; Regular successful result. - ((and result (not fail-start)) - (loop remainder (cons result memo) #f)) - ;; Successful result after some amount of unmatched - ;; characters. - ((and result fail-start) - (loop remainder - (cons* result (substring* cursor fail-start) memo) - #f)) - ;; Consecutive failure. - (fail-start - (loop (move-cursor-by cursor 1) - memo - fail-start)) - ;; First failure. - (else - (loop (move-cursor-by cursor 1) - memo - (cursor-position cursor))))))))) - -(define (lex-regexp pattern) - \"Return a lexer that succeeds with the matched substring when the -input matches the string PATTERN.\" - (let ((rx (make-regexp (string-append \"^\" pattern)))) - (lambda (cursor) - (if (cursor-end? cursor) - (lex-fail cursor) - (let ((result (regexp-exec rx (cursor-text cursor) - (cursor-position cursor)))) - (if result - (let ((str (match:substring result 0))) - (values str (move-cursor-by cursor (string-length str)))) - (lex-fail cursor))))))) - -(define (lex-string str) - \"Return a lexer that succeeds with STR when the input starts with -STR.\" - (lambda (cursor) - (if (string-prefix?* str (cursor-text cursor) (cursor-position cursor)) - (values str (move-cursor-by cursor (string-length str))) - (lex-fail cursor)))) - -(define (lex-char-set char-set) - \"Return a lexer that succeeds with the nonempty input prefix that -matches CHAR-SET, or fails if the first input character does not -belong to CHAR-SET.\" - (define (char-set-substring str start) - (let ((len (string-length str))) - (let loop ((index start)) - (cond - ((>= index len) - (substring str start len)) - ((char-set-contains? char-set (string-ref str index)) - (loop (1+ index))) - (else - (substring str start index)))))) - - (lambda (cursor) - (match (char-set-substring (cursor-text cursor) (cursor-position cursor)) - (\"\" (lex-fail cursor)) - (str (values str (move-cursor-by cursor (string-length str))))))) - -(define* (lex-delimited open #:key (until open) (escape #\\) nested?) - \"Return a lexer that succeeds with the string delimited by the -opening string OPEN and the closing string UNTIL. Characters within -the delimited expression may be escaped with the character ESCAPE. If -NESTED?, allow for delimited expressions to be arbitrarily nested -within.\" - (define (delimit str start) - (let ((len (string-length str))) - (let loop ((index start)) - (cond - ;; Out of bounds. - ((>= index len) - len) - ;; Escape character. - ((eqv? escape (string-ref str index)) - (loop (+ index 2))) - ;; Closing delimiter. - ((string-prefix?* until str index) - (+ index (string-length until))) - ;; Nested delimited string. - ((and nested? (string-prefix?* open str index)) - (loop (delimit str (+ index (string-length open))))) - (else - (loop (1+ index))))))) - - (lambda (cursor) - (let ((str (cursor-text cursor)) - (pos (cursor-position cursor))) - (if (string-prefix?* open str pos) - (let ((end (delimit str (+ pos (string-length open))))) - (values (substring str pos end) (move-cursor cursor end))) - (lex-fail cursor))))) - -(define (lex-tag tag lexer) - \"Wrap the results of LEXER in a two-element tuple whose head is -TAG.\" - (lex-map (cut list tag <>) lexer)) -")) - - (p [Taking a step back, it becomes apparent that dependency isolation -is a general problem that isn’t confined to software written in Ruby: -Node has npm and nvm, Python has pip and virtualenv, and so on. A big -limitation of all these language-specific package managers is that -they cannot control what is outside of their language domain. In -order to use RVM to successfully compile a version of Ruby, you need -to make sure you have the GCC toolchain, OpenSSL, readline, libffi, -etc. installed using the system package manager (note: I’ve seen RVM -try to build prerequisites like OpenSSL before, which I then disabled -to avoid duplication and security issues and I recommend you do the -same.) In order to use Bundler to install Nokogiri, you need to make -sure libxml2 has been installed using the system package manager. If -you work with more than a single language, the number of different -package management tools needed to get work done is staggering. For -web applications, it’s not uncommon to use RVM, Bundler, NPM, Bower, -and the system package manager simultaneously to get all of the -necessary programs and libraries. Large web applications are -notoriously difficult to deploy, and companies hire a bunch of -operations folk like me to try to wrangle it all.]) - - (p [Anyway, let’s forget about Node, Python, etc. and just focus on -Ruby. Have you or someone you work with encountered hard to debug -issues and Git merge conflicts due to a problem with -,(code [Gemfile.lock])? Bundler’s fast and loose versioning in the -,(code [Gemfile]) (e.g. ,(code [rails >= 4.0])) causes headaches when -different users update different gems at different times and check the -resulting auto-generated ,(code [Gemfile.lock]) into the repository. -Have you ever been frustrated that it’s difficult to deduplicate gems -that are shared between multiple bundled gem sets? Have you looked at -the ,(anchor [RVM home page] "https://rvm.io") and been frustrated -that they recommend you to ,(code [curl bash]) to install their -software? Have you been annoyed by RVM’s strange system of overriding -shell built-ins in order to work its magic? I’m not sure how you -feel, dear reader, but my Ruby environments feel like one giant, -brittle hack, and I’m often enough involved in fixing issues with them -on my own workstation, that of my colleagues, and on production -servers.]) - - (p [So, if you’re still with me, what do we do about this? How can we -work to improve upon the status quo? Just use Docker? Docker is -helpful, and certainly much better than no isolation at all, but it -hides the flaws of package management inside an opaque disk image and -restricts the environments in which your application is built to -function. The general problem of dependency isolation is orthogonal -to the runtime environment, be it container, virtual machine, or “bare -metal.” Enter functional package management. What does it mean for a -package manager to be functional? GNU Guix, the functional package -manager that I contribute to and recommend, has this to say:]) - - (blockquote - (p [GNU Guix is a functional package management tool for the GNU -system. Package management consists of all activities that relate -to building packages from sources, honoring their build-time and -run-time dependencies, installing packages in user environments, -upgrading installed packages to new versions or rolling back to a -previous set, removing unused software packages, etc.]) - (p [The term functional refers to a specific package management -discipline. In Guix, the package build and installation process -is seen as a function, in the mathematical sense. That function -takes inputs, such as build scripts, a compiler, and libraries, -and returns an installed package.])) - - (p [Guix has a rich set of features, some of which you may find in -other package managers, but not all of them (unless you use another -functional package manager such as Nix.) Gem/Bundler can do -unprivileged gem installation, but it cannot do transactional upgrades -and rollbacks or install non-Ruby dependencies. Dpkg/yum/pacman can -install all build-time and runtime dependencies, but it cannot do -unprivileged package installation to isolated user environments. And -none of them can precisely describe the ,(em [full]) dependency -graph (all the way down to the C compiler’s compiler) but ,(em [Guix -can]).]) - - (p [Guix is written in Guile, an implementation of the Scheme -programming language. The upcoming release of Guix will feature a -Ruby build system that captures the process of installing gems from -,(code [.gem]) archives and a RubyGems import utility to make it -easier to write Guix packages by using the metadata available on -,(anchor "RubyGems.org" "https://rubygems.org"). Ruby developers -interested in functional package management are encouraged to try -packaging their gems (and dependencies) for Guix.]) - - (p [Now, how exactly can Guix replace RVM and Bundler? Guix uses an -abstraction called a “profile” that represents a user-defined set of -packages that should work together. Think of it as having many -,(code [/usr]) file system trees that can be used in isolation from the -others (without invoking virtualization technologies such as virtual -machines or containers.) To install multiple versions of Ruby and -various gems, the user need only create a separate profile for them:]) - - (source-code - "$ guix package --profile=project-1 --install ruby-2.2 ruby-rspec-3 -# Hypothetical packages: -$ guix package --profile=project-2 --install ruby-1.9 ruby-rspec-2") - - (p [A profile is a “symlink forest” that is the union of all the -packages it includes, and files are deduplicated among all of them. -To actually use the profile, the relevant environment variables must -be configured. Guix is aware of such variables, and can tell you what -to set by running the following:]) - - (source-code - "$ guix package --search-paths --profile=project-1") - - (p [Additionally, you can also create ad-hoc development environments -with the ,(code [guix environment]) tool. This tool will spawn a -sub-shell (or another program of your choice) in an environment in -which a set of specified packages are available. This is my preferred -method as it automagically sets all of the environment variables for -me and Guix is free to garbage collect the packages when I close the -sub-shell:]) - - (source-code - "# Launch a Ruby REPL with ActiveSupport available. -$ guix environment --ad-hoc ruby ruby-activesupport -E irb") - - (p [In order to make this environment reproducible for others, I -recommend keeping a ,(code [package.scm]) file in version control that -describes the complete dependency graph for your project, as well as -metadata such as the license, version, and description:]) - - (source-code - (scheme-source - "(use-modules (guix packages) - (guix licenses) - (guix build-system ruby) - (gnu packages) - (gnu packages version-control) - (gnu packages ssh) - (gnu packages ruby)) - -(package - (name \"cool-ruby-project\") - (version \"1.0\") - (source #f) ; not needed just to create dev environment - (build-system ruby-build-system) - ;; These correspond roughly to \"development\" dependencies. - (native-inputs - `((\"git\" ,git) - (\"openssh\" ,openssh) - (\"ruby-rspec\" ,ruby-rspec))) - (propagated-inputs - `((\"ruby-pg\" ,ruby-pg) - (\"ruby-nokogiri\" ,ruby-nokogiri) - (\"ruby-i18n\" ,ruby-i18n) - (\"ruby-rails\" ,ruby-rails))) - (synopsis \"A cool Ruby project\") - (description \"This software does some cool stuff, trust me.\") - (home-page \"https://example.com\") - (license expat))")) - - (p [With this package file, it is simple to an instantiate a -development environment:]) - - (pre (code [$ guix environment -l package.scm])) - - (p [I’m not covering it in this post, but properly filling out the -blank ,(code [source]) field above would allow for building -development snapshots, including running the test suite, in an -isolated build container using the ,(code [guix build]) utility. This -is very useful when composed with a continuous integration system. -Guix itself uses ,(anchor "Hydra" "https://nixos.org/hydra/") as its -CI system to perform all package builds.]) - - (p [As mentioned earlier, one of the big advantages of writing Guix -package recipes is that the full dependency graph can be captured, -including non-Ruby components. The pg gem provides a good example:]) - - (source-code - (scheme-source -"(define-public ruby-pg - (package - (name \"ruby-pg\") - (version \"0.18.2\") - (source - (origin - (method url-fetch) - (uri (rubygems-uri \"pg\" version)) - (sha256 - (base32 - \"1axxbf6ij1iqi3i1r3asvjc80b0py5bz0m2wy5kdi5xkrpr82kpf\")))) - (build-system ruby-build-system) - (arguments - '(#:test-target \"spec\")) - ;; Native inputs are used only at build and test time. - (native-inputs - `((\"ruby-rake-compiler\" ,ruby-rake-compiler) - (\"ruby-hoe\" ,ruby-hoe) - (\"ruby-rspec\" ,ruby-rspec))) - ;; Native extension links against PostgreSQL shared library. - (inputs - `((\"postgresql\" ,postgresql))) - (synopsis \"Ruby interface to PostgreSQL\") - (description \"Pg is the Ruby interface to the PostgreSQL RDBMS. It works - with PostgreSQL 8.4 and later.\") - (home-page \"https://bitbucket.org/ged/ruby-pg\") - (license license:ruby)))")) - - (p [Note how the recipe specifies the PostgreSQL dependency. Below -is the dependency graph for ruby-pg as produced by ,(code [guix -graph]), excluding the GCC compiler toolchain and other low-level -tools for brevity. Pretty neat, eh?]) - - (image/caption "/images/ruby-pg-graph.png" - "Abbreviated dependency graph for the pg gem") - - (p [Given that Guix doesn’t yet have many gems packaged (help -wanted), it can still be advantageous to use it for getting more -up-to-date packages than many distros provide, but in conjuction with -Bundler for fetching Ruby gems. This gets RVM out of your hair whilst -creating a migration path away from Bundler at a later time once the -required gems have been packaged:]) - - (source-code - "$ cd my-project/ -$ guix environment --ad-hoc ruby bundler libxml2 libxslt # etc. -# A small bash script can be used to make these gem sets. -$ mkdir .gems -$ export GEM_HOME=$PWD/.gems -$ export GEM_PATH=$GEM_HOME:$GEM_PATH -$ export PATH=$GEM_HOME/bin:$PATH -$ bundle install") - - (p [As you’ve seen in the above package snippets, Guix package -definitions are typically very short and rather easy to write -yourself. The ,(code [guix import gem]) tool was made to lower ,(code - [foo bar]) the barrier even more by generating most of the boilerplate -code. For example:]) - - (source-code "$ guix import gem pry") - - (p [Produces this Scheme code:]) - -(source-code - (scheme-source - [;;; hello there -(+ 1 2 3)])) - - (source-code - (scheme-source - "(package - (name \"ruby-pry\") - (version \"0.10.1\") - (source - (origin - (method url-fetch) - (uri (rubygems-uri \"pry\" version)) - (sha256 - (base32 - \"1j0r5fm0wvdwzbh6d6apnp7c0n150hpm9zxpm5xvcgfqr36jaj8z\")))) - (build-system ruby-build-system) - (propagated-inputs - `((\"ruby-coderay\" ,ruby-coderay) - (\"ruby-method-source\" ,ruby-method-source) - (\"ruby-slop\" ,ruby-slop))) - (synopsis - \"An IRB alternative and runtime developer console\") - (description - \"An IRB alternative and runtime developer console\") - (home-page \"http://pryrepl.org\") - (license expat))")) - - (p [One still has to package the propagated inputs if they aren’t -yet available, add the necessary inputs for building native extensions -if needed, and fiddle with the native inputs needed to run the test -suite, but for most pure Ruby gems this gets you close to a working -package quickly.]) - - (p [In conclusion, while support for Ruby in Guix is still in its -early days, I hope that you have seen the benefits that using a -general-purpose, functional package manager can bring to your Ruby -environments (and all other environments, too.) For more information -about Guix concepts, installation instructions, programming interface, -and tools, please refer to the -,(anchor [official manual] "https://gnu.org/software/guix/manual"). - -Check out the ,(anchor [help] "https://gnu.org/software/guix/help") -page for ways to contact the development team for help or to report -bugs. If you are interested in getting your hands dirty, please -,(anchor [contribute] "https://gnu.org/software/guix/contribute"). -Besides contributions of code, art, and docs, we also need ,(anchor -[hardware donations] "https://gnu.org/software/guix/donate") to grow -our build farm to meet the needs of all our users. Happy hacking!])) |