koara 0.9.0

data/test/filereader-unicode.kd

@@ -0,0 +1 @@
+ðinæ

data/test/filereader.kd

@@ -0,0 +1 @@
+abcd

data/test/filereader_test.rb

@@ -0,0 +1,103 @@
+require 'koara'
+require 'minitest/autorun'
+
+class FileReaderTest < MiniTest::Unit::TestCase
+  def setup
+    @buffer = Array.new
+  end
+
+  def test_read
+    @reader = FileReader.new('test/filereader.kd')
+    assert_equal(4, @reader.read(@buffer, 0, 4))
+    assert_equal('a', @buffer[0])
+    assert_equal('b', @buffer[1])
+    assert_equal('c', @buffer[2])
+    assert_equal('d', @buffer[3])
+    assert_equal(4, @buffer.length)
+    assert_equal(-1, @reader.read(@buffer, 0, 4))
+  end
+
+  def test_read_part_of_string
+    @reader = FileReader.new('test/filereader.kd')
+    assert_equal(2, @reader.read(@buffer, 0, 2))
+    assert_equal('a', @buffer[0])
+    assert_equal('b', @buffer[1])
+    assert_equal(2, @buffer.length)
+  end
+
+  def test_read_with_offset_part_of_string
+    @reader = FileReader.new('test/filereader.kd')
+    assert_equal(4, @reader.read(@buffer, 2, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal('a', @buffer[2])
+    assert_equal('b', @buffer[3])
+  end
+
+  def test_read_with_offset_too_large_part_of_string
+    @reader = FileReader.new('test/filereader.kd')
+    assert_equal(4, @reader.read(@buffer, 6, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal(nil, @buffer[2])
+    assert_equal(nil, @buffer[3])
+  end
+
+  def test_read_until_eof
+    @reader = FileReader.new('test/filereader.kd')
+    assert_equal(2, @reader.read(@buffer, 0, 2))
+    assert_equal('a', @buffer[0])
+    assert_equal('b', @buffer[1])
+    assert_equal(2, @reader.read(@buffer, 0, 3))
+    assert_equal('c', @buffer[0])
+    assert_equal('d', @buffer[1])
+    assert_equal(-1, @reader.read(@buffer, 0, 2))
+  end
+
+  def test_read_with_unicode
+    @reader = FileReader.new('test/filereader-unicode.kd')
+    assert_equal(4, @reader.read(@buffer, 0, 4))
+    assert_equal('ð', @buffer[0])
+    assert_equal('i', @buffer[1])
+    assert_equal('n', @buffer[2])
+    assert_equal('æ', @buffer[3])
+    assert_equal(4, @buffer.length)
+  end
+
+  def test_read_with_unicode_part_of_string
+    @reader = FileReader.new('test/filereader-unicode.kd')
+    assert_equal(2, @reader.read(@buffer, 0, 2))
+    assert_equal('ð', @buffer[0])
+    assert_equal('i', @buffer[1])
+    assert_equal(2, @buffer.length)
+  end
+
+  def test_read_with_unicode_and_offset_part_of_string
+    @reader = FileReader.new('test/filereader-unicode.kd')
+    assert_equal(4, @reader.read(@buffer, 2, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal('ð', @buffer[2])
+    assert_equal('i', @buffer[3])
+  end
+
+  def test_read_with_unicode_and_offset_too_large_part_of_string
+    @reader = FileReader.new('test/filereader-unicode.kd')
+    assert_equal(4, @reader.read(@buffer, 6, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal(nil, @buffer[2])
+    assert_equal(nil, @buffer[3])
+  end
+
+  def test_read_with_unicode_until_eof
+    @reader = FileReader.new('test/filereader-unicode.kd')
+    assert_equal(3, @reader.read(@buffer, 0, 3))
+    assert_equal('ð', @buffer[0])
+    assert_equal('i', @buffer[1])
+    assert_equal(1, @reader.read(@buffer, 0, 3))
+    assert_equal('æ', @buffer[0])
+    assert_equal(-1, @reader.read(@buffer, 0, 2))
+  end
+
+end

data/test/html5renderer.rb

@@ -0,0 +1,179 @@
+class Html5Renderer
+
+  def visit_document(node)
+    @level = 0
+    @list_sequence = Array.new
+    @out = StringIO.new
+    node.children_accept(self)
+  end
+
+  def visit_heading(node)
+    @out << indent + '<h' + node.value.to_s + '>'
+    node.children_accept(self)
+    @out << '</h' + node.value.to_s + ">\n"
+    unless node.nested
+      @out << "\n"
+    end
+  end
+
+  def visit_blockquote(node)
+    @out << indent + '<blockquote>'
+    if !node.children.nil? && node.children.any?
+      @out << "\n"
+    end
+    @level += 1
+    node.children_accept(self)
+    @level-=1
+    @out << indent + "</blockquote>\n"
+    if !node.nested
+      @out << "\n"
+    end
+  end
+
+  def visit_list_block(node)
+    @list_sequence.push(0)
+    tag = node.ordered ? 'ol' : 'ul'
+    @out << "#{indent}<#{tag}>\n"
+    @level += 1
+    node.children_accept(self)
+    @level -= 1
+    @out << "#{indent}</#{tag}>\n"
+    if !node.nested
+      @out << "\n"
+    end
+    @list_sequence.pop
+  end
+
+  def visit_list_item(node)
+    seq = @list_sequence.last.to_i + 1
+    @list_sequence[-1] = seq
+    @out << "#{indent}<li"
+
+    if node.number && seq != node.number.to_i
+      @out << " value=\"#{node.number}\""
+      @list_sequence.push(node.number)
+    end
+    @out << '>'
+    if !node.children.nil?
+      block = node.children[0].instance_of?(Paragraph) || node.children[0].instance_of?(BlockElement)
+      if (node.children.length > 1 || !block)
+        @out << "\n"
+      end
+      @level += 1
+      node.children_accept(self)
+      @level -= 1
+      if (node.children.length > 1 || !block)
+        @out << indent
+      end
+    end
+    @out << "</li>\n"
+  end
+
+  def visit_codeblock(node)
+    @out << indent + '<pre><code'
+    if node.language
+      @out << " class=\"language-" + escape(node.language) + "\""
+    end
+    @out << '>'
+    @out << escape(node.value) + "</code></pre>\n"
+    @out << ("\n") if !node.nested
+  end
+
+  def visit_paragraph(node)
+    if node.nested && node.parent.instance_of?(ListItem) && node.is_single_child
+      node.children_accept(self)
+    else
+      @out << indent + '<p>'
+      node.children_accept(self)
+      @out << "</p>\n"
+      unless node.nested
+        @out << "\n"
+      end
+    end
+  end
+
+  def visit_block_element(node)
+    if node.nested && node.parent.instance_of?(ListItem) && node.is_single_child
+      node.children_accept(self)
+    else
+      @out << indent
+      node.children_accept(self)
+      if !node.nested
+        @out << "\n"
+      end
+    end
+  end
+
+  def visit_image(node)
+    @out << "<img src=\"" + escape_url(node.value) + "\" alt=\""
+    node.children_accept(self)
+    @out << "\" />"
+  end
+
+  def visit_link(node)
+    @out << "<a href=\"" + escape_url(node.value) + "\">"
+    node.children_accept(self)
+    @out << '</a>'
+  end
+
+  def visit_strong(node)
+    @out << '<strong>'
+    node.children_accept(self)
+    @out << '</strong>'
+  end
+
+  def visit_em(node)
+    @out << '<em>'
+    node.children_accept(self)
+    @out << '</em>'
+  end
+
+  def visit_code(node)
+    @out << '<code>'
+    node.children_accept(self)
+    @out << '</code>'
+  end
+
+  def visit_text(node)
+    @out << escape(node.value.to_s)
+  end
+
+  #
+  def escape(text)
+    return text.gsub(/&/, '&amp;')
+               .gsub(/</, '&lt;')
+               .gsub(/>/, '&gt;')
+               .gsub(/"/, '&quot;')
+  end
+
+  def visit_linebreak(node)
+    @out << "<br>\n" + indent
+    node.children_accept(self)
+  end
+
+  def escape_url(text)
+    text.gsub(/ /, '%20')
+        .gsub(/"/, '%22')
+        .gsub(/`/, '%60')
+        .gsub(/</, '%3C')
+        .gsub(/>/, '%3E')
+        .gsub(/\[/, '%5B')
+        .gsub(/\]/, '%5D')
+        .gsub(/\\/, '%5C')
+  end
+
+  def indent
+    repeat = @level * 2
+    str = StringIO.new
+    repeat.times {
+      str << ' '
+    }
+    str.string
+  end
+
+  def output
+    @out.string.strip
+  end
+
+
+end

data/test/stringreader_test.rb

@@ -0,0 +1,103 @@
+require 'koara'
+require 'minitest/autorun'
+
+class StringReaderTest < MiniTest::Unit::TestCase
+  def setup
+    @buffer = Array.new
+  end
+
+  def test_read
+    @reader = StringReader.new('abcd')
+    assert_equal(4, @reader.read(@buffer, 0, 4))
+    assert_equal('a', @buffer[0])
+    assert_equal('b', @buffer[1])
+    assert_equal('c', @buffer[2])
+    assert_equal('d', @buffer[3])
+    assert_equal(4, @buffer.length)
+    assert_equal(-1, @reader.read(@buffer, 0, 4))
+  end
+
+  def test_read_part_of_string
+    @reader = StringReader.new('abcd')
+    assert_equal(2, @reader.read(@buffer, 0, 2))
+    assert_equal('a', @buffer[0])
+    assert_equal('b', @buffer[1])
+    assert_equal(2, @buffer.length)
+  end
+
+  def test_read_with_offset_part_of_string
+    @reader = StringReader.new('abcd')
+    assert_equal(4, @reader.read(@buffer, 2, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal('a', @buffer[2])
+    assert_equal('b', @buffer[3])
+  end
+
+  def test_read_with_offset_too_large_part_of_string
+    @reader = StringReader.new('abcd')
+    assert_equal(4, @reader.read(@buffer, 6, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal(nil, @buffer[2])
+    assert_equal(nil, @buffer[3])
+  end
+
+  def test_read_until_eof
+    @reader = StringReader.new('abcd')
+    assert_equal(2, @reader.read(@buffer, 0, 2))
+    assert_equal('a', @buffer[0])
+    assert_equal('b', @buffer[1])
+    assert_equal(2, @reader.read(@buffer, 0, 3))
+    assert_equal('c', @buffer[0])
+    assert_equal('d', @buffer[1])
+    assert_equal(-1, @reader.read(@buffer, 0, 2))
+  end
+
+  def test_read_with_unicode
+    @reader = StringReader.new('ðinæ')
+    assert_equal(4, @reader.read(@buffer, 0, 4))
+    assert_equal('ð', @buffer[0])
+    assert_equal('i', @buffer[1])
+    assert_equal('n', @buffer[2])
+    assert_equal('æ', @buffer[3])
+    assert_equal(4, @buffer.length)
+  end
+
+  def test_read_with_unicode_part_of_string
+    @reader = StringReader.new('ðinæ')
+    assert_equal(2, @reader.read(@buffer, 0, 2))
+    assert_equal('ð', @buffer[0])
+    assert_equal('i', @buffer[1])
+    assert_equal(2, @buffer.length)
+  end
+
+  def test_Read_with_unicode_and_offset_part_of_string
+    @reader = StringReader.new('ðinæ')
+    assert_equal(4, @reader.read(@buffer, 2, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal('ð', @buffer[2])
+    assert_equal('i', @buffer[3])
+  end
+
+  def test_read_with_unicode_and_offset_too_large_part_of_string
+    @reader = StringReader.new('ðinæ')
+    assert_equal(4, @reader.read(@buffer, 6, 4))
+    assert_equal(nil, @buffer[0])
+    assert_equal(nil, @buffer[1])
+    assert_equal(nil, @buffer[2])
+    assert_equal(nil, @buffer[3])
+  end
+
+  def test_read_with_unicode_until_eof
+    @reader = StringReader.new('ðinæ')
+    assert_equal(3, @reader.read(@buffer, 0, 3))
+    assert_equal('ð', @buffer[0])
+    assert_equal('i', @buffer[1])
+    assert_equal(1, @reader.read(@buffer, 0, 3))
+    assert_equal('æ', @buffer[0])
+    assert_equal(-1, @reader.read(@buffer, 0, 2))
+  end
+
+end

data/test/token_manager_test.rb

@@ -0,0 +1,157 @@
+require 'koara'
+require 'minitest/autorun'
+
+class TokenManagerTest < MiniTest::Unit::TestCase
+
+
+  def test_eof
+   token = TokenManager.new(CharStream.new(StringReader.new('')))::get_next_token
+   assert_equal(TokenManager::EOF, token.kind)
+  end
+
+  def test_asterisk
+    token = TokenManager.new(CharStream.new(StringReader.new('*'))).get_next_token
+    assert_equal(TokenManager::ASTERISK, token.kind)
+    assert_equal('*', token.image)
+  end
+
+  def test_backslash
+    token = TokenManager.new(CharStream.new(StringReader.new('\\'))).get_next_token
+    assert_equal(TokenManager::BACKSLASH, token.kind)
+    assert_equal('\\', token.image)
+  end
+
+  def test_backtick
+    token = TokenManager.new(CharStream.new(StringReader.new('`'))).get_next_token
+    assert_equal(TokenManager::BACKTICK, token.kind)
+    assert_equal('`', token.image)
+  end
+
+  def test_char_sequence_lowercase
+    token = TokenManager.new(CharStream.new(StringReader.new('m'))).get_next_token
+    assert_equal(TokenManager::CHAR_SEQUENCE, token.kind)
+    assert_equal('m', token.image)
+  end
+
+  def test_char_sequence_uppercase
+    token = TokenManager.new(CharStream.new(StringReader.new('C'))).get_next_token
+    assert_equal(TokenManager::CHAR_SEQUENCE, token.kind)
+    assert_equal('C', token.image)
+  end
+
+  def test_colon
+    token = TokenManager.new(CharStream.new(StringReader.new(':'))).get_next_token
+    assert_equal(TokenManager::COLON, token.kind)
+    assert_equal(':', token.image)
+  end
+
+  def test_dash
+    token = TokenManager.new(CharStream.new(StringReader.new('-'))).get_next_token
+    assert_equal(TokenManager::DASH, token.kind)
+    assert_equal('-', token.image)
+  end
+
+  def test_digits
+    token = TokenManager.new(CharStream.new(StringReader.new('4'))).get_next_token
+    assert_equal(TokenManager::DIGITS, token.kind)
+    assert_equal('4', token.image)
+  end
+
+  def test_dot
+    token = TokenManager.new(CharStream.new(StringReader.new('.'))).get_next_token
+    assert_equal(TokenManager::DOT, token.kind)
+    assert_equal('.', token.image)
+  end
+
+  def test_eol
+    token = TokenManager.new(CharStream.new(StringReader.new("\n"))).get_next_token
+    assert_equal(TokenManager::EOL, token.kind)
+    assert_equal("\n", token.image)
+  end
+
+  def test_eq
+    token = TokenManager.new(CharStream.new(StringReader.new('='))).get_next_token
+    assert_equal(TokenManager::EQ, token.kind)
+    assert_equal('=', token.image)
+  end
+
+  def test_escaped_char
+    token = TokenManager.new(CharStream.new(StringReader.new("\\*"))).get_next_token
+    assert_equal(TokenManager::ESCAPED_CHAR, token.kind)
+    assert_equal("\\*", token.image)
+  end
+
+  def test_gt
+    token = TokenManager.new(CharStream.new(StringReader.new('>'))).get_next_token
+    assert_equal(TokenManager::GT, token.kind)
+    assert_equal('>', token.image)
+  end
+
+  def test_image_label
+    token = TokenManager.new(CharStream.new(StringReader.new('image:'))).get_next_token
+    assert_equal(TokenManager::IMAGE_LABEL, token.kind)
+    assert_equal('image:', token.image)
+  end
+
+  def test_lbrack
+    token = TokenManager.new(CharStream.new(StringReader.new('['))).get_next_token
+    assert_equal(TokenManager::LBRACK, token.kind)
+    assert_equal('[', token.image)
+  end
+
+  def test_lparen
+    token = TokenManager.new(CharStream.new(StringReader.new('('))).get_next_token
+    assert_equal(TokenManager::LPAREN, token.kind)
+    assert_equal('(', token.image)
+  end
+
+  def test_lt
+    token = TokenManager.new(CharStream.new(StringReader.new('<'))).get_next_token
+    assert_equal(TokenManager::LT, token.kind)
+    assert_equal('<', token.image)
+  end
+
+  def test_rbrack
+    token = TokenManager.new(CharStream.new(StringReader.new(']'))).get_next_token
+    assert_equal(TokenManager::RBRACK, token.kind)
+    assert_equal(']', token.image)
+  end
+
+  def test_rparen
+    token = TokenManager.new(CharStream.new(StringReader.new(')'))).get_next_token
+    assert_equal(TokenManager::RPAREN, token.kind)
+    assert_equal(')', token.image)
+  end
+
+  def test_space
+    token = TokenManager.new(CharStream.new(StringReader.new(' '))).get_next_token
+    assert_equal(TokenManager::SPACE, token.kind)
+    assert_equal(' ', token.image)
+  end
+
+  def test_tab
+    token = TokenManager.new(CharStream.new(StringReader.new("\t"))).get_next_token
+    assert_equal(TokenManager::TAB, token.kind)
+    assert_equal("\t", token.image)
+  end
+
+  def test_underscore
+    token = TokenManager.new(CharStream.new(StringReader.new('_'))).get_next_token
+    assert_equal(TokenManager::UNDERSCORE, token.kind)
+    assert_equal('_', token.image)
+  end
+
+  def test_space_after_char_sequence
+    tm = TokenManager.new(CharStream.new(StringReader.new('a ')))
+    assert_equal('a', tm.get_next_token.image)
+    assert_equal(' ', tm.get_next_token.image)
+  end
+
+  def test_two_distinct_char_sequences
+    tm = TokenManager.new(CharStream.new(StringReader.new('ði ı')))
+    assert_equal('ði', tm.get_next_token.image)
+    assert_equal(' ', tm.get_next_token.image)
+    assert_equal('ı', tm.get_next_token.image)
+  end
+
+end