newstile 1.0.1

data/lib/newstile/parser/newstile/extension.rb

@@ -0,0 +1,116 @@
+# -*- 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/attribute_list'
+
+module Newstile
+  module Parser
+    class Newstile
+
+      def parse_extension_start_tag(type)
+        orig_pos = @src.pos
+        @src.pos += @src.matched_size
+
+        error_block = lambda do |msg|
+          warning(msg)
+          @src.pos = orig_pos
+          add_text(@src.scan(/./)) if type == :span
+          false
+        end
+
+        if @src[4] || @src.matched == '{:/}'
+          name = (@src[4] ? "for '#{@src[4]}' " : '')
+          return error_block.call("Invalid extension stop tag #{name}found - ignoring it")
+        end
+
+        ext = @src[1]
+        opts = {}
+        body = nil
+        parse_attribute_list(@src[2] || '', opts)
+
+        if !@src[3]
+          stop_re = (type == :block ? /#{EXT_BLOCK_STOP_STR % ext}/ : /#{EXT_STOP_STR % ext}/)
+          if result = @src.scan_until(stop_re)
+            body = result.sub!(stop_re, '')
+            body.chomp! if type == :block
+          else
+            return error_block.call("No stop tag for extension '#{ext}' found - ignoring it")
+          end
+        end
+
+        if !handle_extension(ext, opts, body, type)
+          error_block.call("Invalid extension with name '#{ext}' specified - ignoring it")
+        else
+          true
+        end
+      end
+
+      def handle_extension(name, opts, body, type)
+        case name
+        when 'comment'
+          @tree.children << Element.new(:comment, body, nil, :category => type) if body.kind_of?(String)
+          true
+        when 'nomarkdown'
+          @tree.children << Element.new(:raw, body, nil, :category => type, :type => opts['type'].to_s.split(/\s+/)) if body.kind_of?(String)
+          true
+        when 'options'
+          opts.select do |k,v|
+            k = k.to_sym
+            if Newstile::Options.defined?(k)
+              @doc.options[k] = Newstile::Options.parse(k, v) rescue @doc.options[k]
+              false
+            else
+              true
+            end
+          end.each do |k,v|
+            warning("Unknown newstile option '#{k}'")
+          end
+          @tree.children << Element.new(:eob, :extension) if type == :block
+          true
+        else
+          false
+        end
+      end
+
+
+      EXT_STOP_STR = "\\{:/(%s)?\\}"
+      EXT_START_STR = "\\{::(\\w+)(?:\\s(#{ALD_ANY_CHARS}*?)|)(\\/)?\\}"
+      EXT_SPAN_START = /#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME}/
+      EXT_BLOCK_START = /^#{OPT_SPACE}(?:#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME})\s*?\n/
+      EXT_BLOCK_STOP_STR = "^#{OPT_SPACE}#{EXT_STOP_STR}\s*?\n"
+
+      # Parse the extension block at the current location.
+      def parse_block_extension
+        parse_extension_start_tag(:block)
+      end
+      define_parser(:block_extension, EXT_BLOCK_START)
+
+
+      # Parse the extension span at the current location.
+      def parse_span_extension
+        parse_extension_start_tag(:span)
+      end
+      define_parser(:span_extension, EXT_SPAN_START, '\{:[:/]')
+
+    end
+  end
+end

data/lib/newstile/parser/newstile/footnote.rb

@@ -0,0 +1,74 @@
+# -*- 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/attribute_list'
+require 'newstile/parser/newstile/blank_line'
+require 'newstile/parser/newstile/codeblock'
+
+module Newstile
+  module Parser
+    class Newstile
+
+      FOOTNOTE_DEFINITION_START = /^#{OPT_SPACE}\[\^(#{ALD_ID_NAME})\]:\s*?(.*?\n#{CODEBLOCK_MATCH})/
+
+      # Parse the foot note definition at the current location.
+      def parse_footnote_definition
+        @src.pos += @src.matched_size
+
+        el = Element.new(:footnote_def)
+        parse_blocks(el, @src[2].gsub(INDENT, ''))
+        warning("Duplicate footnote name '#{@src[1]}' - overwriting") if @doc.parse_infos[:footnotes][@src[1]]
+        (@doc.parse_infos[:footnotes][@src[1]] = {})[:content] = el
+        @tree.children << Element.new(:eob, :footnote_def)
+        true
+      end
+      define_parser(:footnote_definition, FOOTNOTE_DEFINITION_START)
+
+
+      FOOTNOTE_MARKER_START = /\[\^(#{ALD_ID_NAME})\]/
+
+      # Parse the footnote marker at the current location.
+      def parse_footnote_marker
+        @src.pos += @src.matched_size
+        fn_def = @doc.parse_infos[:footnotes][@src[1]]
+        if fn_def
+          valid = fn_def[:marker] && fn_def[:marker].options[:stack][0..-2].zip(fn_def[:marker].options[:stack][1..-1]).all? do |par, child|
+            par.children.include?(child)
+          end
+          if !fn_def[:marker] || !valid
+            fn_def[:marker] = Element.new(:footnote, nil, nil, :name => @src[1])
+            fn_def[:marker].options[:stack] = [@stack.map {|s| s.first}, @tree, fn_def[:marker]].flatten.compact
+            @tree.children << fn_def[:marker]
+          else
+            warning("Footnote marker '#{@src[1]}' already appeared in document, ignoring newly found marker")
+            add_text(@src.matched)
+          end
+        else
+          warning("Footnote definition for '#{@src[1]}' not found")
+          add_text(@src.matched)
+        end
+      end
+      define_parser(:footnote_marker, FOOTNOTE_MARKER_START, '\[')
+
+    end
+  end
+end

data/lib/newstile/parser/newstile/header.rb

@@ -0,0 +1,84 @@
+# -*- 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/block_boundary'
+
+module Newstile
+  module Parser
+    class Newstile
+
+      HEADER_ID=/(?:[ \t]\{#(\w[\w-]*)\})?/
+      SETEXT_HEADER_START = /^(#{OPT_SPACE}[^ \t].*?)#{HEADER_ID}[ \t]*?\n(-|=)+\s*?\n/
+
+      # Parse the Setext header at the current location.
+      def parse_setext_header
+        return false if !after_block_boundary?
+
+        @src.pos += @src.matched_size
+        text, id, level = @src[1].strip, @src[2], @src[3]
+        el = new_block_el(:header, nil, nil, :level => (level == '-' ? 2 : 1), :raw_text => text)
+        add_text(text, el)
+        el.attr['id'] = id if id
+        @tree.children << el
+        true
+      end
+      define_parser(:setext_header, SETEXT_HEADER_START)
+
+
+      ATX_HEADER_START = /^\#{1,6}/
+      ATX_HEADER_MATCH = /^(\#{1,6})(.+?)\s*?#*#{HEADER_ID}\s*?\n/
+
+      # Parse the Atx header at the current location.
+      def parse_atx_header
+        return false if !after_block_boundary?
+
+        result = @src.scan(ATX_HEADER_MATCH)
+        level, text, id = @src[1], @src[2].strip, @src[3]
+        el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text)
+        add_text(text, el)
+        el.attr['id'] = id if id
+        @tree.children << el
+        true
+      end
+      define_parser(:atx_header, ATX_HEADER_START)
+
+
+      NEWSTILE_HEADER_START = /^!{1,6} /
+      NEWSTILE_HEADER_MATCH = /^(!{1,6}) +(.+?)\s*?\!*#{HEADER_ID}\s*?\n/
+
+      # Parse the newstile header at the current location.
+      def parse_newstile_header
+        return false if !after_block_boundary?
+
+        result = @src.scan(NEWSTILE_HEADER_MATCH)
+        level, text, id = @src[1], @src[2], @src[3]
+        el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text)
+        add_text(text, el)
+        el.attr['id'] = id if id
+        @tree.children << el
+        true
+      end
+      define_parser(:newstile_header, NEWSTILE_HEADER_START)
+
+    end
+  end
+end

data/lib/newstile/parser/newstile/horizontal_rule.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/>.
+#++
+#
+
+module Newstile
+  module Parser
+    class Newstile
+
+      HR_START = /^#{OPT_SPACE}(\*|-|_)[ \t]*\1[ \t]*\1[ \t]*(\1|[ \t])*\n/
+
+      # Parse the horizontal rule at the current location.
+      def parse_horizontal_rule
+        @src.pos += @src.matched_size
+        @tree.children << new_block_el(:hr)
+        true
+      end
+      define_parser(:horizontal_rule, HR_START)
+
+    end
+  end
+end

data/lib/newstile/parser/newstile/html.rb

@@ -0,0 +1,175 @@
+# -*- 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
+
+      include Newstile::Parser::Html::Parser
+
+      def handle_newstile_html_tag(el, closed)
+        parse_type = if @tree.type != :html_element || @tree.options[:parse_type] != :raw
+                       (@doc.options[:parse_block_html] ? HTML_PARSE_AS[el.value] : :raw)
+                     else
+                       :raw
+                     end
+        if val = html_parse_type(el.attr.delete('markdown'))
+          parse_type = (val == :default ? HTML_PARSE_AS[el.value] : val)
+        end
+
+        @src.scan(/[ \t]*\n/) if parse_type == :block
+        el.options[:parse_type] = parse_type
+
+        if !closed
+          if parse_type == :block
+            end_tag_found = parse_blocks(el)
+            if !end_tag_found
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+            end
+          elsif parse_type == :span
+            curpos = @src.pos
+            if result = @src.scan_until(/(?=<\/#{el.value}\s*>)/m)
+              add_text(extract_string(curpos...@src.pos, @src), el)
+              @src.scan(HTML_TAG_CLOSE_RE)
+            else
+              add_text(@src.scan(/.*/m), el)
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+            end
+          else
+            parse_raw_html(el, &method(:handle_newstile_html_tag))
+          end
+          @src.scan(/[ \t]*\n/) unless (@tree.type == :html_element && @tree.options[:parse_type] == :raw)
+        end
+      end
+
+      # Return the HTML parse type defined by the string +val+, i.e. raw when "0", default parsing
+      # (return value +nil+) when "1", span parsing when "span" and block parsing when "block". If
+      # +val+ is nil, then the default parsing mode is used.
+      def html_parse_type(val)
+        case val
+        when "0" then :raw
+        when "1" then :default
+        when "span" then :span
+        when "block" then :block
+        when NilClass then nil
+        else
+          warning("Invalid markdown attribute val '#{val}', using default")
+          nil
+        end
+      end
+
+
+      HTML_BLOCK_START = /^#{OPT_SPACE}<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
+
+      # Parse the HTML at the current position as block level HTML.
+      def parse_block_html
+        if result = @src.scan(HTML_COMMENT_RE)
+          @tree.children << Element.new(:xml_comment, result, nil, :category => :block)
+          @src.scan(/[ \t]*\n/)
+          true
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
+          @src.scan(/[ \t]*\n/)
+          true
+        else
+          if result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
+            @src.pos += @src.matched_size
+            handle_html_start_tag(&method(:handle_newstile_html_tag))
+            Newstile::Parser::Html::ElementConverter.new(@doc).process(@tree.children.last) if @doc.options[:html_to_native]
+            true
+          elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
+            name = @src[1]
+
+            if @tree.type == :html_element && @tree.value == name
+              @src.pos += @src.matched_size
+              throw :stop_block_parsing, :found
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+      end
+      define_parser(:block_html, HTML_BLOCK_START)
+
+
+      HTML_SPAN_START = /<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
+
+      # Parse the HTML at the current position as span level HTML.
+      def parse_span_html
+        if result = @src.scan(HTML_COMMENT_RE)
+          @tree.children << Element.new(:xml_comment, result, nil, :category => :span)
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, nil, :category => :span)
+        elsif result = @src.scan(HTML_TAG_CLOSE_RE)
+          warning("Found invalidly used HTML closing tag for '#{@src[1]}'")
+          add_text(result)
+        elsif result = @src.scan(HTML_TAG_RE)
+          if HTML_BLOCK_ELEMENTS.include?(@src[1])
+            warning("Found block HTML tag '#{@src[1]}' in span level text")
+            add_text(result)
+            return
+          end
+
+          reset_pos = @src.pos
+          attrs = Utils::OrderedHash.new
+          @src[2].scan(HTML_ATTRIBUTE_RE).each {|name,sep,val| attrs[name] = val.gsub(/\n+/, ' ')}
+
+          do_parsing = (HTML_PARSE_AS_RAW.include?(@src[1]) || @tree.options[:parse_type] == :raw ? false : @doc.options[:parse_span_html])
+          if val = html_parse_type(attrs.delete('markdown'))
+            if val == :block
+              warning("Cannot use block level parsing in span level HTML tag - using default mode")
+            elsif val == :span
+              do_parsing = true
+            elsif val == :default
+              do_parsing = !HTML_PARSE_AS_RAW.include?(@src[1])
+            elsif val == :raw
+              do_parsing = false
+            end
+          end
+
+          el = Element.new(:html_element, @src[1], attrs, :category => :span, :parse_type => (do_parsing ? :span : :raw))
+          @tree.children << el
+          stop_re = /<\/#{Regexp.escape(@src[1])}\s*>/
+          if !@src[4] && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
+            warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
+          elsif !@src[4]
+            if parse_spans(el, stop_re, (do_parsing ? nil : [:span_html]))
+              @src.scan(stop_re)
+            else
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+              add_text(@src.scan(/.*/m), el)
+            end
+          end
+          Newstile::Parser::Html::ElementConverter.new(@doc).process(el) if @doc.options[:html_to_native]
+        else
+          add_text(@src.scan(/./))
+        end
+      end
+      define_parser(:span_html, HTML_SPAN_START, '<')
+
+    end
+  end
+end