wptemplates 0.0.3

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'simplecov'
+SimpleCov.start
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require 'wptemplates'

data/spec/utils_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Wptemplates::Utils do
+  
+  describe '.normalize_link' do
+    context 'when anchor is false' do
+      it 'removes spare spaces and underscores ' do
+        expect(subject.normalize_link(" Jimbo_ __ Wales__")).to eq("Jimbo Wales")
+      end
+      it 'removes spare spaces and underscores around namespace nekudotayim' do
+        pending "not sure if to implement here" do
+          expect(subject.normalize_link("_User_: Jimbo_ __ Wales__")).to eq("User:Jimbo Wales")
+        end
+      end
+      it 'capitalizes the first letter' do
+        expect(subject.normalize_link("foo")).to eq("Foo")
+      end
+      it 'preserves case of the other letters' do
+        expect(subject.normalize_link("fOo")).to eq("FOo")
+      end
+      it 'normalizes case of namespace prefix' do
+        pending "not sure if to implement here" do
+          expect(subject.normalize_link("fOoO:Bar")).to eq("Fooo:Bar")
+        end
+      end
+    end
+    context 'when anchor is true' do
+      it 'removes spare spaces and underscores ' do
+        expect(subject.normalize_link(" Jimbo_ __  Wales__", true)).to eq("Jimbo Wales")
+      end
+      it 'preserves case of all the letters' do
+        expect(subject.normalize_link("fOo", true)).to eq("fOo")
+      end
+    end
+  end
+  
+  describe '.normalize_linklabel' do
+    it 'removes spare spaces but not underscores' do
+      expect(subject.normalize_linklabel(" Jimbo_  __ Wales__")).to eq("Jimbo_ __ Wales__")
+    end
+    it 'preserves case of all the letters' do
+      expect(subject.normalize_linklabel("dJango")).to eq("dJango")
+    end
+  end
+  
+  describe '.symbolize' do
+    it "symbolizes strings" do
+      expect(subject.symbolize(" foo ")).to eq(:foo)
+      expect(subject.symbolize("_foo_")).to eq(:foo)
+      expect(subject.symbolize("foo")).to eq(:foo)
+      expect(subject.symbolize("FOO")).to eq(:foo)
+      expect(subject.symbolize("FoO")).to eq(:foo)
+      expect(subject.symbolize("foo bar")).to eq(:foo_bar)
+      expect(subject.symbolize("Foo BAR")).to eq(:foo_bar)
+      expect(subject.symbolize("foo_bar")).to eq(:foo_bar)
+      expect(subject.symbolize("foo__bar")).to eq(:foo_bar)
+      expect(subject.symbolize("fooBar")).to eq(:foobar)
+    end
+  end
+  
+  describe '.fixpoint' do
+    it 'returns nil when immideatly given nil' do
+      expect(subject.fixpoint {nil}).to be_nil
+    end
+    it 'returns the start value when passed the identity' do
+      expect(subject.fixpoint(start: 5) { |x| x } ).to eq(5)
+      expect(subject.fixpoint(start: "haha") { |x| x } ).to eq("haha")
+    end
+    it 'finds the fixpoint of some string algorithm' do
+      expect(subject.fixpoint(start: "haha") { |x| y=x.clone; y[0,1]=""; y } ).to eq("")
+    end
+    it 'finds the fixpoint of some string algorithm with outer var' do
+      x = "haha lol"
+      expect(subject.fixpoint { x[0,1]=""; x.clone }).to eq("")
+      expect(x).to eq("")
+    end
+    it 'finds the fixpoint of cos' do
+      expect(subject.fixpoint(start: 10) { |x| Math.cos(x) }).to be_within(1.0e-6).of(0.739085)
+    end
+    it 'finds the fixpoint of some string algorithm by cloning' do
+      expect(subject.fixpoint(start: "haha", clone: true) { |x| y=x; y[0,1]=""; y } ).to eq("")
+    end
+    it 'finds the fixpoint of some string algorithm with outer var by cloning' do
+      x = "haha lol"
+      expect(subject.fixpoint(clone: true){ x[0,1]=""; x }).to eq("")
+      expect(x).to eq("")
+    end
+  end
+  
+end

data/spec/wptemplates_links_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe Wptemplates do
+  
+  it "parses a basic link without any additions" do
+    parsed = subject.parse("[[foo]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("foo")
+    expect(parsed.links).to eq([parsed[0]])
+    expect(parsed.all_links).to eq([parsed[0]])
+    expect(parsed[0].text).to eq("foo")
+    expect(parsed[0].link).to eq("Foo")
+    expect(parsed[0].links).to eq([parsed[0]])
+    expect(parsed[0].all_links).to eq([parsed[0]])
+    expect(parsed[0].anchor).to be_nil
+  end
+  
+  it "parses a basic link with anchor" do
+    parsed = subject.parse("[[foo#bar]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("foo#bar")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("foo#bar")
+    expect(parsed[0].link).to eq("Foo")
+    expect(parsed[0].anchor).to eq("bar")
+  end
+  
+  it "parses a link with postfix chars" do
+    parsed = subject.parse("[[foo]]nx")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("foonx")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("foonx")
+    expect(parsed[0].link).to eq("Foo")
+  end
+  
+  it "parses a link with a pipe" do
+    parsed = subject.parse("[[foo|bar]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("bar")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("bar")
+    expect(parsed[0].link).to eq("Foo")
+  end
+  
+  it "parses a link with pipe and postfix chars" do
+    parsed = subject.parse("[[foo|bar]]ny")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("barny")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("barny")
+    expect(parsed[0].link).to eq("Foo")
+  end
+  
+  it "parses a link with a pipe" do
+    parsed = subject.parse("[[foo|bar]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("bar")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("bar")
+    expect(parsed[0].link).to eq("Foo")
+  end
+  
+  it "parses a link with pipe trick for comma" do
+    parsed = subject.parse("[[Boston, Massachusetts|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("Boston")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("Boston")
+    expect(parsed[0].link).to eq("Boston, Massachusetts")
+  end
+  
+  it "parses a link with pipe trick for parens" do
+    parsed = subject.parse("[[Pipe (computing)|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("Pipe")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("Pipe")
+    expect(parsed[0].link).to eq("Pipe (computing)")
+  end
+  
+  it "parses a link with pipe trick for parens and comma" do
+    parsed = subject.parse("[[Yours, Mine and Ours (1968 film)|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("Yours, Mine and Ours")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("Yours, Mine and Ours")
+    expect(parsed[0].link).to eq("Yours, Mine and Ours (1968 film)")
+  end
+  
+  it "parses a link with pipe trick for multiple commas" do
+    parsed = subject.parse("[[Il Buono, il Brutto, il Cattivo|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("Il Buono")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("Il Buono")
+    expect(parsed[0].link).to eq("Il Buono, il Brutto, il Cattivo")
+  end
+  
+  it "parses a link without pipe trick when no space after comma" do
+    parsed = subject.parse("[[a,b|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a,b")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a,b")
+    expect(parsed[0].link).to eq("A,b")
+  end
+  
+  it "parses a link without pipe trick when parens are not matched" do
+    parsed = subject.parse("[[a(b|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a(b")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a(b")
+    expect(parsed[0].link).to eq("A(b")
+  end
+  
+  it "parses a link without pipe trick when there is something after parens" do
+    parsed = subject.parse("[[a (b) c|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a (b) c")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a (b) c")
+    expect(parsed[0].link).to eq("A (b) c")
+  end
+  
+  it "parses a link with pipe trick when there is something after parens but there are commas" do
+    parsed = subject.parse("[[a(b), c|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a")
+    expect(parsed[0].link).to eq("A(b), c")
+  end
+  
+  it "parses a link with pipe trick when where is something other than comma after parens an then more commas" do
+    parsed = subject.parse("[[a(b)x, c|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a(b)x")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a(b)x")
+    expect(parsed[0].link).to eq("A(b)x, c")
+  end
+  
+  it "parses a link with pipe trick when where is something after parens but there are commas before" do
+    parsed = subject.parse("[[a, (b)c|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a")
+    expect(parsed[0].link).to eq("A, (b)c")
+  end
+  
+  it "parses appends the lettes to a link with pipe trick (comma)" do
+    parsed = subject.parse("[[a , c|]]n")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a n")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a n")
+    expect(parsed[0].link).to eq("A , c")
+  end
+  
+  it "parses appends the lettes to a link with pipe trick (parens)" do
+    parsed = subject.parse("[[a (2014)|]]n")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("an")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("an")
+    expect(parsed[0].link).to eq("A (2014)")
+  end
+  
+  it "normalizes whitespace in link text" do
+    parsed = subject.parse("[[ a  b __ c .  d  ]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("a b __ c . d")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("a b __ c . d")
+    expect(parsed[0].link).to eq("A b c . d")
+  end
+  
+  it "ignores unclosed links" do
+    parsed = subject.parse("[[a")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("[[a")
+    expect(parsed.links.length).to eq(0)
+  end
+  
+  it "ignores unclosed links up to a newline" do
+    parsed = subject.parse("[[a\nb]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("[[a\nb]]")
+    expect(parsed.links.length).to eq(0)
+  end
+  
+  it "matches ending brackets non-greedy" do
+    parsed = subject.parse("[[a]]b]]c")
+    expect(parsed.length).to eq(2)
+    expect(parsed.text).to eq("ab]]c")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("ab")
+    expect(parsed[0].link).to eq("A")
+  end
+  
+  it "continures the pipe trick stripping a lot" do
+    parsed = subject.parse("[[x(d), (d), (d), d(b), c|]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("x")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("x")
+    expect(parsed[0].link).to eq("X(d), (d), (d), d(b), c")
+  end
+  
+  it "may contain pipes in the description" do
+    parsed = subject.parse("[[a|b|c]]d")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("b|cd")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("b|cd")
+    expect(parsed[0].link).to eq("A")
+  end
+  
+  it "removes html comments between a links tags" do
+    parsed = subject.parse("[[a|<!-- ]] -->b<!-- [[a| -->]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("b")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("b")
+    expect(parsed[0].link).to eq("A")
+  end
+  
+  it "removes html comments around a links pipe" do
+    parsed = subject.parse("[[a<!-- | -->b]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("ab")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("ab")
+    expect(parsed[0].link).to eq("Ab")
+  end
+  
+  it "removes multiline html comments in links" do
+    parsed = subject.parse("[[a<!-- \n\n\n -->b]]")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("ab")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("ab")
+    expect(parsed[0].link).to eq("Ab")
+  end
+  
+end

data/spec/wptemplates_mixed_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Wptemplates do
+  
+  it "parses the empty string" do
+    parsed = subject.parse("")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed.links.length).to eq(0)
+    expect(parsed.templates.length).to eq(0)
+    expect(parsed.all_links.length).to eq(0)
+    expect(parsed.all_templates.length).to eq(0)
+    expect(parsed[0].text).to eq("")
+  end
+  
+  it "parses link, text, template" do
+    parsed = subject.parse("[[foo]] bar {{baz}}")
+    expect(parsed.length).to eq(3)
+    expect(parsed.text).to eq("foo bar ")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("foo")
+    expect(parsed[0].link).to eq("Foo")
+    expect(parsed[1].text).to eq(" bar ")
+    expect(parsed[2].text).to eq("")
+    expect(parsed[2].name).to eq(:baz)
+  end
+  
+  it "parses template, text, link" do
+    parsed = subject.parse("{{baz}} bar [[foo]]")
+    expect(parsed.length).to eq(3)
+    expect(parsed.text).to eq(" bar foo")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("")
+    expect(parsed[0].name).to eq(:baz)
+    expect(parsed[1].text).to eq(" bar ")
+    expect(parsed[2].text).to eq("foo")
+    expect(parsed[2].link).to eq("Foo")
+  end
+  
+  it "parses a link in a template" do
+    parsed = subject.parse("{{baz|[[foo]]}}")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed.all_links.length).to eq(1)
+    expect(parsed.all_templates.length).to eq(1)
+    expect(parsed.templates.length).to eq(1)
+    expect(parsed[0].text).to eq("")
+    expect(parsed[0].name).to eq(:baz)
+    expect(parsed[0].params.keys).to eq([0])
+    expect(parsed[0].params[0].length).to eq(1)
+    expect(parsed[0].params[0].links.length).to eq(1)
+    expect(parsed[0].params[0][0].text).to eq("foo")
+    expect(parsed[0].params[0][0].link).to eq("Foo")
+  end
+  
+  it "parses a link in a template with whitespace removed" do
+    parsed = subject.parse("{{baz|p = [[foo]] }}")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed.templates.length).to eq(1)
+    expect(parsed[0].text).to eq("")
+    expect(parsed[0].name).to eq(:baz)
+    expect(parsed[0].params.keys).to eq([:p])
+    expect(parsed[0].params[:p].text).to eq("foo")
+    expect(parsed[0].params[:p].length).to eq(1)
+    expect(parsed[0].params[:p].links.length).to eq(1)
+    expect(parsed[0].params[:p][0].text).to eq("foo")
+    expect(parsed[0].params[:p][0].link).to eq("Foo")
+  end
+  
+  it "parses text, link, letters, link" do
+    parsed = subject.parse("bar [[foo]]ny baz")
+    expect(parsed.length).to eq(3)
+    expect(parsed.text).to eq("bar foony baz")
+    expect(parsed.links.length).to eq(1)
+    expect(parsed[0].text).to eq("bar ")
+    expect(parsed[1].text).to eq("foony")
+    expect(parsed[1].link).to eq("Foo")
+    expect(parsed[2].text).to eq(" baz")
+  end
+  
+end

data/spec/wptemplates_templates_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe Wptemplates do
+  
+  it "parses a template without any parameters" do
+    parsed = subject.parse("{{foo}}")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed[0].text).to eq("")
+    expect(parsed.templates.length).to eq(1)
+    expect(parsed[0].name).to eq(:foo)
+  end
+  
+  it "parses a template with numeric parameters" do
+    parsed = subject.parse("{{foo|a|b|c}}")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed[0].text).to eq("")
+    expect(parsed.templates.length).to eq(1)
+    expect(parsed[0].name).to eq(:foo)
+    p = parsed[0].params
+    expect(p.keys).to eq([0,1,2])
+    expect(p[0].length).to eq(1)
+    expect(p[0].text).to eq("a")
+    expect(p[0][0].text).to eq("a")
+    expect(p[1].length).to eq(1)
+    expect(p[1].text).to eq("b")
+    expect(p[1][0].text).to eq("b")
+    expect(p[2].length).to eq(1)
+    expect(p[2].text).to eq("c")
+    expect(p[2][0].text).to eq("c")
+  end
+  
+  it "parses a template with named parameters" do
+    parsed = subject.parse("{{foo| a = x |b = y \n|c= z z }}")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed[0].text).to eq("")
+    expect(parsed.templates.length).to eq(1)
+    expect(parsed[0].name).to eq(:foo)
+    p = parsed[0].params
+    expect(p.keys).to eq([:a,:b,:c])
+    expect(p[:a].length).to eq(1)
+    expect(p[:a].text).to eq("x")
+    expect(p[:a][0].text).to eq("x")
+    expect(p[:b].length).to eq(1)
+    expect(p[:b].text).to eq("y")
+    expect(p[:b][0].text).to eq("y")
+    expect(p[:c].length).to eq(1)
+    expect(p[:c].text).to eq("z z")
+    expect(p[:c][0].text).to eq("z z")
+  end
+  
+  it "doesn't have problems with empty numeric parameters" do
+    parsed = subject.parse("{{foo|}}")
+    expect(parsed.length).to eq(1)
+    p = parsed[0].params
+    expect(p.keys).to eq([0])
+    expect(p[0].length).to eq(1)
+    expect(p[0].text).to eq("")
+    expect(p[0][0].text).to eq("")
+  end
+  
+  it "doesn't have problems with empty valued named parameters" do
+    parsed = subject.parse("{{foo|b=}}")
+    expect(parsed.length).to eq(1)
+    p = parsed[0].params
+    expect(p.keys).to eq([:b])
+    expect(p[:b].length).to eq(1)
+    expect(p[:b].text).to eq("")
+    expect(p[:b][0].text).to eq("")
+  end
+  
+  it "doesn't have problems with white spece only valued named parameters" do
+    parsed = subject.parse("{{foo|c= }}")
+    expect(parsed.length).to eq(1)
+    p = parsed[0].params
+    expect(p.keys).to eq([:c])
+    expect(p[:c].length).to eq(1)
+    expect(p[:c].text).to eq("")
+    expect(p[:c][0].text).to eq("")
+  end
+  
+  it "doesn't have problems with empty name parameters" do
+    parsed = subject.parse("{{foo|=3}}")
+    p = parsed[0].params
+    expect(p[:""].length).to eq(1)
+    expect(p[:""].text).to eq("3")
+    expect(p[:""][0].text).to eq("3")
+  end
+  
+  it "doesn't have problems with mixed empty stuff" do
+    parsed = subject.parse("{{foo||b=|c= |=3}}")
+    expect(parsed.length).to eq(1)
+    p = parsed[0].params
+    expect(p.keys).to eq([0,:b,:c,:""])
+    expect(p[0].length).to eq(1)
+    expect(p[0].text).to eq("")
+    expect(p[0][0].text).to eq("")
+    expect(p[:b].length).to eq(1)
+    expect(p[:b].text).to eq("")
+    expect(p[:b][0].text).to eq("")
+    expect(p[:c].length).to eq(1)
+    expect(p[:c].text).to eq("")
+    expect(p[:c][0].text).to eq("")
+    expect(p[:""].length).to eq(1)
+    expect(p[:""].text).to eq("3")
+    expect(p[:""][0].text).to eq("3")
+  end
+  
+  it "parses nested templates" do
+    parsed = subject.parse("{{foo| a = {{bar|j|k}} |b = y {{baz|p=q}} y2 \n|c= z z }}")
+    expect(parsed.length).to eq(1)
+    expect(parsed.text).to eq("")
+    expect(parsed[0].text).to eq("")
+    expect(parsed.templates.length).to eq(1)
+    expect(parsed.all_templates.length).to eq(3)
+    expect(parsed[0].name).to eq(:foo)
+    p = parsed[0].params
+    expect(p.keys).to eq([:a,:b,:c])
+    expect(p[:a].templates.length).to eq(1)
+    expect(p[:a].text).to eq("")
+    expect(p[:a].templates[0].name).to eq(:bar)
+    expect(p[:a].templates[0].params.keys).to eq([0,1])
+    expect(p[:a].templates[0].params[0].text).to eq("j")
+    expect(p[:a].templates[0].params[1].text).to eq("k")
+    expect(p[:b].length).to eq(3)
+    expect(p[:b].templates.length).to eq(1)
+    expect(p[:b].text).to eq("y  y2")
+    expect(p[:b][0].text).to eq("y ")
+    expect(p[:b][2].text).to eq(" y2")
+    expect(p[:b].templates[0].name).to eq(:baz)
+    expect(p[:b].templates[0].params.keys).to eq([:p])
+    expect(p[:b].templates[0].params[:p].text).to eq("q")
+    expect(p[:c].length).to eq(1)
+    expect(p[:c].text).to eq("z z")
+    expect(p[:c][0].text).to eq("z z")
+  end
+  
+  it "barkes about unclosed templates" do
+    expect { subject.parse("{{foo") }.to raise_error
+    expect { subject.parse("{{foo}}{{") }.to raise_error
+  end
+  
+  it "does not bark when {{ is in the name though" do
+    expect(subject.parse("{{{{foo}}")[0].name).to eq(:"{{foo")
+  end
+  
+  it "finds nested templates" do
+    parsed = subject.parse("{{foo| a = {{bar|j|k}} |b = y {{foo|p=q}} y2 \n|c= z z }}")
+    expect(parsed.template_of :foo).to eq(parsed.templates[0])
+    expect(parsed.templates_of :foo).to eq([parsed.templates[0]])
+    expect(parsed.deep_template_of :foo).to eq(parsed.templates[0])
+    expect(parsed.all_templates_of :foo).to eq([parsed.templates[0], parsed.templates[0].params[:b].templates[0]])
+    expect(parsed.template_of :bar).to be_nil
+    expect(parsed.templates_of :bar).to eq([])
+    expect(parsed.deep_template_of :bar).to eq(parsed.templates[0].params[:a].templates[0])
+    expect(parsed.all_templates_of :bar).to eq([parsed.templates[0].params[:a].templates[0]])
+  end
+  
+end