Forem: Ritvik Nag

How I Automated Parking Permit Purchases at GMU with Python

Ritvik Nag — Fri, 05 Sep 2025 03:26:56 +0000

As a grad student at George Mason University (GMU), I commute to Fairfax once a week for evening classes. Like many commuters, I need parking — but only for a few hours, usually 4–7 PM.

Buying a semester-long permit didn’t make sense for my schedule (or wallet). Instead, the daily parking permits turned out to be cheaper and more flexible.

The problem? I always procrastinated. I’d remember to buy a permit at the last minute, sometimes right before class. It was stressful, repetitive, and just annoying.

So, being a CS student, I did what came naturally:

👉 I automated the entire process.

The Idea

Every week, I needed to:

Go to the GMU parking portal.
Log in with my credentials.
Navigate through a bunch of menus.
Select the right permit.
Enter payment details.

It was the same steps every time. Why not let Python handle it?

The Tool

I built a small open-source tool in Python that:

Automates login to the GMU parking portal up to the Duo Mobile 2FA step (which still requires approval on your phone).
Selects the correct daily parking permit.
Completes the checkout flow.
Emails me a confirmation when done.

That’s it — no more last-minute scrambling.

📽️ Demo Video: YouTube

💻 Source Code: GitHub – GMU Daily Permit Automation

Tech Breakdown

At its core, this project uses:

Selenium – to control a browser and interact with the GMU parking site.
Headless mode – so it runs quietly in the background.
Config + Environment variables – to keep credentials and payment info safe.
Task scheduling (optional) – you could use cron (Linux/Mac) or Task Scheduler (Windows) to kick off the script automatically. I usually just run it manually before class.
Duo Mobile 2FA – you’ll still need to approve the login from your phone. The script pauses at this step until Duo is confirmed.

Here’s a simplified example of what the login step looks like in Python with Selenium:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

# Start the browser (headless mode can be enabled too)
driver = webdriver.Chrome()

# Go to GMU parking login page
driver.get("https://gmu.t2hosted.com/Account/Portal")

# Enter username
username_input = driver.find_element(By.ID, "username")
username_input.send_keys("myusername")

# Enter password
password_input = driver.find_element(By.ID, "password")
password_input.send_keys("mypassword")
password_input.send_keys(Keys.RETURN)

# (From here, the script navigates menus and purchases the permit)

The real project handles edge cases, payment, and confirmation, but this snippet shows the basic automation flow.

Lessons Learned

A few interesting takeaways while building this:

University systems often don’t have APIs, so web automation is sometimes the only option.
Security matters – never hardcode sensitive info; use config files or environment variables.
Even small automations can save you from recurring stress (and are great coding practice).

Try It Yourself

If you’re at GMU (or curious about automation), you can try it out:

👉 GitHub Project

The README has setup instructions. Just remember: use responsibly — the tool isn’t affiliated with GMU Parking Services, and you should only automate your own account.

Final Thoughts

This project started as a way to save myself from procrastination, but it turned into a fun automation experiment. It’s one of those small quality-of-life improvements that adds up.

If you’re a fellow GMU commuter, hopefully this helps you too. And if you’re a developer, maybe it’ll inspire you to automate some of your own daily annoyances.

While Duo Mobile means this isn’t 100% hands-free, it still saves me from repeating the same web clicks every week.

As always, thanks for reading. If you liked the article please add a reaction or two so other users can find it more easily. Also feel free to give me a follow at ritvik-nag to stay up to date with any articles I publish.

Originally published at https://ritviknag.com on September 4, 2025.

Sleep Mode: Automating Wi-Fi & Bluetooth Off at Night on Apple Devices

Ritvik Nag — Thu, 22 May 2025 04:53:28 +0000

As a runner and fitness enthusiast, sleep is essential for my recovery — and yet, it’s something I’m constantly working to improve. I aim for 8 hours a night, but my Apple Watch reports an average closer to 6.5 hours over the past few months, with some nights dipping as low as 5. Being a light sleeper doesn’t help either. I’ve experimented with wax earplugs to block out noise and blackout curtains to keep light at bay.

One thing I’ve wanted to automate for a while now is disabling Wi-Fi and Bluetooth on the devices near my bed — including both my personal and work MacBooks, my iPhone, and ideally even my Apple Watch (which I wear to track sleep). These devices all stay in my bedroom overnight, so minimizing potential sleep disruptors has become a personal experiment.

You might ask: why go through the trouble of shutting off Wi-Fi and Bluetooth automatically? It’s a fair question. This study raises concerns that Wi-Fi radiation may impact sleep quality and increase the risk of insomnia. And this video explanation discusses the potential relationship between wireless radiation and disrupted sleep. While scientific research on the topic is still largely inconclusive, I figured that if there's even a slight chance of improving sleep quality by reducing exposure, it's worth exploring.

So for the past several months, I’ve had an automation in place that turns off Wi-Fi and Bluetooth on my Apple devices around bedtime — and in this post, I’ll share how I set that up in case you’re looking to try something similar.

Creating the Shortcuts

The first step involves opening the Shortcuts app on a Mac laptop or device. The easiest way is to hit Cmd + Space and search for Shortcuts.

The icon should look like this:

I’ve created two shortcuts. One called “Start Morning” to enable Wi-Fi/Bluetooth, and another called “Night Time” to disable Wi-Fi/Bluetooth and put the display to sleep, as shown below. They both use the “Set Wi-Fi” and “Set Bluetooth” actions, which you can find using the Action Library on the right.

Creating Automator Scripts

Next, I opened up the Automator app — the Cmd + Space works here too — and go to File > New to create a new automation. I need to do this twice, once for each action.

Search for the “Run Shell Script” action. Then in the settings, select /bin/bash as the Shell, and enter this code in the bash code block:

shortcuts run "Start Morning"

Here, "Start Morning" is the name of your first shortcut. If you named it something else, update the name here accordingly. The executable command shortcuts can also be run from the Mac Terminal app, and is simply a handy, automated way to interact with your shortcuts on the Shortcuts app.

Here’s a screenshot of this — you can name this StartMorning.app and save it to your /Applications folder, but here you can see I’ve saved it to under my iCloud Drive > Automator , for an important reason I’ll cover later:

Lastly, go to File > New again and search for the “Run Shell Script” action. Then in the settings, select /bin/bash as the Shell as last time, and enter this code in the bash code block:

shortcuts run "Night Time"

Replacing "Night Time" if you chose to use a different name for the shortcut. I’ve again saved this to my iCloud Drive, as shown below:

Now, there’s a few way to schedule these two automations on a Mac. You can either set up a cron job or, in my case, I chose to use the Calendar app. I got all these steps from an article a long time ago, but now for the life of me I can’t seem to find that article — I guess that’s one reason to bookmark an interesting site that you come across.

Scheduling with Calendar

Regardless, the next step is to open the Calendar app on your Mac.

Now, remember how I saved the Automator scripts to iCloud Drive, inside an “Automator” folder? There’s a reason for that. If you’re using just one Mac — say, a personal laptop — saving the scripts to /Applications works fine. But in my case, I use both a MacBook Air (personal) and a MacBook Pro (work). I wanted the Wi-Fi and Bluetooth toggling to sync across both devices.

After some trial and error, I found that Calendar events sync automatically across Apple devices — but local file paths like /Applications do not. So, if the script lives in /Applications on one Mac, the synced calendar event on the second Mac will break. By storing the script in iCloud Drive, both Macs can access the same path, and I only have to set up the Calendar automation once (in theory, at least).

First thing I did was hit the + button at the top to create a new Calendar event. I called the first one “Start Morning”, set it to repeat daily at 8:00 AM, and the important bit here is to expand the event, click on “Add Alert, Repeat, or Travel Time”, and then to go to where you see alert: None, click the dropdown, and go to Custom..., choose Open File and then in the second dropdown choose Other... . In the Finder window, locate and select the file location for the Automator script StartMorning.app that you saved in previous step. Next, though technically not needed, I clicked the dropdown to alert 15 Minutes before and changed it to At time of event.

You can see the event which turns on Wi-Fi/Bluetooth here:

Lastly, do the same for the “Night Time” event! I set it to repeat daily at 11:00 PM based on my sleep schedule, but feel free to adjust accordingly based on yours! I followed the same steps as above. I chose Open File and then in the second dropdown choose Other... . In the Finder window, locate and select the file location for the Automator script NightTime.app that you saved in previous step.

You can see the final event which switches off Wi-Fi/Bluetooth here:

And that’s it! All my Mac devices will effectively go into Airplane Mode at my sleep time at 11 PM, and wake up from Airplane Mode at 8 AM the next day automatically. Problem solved!

Scheduling on iPhone

Is it possible to schedule the same on an iPhone?

You betcha! It’s actually a bit easier, since you only have to set Airplane Mode, rather than Wi-Fi and Bluetooth individually.

I opened the “Shortcuts” app on my iPhone. I created my first automation, which runs on a schedule — at 11:00 PM, daily in my case — and the action I chose is Set Airplane Mode > ON. This is shown below:

Lastly, rather than turn on my iPhone in the morning at a specific time, I chose to create an automation with a trigger that runs when my phone is disconnected from power — since I wirelessly charge it overnight — and the action I chose is Set Airplane Mode > OFF. This is shown below:

Scheduling on Apple Watch

The final piece of the puzzle is my Apple Watch. Since I wear it every night to track sleep, I’d hoped to schedule Wi-Fi shutoff there as well. Unfortunately, even with the Shortcuts app, there doesn’t seem to be a way to automate Wi-Fi toggling on the Watch. For now, I’ve resorted to doing it manually: unlock the Watch, press the side button, and tap the blue Wi-Fi icon. Not ideal, but a small inconvenience — especially since everything else is automated.

Whether or not Wi-Fi exposure truly impacts sleep quality remains an open question. But for me, this setup offers peace of mind. And that, in itself, helps me sleep better.

Hope this was helpful — and if you end up building something similar, I’d love to hear how it goes.

Thanks for reading.

Originally published at https://ritviknag.com on May 22, 2025.

Navigating Medium API with JavaScript in 2024

Ritvik Nag — Sun, 18 Feb 2024 02:56:06 +0000

Background

I'm trying to integrate Medium blogging into my personal site at myname.com.

That is, I'm trying to automate the process of publishing an article on my personal blog, and have the contents of the Jekyll-based markdown post -- a .md file -- be posted to the two other blogging sites I'm currently signed up on, medium.com and dev.to.

Towards that end, I tried to search online to see if there is such as a thing as a Medium API that allows me to:

Publish and/or update a post for a user
Retrieve a list of posts for a user

Turns out, only the first point is currently possible via the Official Medium API, and that too, it's only partially satisfied -- there is currently no route via the API to update a post on a Medium. One can only create a new post on Medium via the API, but that's about it.

With the Official Medium API as it stands -- which is no longer supported or maintained by the Medium team -- one can only retrieve user info and create a post, they cannot do anything much more useful than that, for example it is not possible to retrieve a list of a user's posts via the API.

How to Auto-Update a Medium Post

This is slightly tangential to the matter, but I haven't expressed my discontent with not being able to automate the updating of a post on Medium via an API. I fooled around this with their API -- for example using an HTTP PUT request - for way too long, and didn't get anywhere with that at all. It's a real shame that we can only publish new posts via the API, and that it's not possible to update an existing post via an API.

In fact, this proved the impetus or drive for me to publish an online web tool that easily translates posts from markdown to medium, which I have published on my website:

https://ritviknag.com/markdown-to-medium

I made this above tool for myself, so I can take my personal blog posts, written in .md files, paste them in there and copy the output to Medium when using the editor to update an existing post.

Anyway, slight detour there...

All this to say that I was not able to find a solution via the API that worked for me, to list all the posts under a given user. The reason for this is purely for automation purposes, such that whenever I change a blog post -- or .md file -- on my website, I want to publish a new post to Medium, but only if there is not already an existing post with that same title. So basically, I want to avoid re-publishing a post every time I make an update to it -- if that's even possible!

My Search

My search led me to Google search for something along the lines of "medium api get all user posts", which led me more or less to this somewhat informative article on StackOverflow:

https://stackoverflow.com/q/36097527/10237506

As the accepted answer says, the Medium API is only intended for Publishing and is not intended to retrieve posts.

A workaround that is suggested is to simply use the RSS feed that Medium offers, as such:

https://medium.com/feed/@username

For example, here is the RSS feed for my user:

https://medium.com/feed/@ritviknag

One can simply get the RSS feed via GET, then if it's needed in JSON format just use an NPM module like rss-to-json and we're good to go.

However, there is an issue with this approach, as another answer in the same SO post confirms:

[...] has a limit of the latest 10 posts.

So, there is a limit of only retrieving 10 posts for a given user using the RSS feed option.

Looks like we need another solution!

Unofficial Medium API

I would be remiss if I didn't mention an alternate approach.

There is an Unofficial Medium API that someone has come up with. This is the link to it below:

https://mediumapi.com

Unfortunately, it's not an insignificant commitment to sign up with that API. Take a look below:

As noted, there appears to be a subscription tier for using that API.

If I, as a developer, want to build an API wrapper around the Medium SDK to retrieve a User's posts, using this option I would be forced into:

Create a RapidAPI key for mediumapi.com, or directing users of the library to sign up on another site and acquire a RapidAPI key for requests to mediumapi.com.
Rate limiting my library at 150 requests / month, assuming I want to hardcode and provide users with my RapidAPI key, in order to provide convenience and promote adoption of said library.

In short, this is likewise a disaster, albeit of different proportions. There is no way I can use a third-party, unofficial API, even though I have personally tested out this API endpoint and confirmed that it returns the correct and desired data.

Thus, the unavoidable road to the DIY project, begins...

The "Eureka!" Moment

To me, the lightbulb went off, when I was just bored and staring at a random Medium user's profile, and I had Chrome Developer tools open and was just browsing casually through the Network tab.

The graphql endpoints, in particular, stood out to me:

If curious, the URL to that is https://medium.com/_/graphql, and it's an HTTP POST request that gets sent.

Shortly after, I fired up Google search again and this time inputted keywords "how to use medium api graphql to fetch all user posts".

The result was this highly informative post on using Medium's GraphQL endpoint to retrieve Medium posts for a user:

https://medium.com/@mike820324/web-crawler-getting-medium-post-a6e52fd36fd6

I decided to implement the same logic in the JavaScript (Node.js + TypeScript) library I was writing, with an intent to publish as an NPM package to npmjs.com.

The hardest part for me was how to:

Modify the GraphQL query to only return user post titles
Paginate through the results, as GraphQL appears to have a limit of 25 results (posts) per request.

I managed to figure that out, even though it took me a long while.

By the way, I adapted the code from a fork of the Medium SDK for Node.js.

I made my own changes, and a lot of updates along the way.

Simply said, this was the very first TypeScript NPM package I had ever written. So there was a lot of learning curve.

The Result

The work was split into a few main parts:

Porting over existing Medium SDK code from Node.js to TypeScript.
The hurdle that come with publishing a TypeScript NPM package, such as setting up tsconfig.json to allow support for both ESM and CommonJS syntax simultaneously.
Integrating pagination and GraphQL into the codebase.
Best practices for NPM projects in TypeScript, such as setting up code quality checks and CI/CD automation -- such as publishing package to a registry (NPM) automatically.

This project is the direct result of my hard work and effort:

https://github.com/rnag/medium-sdk-ts

Below is the package on the NPM registry:

https://www.npmjs.com/package/medium-sdk-ts

Install

The package can be installed with npm, or a package manager of choice:

npm i medium-sdk-ts

Import

The library supports importing via the newer, more modern ES Module (ESM) syntax prevalent in TypeScript code:

import {
  MediumClient,
  PostContentFormat,
  PostPublishStatus,
} from 'medium-sdk-ts';

Or, for CommonJS syntax in Node.js, using require:

const {
    MediumClient,
    PostContentFormat,
    PostPublishStatus,
} = require('medium-sdk-ts');

Usage

Now create a client for the Medium SDK:

// Access Token is optional, can also be set
// as environment variable `MEDIUM_ACCESS_TOKEN`
const medium = new MediumClient('YOUR_ACCESS_TOKEN');

Retrieve User Details:

const user = await medium.getUser();
console.log(`User: ${JSON.stringify(user, null, 2)}`);

Publish a new Draft Post under your user:

const post = await medium.createPost({
    // Only `title` and `content` are required to create a post
    title: "'A new post',"
    content: '<h1>A New Post</h1><p>This is my new post.</p>',
    // Optional below
    contentFormat: PostContentFormat.HTML,   // Defaults to `markdown`
    publishStatus: PostPublishStatus.DRAFT,  // Defaults to `draft`
    // tags: ["my", "tags"],
    // canonicalUrl: "https://my-url.com",
});

console.log(`New Post: ${JSON.stringify(post, null, 2)}`);

Retrieve a User's Published Posts (using GraphQL endpoint, which does not require an access token):

// Get User's Published Posts
const posts = await medium.getPosts('@username');
console.log(`User Post: ${JSON.stringify(posts, null, 2)}`);

Or, to simply retrieve the user's post titles only -- note that this results in a slightly more simplified GraphQL query being sent:

// Get User's Published Posts (Title Only)
const postTitles = await medium.getPostTitles('@username');
console.log(`User Post Titles: ${JSON.stringify(postTitles, null, 2)}`);

That's all for now!

I hope this post was informative. Feel free to play around with this NPM package I have published.

Again, here is the source code for it: https://github.com/rnag/medium-sdk-ts

If this library has proved useful in your automation efforts, please let me know via the comments down below, and feel free to also star the project on GitHub if you'd like.

As mentioned, this is my first-ever TypeScript library package I have published to NPM, so I would appreciate the support or feedback on it -- do certainly let me know if there's anything else I can improve on it.

Originally published at https://ritviknag.com on February 17, 2024.

How to Mount Current Working Directory To Your Docker Container

Ritvik Nag — Fri, 09 Feb 2024 17:25:31 +0000

My team has been building out a new web app in Express.js, and for local deployment and testing we use nodemon, babel, and Docker.

One of the burning questions we wanted to find an answer to - apart from the ultimate question of all life, the universe, and everything - is how can we mount our local (current) directory to the running Docker container, so that nodemon can listen for local file changes when we develop, and automatically reload or restart the (containerized) web server as needed.

Towards that end, I hastily Googled online for "Can Docker mount local drive and listen for file changes", and even kicked this same prompt to my work-approved AI assistant (*wink* ChatGPT alternative?). Anyway, the responses from the AI prompt are recorded separately below.

By the way, this article is inspired by some other articles on that I found on the web while researching if such a thing is possible - e.g. mounting a local folder to a Docker container - including the following article on Medium, which does a good job of condensing the main points:

How To Mount Your Current Working Directory To Your Docker Container In Windows

As I and my team are developing on an (Apple Silicon-based) Mac, we don't care too much about the docker run command being compatible between Mac and Windows overmuch.

However, I certainly agree that Docker is super handy for anyone wanting to write software in a Linux environment while still running a Mac (or Windows) computer.

Theory

Our Dockerfile - we use the same one for development and production - looks something like this:

# Start from the Node.js image for AMD64 architecture
FROM --platform=linux/amd64 node:latest

# Set the working directory for your Node.js app
WORKDIR /usr/app

ARG PORT
ARG NODE_ENV

ENV PORT=$PORT
ENV NODE_ENV=$NODE_ENV

# Some installation steps
...

# Copy your Node.js application files and the startup script
COPY . .
COPY start.sh .

# Make the startup script executable
RUN chmod +x ./start.sh

# Install Node.js dependencies
RUN npm install --include=dev

# Expose the port your app runs on
EXPOSE $PORT
EXPOSE 80

# Command to run the startup script
CMD ["./start.sh"]

We have a custom start.sh script we use to start our web server. This basically calls npm run start & within it - e.g. our npm script start.

The above Dockerfile basically expects arguments to be passed in during the Docker build step.

This allows us to pass in environment variables (and Bash script values) such as the PORT for the web server, and NODE_ENV for the web app - such as dev or production .

docker build \
  --build-arg PORT=${PORT} \
  --build-arg NODE_ENV=${NODE_ENV} \
  --tag ${TAG} \
  .

To the question of mounting a local folder to a Docker container, obviously we only want to enable this behavior when running in development mode.

That is, we only want to mount a local directory to the container into the location at /usr/app - the WORKDIR from the Docker instructions above - when we are in development mode, and we don't want to mount anything when we are building a production Docker image, to later ship to Amazon ECR for example.

This is a great use case for the potential solution, which will be discussed below. Now that we have the theory in place of what we want to achieve:

We would rather not update Dockerfile to mount a volume or a local folder.
Not necessary (or desirable) to mount local folder to a volume when running docker build to create an image from a Dockerfile . This is because need to create separate docker build commands for development and non-development, which is harder to management.
Ideal solution will be to update only docker run command. Which we only run locally anyway. We do not need to execute docker run for production, as generally for production we just push the final image directly to ECR via a shell command.

Goal

Now that theory is knocked out of the way, we understand that we prefer to update docker run command syntax, rather than touch docker build or Dockerfile itself.

Also, it is important here to go over the problem statement once more.

The goal that we are trying to solve is how to obviate the need to rebuild the Docker image every time an HTML, JS, EJS, CSS, or similar file in the current local directory changes.

The host's current directory is the same that we are copying over to /usr/app on the Docker container, as specified in the above Dockerfile .

This can be a simple change because of renaming your project, or changing any of the code for the project itself. This is not ideal.

There is a way to mount a local folder as a volume on a Docker container. This will solve it for us, when we are running nodemon on the Docker container to listen for file changes on the /usr/app location on the container side. We can instead trick Docker to listen for local file changes instead - let us see how this is possible.

Online Results

When searching online for the prompt "Can Docker mount local drive and listen for file changes" - as this would be incredibly helpful for local development - I found the below articles to be helpful.

Also, note that the first result is from the official Docker documentation itself. This was helpful for me to determine if Docker can mount local drive and listen for file changes.

In short, this appears to be a question of --volume vs. -- mount with a type:bind. The Docker docs (see first link above) mention that using --volume is the old style, and there is one important difference in behavior. Hence, using --mount explicitly going forward seems to be the safer (and more future-proof) approach.

However, note that either approach (--volume or --mount) should work for our use case.

Ask an AI Assistant

When I kicked the same prompt (more or less) to an AI assistant, this is what it replied with - rest of its response truncated for abbreviation sake.

Yes, Docker mount local drive to listen for file changes should certainly be possible.

Mounting a Host Directory in a Docker Container:

You can use the -v flag with the docker run command to mount a local directory into a container. For example:

docker run -v /path/to/host/directory:/path/in/container my_image

Replace /path/to/host/directory with the actual path to your local directory and /path/in/container with the desired path inside the container.
This approach ensures that any updates made in the host directory are reflected within the container.

Wow, that wasn't too bad. It got us more than halfway there. Honestly, if we want to use the legacy --volume option, we can just go with the AI suggestion. But to future-proof it, we can make a small tweak and use --mount instead, as we'll see below.

The Trick

I've found the best, future-proof method is to use the --mount type=bind flag when running the docker run command. With this command, you can attach the local directory to your docker container at runtime instead of during the build process.

The --mount type=bind command takes a single parameter formatted like so:

src=<host directory>,dst=<target directory>

If we want to exclude any sub-folders in our <host directory> when mounting the local folder to the Docker container, we need to pass --mount type=volume with the full path to that sub-folder, and exclude the src argument, as follows:

dst=<host directory to not mount>

Example

It's easier to understand the trick when put into practice.

Putting it all together, here I've created a scenario where I would like to:

Mount my current working directory (/Users/rnag/Git-Projects/Work/my_project) into the alpine:latest image at the /usr/app location in the container.
Make the run command compatible for Apple-silicon-based Mac's, with --platform linux/amd64 .
Exclude (skip) copying over the node_modules sub-folder in my current working directory, when mounting my current working directory . to the /usr/app location in the container.

We would do that as so:

docker run -it --platform linux/amd64 --mount type=bind,src=.,dst=/usr/app --mount type=volume,dst=/usr/app/node_modules alpine:latest

Or, prettified a bit more, for all you neat freaks (like me):

docker run \
  -it \
  --platform linux/amd64 \
  --mount type=bind,src=.,dst=/usr/app \
  --mount type=volume,dst=/usr/app/node_modules \
  alpine:latest

This should start up your container and attach your working directory. Now any changes you make locally (i.e. in your Mac or Windows machine) will be reflected in your Docker container!

In short, this will solve it for us, when we are running nodemon or similar on the Docker container to listen for file changes on the /usr/app location on the container side. We have successfully tricked Docker to listen for local file changes instead - what a win!

Originally published at https://ritviknag.com on February 9, 2024.

Ruby (Versioning) Hell with Jekyll & GitHub Pages

Ritvik Nag — Mon, 29 Jan 2024 01:21:56 +0000

So, huge disclaimer, a lesser-known fact (who am I kidding, I'm not ashamed to admit it) is that I'm a bit of a ruby newbie.

That is, I've never cared to learn ruby before. Also, perhaps as a direct result of that, I am a little taken aback when a project asks me to install ruby and use tools that it provides such as bundler , because the assumption there is that I know what I am doing.

Just to set the record straight, I don't know what I am doing when it comes to anything ruby .

Recently, a lot of stuff blew up and hell broke loose, when I inadvertently ran brew upgrade on my new Mac to update (or upgrade?) packages installed by homebrew.

But alas, I did not take ruby into account. A while back, I had installed ruby with homebrew:

$ brew install ruby

Homebrew, without my permission, apparently took it upon itself to upgrade the bundled ruby version - from 3.2.3 to 3.3.0.

Hell broke lose when I cd'd into my project repo that I use for my website, and ran bundle to install fresh dependencies - which was needed, since ruby version was upgraded, so it was a fresh environment with no gems available.

$ bundle install

The error I received was something like this:

~/<user>/somewhere $ bundle exec jekyll serve
jekyll 3.9.3 | Error:  undefined method `[]' for nil
/usr/local/Cellar/ruby/3.3.0/lib/ruby/3.3.0/logger.rb:384:in `level': undefined method `[]' for nil (NoMethodError)

    @level_override[Fiber.current] || @level

This indeed was the specific error message I saw:
Error: undefined method '[]' for nil

Searching online, you can see a whole slew of posts that mention this error, and apparently it only happens with ruby 3.3.0 and the jekyll version 3.9.3 that comes bundled with github-pages .

Hence, while it might not bear repeating, it helps to clarify - upgrading jeykll version for a project is a no-go, especially when the project Gemfile relies explicitly on github-pages dependency, which itself relies on jekyll :

gem "github-pages", group: :jekyll_plugins

And yes, just to double check, the Gemfile.lock should show the lines that clearly show the dependency relationship between the

    github-pages (228)
      github-pages-health-check (= 1.17.9)
      jekyll (= 3.9.3)
    ...

To recap, if one installs ruby with brew and runs brew upgrade or similar and results in ruby@3.3.0 being inadvertently installed, this can break when attempting to work with projects that rely on a specific version of jekyll, especially ones that rely on github-pages gem for deployment.

There does not appear to be any solution involving brew and ruby alone.

Upon catching the issue that the mismatch b/w the two gems caused the build error when running bundle exec jekyll serve , I immediately tried some steps, that first involved installing csv , as apparently there was a warning printed to terminal since that doesn't come bundled in ruby 3.3.0

$ bundle install csv

Then I tried to upgrade all gem versions in project by running:

$ bundle upgrade

That didn't help, so I tried to specify both gems explicitly:

$ bundle update jekyll
$ bundle update github-pages

Still no dice, and I was at wit's end by now. Manually upgrading either of those gem versions specified in Gemfile.lock didn't help either. There was a dependency conflict if I upgraded jekyll, as github-pages relied on a specific version.

I also tried deleting Gemfile.lock file completely and running bundle again, but still no dice.

In short, this was exactly what they call "dependency hell". I cannot change either gem versions, and hence this is basically a "SNAFU!" situation. As in, there's no solution to be had that allows me to keep the up-to-date ruby version 3.3.0 for use with my project.

I even tried uninstalling and re-installing specific ruby version 2.3.2 via homebrew, but if you can believe it there still was no dice:

$ brew uninstall ruby
$ brew install ruby@3.2
$ echo 'export PATH="/opt/homebrew/opt/ruby@3.2/bin:$PATH"' >> ~/.zshrc
$ source ~/.zshrc
$ ruby -v
ruby 3.2.3
$ gem install bundler
$ bundle
<error>

I'll be honest, I felt like tearing my hair out at this point. Sweat started metaphorically trickling down my back. Being a ruby newb, I was about to throw in the towel, and as a last resort maybe open up an issue on the project page for one of the gems, or post about it on a forum asking other users for help.

Now that I think about it, maybe ChatGPT could have helped me. Hello ChatGPT? Can you explain this error please, and suggest me a solution <paste stack trace>.

However, thankfully, that was ultimately not needed. I found a workaround that helps me to maintain ruby version across different machines, consistently.

After researching online for quite a bit, I found out that someone was using rbenv and decided to look into what that is. Turns out, it's something similar like pyenv for python, or basically a version management tool for a programming language.

Feeling I was on to something at this point, and shrugging my shoulders after realizing I had nothing to lose, I decided to install it after all:

$ brew install rbenv ruby-build
$ echo 'eval "$(rbenv init - zsh)"' >> ~/.zshrc
$ source ~/.zshrc

That got me therbenv command, but of course I wasn't done there yet.

I have to install my necessary previous ruby version 3.2.3 with rbenv :

$ rbenv install 3.2.3

After installing a version with rbenv , you can set it either globally (so that ruby version is changed regardless of your location in terminal) or locally, so it will only affect a project after you cd into its folder.

I decided to do both, because the default ruby version that comes bundled with my new Mac Air M2 laptop is something like 2.x , which is hella old. And I'm clearly never gonna use the built-in one.

$ rbenv global 3.2.3
$ rbenv local 3.2.3

Now we're cooking! To double-check that we got the new ruby version installed:

$ ruby -v
ruby 3.2.3 (2024-01-18 revision 52bb2ac0a6) [arm64-darwin23]

Great! Now that's out of the way, we want to install or upgrade bundler, and then we're good to go.

$ gem install bundler
$ bundle -v
Bundler version 2.5.5

If it helps, one might need to delete and re-createGemfile.lock by running bundle, especially if it says the gems were installed with another version of bundler :

BUNDLED WITH
   2.5.4

After that, you can run bundle exec or however you start up your project that relies on jekyll and github-pages , and then you should be all set.

If it helps, I've actually created an alias command jb , which serves that exact purpose in my case:

$ which jb
jb: aliased to bundle exec jekyll serve -low

It's easy enough to add that alias in to bash or zsh shell configuration. To add it to zsh - my default interpreter - here's what I did:

echo "alias jb='bundle exec jekyll serve -low'" >> ~/.zshenv

Then source ~/.zshenv to reload the changes in the current terminal window.

All said, this whole ordeal took me >1 hour of pointless debuggery. It was the exact opposite of fun. And, ideally not how I would have wanted to spend a Sunday morning.

However, the upshot is that the confusing ruby versioning hell along with two of the aforementioned gems - jekyll and github-pages - is now finally resolved, at long lost.

Here then was a lesson learned: manage ruby versions with rbenv instead of homebrew.

Praise be! Massive dependency hell solved, and headache (mostly) avoided. Hope this helps someone else out. Now go out there and get coding!

Originally published at https://ritviknag.com on January 28, 2024.