rack-seo 0.0.1

data/spec/configuration_spec.rb

@@ -0,0 +1,97 @@
+require 'summarize'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+describe "RackSeo Configuration" do
+  before do
+    @env = Rack::MockRequest.env_for '/'
+  end
+
+  it "reads a configuration file specified in the initializer" do
+    @rack_seo = Rack::RackSeo::Base.new Apps.complex, :public => Fixtures.path, :config => "config/rack_seo.default.yml"
+  end
+
+  context "happy config file" do
+    before do
+      @rack_seo = Rack::RackSeo::Base.new Apps.complex, :public => Fixtures.path, :config => "spec/sample_configs/happy.yml"
+      @happy_page = Fixtures.complex
+      @rack_seo.execute! @happy_page
+
+      @rack_seo_default = Rack::RackSeo::Base.new Apps.complex, :public => Fixtures.path
+      @default_page = Fixtures.complex_copy
+      @rack_seo_default.execute! @default_page
+    end
+    it "allows the title text to be configured" do
+      @happy_page.title_content.should include "#{(@happy_page.at_css('h1').text)} - Happy happy"
+    end
+    it "allows the meta description text source material to be narrowed down by a selector" do
+      @happy_page.at_css("meta[name='description']").attr('content').should_not == @default_page.at_css("meta[name='description']").attr('content')
+    end
+    it "allows the meta keywords source material to be narrowed down by a selector" do
+      @happy_page.at_css("meta[name='keywords']").attr('content').should_not == @default_page.at_css("meta[name='keywords']").attr('content')
+    end
+  end
+
+  context "sad config file" do
+    before do
+      @rack_seo = Rack::RackSeo::Base.new Apps.simple, :public => Fixtures.path, :config => "spec/sample_configs/sad.yml"
+      @sad_page = Fixtures.simple
+      @rack_seo.execute! @sad_page
+    end
+    it "fails gracefully with a bad title, description or keyword selector" do
+      inner_app = lambda { |env| [200, {'Content-Type' => 'text/html'}, [@sad_page.to_html]] }
+      status, headers, body = @rack_seo.call(@env)
+      status.should == 200
+      #TODO double check this test
+    end
+  end
+
+  context "configuring formats based on paths" do
+    before do
+      @page = Fixtures.complex
+      @rack_seo = Rack::RackSeo::Base.new Apps.complex, :public => Fixtures.path
+      @env = Rack::MockRequest.env_for '/'
+      status, headers, body = @rack_seo.call(@env)
+      @response_body = Rack::RackSeo::Document.new(body.first)
+
+      @page_test = Fixtures.complex_copy
+      @rack_seo_test = Rack::RackSeo::Base.new Apps.complex, :public => Fixtures.path, :config => "spec/sample_configs/custom_paths.yml"
+    end
+
+    context "matching path based on a string" do
+      before do
+        env_test = Rack::MockRequest.env_for '/test-path'
+        status, headers, body = @rack_seo_test.call(env_test)
+        @response_body_test = Rack::RackSeo::Document.new(body.first)
+      end
+
+      it "allows title_format to be configured for a certain path" do
+        @response_body_test.title_tag.should_not == @response_body.title_tag
+      end
+      it "allows meta_description_selector to be configured for a certain path" do
+        @response_body_test.description_content.should_not == @response_body.description_content
+      end
+      it "allows meta_keywords_selector to be configured for a certain path" do
+        @response_body_test.keywords_content.should_not == @response_body.keywords_content
+      end
+    end
+
+    context "matching path based on a Regexp" do
+      before do
+        env_test = Rack::MockRequest.env_for '/test-regex-two/subfolder'
+        status, headers, body = @rack_seo_test.call(env_test)
+        @response_body_test = Rack::RackSeo::Document.new(body.first)
+      end
+
+      it "allows title_format to be configured for a certain path" do
+        @response_body_test.title_tag.should_not == @response_body.title_tag
+        @response_body_test.title_content.should include('regex')
+      end
+      it "allows meta_description_selector to be configured for a certain path" do
+        @response_body_test.description_content.should_not == @response_body.description_content
+      end
+      it "allows meta_keywords_selector to be configured for a certain path" do
+        @response_body_test.keywords_content.should_not == @response_body.keywords_content
+      end
+    end
+
+  end
+end

data/spec/fixtures/complex.html

@@ -0,0 +1,437 @@
+<!doctype html>
+<html>
+  <head>
+    <!-- 1140px Grid styles for IE -->
+    <!--[if lte IE 9]><link rel="stylesheet" href="/css/ie.css" type="text/css" media="screen" /><![endif]-->
+    <link rel="stylesheet" href="/css/1140.css" type="text/css" media="screen" />
+    <link rel="stylesheet" href="/css/main.css"href="/css/main.css" type="text/css" media="screen" />
+    <link rel="alternate" type="application/atom+xml" title="Never create Ruby strings longer than 23 characters - feed" href="http://feeds2.feedburner.com/patshaughnessy" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/> 
+    <title>Never create Ruby strings longer than 23 characters - Pat Shaughnessy</title>
+  </head>
+<body>
+  <div id="banner">
+    <div class="row">
+      <div class="onecol"></div>
+      <div class="elevencol last">
+        <a href="/">
+          <span id="title">
+            Pat Shaughnessy
+          </span>
+          <span id="tagline">
+            blogger, rubyist, aspiring author
+          </span>
+        </a>
+      </div>
+    </div>
+  </div>
+  <div id="container">
+    <div class="row">
+      <div class="onecol"></div>
+      
+        <div class="ninecol white">
+      
+        <article class="post">
+  <header>
+  <h1>Never create Ruby strings longer than 23 characters</h1>
+  <div class="metadata">
+  <span class="date">January 4th 2012</span>&nbsp;&mdash;&nbsp;<a href="#disqus_thread" data-disqus-identifier="http://patshaughnessy.net/2012/1/4/never-create-ruby-strings-longer-than-23-characters" class="date">&nbsp; Comments and &nbsp; Reactions</a>&nbsp;&mdash;&nbsp;<a href="/tags/ruby-internals" class="tag">more on Ruby internals</a><br/>
+  
+    <a href="https://twitter.com/share" class="twitter-share-button" data-count="horizontal" data-via="pat_shaughnessy" data-text="Never create Ruby strings longer than 23 characters">Tweet</a><script type="text/javascript" src="//platform.twitter.com/widgets.js"></script>
+  
+  </div>
+  </header>
+
+  <section class="content" id="content">
+    <div style="float: left; padding: 7px 30px 10px 0px">
+<table cellpadding="0" cellspacing="0" border="0">
+  <tr><td><img src="http://patshaughnessy.net/assets/2012/1/4/microscope.jpg"></td></tr>
+  <tr><td align="center"><small><i>Looking at things through a microscope<br/>sometimes leads to surprising discoveries</i></small></td></tr>
+</table>
+</div>
+
+
+<p>Obviously this is an utterly preposterous statement: it’s hard to think of a more ridiculous and esoteric coding requirement. I can just imagine all sorts of amusing conversations with designers and business sponsors: “No&hellip; the size of this &lt;input&gt; field should be 23&hellip; 24 is just too long!”  Or: “We need to explain to users that their subject lines should be less than 23 letters&hellip;” Or: “Twitter got it all wrong&hellip; the 140 limit should have been 23!”</p>
+
+<p>Why in the world would I even imagine saying this? As silly as this requirement might be, there is actually a grain of truth behind it: creating shorter Ruby strings is actually much faster than creating longer ones. It turns out that this line of Ruby code:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str = <span class="s"><span class="dl">&quot;</span><span class="k">1234567890123456789012</span><span class="dl">&quot;</span></span> + <span class="s"><span class="dl">&quot;</span><span class="k">x</span><span class="dl">&quot;</span></span>
+</pre></div>
+</div>
+
+
+
+<p>&hellip; is executed about twice as fast by the MRI 1.9.3 Ruby interpreter than this line of Ruby code:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str = <span class="s"><span class="dl">&quot;</span><span class="k">12345678901234567890123</span><span class="dl">&quot;</span></span> + <span class="s"><span class="dl">&quot;</span><span class="k">x</span><span class="dl">&quot;</span></span>
+</pre></div>
+</div>
+
+
+
+<p>Huh? What’s the difference? These two lines look identical! Well, the difference is that the first line creates a new string containing 23 characters, while the second line creates one with 24. It turns out that the MRI Ruby 1.9 interpreter is optimized to handle strings containing 23 characters or less more quickly than longer strings. This isn’t true for Ruby 1.8.</p>
+
+<p>Today I’m going to take a close look at the MRI Ruby 1.9 interpreter to see how it actually handles saving string values&hellip; and why this is actually true.</p>
+
+<h2>Not all strings are created equal</h2>
+
+<p>Over the holidays I decided to read through the the <a href="http://rhg.rubyforge.org/">Ruby Hacking Guide</a>. If you’ve never heard of it, it’s a great explanation of how the Ruby interpreter works internally. Unfortunately it’s written in Japanese, but a few of the chapters have been translated into English. <a href="http://rhg.rubyforge.org/chapter02.html">Chapter 2</a>, one of the translated chapters, was a great place to start since it explains all of the basic Ruby data types, including strings.</p>
+
+<p>After reading through that, I decided to dive right into the MRI 1.9.3 C source code to learn more about how Ruby handles strings; since I use RVM for me the Ruby source code is located under ~/.rvm/src/ruby-1.9.3-preview1. I started by looking at include/ruby/ruby.h, which defines all of the basic Ruby data types, and string.c, which implements Ruby String objects.</p>
+
+<p>Reading the C code I discovered that Ruby actually uses three different types of string values, which I call:</p>
+
+<ul>
+  <li>Heap Strings,</li>
+  <li>Shared Strings, and</li>
+  <li>Embedded Strings</li>
+</ul>
+
+
+<p>I found this fascinating! For years I’ve assumed every Ruby String object was like every other String object. But it turns out this is not true! Let’s take a closer look&hellip;</p>
+
+<h2>Heap Strings</h2>
+
+<p>The standard and most common way for Ruby to save string data is in the “heap.” The heap is a core concept of the C language: it’s a large pool of memory that C programmers can allocate from and use via a call to the <span class="code">malloc</span> function. For example, this line of C code allocates a 100 byte chunk of memory from the heap and saves its memory address into a pointer:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+<span class="pt">char</span> *ptr = malloc(<span class="i">100</span>);
+</pre></div>
+</div>
+
+
+
+<p>Later, when the C programmer is done with this memory, she can release it and return it to the system using <span class="code">free</span>:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+free(ptr);
+</pre></div>
+</div>
+
+
+
+<p>Avoiding the need to manage memory in this very manual and explicit way is one of the biggest benefits of using any high level programming language, such as Ruby, Java, C#, etc. When you create a string value in Ruby code like this, for example:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str = <span class="s"><span class="dl">&quot;</span><span class="k">Lorem ipsum dolor sit amet, consectetur adipisicing elit</span><span class="dl">&quot;</span></span>
+</pre></div>
+</div>
+
+
+
+<p>&hellip; the Ruby interpreter creates a structure called “RString” that conceptually looks like this:</p>
+
+<p><img src="http://patshaughnessy.net/assets/2012/1/4/heap-string.png" alt="heap strings" /></p>
+
+<p>You can see here that the RString structure contains two values: <span class="code">ptr</span> and <span class="code">len</span>, but not the actual string data itself. Ruby actually saves the string character values themselves in some memory allocated from the heap, and then sets <span class="code">ptr</span> to the location of that heap memory, and <span class="code">len</span> to the length of the string.</p>
+
+<p>Here’s a simplified version of the C RString structure:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+<span class="r">struct</span> RString {
+  <span class="pt">long</span> len;
+  <span class="pt">char</span> *ptr;
+};
+</pre></div>
+</div>
+
+
+
+<p>I’ve simplified this a lot; there are actually a number of other values saved in this C struct. I’ll discuss some of them next, and others I’ll skip over for today. If you’re not familiar with C, you can think of <span class="code">struct</span> (short for “structure”) as an object that contains a set of instance variables, except in C there’s no object at all &ndash; a struct is just a chunk of memory containing a few values.</p>
+
+<p>I refer to this type of Ruby string as “Heap String,” since the actual string data is saved in the heap.</p>
+
+<h2>Shared Strings</h2>
+
+<p>Another type of string value that the Ruby interpreter uses is called a “Shared String” in the Ruby C source code. You create a Shared String every time you write a line of Ruby code that copies one string to another, similar to this:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str = <span class="s"><span class="dl">&quot;</span><span class="k">Lorem ipsum dolor sit amet, consectetur adipisicing elit</span><span class="dl">&quot;</span></span>
+str2 = str
+</pre></div>
+</div>
+
+
+
+<p>Here the Ruby interpreter has realized that you are assigning the same string value to two variables: str and str2. So in fact there’s no need to create two copies of the string data itself; instead Ruby creates two RString values that share the single copy of the string data. The way this works is that both RString structs contain the same ptr value to the shared data&hellip; meaning both strings contain the same value. There’s also a <span class="code">shared</span> value saved in the second RString struct that points to the first RString struct. There are some other details which I’m not showing here, such as some bit mask flags that Ruby uses to keep track of which RString’s are shared and which are not.</p>
+
+<p><img src="http://patshaughnessy.net/assets/2012/1/4/shared-string.png" alt="shared strings" /></p>
+
+<p>Aside from saving memory, this also speeds up execution of your Ruby programs dramatically by avoiding the need to allocate more memory from the heap using another call to <span class="code">malloc</span>. <span class="code">Malloc</span> is actually a fairly expensive operation: it takes time to track down available memory of the proper size in the heap, and also to keep track of it for freeing later.</p>
+
+<p>Here’s a somewhat more accurate version of the C RString structure, including the <span class="code">shared</span> value:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+struct RString {
+    long len;
+    char *ptr;
+    VALUE shared;
+};
+</pre></div>
+</div>
+
+
+
+<p>Strings that are copied from one variable to another like this I call “Shared Strings.”</p>
+
+<h2>Embedded Strings</h2>
+
+<p>The third and last way that MRI Ruby 1.9 saves string data is by embedding the characters into the RString structure itself, like this:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str3 = <span class="s"><span class="dl">&quot;</span><span class="k">Lorem ipsum dolor</span><span class="dl">&quot;</span></span>
+</pre></div>
+</div>
+
+
+
+<p><img src="http://patshaughnessy.net/assets/2012/1/4/embedded-string.png" alt="embedded strings" /></p>
+
+<p>This RString structure contains a character array called <span class="code">ary</span> and not the <span class="code">ptr</span>, <span class="code">len</span> and <span class="code">shared</span> values we saw above. Here’s another simplified definition of the same RString structure, this time containing the <span class="code">ary</span> character array:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+<span class="r">struct</span> RString {
+  <span class="pt">char</span> ary[RSTRING_EMBED_LEN_MAX + <span class="i">1</span>];
+}
+</pre></div>
+</div>
+
+
+
+<p>If you’re not familiar with C code, the syntax <span class="code">char ary[100]</span> creates an array of 100 characters (bytes). Unlike Ruby, C arrays are not objects; instead they are really just a collection of bytes. In C you have to specify the length of the array you want to create ahead of time.</p>
+
+<p>How do Embedded Strings work? Well, the key is the size of the <span class="code">ary</span> array, which is set to <span class="code">RSTRING_EMBED_LEN_MAX+1</span>. If you’re running a 64-bit version of Ruby <span class="code">RSTRING_EMBED_LEN_MAX</span> is set to 24. That means a short string like this will fit into the RString <span class="code">ary</span> array:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str = <span class="s"><span class="dl">&quot;</span><span class="k">Lorem ipsum dolor</span><span class="dl">&quot;</span></span>
+</pre></div>
+</div>
+
+
+
+<p>&hellip; while a longer string like this will not:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+str = <span class="s"><span class="dl">&quot;</span><span class="k">Lorem ipsum dolor sit amet, consectetur adipisicing elit</span><span class="dl">&quot;</span></span>
+</pre></div>
+</div>
+
+
+
+<h2>How Ruby creates new string values</h2>
+
+<p>Whenever you create a string value in your Ruby 1.9 code, the interpreter goes through an algorithm similar to this:</p>
+
+<ul>
+  <li>Is this a new string value? Or a copy of an existing string? If it’s a copy, Ruby creates a Shared String. This is the fastest option, since Ruby only needs a new RString structure, and not another copy of the existing string data.</li>
+  <li>Is this a long string? Or a short string? If the new string value is 23 characters or less, Ruby creates an Embedded String. While not as fast as a Shared String, it’s still fast because the 23 characters are simply copied right into the RString structure and there’s no need to call <span class="code">malloc</span>.</li>
+  <li>Finally, for long string values, 24 characters or more, Ruby creates a Heap String - meaning it calls <span class="code">malloc</span> and gets some new memory from the heap, and then copies the string value there. This is the slowest option.</li>
+</ul>
+
+
+<h2>The actual RString structure</h2>
+
+<p>For those of you familiar with the C language, here’s the actual Ruby 1.9 definition of RString:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+<span class="r">struct</span> RString {
+
+  <span class="r">struct</span> RBasic basic;
+
+  <span class="r">union</span> {
+    <span class="r">struct</span> {
+      <span class="pt">long</span> len;
+      <span class="pt">char</span> *ptr;
+      <span class="r">union</span> {
+        <span class="pt">long</span> capa;
+        VALUE shared;
+      } aux;
+    } heap;
+
+    <span class="pt">char</span> ary[RSTRING_EMBED_LEN_MAX + <span class="i">1</span>];
+  } as;
+};
+</pre></div>
+</div>
+
+
+
+<p>I won’t try to explain all the code details here, but here are a couple important things to learn about Ruby strings from this definition:</p>
+
+<ul>
+<li>The <span class="code">RBasic</span> structure keeps track of various important bits of information about this string, such as flags indicating whether it’s shared or embedded, and a pointer to the corresponding Ruby String object structure.</li>
+<li>The <span class="code">capa</span> value keeps track of the “capacity” of each heap string... it turns out Ruby will often allocate more memory than is required for each heap string, again to avoid extra calls to <span class="code">malloc</span> if a string size changes.</li>
+<li>The use of <span class="code">union</span> allows Ruby to EITHER save the len/ptr/capa/shared information OR the actual string data itself.</li>
+<li>The value of <span class="code">RSTRING_EMBED_LEN_MAX</span> was chosen to match the size of the len/ptr/capa values. That’s where the 23 limit comes from.</li>
+</ul>
+
+
+<p>Here’s the line of code from ruby.h that defines this value:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+<span class="pp">#define</span> RSTRING_EMBED_LEN_MAX ((<span class="pt">int</span>)((<span class="r">sizeof</span>(VALUE)*<span class="i">3</span>)/<span class="r">sizeof</span>(<span class="pt">char</span>)-<span class="i">1</span>))
+</pre></div>
+</div>
+
+
+
+<p>On a 64 bit machine, sizeof(VALUE) is 8, leading to the limit of 23 characters. This will be smaller for a 32 bit machine.</p>
+
+<h2>Benchmarking Ruby string allocation</h2>
+
+<p>Let’s try to measure how much faster short strings are vs. long strings in Ruby 1.9.3 &ndash; here’s a simple line of code that dynamically creates a new string by appending a single character onto the end:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+new_string = str + <span class="s"><span class="dl">'</span><span class="k">x</span><span class="dl">'</span></span>
+</pre></div>
+</div>
+
+
+
+<p>The <span class="code">new_string</span> value will either be a Heap String or an Embedded String, depending on how long the <span class="code">str</span> variable’s value is. The reason I need to use a string concatenation operation, the <span class="code">+ &lsquo;x&rsquo;</span> part, is to force Ruby to allocate a new string dynamically. Otherwise if I just used <span class="code">new_string = str</span>, I would get a Shared String.</p>
+
+<p>Now I’ll call this method from a loop and benchmark it:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+require <span class="s"><span class="dl">'</span><span class="k">benchmark</span><span class="dl">'</span></span>
+
+<span class="co">ITERATIONS</span> = <span class="i">1000000</span>
+
+<span class="r">def</span> <span class="fu">run</span>(str, bench)
+  bench.report(<span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>str.length + <span class="i">1</span><span class="idl">}</span></span><span class="k"> chars</span><span class="dl">&quot;</span></span>) <span class="r">do</span>
+    <span class="co">ITERATIONS</span>.times <span class="r">do</span>
+      new_string = str + <span class="s"><span class="dl">'</span><span class="k">x</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+</pre></div>
+</div>
+
+
+
+<p>Here I’m using the benchmark library to measure how long it takes to call that method 1 million times. Now running this with a variety of different string lengths:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+<span class="co">Benchmark</span>.bm <span class="r">do</span> |bench|
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">12345678901234567890</span><span class="dl">&quot;</span></span>, bench)
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">123456789012345678901</span><span class="dl">&quot;</span></span>, bench)
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">1234567890123456789012</span><span class="dl">&quot;</span></span>, bench)
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">12345678901234567890123</span><span class="dl">&quot;</span></span>, bench)
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">123456789012345678901234</span><span class="dl">&quot;</span></span>, bench)
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">1234567890123456789012345</span><span class="dl">&quot;</span></span>, bench)
+  run(<span class="s"><span class="dl">&quot;</span><span class="k">12345678901234567890123456</span><span class="dl">&quot;</span></span>, bench)
+<span class="r">end</span>
+</pre></div>
+</div>
+
+
+
+<p>We get an interesting result:</p>
+
+<div class="CodeRay">
+  <div class="code"><pre>
+       user     system      total        real
+21 chars  0.250000   0.000000   0.250000 (  0.247459)
+22 chars  0.250000   0.000000   0.250000 (  0.246954)
+23 chars  0.250000   0.000000   0.250000 (  0.248440)
+24 chars  0.480000   0.000000   0.480000 (  0.478391)
+25 chars  0.480000   0.000000   0.480000 (  0.479662)
+26 chars  0.480000   0.000000   0.480000 (  0.481211)
+27 chars  0.490000   0.000000   0.490000 (  0.490404)
+</pre></div>
+</div>
+
+
+
+<p>Note that when the string length is 23 or less, it takes about 250ms to create 1 million new strings. But when my string length is 24 or more, it takes around 480ms, almost twice as long!</p>
+
+<p>Here’s a graph showing some more data; the bars show how long it takes to allocate 1 million strings of the given length:</p>
+
+<p><img src="http://patshaughnessy.net/assets/2012/1/4/string-allocations.png" alt="string allocation chart" /></p>
+
+<h2>Conclusion</h2>
+
+<p>Don’t worry! I don’t think you should refactor all your code to be sure you have strings of length 23 or less. That would obviously be ridiculous. The speed increase sounds impressive, but actually the time differences I measured were insignificant until I allocated 100,000s or millions of strings &ndash; how many Ruby applications will need to create this many string values? And even if you do need to create many string objects, the pain and confusion caused by using only short strings would overwhelm any performance benefit you might get.</p>
+
+<p>For me I really think understanding something about how the Ruby interpreter works is just fun! I enjoyed taking a look through a microscope at these sorts of tiny details. I do also suspect having some understanding of how Matz and his colleagues actually implemented the language will eventually help me to use Ruby in a wiser and more knowledgeable way. We’ll have to see&hellip; stay tuned for some more posts about Ruby internals!</p>
+
+  </section>
+
+  
+    <section class="comments">
+      <a href="http://patshaughnessy.disqus.com/?url=ref">View the discussion thread.</a>
+    </section>
+  
+</article>
+
+      </div>
+      
+        <div class="twocol last" id="right">
+          <div id="sidebar">
+            <img src="/images/pat.jpg"/>
+            <div class="header">Subscribe&nbsp;<a href="http://feeds.feedburner.com/patshaughnessy"><img src="/images/feed-icon16x16.png"/></a></div>
+            <div class="links">
+              <ul>
+                <li>
+                  <a href="http://feeds.feedburner.com/patshaughnessy"><img src="http://feeds.feedburner.com/~fc/patshaughnessy?bg=99CCFF&amp;fg=444444&amp;anim=0" height="26" width="88" style="border:0" alt="" /></a>
+                </li>
+                <li>
+                  <a href="https://twitter.com/pat_shaughnessy" class="twitter-follow-button" data-show-count="false" data-show-screen-name="false">Follow @pat_shaughnessy</a>
+                  <a href="http://twitter.com/pat_shaughnessy">@pat_shaughnessy</a>
+                </li>
+              </ul>
+            </div>
+            <div class="header">Buy my book</div>
+            <div class="links">
+              <ul>
+                <li><a href="http://patshaughnessy.net/ruby-under-a-microscope"><img src="http://patshaughnessy.net/images/cover-ana.png"></a></li>
+                <li id="eBook"><a href="http://patshaughnessy.net/ruby-under-a-microscope">Ruby Under a Microscope</a></li>
+              </ul>
+            </div>
+            <div class="header">Popular</div>
+            <div class="links">
+              <ul>
+                <li><a href="http://patshaughnessy.net/2012/1/4/never-create-ruby-strings-longer-than-23-characters">Never create Ruby strings longer than 23 characters</a></li>
+                <li><a href="http://patshaughnessy.net/2012/3/23/why-you-should-be-excited-about-garbage-collection-in-ruby-2-0">Why You Should Be Excited About Garbage Collection in Ruby 2.0</a></li>
+                <li><a href="http://patshaughnessy.net/2011/10/14/why-bundler-1-1-will-be-much-faster">Why Bundler 1.1 will be much faster</a></li>
+                <li><a href="http://patshaughnessy.net/2012/2/29/the-joke-is-on-us-how-ruby-1-9-supports-the-goto-statement">The Joke Is On Us: How Ruby 1.9 Supports the Goto Statement</a></li>
+              </ul>
+            </div>
+            <div class="header">Recent</div>
+            <div class="links">
+              <ul>
+                <li><a href="http://patshaughnessy.net/2013/2/12/an-interview-with-laurent-sansonetti">An Interview With Laurent Sansonetti</a></li>
+                <li><a href="http://patshaughnessy.net/2013/2/8/ruby-mri-source-code-idioms-3-embedded-objects">Ruby MRI Source Code Idioms #3: Embedded Objects</a></li>
+                <li><a href="http://patshaughnessy.net/2013/1/31/ruby-mri-source-code-idioms-2-c-that-resembles-ruby">Ruby MRI Source Code Idioms #2: C That Resembles Ruby</a></li>
+                <li><a href="http://patshaughnessy.net/2013/1/23/ruby-mri-source-code-idioms-1-accessing-data-via-macros">Ruby MRI Source Code Idioms #1: Accessing Data Via Macros</a></li>
+              </ul>
+            </div>
+            <div class="header"><a href="/">More...</a></div>
+          </div>
+        </div>
+      
+    <div class="row" id="copyright">
+      <p>Content and UI design &copy; 2013 Pat Shaughnessy &mdash; powered by <a href="http://cloudhead.io/toto">Toto</a> &mdash; comments powered by <a href="http://disqus.com">Disqus</a>
+    </div>
+  </div>
+</body>
+</html>

data/spec/fixtures/simple.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+<body>
+  <h1>
+         Bonjour,
+         tout les monde!
+  </h1>
+  <div>Here is some sample text to keep you busy.</div>
+</body>
+</html>