Markdown using code blocks within bullets, broken by latest release

[arvoelke]

In my README.md, I have chains of code blocks inside of bullet points, e.g.,

• foo1
  ```
  bar1
  ```
  ```
  bar2
  ```
• foo2
  ```
  bar3
  ```
  ```
  bar4
  ```

This used to render fine, but suddenly within the past week it started rending incorrectly.

You can see the issue in how it renders here (scroll to half-way): https://github.com/arvoelke/nengolib/blob/aee92b8fc45749f07f663fe696745cf0a33bfa17/README.md

This issue applies to all of my committed README's dating back for a year, that contain this kind of syntax. It definitely worked before.

[kivikakk]

In general, questions like this should go to our support team, since they can help you a lot faster than me (there's only a couple engineers watching github/markup as part of their job, but lots of Supportocats answering emails 24/7), and the Markup repository is really just for issues relating to the github-markup gem itself, rather than the renderers it uses.

The problem you're seeing is related to our switch to CommonMark — we're now using a standard, specified version of Markdown, rather than a vague "whatever our parser says goes" one.

Using CommonMark, you'll need to indent the code blocks' contents to the same level as the list items. Like this:

 - These synapses can be easily simulated within Nengo. For example, to introduce a pure delay of `k` timesteps:

   ```
   from nengolib.signal import s, z
   nengo.Connection(a, b, synapse=z**(-k))
   ```
   which is equivalent to using `nengolib.synapses.DiscreteDelay(k)` or `(~z)**k` by use of the _reverse shift operator_. Or we can implement a double-exponential synapse:
   ```
   nengolib.synapses.DoubleExp(tau1, tau2)
   ```
   which is equivalent to using `1/((tau1*s + 1)*(tau2*s + 1))` by use of the continuous _differential operator_.
 - `nengolib.synapses.PureDelay(theta, order)` approximates a continuous-time delay of length `theta` seconds, by using a low-frequency expansion of the given order.

Which renders as follows:

• These synapses can be easily simulated within Nengo. For example, to introduce a pure delay of k timesteps:

  from nengolib.signal import s, z
  nengo.Connection(a, b, synapse=z**(-k))
  

  which is equivalent to using nengolib.synapses.DiscreteDelay(k) or (~z)**k by use of the reverse shift operator. Or we can implement a double-exponential synapse:

  nengolib.synapses.DoubleExp(tau1, tau2)
  

  which is equivalent to using 1/((tau1*s + 1)*(tau2*s + 1)) by use of the continuous differential operator.

• nengolib.synapses.PureDelay(theta, order) approximates a continuous-time delay of length theta seconds, by using a low-frequency expansion of the given order.