lisp/ox-md.el

   1 ;;; ox-md.el --- Markdown Back-End for Org Export Engine -*- lexical-binding: t; -*-
   2
   3 ;; Copyright (C) 2012-2017 Free Software Foundation, Inc.
   4
   5 ;; Author: Nicolas Goaziou <n.goaziou@gmail.com>
   6 ;; Keywords: org, wp, markdown
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24
  25 ;; This library implements a Markdown back-end (vanilla flavor) for
  26 ;; Org exporter, based on `html' back-end.  See Org manual for more
  27 ;; information.
  28
  29 ;;; Code:
  30
  31 (require 'cl-lib)
  32 (require 'ox-html)
  33 (require 'ox-publish)
  34
  35 \f
  36 ;;; User-Configurable Variables
  37
  38 (defgroup org-export-md nil
  39   "Options specific to Markdown export back-end."
  40   :tag "Org Markdown"
  41   :group 'org-export
  42   :version "24.4"
  43   :package-version '(Org . "8.0"))
  44
  45 (defcustom org-md-headline-style 'atx
  46   "Style used to format headlines.
  47 This variable can be set to either `atx' or `setext'."
  48   :group 'org-export-md
  49   :type '(choice
  50           (const :tag "Use \"atx\" style" atx)
  51           (const :tag "Use \"Setext\" style" setext)))
  52
  53
  54 ;;;; Footnotes
  55
  56 (defcustom org-md-footnotes-section "%s%s"
  57   "Format string for the footnotes section.
  58 The first %s placeholder will be replaced with the localized Footnotes section
  59 heading, the second with the contents of the Footnotes section."
  60  :group 'org-export-md
  61  :type 'string
  62  :version "26.1"
  63  :package-version '(Org . "9.0"))
  64
  65 (defcustom org-md-footnote-format "<sup>%s</sup>"
  66   "Format string for the footnote reference.
  67 The %s will be replaced by the footnote reference itself."
  68   :group 'org-export-md
  69   :type 'string
  70   :version "26.1"
  71   :package-version '(Org . "9.0"))
  72
  73 \f
  74 ;;; Define Back-End
  75
  76 (org-export-define-derived-backend 'md 'html
  77   :filters-alist '((:filter-parse-tree . org-md-separate-elements))
  78   :menu-entry
  79   '(?m "Export to Markdown"
  80        ((?M "To temporary buffer"
  81             (lambda (a s v b) (org-md-export-as-markdown a s v)))
  82         (?m "To file" (lambda (a s v b) (org-md-export-to-markdown a s v)))
  83         (?o "To file and open"
  84             (lambda (a s v b)
  85               (if a (org-md-export-to-markdown t s v)
  86                 (org-open-file (org-md-export-to-markdown nil s v)))))))
  87   :translate-alist '((bold . org-md-bold)
  88                      (code . org-md-verbatim)
  89                      (example-block . org-md-example-block)
  90                      (export-block . org-md-export-block)
  91                      (fixed-width . org-md-example-block)
  92                      (headline . org-md-headline)
  93                      (horizontal-rule . org-md-horizontal-rule)
  94                      (inline-src-block . org-md-verbatim)
  95                      (inner-template . org-md-inner-template)
  96                      (italic . org-md-italic)
  97                      (item . org-md-item)
  98                      (keyword . org-md-keyword)
  99                      (line-break . org-md-line-break)
 100                      (link . org-md-link)
 101                      (node-property . org-md-node-property)
 102                      (paragraph . org-md-paragraph)
 103                      (plain-list . org-md-plain-list)
 104                      (plain-text . org-md-plain-text)
 105                      (property-drawer . org-md-property-drawer)
 106                      (quote-block . org-md-quote-block)
 107                      (section . org-md-section)
 108                      (src-block . org-md-example-block)
 109                      (template . org-md-template)
 110                      (verbatim . org-md-verbatim))
 111   :options-alist
 112   '((:md-footnote-format nil nil org-md-footnote-format)
 113     (:md-footnotes-section nil nil org-md-footnotes-section)
 114     (:md-headline-style nil nil org-md-headline-style)))
 115
 116 \f
 117 ;;; Filters
 118
 119 (defun org-md-separate-elements (tree _backend info)
 120   "Fix blank lines between elements.
 121
 122 TREE is the parse tree being exported.  BACKEND is the export
 123 back-end used.  INFO is a plist used as a communication channel.
 124
 125 Enforce a blank line between elements.  There are two exceptions
 126 to this rule:
 127
 128   1. Preserve blank lines between sibling items in a plain list,
 129
 130   2. In an item, remove any blank line before the very first
 131      paragraph and the next sub-list when the latter ends the
 132      current item.
 133
 134 Assume BACKEND is `md'."
 135   (org-element-map tree (remq 'item org-element-all-elements)
 136     (lambda (e)
 137       (org-element-put-property
 138        e :post-blank
 139        (if (and (eq (org-element-type e) 'paragraph)
 140                 (eq (org-element-type (org-element-property :parent e)) 'item)
 141                 (org-export-first-sibling-p e info)
 142                 (let ((next (org-export-get-next-element e info)))
 143                   (and (eq (org-element-type next) 'plain-list)
 144                        (not (org-export-get-next-element next info)))))
 145            0
 146          1))))
 147   ;; Return updated tree.
 148   tree)
 149
 150
 151 \f
 152 ;;; Transcode Functions
 153
 154 ;;;; Bold
 155
 156 (defun org-md-bold (_bold contents _info)
 157   "Transcode BOLD object into Markdown format.
 158 CONTENTS is the text within bold markup.  INFO is a plist used as
 159 a communication channel."
 160   (format "**%s**" contents))
 161
 162
 163 ;;;; Code and Verbatim
 164
 165 (defun org-md-verbatim (verbatim _contents _info)
 166   "Transcode VERBATIM object into Markdown format.
 167 CONTENTS is nil.  INFO is a plist used as a communication
 168 channel."
 169   (let ((value (org-element-property :value verbatim)))
 170     (format (cond ((not (string-match "`" value)) "`%s`")
 171                   ((or (string-prefix-p "`" value)
 172                        (string-suffix-p "`" value))
 173                    "`` %s ``")
 174                   (t "``%s``"))
 175             value)))
 176
 177
 178 ;;;; Example Block, Src Block and export Block
 179
 180 (defun org-md-example-block (example-block _contents info)
 181   "Transcode EXAMPLE-BLOCK element into Markdown format.
 182 CONTENTS is nil.  INFO is a plist used as a communication
 183 channel."
 184   (replace-regexp-in-string
 185    "^" "    "
 186    (org-remove-indentation
 187     (org-export-format-code-default example-block info))))
 188
 189 (defun org-md-export-block (export-block contents info)
 190   "Transcode a EXPORT-BLOCK element from Org to Markdown.
 191 CONTENTS is nil.  INFO is a plist holding contextual information."
 192   (if (member (org-element-property :type export-block) '("MARKDOWN" "MD"))
 193       (org-remove-indentation (org-element-property :value export-block))
 194     ;; Also include HTML export blocks.
 195     (org-export-with-backend 'html export-block contents info)))
 196
 197
 198 ;;;; Headline
 199
 200 (defun org-md-headline (headline contents info)
 201   "Transcode HEADLINE element into Markdown format.
 202 CONTENTS is the headline contents.  INFO is a plist used as
 203 a communication channel."
 204   (unless (org-element-property :footnote-section-p headline)
 205     (let* ((level (org-export-get-relative-level headline info))
 206            (title (org-export-data (org-element-property :title headline) info))
 207            (todo (and (plist-get info :with-todo-keywords)
 208                       (let ((todo (org-element-property :todo-keyword
 209                                                         headline)))
 210                         (and todo (concat (org-export-data todo info) " ")))))
 211            (tags (and (plist-get info :with-tags)
 212                       (let ((tag-list (org-export-get-tags headline info)))
 213                         (and tag-list
 214                              (format "     :%s:"
 215                                      (mapconcat 'identity tag-list ":"))))))
 216            (priority
 217             (and (plist-get info :with-priority)
 218                  (let ((char (org-element-property :priority headline)))
 219                    (and char (format "[#%c] " char)))))
 220            ;; Headline text without tags.
 221            (heading (concat todo priority title))
 222            (style (plist-get info :md-headline-style)))
 223       (cond
 224        ;; Cannot create a headline.  Fall-back to a list.
 225        ((or (org-export-low-level-p headline info)
 226             (not (memq style '(atx setext)))
 227             (and (eq style 'atx) (> level 6))
 228             (and (eq style 'setext) (> level 2)))
 229         (let ((bullet
 230                (if (not (org-export-numbered-headline-p headline info)) "-"
 231                  (concat (number-to-string
 232                           (car (last (org-export-get-headline-number
 233                                       headline info))))
 234                          "."))))
 235           (concat bullet (make-string (- 4 (length bullet)) ?\s) heading tags "\n\n"
 236                   (and contents (replace-regexp-in-string "^" "    " contents)))))
 237        (t
 238         (let ((anchor
 239                (and (org-md--headline-referred-p headline info)
 240                     (format "<a id=\"%s\"></a>"
 241                             (or (org-element-property :CUSTOM_ID headline)
 242                                 (org-export-get-reference headline info))))))
 243           (concat (org-md--headline-title style level title anchor tags)
 244                   contents)))))))
 245
 246
 247 (defun org-md--headline-referred-p (headline info)
 248   "Non-nil when HEADLINE is being referred to.
 249 INFO is a plist used as a communication channel.  Links and table
 250 of contents can refer to headlines."
 251   (or (plist-get info :with-toc)
 252       (org-element-map (plist-get info :parse-tree) 'link
 253         (lambda (link)
 254           (eq headline
 255               (pcase (org-element-property :type link)
 256                 ((or "custom-id" "id") (org-export-resolve-id-link link info))
 257                 ("fuzzy" (org-export-resolve-fuzzy-link link info))
 258                 (_ nil))))
 259         info t)))
 260
 261 (defun org-md--headline-title (style level title &optional anchor tags)
 262   "Generate a headline title in the preferred Markdown headline style.
 263 STYLE is the preferred style (`atx' or `setext').  LEVEL is the
 264 header level.  TITLE is the headline title.  ANCHOR is the HTML
 265 anchor tag for the section as a string.  TAGS are the tags set on
 266 the section."
 267   (let ((anchor-lines (and anchor (concat anchor "\n\n"))))
 268     ;; Use "Setext" style
 269     (if (and (eq style 'setext) (< level 3))
 270         (let* ((underline-char (if (= level 1) ?= ?-))
 271                (underline (concat (make-string (length title) underline-char)
 272                                   "\n")))
 273           (concat "\n" anchor-lines title tags "\n" underline "\n"))
 274         ;; Use "Atx" style
 275         (let ((level-mark (make-string level ?#)))
 276           (concat "\n" anchor-lines level-mark " " title tags "\n\n")))))
 277
 278 ;;;; Horizontal Rule
 279
 280 (defun org-md-horizontal-rule (_horizontal-rule _contents _info)
 281   "Transcode HORIZONTAL-RULE element into Markdown format.
 282 CONTENTS is the horizontal rule contents.  INFO is a plist used
 283 as a communication channel."
 284   "---")
 285
 286
 287 ;;;; Italic
 288
 289 (defun org-md-italic (_italic contents _info)
 290   "Transcode ITALIC object into Markdown format.
 291 CONTENTS is the text within italic markup.  INFO is a plist used
 292 as a communication channel."
 293   (format "*%s*" contents))
 294
 295
 296 ;;;; Item
 297
 298 (defun org-md-item (item contents info)
 299   "Transcode ITEM element into Markdown format.
 300 CONTENTS is the item contents.  INFO is a plist used as
 301 a communication channel."
 302   (let* ((type (org-element-property :type (org-export-get-parent item)))
 303          (struct (org-element-property :structure item))
 304          (bullet (if (not (eq type 'ordered)) "-"
 305                    (concat (number-to-string
 306                             (car (last (org-list-get-item-number
 307                                         (org-element-property :begin item)
 308                                         struct
 309                                         (org-list-prevs-alist struct)
 310                                         (org-list-parents-alist struct)))))
 311                            "."))))
 312     (concat bullet
 313             (make-string (- 4 (length bullet)) ? )
 314             (pcase (org-element-property :checkbox item)
 315               (`on "[X] ")
 316               (`trans "[-] ")
 317               (`off "[ ] "))
 318             (let ((tag (org-element-property :tag item)))
 319               (and tag (format "**%s:** "(org-export-data tag info))))
 320             (and contents
 321                  (org-trim (replace-regexp-in-string "^" "    " contents))))))
 322
 323
 324
 325 ;;;; Keyword
 326
 327 (defun org-md-keyword (keyword contents info)
 328   "Transcode a KEYWORD element into Markdown format.
 329 CONTENTS is nil.  INFO is a plist used as a communication
 330 channel."
 331   (if (member (org-element-property :key keyword) '("MARKDOWN" "MD"))
 332       (org-element-property :value keyword)
 333     (org-export-with-backend 'html keyword contents info)))
 334
 335
 336 ;;;; Line Break
 337
 338 (defun org-md-line-break (_line-break _contents _info)
 339   "Transcode LINE-BREAK object into Markdown format.
 340 CONTENTS is nil.  INFO is a plist used as a communication
 341 channel."
 342   "  \n")
 343
 344
 345 ;;;; Link
 346
 347 (defun org-md-link (link contents info)
 348   "Transcode LINE-BREAK object into Markdown format.
 349 CONTENTS is the link's description.  INFO is a plist used as
 350 a communication channel."
 351   (let ((link-org-files-as-md
 352          (lambda (raw-path)
 353            ;; Treat links to `file.org' as links to `file.md'.
 354            (if (string= ".org" (downcase (file-name-extension raw-path ".")))
 355                (concat (file-name-sans-extension raw-path) ".md")
 356              raw-path)))
 357         (type (org-element-property :type link)))
 358     (cond
 359      ;; Link type is handled by a special function.
 360      ((org-export-custom-protocol-maybe link contents 'md))
 361      ((member type '("custom-id" "id" "fuzzy"))
 362       (let ((destination (if (string= type "fuzzy")
 363                              (org-export-resolve-fuzzy-link link info)
 364                            (org-export-resolve-id-link link info))))
 365         (pcase (org-element-type destination)
 366           (`plain-text                  ; External file.
 367            (let ((path (funcall link-org-files-as-md destination)))
 368              (if (not contents) (format "<%s>" path)
 369                (format "[%s](%s)" contents path))))
 370           (`headline
 371            (format
 372             "[%s](#%s)"
 373             ;; Description.
 374             (cond ((org-string-nw-p contents))
 375                   ((org-export-numbered-headline-p destination info)
 376                    (mapconcat #'number-to-string
 377                               (org-export-get-headline-number destination info)
 378                               "."))
 379                   (t (org-export-data (org-element-property :title destination)
 380                                       info)))
 381             ;; Reference.
 382             (or (org-element-property :CUSTOM_ID destination)
 383                 (org-export-get-reference destination info))))
 384           (_
 385            (let ((description
 386                   (or (org-string-nw-p contents)
 387                       (let ((number (org-export-get-ordinal destination info)))
 388                         (cond
 389                          ((not number) nil)
 390                          ((atom number) (number-to-string number))
 391                          (t (mapconcat #'number-to-string number ".")))))))
 392              (when description
 393                (format "[%s](#%s)"
 394                        description
 395                        (org-export-get-reference destination info))))))))
 396      ((org-export-inline-image-p link org-html-inline-image-rules)
 397       (let ((path (let ((raw-path (org-element-property :path link)))
 398                     (if (not (file-name-absolute-p raw-path)) raw-path
 399                       (expand-file-name raw-path))))
 400             (caption (org-export-data
 401                       (org-export-get-caption
 402                        (org-export-get-parent-element link)) info)))
 403         (format "![img](%s)"
 404                 (if (not (org-string-nw-p caption)) path
 405                   (format "%s \"%s\"" path caption)))))
 406      ((string= type "coderef")
 407       (let ((ref (org-element-property :path link)))
 408         (format (org-export-get-coderef-format ref contents)
 409                 (org-export-resolve-coderef ref info))))
 410      ((equal type "radio") contents)
 411      (t (let* ((raw-path (org-element-property :path link))
 412                (path
 413                 (cond
 414                  ((member type '("http" "https" "ftp"))
 415                   (concat type ":" raw-path))
 416                  ((string= type "file")
 417                   (org-export-file-uri (funcall link-org-files-as-md raw-path)))
 418                  (t raw-path))))
 419           (if (not contents) (format "<%s>" path)
 420             (format "[%s](%s)" contents path)))))))
 421
 422
 423 ;;;; Node Property
 424
 425 (defun org-md-node-property (node-property _contents _info)
 426   "Transcode a NODE-PROPERTY element into Markdown syntax.
 427 CONTENTS is nil.  INFO is a plist holding contextual
 428 information."
 429   (format "%s:%s"
 430           (org-element-property :key node-property)
 431           (let ((value (org-element-property :value node-property)))
 432             (if value (concat " " value) ""))))
 433
 434
 435 ;;;; Paragraph
 436
 437 (defun org-md-paragraph (paragraph contents _info)
 438   "Transcode PARAGRAPH element into Markdown format.
 439 CONTENTS is the paragraph contents.  INFO is a plist used as
 440 a communication channel."
 441   (let ((first-object (car (org-element-contents paragraph))))
 442     ;; If paragraph starts with a #, protect it.
 443     (if (and (stringp first-object) (string-prefix-p "#" first-object))
 444         (concat "\\" contents)
 445       contents)))
 446
 447
 448 ;;;; Plain List
 449
 450 (defun org-md-plain-list (_plain-list contents _info)
 451   "Transcode PLAIN-LIST element into Markdown format.
 452 CONTENTS is the plain-list contents.  INFO is a plist used as
 453 a communication channel."
 454   contents)
 455
 456
 457 ;;;; Plain Text
 458
 459 (defun org-md-plain-text (text info)
 460   "Transcode a TEXT string into Markdown format.
 461 TEXT is the string to transcode.  INFO is a plist holding
 462 contextual information."
 463   (when (plist-get info :with-smart-quotes)
 464     (setq text (org-export-activate-smart-quotes text :html info)))
 465   ;; Protect ambiguous #.  This will protect # at the beginning of
 466   ;; a line, but not at the beginning of a paragraph.  See
 467   ;; `org-md-paragraph'.
 468   (setq text (replace-regexp-in-string "\n#" "\n\\\\#" text))
 469   ;; Protect ambiguous !
 470   (setq text (replace-regexp-in-string "\\(!\\)\\[" "\\\\!" text nil nil 1))
 471   ;; Protect `, *, _ and \
 472   (setq text (replace-regexp-in-string "[`*_\\]" "\\\\\\&" text))
 473   ;; Handle special strings, if required.
 474   (when (plist-get info :with-special-strings)
 475     (setq text (org-html-convert-special-strings text)))
 476   ;; Handle break preservation, if required.
 477   (when (plist-get info :preserve-breaks)
 478     (setq text (replace-regexp-in-string "[ \t]*\n" "  \n" text)))
 479   ;; Return value.
 480   text)
 481
 482
 483 ;;;; Property Drawer
 484
 485 (defun org-md-property-drawer (_property-drawer contents _info)
 486   "Transcode a PROPERTY-DRAWER element into Markdown format.
 487 CONTENTS holds the contents of the drawer.  INFO is a plist
 488 holding contextual information."
 489   (and (org-string-nw-p contents)
 490        (replace-regexp-in-string "^" "    " contents)))
 491
 492
 493 ;;;; Quote Block
 494
 495 (defun org-md-quote-block (_quote-block contents _info)
 496   "Transcode QUOTE-BLOCK element into Markdown format.
 497 CONTENTS is the quote-block contents.  INFO is a plist used as
 498 a communication channel."
 499   (replace-regexp-in-string
 500    "^" "> "
 501    (replace-regexp-in-string "\n\\'" "" contents)))
 502
 503
 504 ;;;; Section
 505
 506 (defun org-md-section (_section contents _info)
 507   "Transcode SECTION element into Markdown format.
 508 CONTENTS is the section contents.  INFO is a plist used as
 509 a communication channel."
 510   contents)
 511
 512
 513 ;;;; Template
 514
 515 (defun org-md--footnote-formatted (footnote info)
 516   "Formats a single footnote entry FOOTNOTE.
 517 FOOTNOTE is a cons cell of the form (number . definition).
 518 INFO is a plist with contextual information."
 519   (let* ((fn-num (car footnote))
 520          (fn-text (cdr footnote))
 521          (fn-format (plist-get info :md-footnote-format))
 522          (fn-anchor (format "fn.%d" fn-num))
 523          (fn-href (format " href=\"#fnr.%d\"" fn-num))
 524          (fn-link-to-ref (org-html--anchor fn-anchor fn-num fn-href info)))
 525     (concat (format fn-format fn-link-to-ref) " " fn-text "\n")))
 526
 527 (defun org-md--footnote-section (info)
 528   "Format the footnote section.
 529 INFO is a plist used as a communication channel."
 530   (let* ((fn-alist (org-export-collect-footnote-definitions info))
 531          (fn-alist (cl-loop for (n _type raw) in fn-alist collect
 532                             (cons n (org-trim (org-export-data raw info)))))
 533          (headline-style (plist-get info :md-headline-style))
 534          (section-title (org-html--translate "Footnotes" info)))
 535     (when fn-alist
 536       (format (plist-get info :md-footnotes-section)
 537               (org-md--headline-title headline-style 1 section-title)
 538               (mapconcat (lambda (fn) (org-md--footnote-formatted fn info))
 539                          fn-alist
 540                          "\n")))))
 541
 542 (defun org-md-inner-template (contents info)
 543   "Return body of document after converting it to Markdown syntax.
 544 CONTENTS is the transcoded contents string.  INFO is a plist
 545 holding export options."
 546   ;; Make sure CONTENTS is separated from table of contents and
 547   ;; footnotes with at least a blank line.
 548   (concat
 549    ;; Table of contents.
 550    (let ((depth (plist-get info :with-toc)))
 551      (when depth (org-html-toc depth info)))
 552    ;; Document contents.
 553    contents
 554    "\n"
 555    ;; Footnotes section.
 556    (org-md--footnote-section info)))
 557
 558 (defun org-md-template (contents _info)
 559   "Return complete document string after Markdown conversion.
 560 CONTENTS is the transcoded contents string.  INFO is a plist used
 561 as a communication channel."
 562   contents)
 563
 564
 565 \f
 566 ;;; Interactive function
 567
 568 ;;;###autoload
 569 (defun org-md-export-as-markdown (&optional async subtreep visible-only)
 570   "Export current buffer to a Markdown buffer.
 571
 572 If narrowing is active in the current buffer, only export its
 573 narrowed part.
 574
 575 If a region is active, export that region.
 576
 577 A non-nil optional argument ASYNC means the process should happen
 578 asynchronously.  The resulting buffer should be accessible
 579 through the `org-export-stack' interface.
 580
 581 When optional argument SUBTREEP is non-nil, export the sub-tree
 582 at point, extracting information from the headline properties
 583 first.
 584
 585 When optional argument VISIBLE-ONLY is non-nil, don't export
 586 contents of hidden elements.
 587
 588 Export is done in a buffer named \"*Org MD Export*\", which will
 589 be displayed when `org-export-show-temporary-export-buffer' is
 590 non-nil."
 591   (interactive)
 592   (org-export-to-buffer 'md "*Org MD Export*"
 593     async subtreep visible-only nil nil (lambda () (text-mode))))
 594
 595 ;;;###autoload
 596 (defun org-md-convert-region-to-md ()
 597   "Assume the current region has Org syntax, and convert it to Markdown.
 598 This can be used in any buffer.  For example, you can write an
 599 itemized list in Org syntax in a Markdown buffer and use
 600 this command to convert it."
 601   (interactive)
 602   (org-export-replace-region-by 'md))
 603
 604
 605 ;;;###autoload
 606 (defun org-md-export-to-markdown (&optional async subtreep visible-only)
 607   "Export current buffer to a Markdown file.
 608
 609 If narrowing is active in the current buffer, only export its
 610 narrowed part.
 611
 612 If a region is active, export that region.
 613
 614 A non-nil optional argument ASYNC means the process should happen
 615 asynchronously.  The resulting file should be accessible through
 616 the `org-export-stack' interface.
 617
 618 When optional argument SUBTREEP is non-nil, export the sub-tree
 619 at point, extracting information from the headline properties
 620 first.
 621
 622 When optional argument VISIBLE-ONLY is non-nil, don't export
 623 contents of hidden elements.
 624
 625 Return output file's name."
 626   (interactive)
 627   (let ((outfile (org-export-output-file-name ".md" subtreep)))
 628     (org-export-to-file 'md outfile async subtreep visible-only)))
 629
 630 ;;;###autoload
 631 (defun org-md-publish-to-md (plist filename pub-dir)
 632   "Publish an org file to Markdown.
 633
 634 FILENAME is the filename of the Org file to be published.  PLIST
 635 is the property list for the given project.  PUB-DIR is the
 636 publishing directory.
 637
 638 Return output file name."
 639   (org-publish-org-to 'md filename ".md" plist pub-dir))
 640
 641 (provide 'ox-md)
 642
 643 ;; Local variables:
 644 ;; generated-autoload-file: "org-loaddefs.el"
 645 ;; End:
 646
 647 ;;; ox-md.el ends here