<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.3.2">Jekyll</generator><link href="https://www.buddhistuniversity.net/jekyll-dev-notes/feed.xml" rel="self" type="application/atom+xml" /><link href="https://www.buddhistuniversity.net/jekyll-dev-notes/" rel="alternate" type="text/html" /><updated>2023-02-28T07:19:47+00:00</updated><id>https://www.buddhistuniversity.net/jekyll-dev-notes/feed.xml</id><title type="html">Jekyll Dev Notes</title><subtitle>A small blog for random musings about Jekyll.</subtitle><entry><title type="html">Running Jekyll on Android</title><link href="https://www.buddhistuniversity.net/jekyll-dev-notes/2023/02/13/running-jekyll-on-android.html" rel="alternate" type="text/html" title="Running Jekyll on Android" /><published>2023-02-13T00:58:00+00:00</published><updated>2023-02-13T00:58:00+00:00</updated><id>https://www.buddhistuniversity.net/jekyll-dev-notes/2023/02/13/running-jekyll-on-android</id><content type="html" xml:base="https://www.buddhistuniversity.net/jekyll-dev-notes/2023/02/13/running-jekyll-on-android.html"><![CDATA[<p>My primary dev machine (odd as this may sound) is my Android phone.
It’s always with me, and it’s plenty capable for jotting down quick notes like this one.</p>

<p>For any development on Android, you’ll of course need to <a href="https://termux.dev/en/">install Termux</a>.</p>

<p>To run a Jekyll build (or even serve!) on Termux, I just needed to do a couple things:</p>

<ol>
  <li><code class="language-plaintext highlighter-rouge">pkg install ruby</code></li>
  <li><code class="language-plaintext highlighter-rouge">gem install bundler</code></li>
  <li>Add the following line to your <code class="language-plaintext highlighter-rouge">Gemfile</code>:</li>
</ol>

<figure class="highlight"><pre><code class="language-rb" data-lang="rb"><span class="n">gem</span> <span class="s2">"webrick"</span><span class="p">,</span> <span class="s2">"~&gt; 1.7"</span></code></pre></figure>

<p>This line explicitly asks for a hidden dependency.</p>

<p>And that’s it!
Just <code class="language-plaintext highlighter-rouge">bundle install</code> and <code class="language-plaintext highlighter-rouge">bundle exec jekyll serve</code> as you normally would.</p>

<p>Happy Jekylling on-the-go!</p>]]></content><author><name></name></author><summary type="html"><![CDATA[My primary dev machine (odd as this may sound) is my Android phone. It’s always with me, and it’s plenty capable for jotting down quick notes like this one.]]></summary></entry><entry><title type="html">Advanced Liquid Recipes</title><link href="https://www.buddhistuniversity.net/jekyll-dev-notes/2023/02/12/liquid-recipes.html" rel="alternate" type="text/html" title="Advanced Liquid Recipes" /><published>2023-02-12T13:17:00+00:00</published><updated>2023-02-12T13:17:00+00:00</updated><id>https://www.buddhistuniversity.net/jekyll-dev-notes/2023/02/12/liquid-recipes</id><content type="html" xml:base="https://www.buddhistuniversity.net/jekyll-dev-notes/2023/02/12/liquid-recipes.html"><![CDATA[<h2 id="introduction">Introduction</h2>

<p>After using Jekyll for a number of years, I’ve had to discover or invent a number of Liquid “recipes” (cocktails?) for doing common tasks that <em>should</em> be easy in a sane language, but which are not obvious how to do in Liquid.</p>

<p>Since these (anti-?)patterns are under-documented elsewhere, I thought I’d collect them here in case this list is useful for others, especially those who are starting to use Jekyll / Liquid for serious development.</p>

<h2 id="format">Format</h2>

<p>Each entry below will show off some Liquid code and what that code outputs:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">hello</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"world"</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{{</span><span class="w"> </span><span class="nv">hello</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<blockquote>
  <p>world</p>
</blockquote>

<p>It assumes you’re already familliar with the fundamentals of writing <a href="https://jekyllrb.com/docs/liquid/">Liquid in Jekyll</a>.</p>

<h2 id="the-recipes-how-to">The Recipes: How to…</h2>

<h3 id="comment-out-some-broken-code">Comment out some broken code</h3>

<p>The <code class="language-plaintext highlighter-rouge">comment</code> tag in Liquid unfortunately will parse and process the inner <code class="language-plaintext highlighter-rouge">content</code> block 😮‍💨</p>

<p>In order to temporarily comment out broken Liquid code, you need to double wrap it first in <code class="language-plaintext highlighter-rouge">raw</code> and <em>then</em> in <code class="language-plaintext highlighter-rouge">comment</code> to ensure Liquid doesn’t try to parse the code inside the comment:</p>

<p><code>
&lcub;% comment %&rcub;&lcub;% raw %&rcub;
&lcub;% broked
&lcub;% endraw %&rcub;&lcub;% endcomment %&rcub;
</code></p>

<p>Just beware of any <code>&lcub;% endraw %&rcub;</code>s inside the comment!</p>

<h3 id="make-a-literal-string-list">Make a literal string list</h3>

<p>You cannot directly instantiate a list in liquid.
To make a list of literal strings, you’ll have to use “split”:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">mylist</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"hello,world,you're,looking,great!"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{{</span><span class="w"> </span><span class="nv">mylist</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<blockquote>
  <p>hello</p>
</blockquote>

<h3 id="filter-a-list-to-elements-containing-a-substring">Filter a list to elements containing a substring</h3>

<p>Don’t be discouraged! <code class="language-plaintext highlighter-rouge">contains</code> works as you’d expect inside a <code class="language-plaintext highlighter-rouge">where_exp</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">mylist</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"hello,world,you're,looking,great!"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">filtered</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">mylist</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">where_exp</span><span class="p">:</span><span class="w"> </span><span class="s2">"item"</span><span class="p">,</span><span class="w"> </span><span class="s2">"item contains 'e'"</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{{</span><span class="w"> </span><span class="nv">filtered</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<blockquote>
  <p>great!</p>
</blockquote>

<h3 id="filter-a-list-to-elements-containing-a-variable-substring">Filter a list to elements containing a <em>variable</em> substring</h3>

<p>The above is all well and good, but what if the substring you’re looking for is contained in a variable?</p>

<p>In that case, use <code class="language-plaintext highlighter-rouge">{% capture %}</code> to build the filter expression dynamically!<sup id="fnref:eval" role="doc-noteref"><a href="#fn:eval" class="footnote" rel="footnote">1</a></sup></p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">mylist</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"hello,world,you're,looking,great!"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">lookingfor</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"r"</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">capture</span><span class="w"> </span><span class="nv">filterexp</span><span class="w"> </span><span class="p">%}</span>item contains '<span class="p">{{</span><span class="w"> </span><span class="nv">lookingfor</span><span class="w"> </span><span class="p">}}</span>'<span class="p">{%</span><span class="w"> </span><span class="nt">endcapture</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">filtered</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">mylist</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">where_exp</span><span class="p">:</span><span class="w"> </span><span class="s2">"item"</span><span class="p">,</span><span class="w"> </span><span class="nv">filterexp</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{{</span><span class="w"> </span><span class="nv">filtered</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<blockquote>
  <p>world</p>
</blockquote>

<h3 id="write-test-cases-using-capture">Write test cases using <code class="language-plaintext highlighter-rouge">capture</code></h3>

<p>Yes, the <code class="language-plaintext highlighter-rouge">capture</code> tag is super powerful!</p>

<p>One of my favorite uses is to write test cases!
You can simply <code class="language-plaintext highlighter-rouge">capture</code> the output of an <code class="language-plaintext highlighter-rouge">include</code> and then make sure it <code class="language-plaintext highlighter-rouge">contains</code> the expected string:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid">My test:
<span class="p">{%</span><span class="w"> </span><span class="nt">capture</span><span class="w"> </span><span class="nv">output</span><span class="w"> </span><span class="p">%}{%</span><span class="w"> </span><span class="nt">include</span><span class="w"> </span>my_include.md<span class="w"> </span><span class="na">value</span><span class="o">=</span><span class="mi">5</span><span class="w"> </span><span class="p">%}{%</span><span class="w"> </span><span class="nt">endcapture</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="nv">output</span><span class="w"> </span><span class="ow">contains</span><span class="w"> </span><span class="s1">'expected string'</span><span class="w"> </span><span class="p">%}</span>Passes!<span class="p">{%</span><span class="w"> </span><span class="kr">else</span><span class="w"> </span><span class="p">%}</span>Fails!<span class="p">{%</span><span class="w"> </span><span class="kr">endif</span><span class="w"> </span><span class="p">%}</span></code></pre></figure>

<blockquote>
  <p>My test: Passes!</p>
</blockquote>

<h3 id="using-liquid-to-generate-non-html-files">Using Liquid to generate non-html files</h3>

<p>I usually will make a null layout file for this case:</p>

<p><code class="language-plaintext highlighter-rouge">_layouts/nil.html</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{{</span><span class="w"> </span><span class="nv">content</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<p>Then, in whatever file you want Jekyll to process, just add the null layout:</p>

<p><code class="language-plaintext highlighter-rouge">create-dynamic-bash-file.html</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid">---
layout: nil
permalink: my-script.bash
---
# prints all the page paths to stdout
<span class="p">{%</span><span class="w"> </span><span class="nt">for</span><span class="w"> </span><span class="nv">page</span><span class="w"> </span><span class="nt">in</span><span class="w"> </span><span class="nv">site.pages</span><span class="w"> </span><span class="p">%}</span>
echo "<span class="p">{{</span><span class="w"> </span><span class="nv">page</span><span class="p">.</span><span class="nv">path</span><span class="w"> </span><span class="p">}}</span>"
<span class="p">{%</span><span class="w"> </span><span class="nt">endfor</span><span class="w"> </span><span class="p">%}</span></code></pre></figure>

<p>Note that the template ends in <code class="language-plaintext highlighter-rouge">.html</code> so that Jekyll knows not to <code class="language-plaintext highlighter-rouge">markdownify</code> it.
It will be renamed to <code class="language-plaintext highlighter-rouge">my-script.bash</code> in the output directory.
This will always work, even to generate a markdown file, and it makes it clear that the source file is not (yet) a real e.g. bash script.</p>

<h3 id="strip-your-includes">Strip your includes</h3>

<p>When you call <code class="language-plaintext highlighter-rouge">{% include something.md %}</code>, newlines will be automatically added—even if they aren’t in the original file!
Since this breaks certain markdown patterns, you may want to have a <code class="language-plaintext highlighter-rouge">strip</code>ped include.</p>

<p>You could could <code class="language-plaintext highlighter-rouge">capture</code> the output, then call <code class="language-plaintext highlighter-rouge">{{ captured_output | strip }}</code> but this is cumbersome and ugly for the caller.
To make the include self-stripping, just make sure to put a whitespace-erasing <code class="language-plaintext highlighter-rouge">{%- -%}</code>s at the ends of the include:</p>

<p><code class="language-plaintext highlighter-rouge">_includes/inline_bold.md</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%-</span><span class="w"> </span><span class="nt">comment</span><span class="w"> </span><span class="p">-%}</span><span class="c">This include can safely be used in an inline manner</span><span class="p">{%-</span><span class="w"> </span><span class="nt">endcomment</span><span class="w"> </span><span class="p">-%}</span>
**<span class="p">{{</span><span class="w"> </span><span class="nv">include</span><span class="p">.</span><span class="nv">text</span><span class="w"> </span><span class="p">}}</span>**
<span class="p">{%-</span><span class="w"> </span><span class="nt">comment</span><span class="w"> </span><span class="p">-%}</span><span class="c">Just make sure the include ends in a %- comment -% like this one!</span><span class="p">{%-</span><span class="w"> </span><span class="nt">endcomment</span><span class="w"> </span><span class="p">-%}</span></code></pre></figure>

<p><code class="language-plaintext highlighter-rouge">_somewhere/else.md</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid">- my
- <span class="p">{%</span><span class="w"> </span><span class="nt">include</span><span class="w"> </span>inline_bold.md<span class="w"> </span><span class="na">text</span><span class="o">=</span><span class="s2">"amazing"</span><span class="w"> </span><span class="p">%}</span>
- list</code></pre></figure>

<blockquote>
  <ul>
    <li>my</li>
    <li><strong>amazing</strong></li>
    <li>list</li>
  </ul>
</blockquote>

<h3 id="make-a-map">Make a map</h3>

<p>Sometimes you need a more advanced data structure than just a list.</p>

<p>To implement a Map, I usually use two parallel lists of keys and values.</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">mykeys</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"foo,bar"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">myvalues</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"baz,bat"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">mykeys</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">mykeys</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">push</span><span class="p">:</span><span class="w"> </span><span class="s2">"new key"</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">myvalues</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">myvalues</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">push</span><span class="p">:</span><span class="w"> </span><span class="s2">"new value"</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{{</span><span class="w"> </span><span class="nv">mykeys</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="w"> </span><span class="p">}}</span> =&gt; <span class="p">{{</span><span class="w"> </span><span class="nv">myvalues</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<blockquote>
  <p>new key =&gt; new value</p>
</blockquote>

<p>See the next recipe for how to access <code class="language-plaintext highlighter-rouge">my_map[some_key]</code></p>

<h3 id="return-a-value-from-an-include">Return a value from an include</h3>

<p>Sometimes you find yourself doing some messy calculation in multiple places, and (being a good programmer) you want to <a href="https://en.wikipedia.org/wiki/Don%27t_repeat_yourself">DRY</a> out your code.
But Liquid <code class="language-plaintext highlighter-rouge">_includes</code> don’t have <code class="language-plaintext highlighter-rouge">return</code> statements… so, can you actually write an <code class="language-plaintext highlighter-rouge">_include</code> which just performs a calculation?</p>

<p>Of course!</p>

<p>Your first thought might be to use <code class="language-plaintext highlighter-rouge">{% capture returnvalue %}{% include my_func.liquid param="foo" %}{% endcapture %}</code> and to just output your return value inside the include.
And that will work!
But that’s limited to returning strings, and usually it’ll come with lots of added whitespace.</p>

<p>To return arbitrary variables, leverage the fact that <strong>your local variables aren’t actually local!!</strong></p>

<p><code class="language-plaintext highlighter-rouge">_includes/ArrayDict_lookup.liquid</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">nil</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">for</span><span class="w"> </span><span class="nv">k</span><span class="w"> </span><span class="nt">in</span><span class="w"> </span><span class="nv">include.keys</span><span class="w"> </span><span class="p">%}</span>
  <span class="p">{%</span><span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="nv">k</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="nv">include</span><span class="p">.</span><span class="nv">key</span><span class="w"> </span><span class="p">%}</span>
    <span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nv">include</span><span class="p">.</span><span class="nv">values</span><span class="p">[</span><span class="nb">forloop.index0</span><span class="p">]</span><span class="w"> </span><span class="p">%}</span>
    <span class="p">{%</span><span class="w"> </span><span class="nt">break</span><span class="w"> </span><span class="p">%}</span>
  <span class="p">{%</span><span class="w"> </span><span class="kr">endif</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">endfor</span><span class="w"> </span><span class="p">%}</span></code></pre></figure>

<p><code class="language-plaintext highlighter-rouge">_somewhere/else.markdown</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">mykeys</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"me,you,us,them"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">myvalues</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">"Alice,Bob,World,Mars"</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s2">","</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">include</span><span class="w"> </span>ArrayDict_lookup.liquid<span class="w"> </span><span class="na">values</span><span class="o">=</span><span class="nv">myvalues</span><span class="w"> </span><span class="na">keys</span><span class="o">=</span><span class="nv">mykeys</span><span class="w"> </span><span class="na">key</span><span class="o">=</span><span class="s2">"us"</span><span class="w"> </span><span class="p">%}</span>
Hello <span class="p">{{</span><span class="w"> </span><span class="nv">value</span><span class="w"> </span><span class="p">}}</span></code></pre></figure>

<blockquote>
  <p>Hello World</p>
</blockquote>

<p>Note how in the above, <code class="language-plaintext highlighter-rouge">value</code> was set in the <code class="language-plaintext highlighter-rouge">_include</code> but then <em>used</em> by the calling template!
This means (among other things) that you should <strong>never <code class="language-plaintext highlighter-rouge">{% assign content = </code></strong> in an <code class="language-plaintext highlighter-rouge">_include</code> as this will nuke the parent page’s <code class="language-plaintext highlighter-rouge">content</code>!</p>

<h3 id="recurse-in-an-include">Recurse in an include</h3>

<p>You might think that local variables always leaking their scope would make recursive includes impossible.
It certainly makes them tricky!</p>

<p>While general, “local” variables are a no-go in a recursive include, you <strong>can</strong> use:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">include.parameter</code> variables (as the include objects are indeed put on a stack)</li>
  <li><code class="language-plaintext highlighter-rouge">for</code> loop variables (as the loop tracks its own state)</li>
  <li>Temporary variables (who are assigned and used on the same side of a recursive call)</li>
</ul>

<p>For example, this <code class="language-plaintext highlighter-rouge">_include</code> takes a list of lists and outputs them as nested markdown:</p>

<p><code class="language-plaintext highlighter-rouge">_includes/recursive_lists.md</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">for</span><span class="w"> </span><span class="nv">item</span><span class="w"> </span><span class="nt">in</span><span class="w"> </span><span class="nv">include.list</span><span class="w"> </span><span class="p">-%}</span>
<span class="p">{%-</span><span class="w"> </span><span class="kr">if</span><span class="w"> </span><span class="nv">item</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="w"> </span><span class="p">%}{{</span><span class="w"> </span><span class="nv">include</span><span class="p">.</span><span class="nv">prefix</span><span class="w"> </span><span class="p">}}</span>Sublist:
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">p</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s1">'  '</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">append</span><span class="p">:</span><span class="w"> </span><span class="nv">include</span><span class="p">.</span><span class="nv">prefix</span><span class="w"> </span><span class="p">%}{%</span><span class="w"> </span><span class="nt">include</span><span class="w"> </span>recursive_lists.md<span class="w"> </span><span class="na">list</span><span class="o">=</span><span class="nv">item</span><span class="w"> </span><span class="na">prefix</span><span class="o">=</span><span class="nv">p</span><span class="w"> </span><span class="p">%}{%</span><span class="w"> </span><span class="kr">else</span><span class="w"> </span><span class="p">%}{{</span><span class="w"> </span><span class="nv">include</span><span class="p">.</span><span class="nv">prefix</span><span class="w"> </span><span class="p">}}{{</span><span class="w"> </span><span class="nv">item</span><span class="w"> </span><span class="p">}}</span>
<span class="p">{%</span><span class="w"> </span><span class="kr">endif</span><span class="w"> </span><span class="p">%}{%-</span><span class="w"> </span><span class="nt">endfor</span><span class="w"> </span><span class="p">-%}</span></code></pre></figure>

<p><code class="language-plaintext highlighter-rouge">_somewhere/else.md</code>:</p>

<figure class="highlight"><pre><code class="language-liquid" data-lang="liquid"><span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">list</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s1">'Z,Y,X'</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s1">','</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">list</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s1">'1,2,3'</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s1">','</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">push</span><span class="p">:</span><span class="w"> </span><span class="nv">list</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">push</span><span class="p">:</span><span class="w"> </span><span class="s1">'5'</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">assign</span><span class="w"> </span><span class="nv">list</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s1">'a,b,c'</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">split</span><span class="p">:</span><span class="w"> </span><span class="s1">','</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">push</span><span class="p">:</span><span class="w"> </span><span class="nv">list</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nf">push</span><span class="p">:</span><span class="w"> </span><span class="s1">'e'</span><span class="w"> </span><span class="p">%}</span>
<span class="p">{%</span><span class="w"> </span><span class="nt">include</span><span class="w"> </span>recursive_lists.md<span class="w"> </span><span class="na">list</span><span class="o">=</span><span class="nv">list</span><span class="w"> </span><span class="na">prefix</span><span class="o">=</span><span class="s2">"- "</span><span class="w"> </span><span class="p">%}</span></code></pre></figure>

<p>Outputs:</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>- a
- b
- c
- Sublist:
  - 1
  - 2
  - 3
  - Sublist:
    - Z
    - Y
    - X
  - 5
- e

</code></pre></div></div>

<p><strong>Check your understanding</strong>: What do you think would happen if that <code class="language-plaintext highlighter-rouge">{%- endfor -%}</code> at the end of the above <code class="language-plaintext highlighter-rouge">_include</code> was instead <code class="language-plaintext highlighter-rouge">{% endfor %}</code>?</p>

<h2 id="conclusion">Conclusion</h2>

<p>Liquid can be a frustrating language at times, but you can usually convince it to do what you want.
And if you can’t, you can always write a <code class="language-plaintext highlighter-rouge">_plugin</code>!</p>

<p><strong>Footnotes:</strong></p>

<div class="footnotes" role="doc-endnotes">
  <ol>
    <li id="fn:eval" role="doc-endnote">
      <p>Yes, this is basically a hidden <code class="language-plaintext highlighter-rouge">eval</code> function. With great power… <a href="#fnref:eval" class="reversefootnote" role="doc-backlink">&#8617;</a></p>
    </li>
  </ol>
</div>]]></content><author><name></name></author><summary type="html"><![CDATA[Introduction]]></summary></entry></feed>