newstile 1.0.1

data/lib/newstile/parser/newstile/html_entity.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of newstile.
+#
+# newstile is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+require 'newstile/parser/html'
+
+module Newstile
+  module Parser
+    class Newstile
+
+      # Parse the HTML entity at the current location.
+      def parse_html_entity
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:entity, ::Newstile::Utils::Entities.entity(@src[1] || (@src[2] && @src[2].to_i) || @src[3].hex),
+                                      nil, :original => @src.matched)
+      end
+      define_parser(:html_entity, Newstile::Parser::Html::Constants::HTML_ENTITY_RE, '&')
+
+    end
+  end
+end

data/lib/newstile/parser/newstile/line_break.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of newstile.
+#
+# newstile is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+module Newstile
+  module Parser
+    class Newstile
+
+      LINE_BREAK = /(  |\\\\)(?=\n)/
+
+      # Parse the line break at the current location.
+      def parse_line_break
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:br)
+      end
+      define_parser(:line_break, LINE_BREAK, '(  |\\\\)(?=\n)')
+
+    end
+  end
+end

data/lib/newstile/parser/newstile/link.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of newstile.
+#
+# newstile is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+module Newstile
+  module Parser
+    class Newstile
+
+      PUNCTUATION_CHARS = "_.:,;!?-"
+      LINK_ID_CHARS = /[a-zA-Z0-9 #{PUNCTUATION_CHARS}]/
+      LINK_ID_NON_CHARS = /[^a-zA-Z0-9 #{PUNCTUATION_CHARS}]/
+      LINK_DEFINITION_START = /^#{OPT_SPACE}\[(#{LINK_ID_CHARS}+)\]:[ \t]*(?:<(.*?)>|([^'"\n]*?\S[^'"\n]*?))[ \t]*?(?:\n?[ \t]*?(["'])(.+?)\4[ \t]*?)?\n/
+
+      # Parse the link definition at the current location.
+      def parse_link_definition
+        @src.pos += @src.matched_size
+        link_id, link_url, link_title = @src[1].downcase, @src[2] || @src[3], @src[5]
+        warning("Duplicate link ID '#{link_id}' - overwriting") if @doc.parse_infos[:link_defs][link_id]
+        @doc.parse_infos[:link_defs][link_id] = [link_url, link_title]
+        @tree.children << Element.new(:eob, :link_def)
+        true
+      end
+      define_parser(:link_definition, LINK_DEFINITION_START)
+
+
+      # This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
+      # and the element itself to the <tt>@tree</tt>.
+      def add_link(el, href, title, alt_text = nil)
+        if el.type == :a
+          el.attr['href'] = href
+        else
+          el.attr['src'] = href
+          el.attr['alt'] = alt_text
+          el.children.clear
+        end
+        el.attr['title'] = title if title
+        @tree.children << el
+      end
+
+      LINK_TEXT_BRACKET_RE = /\\\[|\\\]|\[|\]/
+      LINK_INLINE_ID_RE = /\s*?\[(#{LINK_ID_CHARS}+)?\]/
+      LINK_INLINE_TITLE_RE = /\s*?(["'])(.+?)\1\s*?\)/
+      LINK_START = /!?\[(?=[^^])/
+
+      # Parse the link at the current scanner position. This method is used to parse normal links as
+      # well as image links.
+      def parse_link
+        result = @src.scan(LINK_START)
+        reset_pos = @src.pos
+
+        link_type = (result =~ /^!/ ? :img : :a)
+
+        # no nested links allowed
+        if link_type == :a && (@tree.type == :img || @tree.type == :a || @stack.any? {|t,s| t && (t.type == :img || t.type == :a)})
+          add_text(result)
+          return
+        end
+        el = Element.new(link_type)
+
+        stop_re = /\]|!?\[/
+        count = 1
+        found = parse_spans(el, stop_re) do
+          case @src.matched
+          when "[", "!["
+            count += 1
+          when "]"
+            count -= 1
+          end
+          count - el.children.select {|c| c.type == :img}.size == 0
+        end
+        if !found || (link_type == :a && el.children.empty?)
+          @src.pos = reset_pos
+          add_text(result)
+          return
+        end
+        alt_text = extract_string(reset_pos...@src.pos, @src)
+        conv_link_id = alt_text.gsub(/(\s|\n)+/m, ' ').gsub(LINK_ID_NON_CHARS, '').downcase
+        @src.scan(stop_re)
+
+        # reference style link or no link url
+        if @src.scan(LINK_INLINE_ID_RE) || !@src.check(/\(/)
+          link_id = (@src[1] || conv_link_id).downcase
+          if link_id.empty?
+            @src.pos = reset_pos
+            add_text(result)
+          elsif @doc.parse_infos[:link_defs].has_key?(link_id)
+            add_link(el, @doc.parse_infos[:link_defs][link_id].first, @doc.parse_infos[:link_defs][link_id].last, alt_text)
+          else
+            warning("No link definition for link ID '#{link_id}' found")
+            @src.pos = reset_pos
+            add_text(result)
+          end
+          return
+        end
+
+        # link url in parentheses
+        if @src.scan(/\(<(.*?)>/)
+          link_url = @src[1]
+          if @src.scan(/\)/)
+            add_link(el, link_url, nil, alt_text)
+            return
+          end
+        else
+          link_url = ''
+          re = /\(|\)|\s(?=['"])/
+          nr_of_brackets = 0
+          while temp = @src.scan_until(re)
+            link_url += temp
+            case @src.matched
+            when /\s/
+              break
+            when '('
+              nr_of_brackets += 1
+            when ')'
+              nr_of_brackets -= 1
+              break if nr_of_brackets == 0
+            end
+          end
+          link_url = link_url[1..-2].strip
+
+          if nr_of_brackets == 0
+            add_link(el, link_url, nil, alt_text)
+            return
+          end
+        end
+
+        if @src.scan(LINK_INLINE_TITLE_RE)
+          add_link(el, link_url, @src[2], alt_text)
+        else
+          @src.pos = reset_pos
+          add_text(result)
+        end
+      end
+      define_parser(:link, LINK_START, '!?\[')
+
+
+      NEWSTILE_LINK_START = /!?([^\\]?)\"([^\"]+)\"\:([\S]+[\w\/])/
+      # Parse the link definition at the current location.
+      def parse_newstile_link
+        link_type = (@src.string[@src.pos] == '!'[0] ? :img : :a)
+        @src.pos += @src.matched_size
+        add_text @src[1] if @src[1]
+        case link_type
+        when :a then
+          text, href = @src[2], @src[3]
+          el = Element.new(:a, nil, {'href' => href})
+          el.children = [ Element.new(:text, text) ]
+          @tree.children << el
+        when :img then
+          alt, src = @src[2], @src[3]
+          el = Element.new(:img, nil, {'src' => src, 'alt' => alt})
+          @tree.children << el
+        end
+        true
+      end
+      define_parser(:newstile_link, NEWSTILE_LINK_START, '!?\"')
+    end
+  end
+end

data/lib/newstile/parser/newstile/list.rb

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of newstile.
+#
+# newstile is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+require 'newstile/parser/newstile/blank_line'
+require 'newstile/parser/newstile/eob'
+require 'newstile/parser/newstile/horizontal_rule'
+require 'newstile/parser/newstile/attribute_list'
+
+module Newstile
+  module Parser
+    class Newstile
+
+      LIST_ITEM_IAL = /^\s*(#{IAL_SPAN_START})?\s*\n/
+
+      # Used for parsing the first line of a list item or a definition, i.e. the line with list item
+      # marker or the definition marker.
+      def parse_first_list_line(indentation, content)
+        if content =~ LIST_ITEM_IAL
+          indentation = 4
+        else
+          while content =~ /^ *\t/
+            temp = content.scan(/^ */).first.length + indentation
+            content.sub!(/^( *)(\t+)/) {$1 + " "*(4 - (temp % 4)) + " "*($2.length - 1)*4}
+          end
+          indentation += content.scan(/^ */).first.length
+        end
+        content.sub!(/^\s*/, '')
+
+        indent_re = /^ {#{indentation}}/
+        content_re = /^(?:(?:\t| {4}){#{indentation / 4}} {#{indentation % 4}}|(?:\t| {4}){#{indentation / 4 + 1}}).*\S.*\n/
+        lazy_re = /(?!^ {0,#{[indentation, 3].min}}(?:#{IAL_BLOCK}|#{LAZY_END_HTML_STOP}|#{LAZY_END_HTML_START})).*\S.*\n/
+        [content, indentation, content_re, lazy_re, indent_re]
+      end
+
+
+      LIST_START_UL = /^(#{OPT_SPACE}[+*])([\t| ].*?\n)/
+      LIST_START_OL = /^(#{OPT_SPACE}\d+\.)([\t| ].*?\n)/
+      LIST_START = /#{LIST_START_UL}|#{LIST_START_OL}/
+
+      # Parse the ordered or unordered list at the current location.
+      def parse_list
+        type, list_start_re = (@src.check(LIST_START_UL) ? [:ul, LIST_START_UL] : [:ol, LIST_START_OL])
+        list = new_block_el(type)
+
+        item = nil
+        content_re, lazy_re, indent_re = nil
+        eob_found = false
+        nested_list_found = false
+        last_is_blank = false
+        while !@src.eos?
+          if last_is_blank && @src.check(HR_START)
+            break
+          elsif @src.scan(EOB_MARKER)
+            eob_found = true
+            break
+          elsif @src.scan(list_start_re)
+            item = Element.new(:li)
+            item.value, indentation, content_re, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
+            list.children << item
+
+            item.value.sub!(/^#{IAL_SPAN_START}\s*/) do |match|
+              parse_attribute_list($~[1], item.options[:ial] ||= {})
+              ''
+            end
+
+            list_start_re = (type == :ul ? /^( {0,#{[3, indentation - 1].min}}[+*-])([\t| ].*?\n)/ :
+                             /^( {0,#{[3, indentation - 1].min}}\d+\.)([\t| ].*?\n)/)
+            nested_list_found = (item.value =~ LIST_START)
+            last_is_blank = false
+          elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
+            result.sub!(/^(\t+)/) { " "*4*($1 ? $1.length : 0) }
+            result.sub!(indent_re, '')
+            if !nested_list_found && result =~ LIST_START
+              item.value << "^\n"
+              nested_list_found = true
+            end
+            item.value << result
+            last_is_blank = false
+          elsif result = @src.scan(BLANK_LINE)
+            nested_list_found = true
+            last_is_blank = true
+            item.value << result
+          else
+            break
+          end
+        end
+
+        @tree.children << list
+
+        last = nil
+        list.children.each do |it|
+          temp = Element.new(:temp)
+          parse_blocks(temp, it.value)
+          it.children = temp.children
+          it.value = nil
+          next if it.children.size == 0
+
+          # Handle the case where an EOB marker is inserted by a block IAL for the first paragraph
+          it.children.delete_at(1) if it.children.first.type == :p &&
+            it.children.length >= 2 && it.children[1].type == :eob && it.children.first.options[:ial]
+
+          if it.children.first.type == :p &&
+              (it.children.length < 2 || it.children[1].type != :blank ||
+               (it == list.children.last && it.children.length == 2 && !eob_found)) &&
+              (list.children.last != it || list.children.size == 1 ||
+               list.children[0..-2].any? {|cit| cit.children.first.type != :p || cit.children.first.options[:transparent]})
+            it.children.first.children.first.value += "\n" if it.children.size > 1 && it.children[1].type != :blank
+            it.children.first.options[:transparent] = true
+          end
+
+          if it.children.last.type == :blank
+            last = it.children.pop
+          else
+            last = nil
+          end
+        end
+
+        @tree.children << last if !last.nil? && !eob_found
+
+        true
+      end
+      define_parser(:list, LIST_START)
+
+
+      DEFINITION_LIST_START = /^(#{OPT_SPACE}:)([\t| ].*?\n)/
+
+      # Parse the ordered or unordered list at the current location.
+      def parse_definition_list
+        children = @tree.children
+        if !children.last || (children.length == 1 && children.last.type != :p ) ||
+            (children.length >= 2 && children[-1].type != :p && (children[-1].type != :blank || children[-1].value != "\n" || children[-2].type != :p))
+          return false
+        end
+
+        first_as_para = false
+        deflist = new_block_el(:dl)
+        para = @tree.children.pop
+        if para.type == :blank
+          para = @tree.children.pop
+          first_as_para = true
+        end
+        para.children.first.value.split("\n").each do |term|
+          el = Element.new(:dt)
+          el.children << Element.new(:raw_text, term)
+          deflist.children << el
+        end
+
+        item = nil
+        content_re, lazy_re, indent_re = nil
+        def_start_re = DEFINITION_LIST_START
+        last_is_blank = false
+        while !@src.eos?
+          if @src.scan(def_start_re)
+            item = Element.new(:dd)
+            item.options[:first_as_para] = first_as_para
+            item.value, indentation, content_re, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
+            deflist.children << item
+
+            item.value.sub!(/^#{IAL_SPAN_START}\s*/) do |match|
+              parse_attribute_list($~[1], item.options[:ial] ||= {})
+              ''
+            end
+
+            def_start_re = /^( {0,#{[3, indentation - 1].min}}:)([\t| ].*?\n)/
+            first_as_para = false
+            last_is_blank = false
+          elsif @src.check(EOB_MARKER)
+            break
+          elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
+            result.sub!(/^(\t+)/) { " "*4*($1 ? $1.length : 0) }
+            result.sub!(indent_re, '')
+            item.value << result
+            first_as_para = false
+            last_is_blank = false
+          elsif result = @src.scan(BLANK_LINE)
+            first_as_para = true
+            item.value << result
+            last_is_blank = true
+          else
+            break
+          end
+        end
+
+        last = nil
+        deflist.children.each do |it|
+          next if it.type == :dt
+
+          parse_blocks(it, it.value)
+          it.value = nil
+          next if it.children.size == 0
+
+          if it.children.last.type == :blank
+            last = it.children.pop
+          else
+            last = nil
+          end
+          if it.children.first.type == :p && !it.options.delete(:first_as_para)
+            it.children.first.children.first.value += "\n" if it.children.size > 1
+            it.children.first.options[:transparent] = true
+          end
+        end
+
+        if @tree.children.length >= 1 && @tree.children.last.type == :dl
+          @tree.children[-1].children += deflist.children
+        elsif @tree.children.length >= 2 && @tree.children[-1].type == :blank && @tree.children[-2].type == :dl
+          @tree.children.pop
+          @tree.children[-1].children += deflist.children
+        else
+          @tree.children << deflist
+        end
+
+        @tree.children << last if !last.nil?
+
+        true
+      end
+      define_parser(:definition_list, DEFINITION_LIST_START)
+
+    end
+  end
+end