require 'test/unit'
require 'kashmir'
require 'elusion'

# Fake object.
class TestHelper
  def [](x); x * 2; end
  
  def bar; "BAR"; end
  def quux; "QUUUX"; end
  def hard; "Th'is ha;rd!"; end
  def multiline; "hack\nme!"; end
  def numbers; [1, 2, 3, 4, 5]; end
  def tags; %w{<foo> <bar> <baz>}; end

  def wahr; true; end
  def falsch; false; end
  def nix; nil; end

  def xml
    %{<foo><bar attr="true">text&#x10;'alright'</bar></foo>}
  end
end

# And time stood still...
def Time.now
  Time.at 1095096544
end

class KashmirTest < Test::Unit::TestCase

  # Test verbatim copying
  def test_verbatim
    template = Kashmir.new("")
    assert_equal "", template.expand(nil)

    template = Kashmir.new("foo")
    assert_equal "foo", template.expand(nil)
  end

  def test_simple_replacement
    template = Kashmir.new("^bar ^quux")
    assert_equal "BAR QUUUX", template.expand(TestHelper.new)

    template = Kashmir.new("foo ^bar ^quux quux")
    assert_equal "foo BAR QUUUX quux", template.expand(TestHelper.new)

    template = Kashmir.new("and;now'a,hard$stuff% : ^hard")
    assert_equal "and;now'a,hard$stuff% : Th'is ha;rd!",
                 template.expand(TestHelper.new)
  end

  def test_eval_replacement
    template = Kashmir.new(
      "foo ^(bar.downcase) ^(quux.reverse.tr('U','M')) quux")
    assert_equal "foo bar XMMMQ quux", template.expand(TestHelper.new)

    template = Kashmir.new("1+1 = ^(1+1)")
    assert_equal "1+1 = 2", template.expand(TestHelper.new)
  end

  def test_multiline
    template = Kashmir.new <<EOF
Multiline test:
^bar ^quux
^multiline
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
Multiline test:
BAR QUUUX
hack
me!
EOF
  end

  def test_read_to
    assert_equal "(foo)", Kashmir.new("(foo)").instance_eval {
      @cursor = 0
      @mark = 0
      read_to ?(, ?)
    }
    assert_equal "{fo{o}}", Kashmir.new("{fo{o}}").instance_eval {
      @cursor = 0
      @mark = 0
      read_to ?{, ?}
    }
    assert_raises(RuntimeError, "Hit end of template looking for matching `)'."){
      assert_equal "{fo{o}}", Kashmir.new("{fo{o}}").instance_eval {
        @cursor = 0
        @mark = 0
        read_to ?(, ?)
      }
    }
  end

  def test_comments
    template = Kashmir.new <<EOF
first
^#comment
last
EOF
    assert_equal template.expand(TestHelper.new), <<EOF
first
last
EOF
  end

  def test_blocks
    template = Kashmir.new <<EOF
first
^numbers.each{<^to_s> }
^numbers.reverse.each{<^to_s> }
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
<1> <2> <3> <4> <5> 
<5> <4> <3> <2> <1> 
last
EOF

    template = Kashmir.new <<EOF
first
^wahr.true?{Yep}
^falsch.true?{Nope}
^nix.true?{No way}
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
Yep


last
EOF

    template = Kashmir.new <<EOF
first
^wahr.true?{^^wahr}
^falsch.true?{^^falsch}
^nix.true?{^^nix}
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
true


last
EOF

    template = Kashmir.new <<EOF
first
^(wahr.true?){^^wahr}
^(falsch.true?){^^falsch}
^(nix.true?){^^nix}
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
true


last
EOF

    template = Kashmir.new <<EOF
first
^("abc def ghi".split.each){^reverse }
^("abc def ghi".scan(/\\w+/)){^reverse }
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
cba fed ihg 
cba fed ihg 
last
EOF
  end
  
  def test_parent
    template = Kashmir.new <<EOF
first
^quux.true?{^to_s ^^quux ^reverse ^^quux.reverse ^^^inspect}
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
QUUUX QUUUX XUUUQ XUUUQ nil
last
EOF
  end

  class Blog
    def title
      "chris blogs"
    end
    
    def tagline
      "a blog by christian neukirchen"
    end
    
    def entries
      [] << Entry.new("head", "some <content>") \
         << Entry.new("another", "again")
    end
  end
  
  Entry = Struct.new(:title, :body)
  class Entry    
    # Only entries with a 'd' in the title are considered recent. :P
    def recent?
      title =~ /d/
    end
  end

  def test_blog_example
    template = Kashmir.new <<EOF
<h1>^title</h1>
<h2>^tagline</h2>
<p>^(Time.now)</p>

^# overview
<ul id="toc">
^entries.each{
  [<li>^title.upcase</li>]
}</ul>

^entries.each{
<h3>^title</h3>
  ^recent?.true?{<em>[New]</em>}
  <p>^body</p>
<hr />

}
<p>^title -- ^tagline. ^(Time.now.strftime("%d%b%Y").downcase)</p>
EOF

    assert_equal template.expand(Blog.new), <<EOF
<h1>chris blogs</h1>
<h2>a blog by christian neukirchen</h2>
<p>#{Time.now}</p>

<ul id="toc">
  [<li>HEAD</li>]
  [<li>ANOTHER</li>]
</ul>

<h3>head</h3>
  <em>[New]</em>
  <p>some <content></p>
<hr />

<h3>another</h3>
  
  <p>again</p>
<hr />


<p>chris blogs -- a blog by christian neukirchen. 13sep2004</p>
EOF
  end

  def test_errors
    template = Kashmir.new('^foo')
    assert_raises(NoMethodError, "During template expansion: undefined method `foo' for nil:NilClass") {
      template.expand(nil)
    }
  end

  def test_output
    s = ""
    template = Kashmir.new('^bar')
    template.expand(TestHelper.new, s)
    assert_equal "BAR", s

    a = []
    template = Kashmir.new('^bar ^quux')
    template.expand(TestHelper.new, a)
    assert_equal ["BAR", " ", "QUUUX"], a
  end

  def test_multiple_send
    template = Kashmir.new("^quux.reverse.to_s")
    assert_equal template.expand(TestHelper.new), "XUUUQ"

    template = Kashmir.new("^(quux).reverse")
    assert_equal template.expand(TestHelper.new), "QUUUX.reverse"
  end

  def test_xml_escape
    template = Kashmir.for_XML <<EOF
first
^xml
^(raw xml)
^tags.each{^to_s}
last
EOF

    assert_equal <<EOF, template.expand(TestHelper.new)
first
&lt;foo&gt;&lt;bar attr=&quot;true&quot;&gt;text&amp;#x10;&apos;alright&apos;&lt;/bar&gt;&lt;/foo&gt;
<foo><bar attr="true">text&#x10;\'alright\'</bar></foo>
&lt;foo&gt;&lt;bar&gt;&lt;baz&gt;
last
EOF
  end

  def test_ignore
    template = Kashmir.for_XML <<EOF
first
^bar
^(ignore bar)
last
EOF

    assert_equal <<EOF, template.expand(TestHelper.new)
first
BAR

last
EOF
  end

  def test_parameters
    template = Kashmir.new <<EOF
first
^1 ^2 ^3
^({"foo" => "bar", "quux" => "pling"}.each){
  ^0 -> ^1 -> ^1.reverse
}
last
EOF
    assert_equal <<EOF, template.expand(TestHelper.new)
first
2 4 6
  quux -> pling -> gnilp
  foo -> bar -> rab

last
EOF
  end

  class MyTaglib
    def [](tag)
      "#{tag}=^#{tag}"
    end
  end

  def test_taglib
    template = Kashmir.new("^quux ^(call quux) ^bar ^(call bar)", MyTaglib.new)
    assert_equal "QUUUX quux=QUUUX BAR bar=BAR", template.expand(TestHelper.new)

    template = Kashmir.new("  ^(call multiline) ^(call bar)", MyTaglib.new)
    assert_equal "  multiline=hack\nme! bar=BAR",
                 template.expand(TestHelper.new)

    assert_raises(RuntimeError, 'no taglib defined') {
      template = Kashmir.new("^(call notaglib)")
    }
  end

  def test_blog_with_elusion
    template = Kashmir.new <<EOF
<h1>^title</h1>
<h2>^tagline</h2>
<p>^(Time.now)</p>

^# overview
<ul id="toc">
^entries.each{
  [<li>^title.upcase</li>]
}</ul>

^entries.each{
<h3>^title</h3>
  ^recent?.true?{<em>[New]</em>}
  <p>^body</p>
<hr />

}
<p>^title -- ^tagline. ^(Time.now.strftime("%d%b%Y").downcase)</p>
EOF

  elusion = Elusion.new { |e|
    e.title "chris blogs"
    e.tagline "a blog by christian neukirchen"
    
    e.entries { |f|
      f.title "head"
      f.body "some <content>"
      f.recent? true
    }
    e.entries { |f|
      f.title "another"
      f.body "again"
      f.recent? false
    }
  }
   
  assert_equal template.expand(elusion), <<EOF
<h1>chris blogs</h1>
<h2>a blog by christian neukirchen</h2>
<p>#{Time.now}</p>

<ul id="toc">
  [<li>HEAD</li>]
  [<li>ANOTHER</li>]
</ul>

<h3>head</h3>
  <em>[New]</em>
  <p>some <content></p>
<hr />

<h3>another</h3>
  
  <p>again</p>
<hr />


<p>chris blogs -- a blog by christian neukirchen. 13sep2004</p>
EOF
  end

  def test_blog_with_elusion_dwim
    template = Kashmir.new <<EOF
<h1>^title</h1>
<h2>^tagline</h2>
<p>^(Time.now)</p>

^# overview
<ul id="toc">
^entries{
  [<li>^title.upcase</li>]
}</ul>

^entries{
<h3>^title</h3>
  ^recent?{<em>[New]</em>}
  <p>^body</p>
<hr />

}
<p>^title -- ^tagline. ^(Time.now.strftime("%d%b%Y").downcase)</p>
EOF

  expansion = template.expand { |e|
    e.title "chris blogs"
    e.tagline "a blog by christian neukirchen"
    
    e.entries { |f|
      f.title "head"
      f.body "some <content>"
      f.recent? true
    }
    e.entries { |f|
      f.title "another"
      f.body "again"
      f.recent? false
    }
  }

  assert_equal expansion, <<EOF
<h1>chris blogs</h1>
<h2>a blog by christian neukirchen</h2>
<p>#{Time.now}</p>

<ul id="toc">
  [<li>HEAD</li>]
  [<li>ANOTHER</li>]
</ul>

<h3>head</h3>
  <em>[New]</em>
  <p>some <content></p>
<hr />

<h3>another</h3>
  
  <p>again</p>
<hr />


<p>chris blogs -- a blog by christian neukirchen. 13sep2004</p>
EOF
  end
end