tdiary 3.2.2.20130518 → 3.2.2.20130527

data/vendor/rdtool-0.6.38/test/test-textblock.rb

@@ -1,44 +0,0 @@
-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/vendor/rdtool-0.6.38/test/test-tree.rb

@@ -1,82 +0,0 @@
-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/vendor/rdtool-0.6.38/test/test-version.rb

@@ -1,57 +0,0 @@
-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/vendor/rdtool-0.6.38/test/test-visitor.rb

@@ -1,230 +0,0 @@
-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/vendor/rdtool-0.6.38/utils/rd-mode.el

@@ -1,464 +0,0 @@
-;;; 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)
-  (setq imenu-create-index-function 'rd-imenu-create-index)
-  (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) )
-    )
-  )
-
-(defun rd-imenu-create-index ()
-  (let ((root '(nil . nil))
-        cur-alist
-        (cur-level 0)
-        (pattern "^\\(=+\\)[ \t\v\f]*\\(.*?\\)[ \t\v\f]*$")
-        (empty-heading "-")
-        (self-heading ".")
-        pos level heading alist)
-    (save-excursion
-      (goto-char (point-min))
-      (while (re-search-forward pattern (point-max) t)
-        (setq heading (match-string-no-properties 2)
-              level (min 6 (length (match-string-no-properties 1)))
-              pos (match-beginning 1))
-        (if (= (length heading) 0)
-            (setq heading empty-heading))
-        (setq alist (list (cons heading pos)))
-        (cond
-         ((= cur-level level)		; new sibling
-          (setcdr cur-alist alist)
-          (setq cur-alist alist))
-         ((< cur-level level)		; first child
-          (dotimes (i (- level cur-level 1))
-            (setq alist (list (cons empty-heading alist))))
-          (if cur-alist
-              (let* ((parent (car cur-alist))
-                     (self-pos (cdr parent)))
-                (setcdr parent (cons (cons self-heading self-pos) alist)))
-            (setcdr root alist))	; primogenitor
-          (setq cur-alist alist
-                cur-level level))
-         (t				; new sibling of an ancestor
-          (let ((sibling-alist (last (cdr root))))
-            (dotimes (i (1- level))
-              (setq sibling-alist (last (cdar sibling-alist))))
-            (setcdr sibling-alist alist)
-            (setq cur-alist alist
-                  cur-level level))))))
-    (cdr root)))
-
-(provide 'rd-mode)
-;;; rd-mode.el ends here
-