rdtool 0.6.23

data/test/test-textblock.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+
+require 'rd/block-element'
+require 'rd/inline-element'
+require 'rd/rd-struct'
+
+include RD
+
+class TestTextBlock < Test::Unit::TestCase
+  def setup
+    @p = TextBlock.new
+    @c1 = StringElement.new "string"
+    @c2 = Emphasis.new
+    @c21 = StringElement.new "in emphasis"
+    @c2.add_child_under_document_struct(@c21, DocumentStructure::RD)
+    @c3 = Code.new
+    @c31 = StringElement.new "code"
+    @c32 = Var.new
+    @c321 = StringElement.new "var"
+    @c32.add_child_under_document_struct(@c321, DocumentStructure::RD)
+    @c3.add_children_under_document_struct([@c31, @c32], DocumentStructure::RD)
+    @c4 = Verb.new "verb"
+    @p.add_children_under_document_struct([@c1, @c2, @c3, @c4],
+                                          DocumentStructure::RD)
+  end
+
+  def test_each_child
+    exp = [@c1, @c2, @c3, @c4]
+    i = 0
+    @p.each_child do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+  end
+
+  def test_each_element
+    exp = [@p, @c1, @c2, @c21, @c3, @c31, @c32, @c321, @c4]
+    i = 0
+    @p.each_element do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+  end
+end

data/test/test-tree.rb

@@ -0,0 +1,82 @@
+require 'test/unit'
+
+require 'rd/tree'
+require 'rd/element'
+require 'rd/rd-struct'
+require 'rd/loose-struct'
+
+include RD
+
+class TestTree < Test::Unit::TestCase
+  def test_new_with_document_struct
+    tr = Tree.new_with_document_struct(DocumentStructure::RD, ["test/data"])
+    assert_equal(nil, tr.root)
+    assert_equal(["test/data"], tr.include_paths)
+  end
+
+  def test_set_root
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    de = DocumentElement.new
+    tr.set_root(de)
+    assert_equal(de, tr.root)
+    assert_equal(tr, de.tree)    
+  end
+
+  def test_each_element
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    de = DocumentElement.new
+    tr.root = de
+    exp = [de]
+    i = 0
+    tr.each_element do |b|
+      assert_equal(exp[i], b)
+    end
+    
+    tr_emp = Tree.new_with_document_struct(DocumentStructure::RD)
+    assert_equal(nil, tr_emp.each_element)
+  end
+
+  def test_make_root
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    res = tr.make_root
+    assert(tr.root)
+    assert_equal(tr.root, res)
+    
+    tr2 = Tree.new_with_document_struct(DocumentStructure::RD)
+    res2 = tr2.make_root do
+      new TextBlock
+    end
+    assert(tr2.root)
+    assert_equal("<RD::DocumentElement>\n  <RD::TextBlock>", tr2.root.inspect)
+    assert_equal(tr2.root, res2)
+  end
+
+  def test_check_valid
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    de = DocumentElement.new
+    tr.root = de
+    de.build do
+      new Headline, 1 do
+        new StringElement, "label"
+      end
+      new TextBlock do
+        new Emphasis do
+          new StringElement, "emphasis"
+        end
+      end
+    end
+    assert_equal(true, tr.check_valid)
+
+    tr_fail = Tree.new_with_document_struct(DocumentStructure::RD)
+    de_fail = DocumentElement.new
+    tr_fail.root = de_fail
+    tb_fail = TextBlock.new
+    tb_fail.build(DocumentStructure::LOOSE) do
+      new Headline, 1
+    end
+    de_fail.add_child(tb_fail)
+    assert_raises(RuntimeError) do
+      tr_fail.check_valid
+    end
+  end
+end

data/test/test-version.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+
+require 'rd/version'
+
+include RD
+
+class TestVersion < Test::Unit::TestCase
+  def test_s_new_from_version_string
+    ver011 = Version.new_from_version_string("name", "$Version: 0.1.1$") # "
+    assert_equal("name", ver011.name)
+    assert_equal(0, ver011.major)
+    assert_equal(1, ver011.minor)
+    assert_equal(1, ver011.patch_level)
+
+    ver0101 = Version.new_from_version_string("name", "$Version: 0.10.1$") #"
+    assert_equal(0, ver0101.major)
+    assert_equal(10, ver0101.minor)
+    assert_equal(1, ver0101.patch_level)
+
+    ver01 = Version.new_from_version_string("name", "$Version: 0.1$") # "
+    assert_equal(0, ver01.major)
+    assert_equal(1, ver01.minor)
+    assert_equal(nil, ver01.patch_level)
+
+    ver0 = Version.new_from_version_string("name", "$Version: 0$") # "
+    assert_equal(0, ver0.major)
+    assert_equal(nil, ver0.minor)
+    assert_equal(nil, ver0.patch_level)
+    
+    ver011_2 = Version.new_from_version_string("name", "0.1.1") # "
+    assert_equal("name", ver011_2.name)
+    assert_equal(0, ver011_2.major)
+    assert_equal(1, ver011_2.minor)
+    assert_equal(1, ver011_2.patch_level)
+  end
+
+  def test_s_clean_up_version_string
+    assert_equal("0.1.1",
+                 Version.clean_up_version_string("$Version: 0.1.1$")) #"
+    assert_equal("0.1.1",
+                 Version.clean_up_version_string("0.1.1"))
+    assert_equal("", Version.clean_up_version_string("$Version$")) # "
+  end
+
+  def test_to_s
+    ver011 = Version.new("name", 0, 1, 1)
+    assert_equal("name 0.1.1", ver011.to_s)
+    ver0101 = Version.new("name", 0, 10, 1)
+    assert_equal("name 0.10.1", ver0101.to_s)
+
+    ver01 = Version.new("name", 0, 1, nil)
+    assert_equal("name 0.1", ver01.to_s)
+
+    ver0 = Version.new("name", 0, nil, nil)
+    assert_equal("name 0", ver0.to_s)
+  end
+end

data/test/test-visitor.rb

@@ -0,0 +1,230 @@
+require 'test/unit'
+
+require 'rd/visitor'
+require 'rd/block-element'
+require 'rd/list'
+require 'rd/desclist'
+require 'rd/methodlist'
+require 'rd/inline-element'
+require 'rd/tree'
+require 'rd/rd-struct'
+require 'dummy'
+
+include RD
+
+DummyStruct.define_relationship(NonterminalElement, DummyElement)
+
+class TestVisitor < Test::Unit::TestCase
+  def setup
+    @vis = DummyVisitor.new
+  end
+  
+  def test_visit_children
+    el = TextBlock.new
+    add_2_children(el)
+    assert_equal(["dummy", "dummy"], @vis.visit_children(el))
+
+    empty = TextBlock.new
+    assert_equal([], @vis.visit_children(empty))
+  end
+
+  def test_visit_DocumentElement
+    el = DocumentElement.new
+    add_2_children(el)
+    assert_equal(["apply_to_DocumentElement", [el, ["dummy", "dummy"]]],
+                 @vis.visit_DocumentElement(el))
+  end
+
+  def test_visit_Headline
+    el = Headline.new(1)
+    add_2_children(el)
+    assert_equal(["apply_to_Headline", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Headline(el))
+  end
+
+  def test_visit_Include
+    el = Include.new "include"
+    assert_equal(["apply_to_Include", [el]],
+                 @vis.visit_Include(el))
+  end
+
+  def test_visit_TextBlock
+    el = TextBlock.new
+    add_2_children(el)
+    assert_equal(["apply_to_TextBlock", [el, ["dummy", "dummy"]]],
+                 @vis.visit_TextBlock(el))
+  end
+
+  def test_visit_Verbatim
+    el = Verbatim.new "Verbatim"
+    assert_equal(["apply_to_Verbatim", [el]],
+                 @vis.visit_Verbatim(el))
+  end
+
+  def test_visit_ItemList
+    el = ItemList.new
+    add_2_children(el)
+    assert_equal(["apply_to_ItemList", [el, ["dummy", "dummy"]]],
+                 @vis.visit_ItemList(el))
+  end
+
+  def test_visit_EnumList
+    el = EnumList.new
+    add_2_children(el)
+    assert_equal(["apply_to_EnumList", [el, ["dummy", "dummy"]]],
+                 @vis.visit_EnumList(el))
+  end
+
+  def test_visit_DescList
+    el = DescList.new
+    add_2_children(el)
+    assert_equal(["apply_to_DescList", [el, ["dummy", "dummy"]]],
+                 @vis.visit_DescList(el))
+  end
+
+  def test_visit_MethodList
+    el = MethodList.new
+    add_2_children(el)
+    assert_equal(["apply_to_MethodList", [el, ["dummy", "dummy"]]],
+                 @vis.visit_MethodList(el))
+  end
+
+  def test_visit_ItemListItem
+    el = ItemListItem.new
+    add_2_children(el)
+    assert_equal(["apply_to_ItemListItem", [el, ["dummy", "dummy"]]],
+                 @vis.visit_ItemListItem(el))
+  end
+
+  def test_visit_EnumListItem
+    el = EnumListItem.new
+    add_2_children(el)
+    assert_equal(["apply_to_EnumListItem", [el, ["dummy", "dummy"]]],
+                 @vis.visit_EnumListItem(el))
+  end
+
+  def test_visit_DescListItem
+    el = DescListItem.new
+    el.set_term_under_document_struct(DummyElement.new, DummyStruct)
+    add_2_children(el)
+    assert_equal(["apply_to_DescListItem", [el, "dummy", ["dummy", "dummy"]]],
+                 @vis.visit_DescListItem(el))
+
+    empty = DescListItem.new
+    empty.set_term_under_document_struct(DummyElement.new, DummyStruct)
+    assert_equal(["apply_to_DescListItem", [empty, "dummy", []]],
+                 @vis.visit_DescListItem(empty))
+  end
+
+  def test_visit_DescListItemTerm
+    el = DescListItem::Term.new
+    add_2_children(el)
+    assert_equal(["apply_to_DescListItemTerm", [el, ["dummy", "dummy"]]],
+                 @vis.visit_DescListItemTerm(el))
+  end
+
+  def test_visit_MethodListItem
+    el = MethodListItem.new
+    el.set_term_under_document_struct(DummyElement.new, DummyStruct)
+    add_2_children(el)
+    assert_equal(["apply_to_MethodListItem", [el, "dummy", ["dummy", "dummy"]]],
+                 @vis.visit_MethodListItem(el))
+
+    empty = MethodListItem.new
+    empty.set_term_under_document_struct(DummyElement.new, DummyStruct)
+    assert_equal(["apply_to_MethodListItem", [empty, "dummy", []]],
+                 @vis.visit_MethodListItem(empty))
+  end
+
+  def test_visit_MethodListItemTerm
+    el = MethodListItem::Term.new
+    assert_equal(["apply_to_MethodListItemTerm", [el]],
+                 @vis.visit_MethodListItemTerm(el))
+  end
+
+  def test_visit_StringElement
+    el = StringElement.new "string"
+    assert_equal(["apply_to_StringElement", [el]], @vis.visit_StringElement(el))
+  end
+
+  def test_visit_Verb
+    el = Verb.new "string"
+    assert_equal(["apply_to_Verb", [el]], @vis.visit_Verb(el))
+  end
+
+  def test_visit_Emphasis
+    el = Emphasis.new
+    add_2_children(el)
+    assert_equal(["apply_to_Emphasis", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Emphasis(el))
+  end
+
+  def test_visit_Code
+    el = Code.new
+    add_2_children(el)
+    assert_equal(["apply_to_Code", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Code(el))
+  end
+
+  def test_visit_Var
+    el = Var.new
+    add_2_children(el)
+    assert_equal(["apply_to_Var", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Var(el))
+  end
+
+  def test_visit_Keyboard
+    el = Keyboard.new
+    add_2_children(el)
+    assert_equal(["apply_to_Keyboard", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Keyboard(el))
+  end
+
+  def test_visit_Index
+    el = Index.new
+    add_2_children(el)
+    assert_equal(["apply_to_Index", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Index(el))
+  end
+
+  def test_visit_Footnote
+    el = Footnote.new
+    add_2_children(el)
+    assert_equal(["apply_to_Footnote", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Footnote(el))
+  end
+
+  def test_visit_Reference
+    el = Reference.new(Reference::RDLabel.new("label"))
+    add_2_children(el)
+    assert_equal(["apply_to_Reference_with_RDLabel", [el, ["dummy", "dummy"]]],
+                 @vis.visit_Reference(el))
+
+    empty = Reference.new(Reference::RDLabel.new("label"))
+    assert_equal(["apply_to_Reference_with_RDLabel", [empty, []]],
+                 @vis.visit_Reference(empty))
+
+    url_reference = Reference.new(Reference::URL.new("url"))
+    add_2_children(url_reference)
+    assert_equal(["apply_to_Reference_with_URL",
+                   [url_reference, ["dummy", "dummy"]]],
+                 @vis.visit_Reference(url_reference))
+
+    # OldStyleDummyVisitor#apply_to_Reference_with_RDLabel is not implemented.
+    # So, #apply_to_reference is called instead of it.
+    old_visitor = OldStyleDummyVisitor.new
+    assert_equal(["apply_to_Reference", [el, ["dummy", "dummy"]]],
+                 old_visitor.visit_Reference(el))
+  end
+
+  def add_2_children(el)
+    el.add_children_under_document_struct([DummyElement.new, DummyElement.new],
+                                          DummyStruct)
+  end
+end
+
+class OldStyleDummyVisitor < Visitor
+  def apply_to_Reference(*args)
+    ["apply_to_Reference", args]
+  end
+end

data/utils/rd-mode.el

@@ -0,0 +1,425 @@
+;;;
+;;; rd-mode.el
+;;; Major mode for RD editing
+;;; 
+;;; NOTE: experimental.
+
+;; Copyright (C) 1999 Koji Arai, Toshiro Kuwabara.
+
+;; Author: Koji Arai, Toshiro Kuwabara
+;; Created: Sat Nov 27 00:08:12 1999
+
+;; This file is not part of GNU Emacs, but the same permissions apply.
+
+;; GNU Emacs 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, or (at your option)
+;; any later version.
+
+;; GNU Emacs 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;; Settings:
+;;
+;; add below lines in your ~/.emacs
+;;
+;; (global-font-lock-mode 1 t)
+;; (autoload 'rd-mode "rd-mode" "major mode for ruby document formatter RD" t)
+;; (add-to-list 'auto-mode-alist '("\\.rd$" . rd-mode))
+
+(require 'derived)
+
+(defvar rd-use-prompt-when-insertion-p nil
+  "Whether to use prompt when inserting inline.")
+
+(defvar rd-selective-display-ellipses t
+  "*Displays ellipses in RD-mode if non-nil")
+
+(defvar rd-mode-hook nil
+  "Hooks run when entering `rd-mode' major mode")
+
+(define-derived-mode rd-mode text-mode "RD"
+  "Major mode for RD editing.
+\\{rd-mode-map}"
+  (make-local-variable 'paragraph-separate)
+  (setq paragraph-separate "=+\\|\\++\\|[ \t\n\^L]*$")
+  (make-local-variable 'paragraph-start)
+  (setq paragraph-start "=+\\|\\++\\|[ \t\n\^L]")
+  (make-local-variable 'require-final-newline)  
+  (setq require-final-newline t)
+  (make-local-variable 'font-lock-defaults)
+  (setq font-lock-defaults '((rd-font-lock-keywords) t nil))
+  (make-local-variable 'font-lock-keywords)
+  (setq font-lock-keywords rd-font-lock-keywords)
+  (make-local-variable 'outline-regexp)
+  (setq outline-regexp "^\\(=+\\)")
+  (outline-minor-mode t)
+  (add-hook (make-local-variable 'write-contents-hooks) 'rd-strip-cr-on-top)
+  (add-hook (make-local-variable 'after-save-hook) 'rd-rehide-endline)
+  (rd-hide-other-block-all)
+  (rd-setup-keys)
+  (setq indent-tabs-mode nil)
+  (run-hooks 'rd-mode-hook)
+)
+
+(defvar rd-heading1-face 'font-lock-keyword-face)
+(defvar rd-heading2-face 'font-lock-type-face)
+(defvar rd-heading3-face 'font-lock-variable-name-face)
+(defvar rd-heading4-face 'font-lock-comment-face)
+(defvar rd-emphasis-face 'font-lock-function-name-face)
+(defvar rd-keyboard-face 'font-lock-function-name-face)
+(defvar rd-variable-face 'font-lock-function-name-face)
+(defvar rd-verbatim-face 'font-lock-function-name-face)
+(defvar rd-term-face 'font-lock-function-name-face)
+(defvar rd-footnote-face 'font-lock-function-name-face)
+(defvar rd-link-face 'font-lock-function-name-face)
+(defvar rd-code-face 'font-lock-function-name-face)
+(defvar rd-description-face 'font-lock-constant-face)
+
+(defvar rd-font-lock-keywords
+  (list
+   '("^= .*$"
+     0 rd-heading1-face)
+   '("^== .*$"
+     0 rd-heading2-face)
+   '("^=== .*$"
+     0 rd-heading3-face)
+   '("^=====* .*$"
+     0 rd-heading4-face)
+   '("((\\*[^*]*\\*+\\([^)*][^%]*\\*+\\)*))"    ; ((* ... *))
+     0 rd-emphasis-face)
+   '("((%[^%]*%+\\([^)%][^%]*%+\\)*))"      ; ((% ... %))
+     0 rd-keyboard-face)
+   '("((|[^|]*|+\\([^)|][^|]*|+\\)*))"      ; ((| ... |))
+     0 rd-variable-face)
+   '("(('[^']*'+\\([^)'][^']*'+\\)*))"      ; ((' ... '))
+     0 rd-verbatim-face)
+   '("((:[^:]*:+\\([^):][^:]*:+\\)*))"      ; ((: ... :))
+     0 rd-term-face)
+   '("((-[^-]*-+\\([^)-][^-]*-+\\)*))"      ; ((- ... -))
+     0 rd-footnote-face)
+   '("((<[^>]*>+\\([^)>][^>]*>+\\)*))"      ; ((< ... >))
+     0 rd-link-face)
+   '("(({[^}]*}+\\([^)}][^}]*}+\\)*))"      ; (({ ... }))
+     0 rd-code-face)
+   '("^:.*$"
+     0 rd-description-face)
+   ))
+
+(defun rd-setup-keys ()
+  (interactive)
+  (define-key rd-mode-map "\t" 'rd-indent-line)
+  (define-key rd-mode-map "\C-j" 'rd-newline-and-indent)
+  (define-key rd-mode-map "\C-c\C-v" 'rd-cite-region)
+  (define-key rd-mode-map "\C-c\C-ie" 'rd-insert-emphasis)
+  (define-key rd-mode-map "\C-c\C-ic" 'rd-insert-code)
+  (define-key rd-mode-map "\C-c\C-iv" 'rd-insert-var)
+  (define-key rd-mode-map "\C-c\C-ik" 'rd-insert-keyboard)
+  (define-key rd-mode-map "\C-c\C-ii" 'rd-insert-index)
+  (define-key rd-mode-map "\C-c\C-ir" 'rd-insert-ref)
+  (define-key rd-mode-map "\C-c\C-iu" 'rd-insert-reftourl)
+  (define-key rd-mode-map "\C-c\C-if" 'rd-insert-footnote)
+  (define-key rd-mode-map "\C-c\C-ib" 'rd-insert-verb)
+  (define-key rd-mode-map "\C-c\C-y" 'rd-yank-as-url)
+  (define-key rd-mode-map "\C-c\M-y" 'rd-yank-pop-as-url)
+  (define-key rd-mode-map "\C-c\C-u" 'rd-insert-url)
+  (define-key rd-mode-map "\M-\C-m" 'rd-intelligent-newline))
+
+(defun rd-strip-cr-on-top ()
+  (save-excursion
+    (widen)
+    (goto-char (point-min))
+    (let ((mod (buffer-modified-p)))
+      (while (re-search-forward "^\r=end\\>" nil t)
+	(beginning-of-line)
+	(delete-char 1)
+	(forward-line))
+      (set-buffer-modified-p mod)))
+  nil)
+
+(defun rd-rehide-endline ()
+  (save-excursion
+    (widen)
+    (goto-char (point-min))
+    (let ((mod (buffer-modified-p)))
+      (while (re-search-forward "^=end\\>.*\r" nil t)
+	(beginning-of-line)
+	(insert "\r")
+	(forward-line))
+      (set-buffer-modified-p mod))))
+
+(defun rd-hide-other-block ()
+  "Hides following lines not in RD format."
+  (interactive)
+  (let (end (mod (buffer-modified-p)))
+    (save-excursion
+      (widen)
+      (and (setq end (re-search-forward "^=begin\\>" nil t))
+	   (re-search-backward "^=end\\>" nil t))
+	(insert "\r")
+	(while (search-forward "\n" end t)
+	  (replace-match "\r" t t)))
+    (set-buffer-modified-p mod))
+  (setq selective-display t
+	selective-display-ellipses rd-selective-display-ellipses))
+
+(defun rd-hide-other-block-all ()
+  "Hides all lines not in RD format."
+  (interactive)
+  (let (beg end (mod (buffer-modified-p)))
+    (save-excursion
+      (widen)
+      (goto-char (point-min))
+      (while (and (re-search-forward "^=end\\>" nil t)
+		  (setq beg (progn (beginning-of-line) (point)))
+		  (setq end (re-search-forward "^=begin\\>" nil t)))
+	(goto-char beg)
+	(insert "\r")
+	(while (search-forward "\n" end t)
+	  (replace-match "\r" t t))))
+    (set-buffer-modified-p mod))
+  (setq selective-display t
+	selective-display-ellipses rd-selective-display-ellipses))
+ 
+(defun rd-show-other-block ()
+  "Shows lines not in RD format before current point."
+  (interactive)
+  (if selective-display
+      (save-excursion
+	(let (end (mod (buffer-modified-p)))
+	  (widen)
+	  (if (re-search-forward "^\r=end\\>" nil t)
+	      (progn
+		(end-of-line)
+		(setq end (point))
+		(beginning-of-line)
+		(delete-char 1)
+		(while (search-forward "\r" end t)
+		  (replace-match "\n" t t))))
+	  (set-buffer-modified-p mod)))))
+
+(defun rd-show-other-block-all ()
+  "Shows all lines not in RD format."
+  (interactive)
+  (if selective-display
+      (save-excursion
+	(let (end (mod (buffer-modified-p)))
+	  (widen)
+	  (goto-char (point-min))
+	  (while (re-search-forward "^\r=end\\>" nil t)
+	    (end-of-line)
+	    (setq end (point))
+	    (beginning-of-line)
+	    (delete-char 1)
+	    (while (search-forward "\r" end t)
+	      (replace-match "\n" t t)))
+	  (set-buffer-modified-p mod))))
+  (setq selective-display nil selective-display-ellipses t))
+
+(defun rd-show-label-list ()
+  "Show RD Label list through temporary buffer."
+  (interactive)
+  (occur "^\\(=+\\s-\\|\\+\\|\\s-*:\\|\\s-*---\\)"))
+
+(defun rd-insert-inline (beg end str)
+  "Insert Inline Inline (general)."
+  (if str
+      (insert (concat beg str end))
+  (progn
+    (if rd-use-prompt-when-insertion-p
+        (rd-insert-inline beg end (read-string (concat beg " elm " end ": ")))
+      (insert beg end)
+      (backward-char (length end))))))
+
+(defun rd-insert-emphasis (&optional str)
+  "Insert Inline Emphasis."
+  (interactive "*") (rd-insert-inline "((*" "*))" str))
+
+(defun rd-insert-code (&optional str)
+  "Insert Inline Code."
+  (interactive "*") (rd-insert-inline "(({" "}))" str))
+
+(defun rd-insert-var (&optional str)
+  "Insert Inline Var."
+  (interactive "*") (rd-insert-inline "((|" "|))" str))
+
+(defun rd-insert-keyboard (&optional str)
+  "Insert Inline Keyboard."
+  (interactive "*") (rd-insert-inline "((%" "%))" str))
+
+(defun rd-insert-index (&optional str)
+  "Insert Inline Index."
+  (interactive "*") (rd-insert-inline "((:" ":))" str))
+
+(defun rd-insert-ref (&optional str)
+  "Insert Inline Reference."
+  (interactive "*") (rd-insert-inline "((<" ">))" str))
+
+(defun rd-insert-reftourl (&optional str)
+  "Insert Inline RefToURL."
+  (interactive "*") (rd-insert-inline "((<URL:" ">))" str))
+
+(defun rd-insert-footnote (&optional str)
+  "Insert Inline Footnote."
+  (interactive "*") (rd-insert-inline "((-" "-))" str))
+
+(defun rd-insert-verb (&optional str)
+  "Insert Inline Verb."
+  (interactive "*") (rd-insert-inline "(('" "'))" str))
+
+(defun rd-yank-as-url (&optional arg)
+  "Yank as Inline RefToURL."
+  (interactive "*P")
+  (yank arg)
+  (setq this-command 'yank)
+  (let ((yanked-str
+	 (concat "((<URL:" (buffer-substring (point) (mark t)) ">))")))
+    (delete-region (point) (mark t))
+    (if (listp arg)
+	(insert yanked-str)
+      (insert-before-markers yanked-str))))
+
+(defun rd-yank-pop-as-url (arg)
+  "Yank pop as Inline RefToURL."
+  (interactive "*p")
+  (if (not (eq last-command 'yank))
+      (progn
+	(insert (symbol-name last-command))
+      (error "Previous command is not yank-like.")))
+  (setq this-command 'yank)
+  (yank-pop arg)
+  (let ((yanked-str
+	 (concat "((<URL:" (buffer-substring (point) (mark t)) ">))")))
+    (delete-region (point) (mark t))
+    (insert yanked-str)))
+
+(defun rd-newline-and-indent ()
+  "Newline and indent as deep as prev line."
+  (interactive "*")
+  (newline)
+  (rd-indent-line))
+
+(defun rd-indent-line ()
+  "Indent line as deep as prev line."
+  (interactive "*")
+  (let ((prev-indent (progn
+		       (forward-line -1)
+		       (rd-current-indentation))))
+    (forward-line 1)
+    (rd-indent-to prev-indent)
+    (back-to-indentation)))
+
+(defun rd-line-list-p ()
+  "Whether the line is list or not."
+  (save-excursion
+    (beginning-of-line)
+    (looking-at " *\\*\\|---")))
+
+(defun rd-indent-to (num)
+  (let (beg)
+    (save-excursion
+      (beginning-of-line)
+      (setq beg (point))
+      (back-to-indentation)
+      (delete-region beg (point))
+      (indent-to num))))
+
+(defun rd-current-indentation ()
+  ""
+  (save-excursion
+    (beginning-of-line)
+    (looking-at "--- +\\| *\\(\\* +\\|([0-9]+) +\\)?")
+    (length (buffer-substring (match-beginning 0)(match-end 0)))))
+  
+(defun rd-cite-region (beg end)
+  "Make region into Verbatim."
+  (interactive "r*")
+  (let (listp prev-indent indent)
+    (save-excursion
+      (goto-char beg)
+      (forward-line -1)
+      (setq listp (rd-line-list-p)
+            prev-indent (rd-current-indentation))
+      (forward-line 1)
+      (setq indent (rd-current-indentation))
+      (if (and listp
+               (not (= (- indent prev-indent) 2)))
+          (rd-indent-region beg end (- (+ prev-indent 2) indent))
+        (cond ((= prev-indent indent)
+               (rd-indent-region beg end 2))
+              ((> prev-indent indent)
+               (rd-indent-region beg end prev-indent))
+              (t
+               (goto-char end)))))))
+  
+(defun rd-indent-region (beg end &optional indent)
+  "Make the indent of region deeper by INDENT."
+  (interactive "r*")
+  (setq indent (or indent 2))
+  (save-excursion
+    (goto-char beg)
+    (while (< (point) end)
+      (setq end (+ end indent))
+      (insert-char ?  indent)
+      (forward-line 1))))
+
+(defun rd-yank-as-verbatim (&optional arg)
+  (interactive "P")
+  (let ((beg (point))
+        (end (progn
+               (yank)
+              (point)))
+        )
+    (rd-cite-region beg end)
+    (if arg (goto-char beg))))
+
+(defun rd-insert-buffer-as-verbatim (buf)
+  (interactive "bInsert buffer (verb): ")
+  (insert-buffer buf)
+  (rd-cite-region (point)(mark)))
+
+
+(defun rd-insert-url (url label)
+  ""
+  (interactive "sURL: \nsLabel: ")
+  (if (string= label "")
+      (rd-insert-reftourl url)
+    (rd-insert-ref (concat label "|URL:" url))))
+
+(defun rd-search-last-listitem ()
+  (beginning-of-line)
+  (if (looking-at "[ \t]*\\(\\*\\|([0-9])\\|:\\|---\\)[ \t]*")
+      (match-string 0)
+    (and (and (eq
+               (rd-current-indentation)
+               (progn (forward-line -1) (rd-current-indentation))
+               )
+              (not (eq (point) (point-min)) )
+              )
+         (rd-search-last-listitem)
+         )
+    )
+  )
+
+(defun rd-intelligent-newline ()
+  (interactive)
+  (let (item)
+    (setq item
+          (save-excursion (rd-search-last-listitem) )
+          )
+    (end-of-line)
+    (newline)
+    (if item (insert-string item) )
+    )
+  )
+
+(provide 'rd-mode)
+;;; rd-mode.el ends here
+