The main reason I blog is to remember and share my life lessons (and get my thoughts out so my head doesn’t explode). It’s not always easy, between finding time to do it, not tearing apart my laptop after the first draft, and cringing over grammar mistakes notice months after posting.

But the toughest part is when I learn a lesson or overcome a struggle, only to realize I wrote about the same lesson months ago. Probably like most writers/bloggers/international spies, I have a hard time remembering my notes and how I’ve grown over time.

So last week, I made it a lot easier and wrote a script to email myself random bits of my writing each day.

Exposing all my site’s writing for this was as simple as making a couple of giant XML files. There’s one for blog posts, one for the Exocortex, and one for my notes. You can see the blog post example below, and you can see the output at this XML file.

{% assign posts = site.posts %}

{% for post in posts %}
  {% assign url = post.url | prepend: site.url %}

    <title type="html">{{ post.title }}</title>
    <link href="{{ url }}" rel="alternate" type="text/html" title="{{ post.title }}"/>

    <content type="html" xml:base="{{ url }}">
      {{ post.content | xml_escape }}
{% endfor %}

Next up is a Ruby class that can visit any of these URLs, parse the content, and grab a random item.

require 'net/http'
require 'json'
require "base64"
require 'nokogiri'
require 'redcarpet'
require 'redcarpet/render_strip'

class WebsiteContent
  def initialize(content_type)
    @url = "{content_type}.xml"

  def get_page
    response = api_response(@url)


  def parse_xml(body)
    xml_doc = Nokogiri::XML.parse(body)
    all_items = xml_doc.css("entry").map do |entry|
        title: entry.css("title").text,
        content: render_markdown(entry.css("content").text)


  def api_response(url)
    uri = URI(url)

  def render_markdown(content)
    markdown =, disable_indented_code_blocks: true, fenced_code_blocks: true)

Nokogiri is great for doing the parsing the XML document, and sample is one of those lovely Ruby methods for common tasks I wish JavaScript had.

All my site content is written in markdown, so that needs to be rendered into HTML. Redcarpet is good for this since it can handle the code blocks and snippets on some pages.

One last class is needed to email this content to me. It calls up the last class to grab something from my site and uses the mail gem to send it over. Any email server info I want to keep private is saved in environmental variables and pulled out with dotenv/load.

require 'mail'
require 'dotenv/load'
require_relative 'website_content.rb'

class EmailSender
  def initialize(type)
    @type = type
    options = email_options
    Mail.defaults do
      delivery_method :smtp, options

  def send_email
    page =
    sender = email_sender
    recipient = email_recipient

    Mail.deliver do
      from    sender
      to      recipient
      subject page[:title]

      html_part do
        content_type 'text/html; charset=UTF-8'
        body page[:content]


  def email_sender

  def email_password

  def email_recipient

  def email_options
    { address: "",
      port: 587,
      user_name: email_sender,
      password: email_password,
      authentication: 'plain',
      enable_starttls_auto: true  }

Now I just need a task to run all this, which I have in bin/send that runs the EmailSender class.

#!/usr/bin/env ruby

category = ARGV[0] || "blog" ;

require_relative '../lib/email_sender.rb'

From this project directory, I can call bin/send blog, bin/send notes, or bin/send exocortex and get an email with a random piece from said category. The joys of coding in Ruby! So simple and so enjoyable to write.

I admit all this is a little self-indulgent. But I’m an admitted selfish and casual blogger, so I feel no shame. If this little script helps remind myself to build good habits, write good Ruby, and embrace the horrors of life with humor and curiosity, then I’ll take it.