patcito-maruku 0.6.0

data/lib/maruku/structures.rb

@@ -0,0 +1,143 @@
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
+#
+# This file is part of Maruku.
+#
+#   Maruku 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 2 of the License, or
+#   (at your option) any later version.
+#
+#   Maruku 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 Maruku; if not, write to the Free Software
+#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+module MaRuKu
+  # Rather than having a separate class for every possible element,
+  # Maruku has a single {MDElement} class
+  # that represents eveything in the document (paragraphs, headers, etc).
+  # The type of each element is available via \{#node\_type}.
+  class MDElement
+    # The type of this node (e.g. `:quote`, `:image`, `:abbr`).
+    # See {Helpers} for a list of possible values.
+    #
+    # @return [Symbol]
+    attr_accessor :node_type
+
+    # The child nodes of this element.
+    #
+    # @return [Array<String or MDElement>]
+    attr_accessor :children
+
+    # An attribute list. May not be nil.
+    #
+    # @return [AttributeList]
+    attr_accessor :al
+
+    # The processed attributes.
+    #
+    # For the {Maruku document root},
+    # this contains properties listed
+    # at the beginning of the document.
+    # The properties will be downcased and any spaces
+    # will be converted to underscores.
+    # For example, if you write in the source document:
+    #
+    #     !!!text
+    #     Title: test document
+    #     My property: value
+    #
+    #     content content
+    #
+    # Then \{#attributes} will return:
+    #
+    #     {:title => "test document", :my_property => "value"}
+    #
+    # @return [{Symbol => String}]
+    attr_accessor :attributes
+
+    # The root element of the document
+    # to which this element belongs.
+    #
+    # @return [Maruku]
+    attr_accessor :doc
+
+    def initialize(node_type = :unset, children = [], meta = {}, al = nil)
+      self.children = children
+      self.node_type = node_type
+      self.attributes = {}
+
+      meta.each do |symbol, value|
+        self.instance_eval <<RUBY
+          def #{symbol}; @#{symbol}; end
+          def #{symbol}=(val); @#{symbol} = val; end
+RUBY
+        self.send "#{symbol}=", value
+      end
+
+      self.al = al || AttributeList.new
+      self.meta_priv = meta
+    end
+
+    # @private
+    attr_accessor :meta_priv
+
+    def ==(o)
+      o.is_a?(MDElement) &&
+        self.node_type == o.node_type &&
+        self.meta_priv == o.meta_priv &&
+        self.children == o.children
+    end
+  end
+
+  # This represents the whole document and holds global data.
+  class MDDocument
+    # @return [{String => {:url => String, :title => String}}]
+    attr_accessor :refs
+
+    # @return [{String => MDElement}]
+    attr_accessor :footnotes
+
+    # @return [{String => String}]
+    attr_accessor :abbreviations
+
+    # Attribute definition lists.
+    #
+    # @return [{String => AttributeList}]
+    attr_accessor :ald
+
+    # The order in which footnotes are used. Contains the id.
+    #
+    # @return [Array<String>]
+    attr_accessor :footnotes_order
+
+    # @return [Array<String>]
+    attr_accessor :latex_required_packages
+
+    # @return [{String => {String => MDElement}}]
+    attr_accessor :refid2ref
+
+    # A counter for generating unique IDs [Integer]
+    attr_accessor :id_counter
+
+    def initialize(s=nil)
+      super(:document)
+
+      self.doc = self
+      self.refs = {}
+      self.footnotes = {}
+      self.footnotes_order = []
+      self.abbreviations = {}
+      self.ald = {}
+      self.latex_required_packages = []
+      self.id_counter = 0
+
+      parse_doc(s) if s
+    end
+  end
+end

data/lib/maruku/structures_inspect.rb

@@ -0,0 +1,51 @@
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
+#
+# This file is part of Maruku.
+#
+#   Maruku 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 2 of the License, or
+#   (at your option) any later version.
+#
+#   Maruku 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 Maruku; if not, write to the Free Software
+#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+module MaRuKu
+  class MDElement
+    def inspect(compact=true)
+      if compact
+        i2 = inspect2
+        return i2 if i2
+      end
+
+      # Make sure the attributes are lexically ordered
+      meta_ordered = "{" + @meta_priv.keys.
+        map {|x| x.to_s}.sort.map {|x| x.to_sym}.
+        map {|k| k.inspect + "=>" + @meta_priv[k].inspect}.
+        join(',') + "}"
+
+      "md_el(%s,%s,%s,%s)" % [
+        self.node_type.inspect,
+        children_inspect(compact),
+        meta_ordered,
+        self.al.inspect
+      ]
+    end
+
+    def children_inspect(compact=true)
+      kids = @children.map {|x| x.is_a?(MDElement) ? x.inspect(compact) : x.inspect}
+      comma = kids.join(", ")
+
+      return "[#{comma}]" if comma.size < 70
+      "[\n\t#{kids.join(",\n\t")}\n]"
+    end
+
+  end
+end

data/lib/maruku/structures_iterators.rb

@@ -0,0 +1,48 @@
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
+#
+# This file is part of Maruku.
+#
+#   Maruku 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 2 of the License, or
+#   (at your option) any later version.
+#
+#   Maruku 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 Maruku; if not, write to the Free Software
+#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+module MaRuKu
+  class MDElement
+    # Iterates through each {MDElement} child node of this element.
+    # This includes deeply-nested child nodes.
+    # If `e_node_type` is specified, only yields nodes of that type.
+    def each_element(e_node_type=nil, &block)
+      @children.each do |c|
+        next unless c.is_a? MDElement
+        yield c if e_node_type.nil? || c.node_type == e_node_type
+        c.each_element(e_node_type, &block)
+      end
+    end
+
+    # Iterates through each String child node of this element,
+    # replacing it with the result of the block.
+    # This includes deeply-nested child nodes.
+    #
+    # This destructively modifies this node and its children.
+    #
+    # @todo Make this non-destructive
+    def replace_each_string(&block)
+      @children.map! do |c|
+        next yield c unless c.is_a?(MDElement)
+        c.replace_each_string(&block)
+        c
+      end.flatten!
+    end
+  end
+end

data/lib/maruku/textile2.rb

@@ -0,0 +1 @@
+require 'maruku/input_textile2/t2_parser'

data/lib/maruku/toc.rb

@@ -0,0 +1,214 @@
+#   Copyright (C) 2006  Andrea Censi  <andrea (at) rubyforge.org>
+#
+# This file is part of Maruku.
+#
+#   Maruku 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 2 of the License, or
+#   (at your option) any later version.
+#
+#   Maruku 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 Maruku; if not, write to the Free Software
+#   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+module MaRuKu
+  # A section in the table of contents of a document.
+  class Section
+    # The depth of the section (0 for toplevel).
+    #
+    # Equivalent to `header_element.level`.
+    #
+    # @return [Fixnum]
+    attr_accessor :section_level
+
+    # The nested section number, e.g. `[1, 2, 5]` for Section 1.2.5.
+    #
+    # @return [Array<Fixnum>]
+    attr_accessor :section_number
+
+    # The `:header` node for this section.
+    # The value of `meta[:section]` for the header will be this node.
+    #
+    # @return [MDElement]
+    attr_accessor :header_element
+
+    # The immediate child nodes of this section.
+    #
+    # @todo Why does this never contain Strings?
+    #
+    # @return [Array<MDElement>]
+    attr_accessor :immediate_children
+
+    # The subsections of this section.
+    #
+    # @return [Array<Section>]
+    attr_accessor :section_children
+
+    def initialize
+      @immediate_children = []
+      @section_children = []
+    end
+
+    def inspect(indent = 1)
+      s = ""
+
+      if @header_element
+        s << "\_" * indent <<
+          "(#{@section_level})>\t #{@section_number.join('.')} : " <<
+          @header_element.children_to_s <<
+          " (id: '#{@header_element.attributes[:id]}')\n"
+      else
+        s << "Master\n"
+      end
+      @section_children.each {|c| s << c.inspect(indent+1)}
+
+      s
+    end
+
+    # Assign \{#section\_number section numbers}
+    # to this section and its children.
+    # This also assigns the section number attribute
+    # to the sections' headers.
+    #
+    # This should only be called on the root section.
+    #
+    # @overload def numerate
+    def numerate(a = [])
+      self.section_number = a
+      section_children.each_with_index {|c, i| c.numerate(a + [i + 1])}
+      if h = self.header_element
+        h.attributes[:section_number] = self.section_number
+      end
+    end
+
+    include REXML
+
+    # Returns an HTML representation of the table of contents.
+    #
+    # This should only be called on the root section.
+    def to_html
+      div = Element.new 'div'
+      div.attributes['class'] = 'maruku_toc'
+      div << _to_html
+      div
+    end
+
+    # Returns a LaTeX representation of the table of contents.
+    #
+    # This should only be called on the root section.
+    def to_latex
+      _to_latex + "\n\n"
+    end
+
+    protected
+
+    def _to_html
+      ul = Element.new 'ul'
+      # let's remove the bullets
+      ul.attributes['style'] = 'list-style: none;'
+      @section_children.each do |c|
+        li = Element.new 'li'
+        if span = c.header_element.render_section_number
+          li << span
+        end
+
+        a = c.header_element.wrap_as_element('a')
+        a.delete_attribute 'id'
+        a.attributes['href'] = "##{c.header_element.attributes[:id]}"
+
+        li << a
+        li << c._to_html if c.section_children.size > 0
+        ul << li
+      end
+      ul
+    end
+
+    def _to_latex
+      s = ""
+      @section_children.each do |c|
+        s << "\\noindent"
+        if number = c.header_element.section_number
+          s << number
+        end
+        id = c.header_element.attributes[:id]
+        text = c.header_element.children_to_latex
+        s << "\\hyperlink{#{id}}{#{text}}"
+        s << "\\dotfill \\pageref*{#{id}} \\linebreak\n"
+        s << c._to_latex if c.section_children.size > 0
+      end
+      s
+    end
+  end
+
+  class MDDocument
+    # The table of contents for the document.
+    #
+    # @return [Section]
+    attr_accessor :toc
+
+    def create_toc
+      each_element(:header) {|h| h.attributes[:id] ||= h.generate_id}
+
+      stack = []
+
+      # The root section
+      s = Section.new
+      s.section_level = 0
+
+      stack.push s
+
+      # TODO: Clean up the logic here once we have better tests
+      i = 0
+      while i < @children.size
+        while i < @children.size
+          if @children[i].node_type == :header
+            level = @children[i].level
+            break if level <= stack.last.section_level + 1
+          end
+
+          stack.last.immediate_children.push @children[i]
+          i += 1
+        end
+
+        break if i >= @children.size
+
+        header = @children[i]
+        level = header.level
+
+        if level > stack.last.section_level
+          # this level is inside
+
+          s2 = Section.new
+          s2.section_level = level
+          s2.header_element = header
+          header.instance_variable_set :@section, s2
+
+          stack.last.section_children.push s2
+          stack.push s2
+
+          i += 1
+        elsif level == stack.last.section_level
+          # this level is a sibling
+          stack.pop
+        else
+          # this level is a parent
+          stack.pop
+        end
+      end
+
+      # If there is only one big header, then assume it is the master
+      s = s.section_children.first if s.section_children.size == 1
+
+      # Assign section numbers
+      s.numerate
+
+      s
+    end
+  end
+end