diff --git a/BSD3.md b/BSD3.md new file mode 100644 --- /dev/null +++ b/BSD3.md @@ -0,0 +1,30 @@ +data-accessor +------------- + +Copyright (c) Henning Thielemann , Luke Palmer . +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of data-accessor nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,339 @@ +GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + {description} + Copyright (C) {year} {fullname} + + This program 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + {signature of Ty Coon}, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,150 @@ +# pandoc-crossref filter ![](https://travis-ci.org/lierdakil/pandoc-crossref.svg) + +pandoc-crossref is a pandoc filter for numbering figures, equations, tables and cross-references to them. + +Input file (like [demo.md][demo-md]) can be converted into [html][html], [latex][latex], [pdf][pdf], [md][md] or other formats. + +Optionally, you can use cleveref for latex/pdf output, e.g. [cleveref pdf][cpdf], [cleveref latex][clatex] + +You can also enable per-chapter numbering (as with `--chapters` for latex output). You need to specify `-M chapters` for non-latex/pdf output however. Examples: [html][chap-html], [markdown][chap-markdown], [latex][chap-latex], [pdf][chap-pdf]. + +[demo-md]: http://lierdakil.github.io/pandoc-crossref/demo.md +[html]: http://lierdakil.github.io/pandoc-crossref/output.html +[latex]: http://lierdakil.github.io/pandoc-crossref/output.latex +[pdf]: http://lierdakil.github.io/pandoc-crossref/output.pdf +[md]: http://lierdakil.github.io/pandoc-crossref/output.md +[chap-html]: http://lierdakil.github.io/pandoc-crossref/output-chapters.html +[chap-latex]:http://lierdakil.github.io/pandoc-crossref/output-chapters.latex +[chap-markdown]:http://lierdakil.github.io/pandoc-crossref/output-chapters.md +[chap-pdf]:http://lierdakil.github.io/pandoc-crossref/output-chapters.pdf +[clatex]: http://lierdakil.github.io/pandoc-crossref/output-cref.latex +[cpdf]: http://lierdakil.github.io/pandoc-crossref/output-cref.pdf + + +Tested with pandoc 1.13.2. + +This work is inspired by [pandoc-fignos][1] and [pandoc-eqnos][2] by @tomduck. + +[1]: https://github.com/tomduck/pandoc-fignos +[2]: https://github.com/tomduck/pandoc-eqnos + +This package tries to use latex labels and references if output type is latex. + +## Syntax + +Syntax is loosely based on discussion in + +### Image labels + +```markdown +![Caption](file.ext){#fig:label} +``` + +To label an (implicit) figure, append `{#fig:label}` (with `label` being something unique to reference this figure by) immediately after image definition. + +This only works on implicit figures, i.e. an image occurring by itself in a paragraph (which will be rendered as a figure with caption by pandoc) + +Image block and label *can* be separated by one or more spaces. + +### Equation labels + +```markdown +$$ math $$ {#eq:label} +``` + +To label a display equation, append `{#eq:label}` (with `label` being something unique to reference this equation by) immediately after math block. + +This only works if display math and label specification are in a paragraph of its own. + +Math block and label *can* be separated by one or more spaces. + +### Table labels + +```markdown +a b c +--- --- --- +1 2 3 +4 5 6 + +: Caption {#tbl:label} +``` + +To label a table, append `{#tbl:label}` at the end of table caption (with `label` being something unique to reference this table by). Caption and label *must* be separated by at least one space. + +### References + +```markdown +[@fig:label1;@fig:label2;...] or [@eq:label1;@eq:label2;...] or [@tbl:label1;@tbl:label2;...] or @fig:label or @eq:label or @tbl:label +``` + +Reference syntax heavily relies on citation syntax. Basic reference is created by writing `@`, then basically desired label with prefix. It is also possible to reference a group of objects *of the same type*, by putting them into brackets with `;` as separator. Sequential reference numbers will be shortened, e.g. `1,2,3` will be shortened to `1-3`. + +### Lists + +It's possible to use raw latex commands `\listoffigures` and `\listoftables`, which will produce ordered list of figure/table titles, in order of appearance in document. + +## Installation + +Assuming you already installed [Haskell platform](http://hackage.haskell.org/platform/), you can install pandoc-crossref with cabal: + +```bash +cabal update +cabal install pandoc-crossref +``` + +## Usage + +Run pandoc with `--filter` option, passing path to pandoc-crossref executable, or simply `pandoc-crossref`, if it's in PATH: + +`pandoc --filter pandoc-crossref` + +If you installed with cabal, it's most likely located in `$HOME/.cabal/bin` on \*NIX systems, or in `%AppData%\cabal\bin` on Windows. + +### Customization + +There are several parameters that can be set via YAML metadata (either by passing `-M` to `pandoc`, or by setting it in source markdown) + +Following variables are supported: + +* `cref`: if True, latex export will use `\cref` from cleveref package. It is user's responsibility to include relevant `\usepackage` directives in template +* `chapter`: if True, number elements as `chapter.item`, and restart `item` on each first-level heading (as `--chapters` for latex/pdf output) +* `figureTitle`, default `Figure`: Word(s) to prepend to figure titles, e.g. `Figure 1: Description` +* `tableTitle`, default `Table`: Word(s) to prepend to table titles, e.g. `Table 1: Description` +* `titleDelimiter`, default `:`: What to put between object number and caption text. +* `figPrefix`, default `fig.`: Prefix for references to figures, e.g. `fig. 1-3` +* `eqnPrefix`, default `eq.`: Prefix for references to equations, e.g. `eq. 3,4` +* `tblPrefix`, default `tbl.`: Prefix for references to tables, e.g. `tbl. 2` +* `chapDelim`, default `.`: Delimiter between chapter number and item number. +* `rangeDelim`, default `-`: Delimiter between reference ranges, e.g. `eq. 2-5` +* `lofTitle`, default `# List of Figures`: Title for list of figures (lof) +* `lotTitle`, default `# List of Tables`: Title for list of tables (lot) +* `figureTemplate`, default `\\[figureTitle\\] \\[i\\]\\[titleDelim\\] \\[t\\]`: template for figure captions, see [Templates](#templates) +* `tableTemplate`, default `\\[tableTitle\\] \\[i\\]\\[titleDelim\\] \\[t\\]`: template for table captions, see [Templates](#templates) + +### Templates + +pandoc-crossref supports advanced caption customization via caption templates. Templates are specified as YAML metadata variables (see [Customization](#customization)), and are parsed as default Pandoc Markdown. Variables are specified with display math syntax, i.e. `$$var$$` in a template will be replaced with value of variable `var`. +Variables can be specified in YAML metadata block, or from command line (with `-M` switch). There are two special variables, that are set internally: + +* `i` -- object number, possibly with chapter number (if `chapter=True`) +* `t` -- object caption, as given in source Markdown + +### Settings file + +It is also possible to set variables used by pandoc-crossref with a separate YAML file. If a given variable is not set in metadata, then pandoc-crossref will attempt to read it from file specified by `crossrefYaml` metadata variable, or, if not set, from `pandoc-crossref.yaml` from current working directory. This allows for reusable configurations. One possible application is ad-hoc internationalization. + +For example, consider `$HOME/misc/pandoc-crossref-es.yaml`: + +```yaml +figureTitle: "Figura" +tableTitle: "Tabla" +figPrefix: "fig." +eqnPrefix: "ec." +tblPrefix: "tbl." +loftitle: "# Lista de figuras" +lotTitle: "# Lista de tablas" +``` + +One could use this with pandoc-crossref as follows: + +`pandoc -F pandoc-crossref.hs -M "crossrefYaml=$HOME/misc/pandoc-crossref-es.yaml"` diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/pandoc-crossref.cabal b/pandoc-crossref.cabal new file mode 100644 --- /dev/null +++ b/pandoc-crossref.cabal @@ -0,0 +1,69 @@ +-- Initial pandoc-crossref.cabal generated by cabal init. For further +-- documentation, see http://haskell.org/cabal/users-guide/ + +name: pandoc-crossref +version: 0.1.0.0 +synopsis: Pandoc filter for cross-references +description: pandoc-crossref is a pandoc filter for numbering figures, equations, tables and cross-references to them. +license: GPL-2 +license-file: LICENSE.md +author: Nikolay Yakimov +maintainer: root@livid.pp.ru +-- copyright: +category: Text +build-type: Simple +extra-doc-files: README.md + BSD3.md +cabal-version: >=1.10 + +source-repository head + type: git + location: https://github.com/lierdakil/pandoc-crossref + +source-repository this + type: git + location: https://github.com/lierdakil/pandoc-crossref + tag: v0.1.0.0 + +executable pandoc-crossref + main-is: pandoc-crossref.hs + other-modules: References + , References.Accessors + , References.Blocks + , References.List + , References.Refs + , References.Types + , Util.Default.Default + , Util.Default.Settings + , Util.Accessor + , Util.Meta + , Util.Options + , Util.Template + , Util.Util + -- other-extensions: + build-depends: base >=4.2 && <5 + , pandoc >= 1.13 && <1.14 + , mtl >= 1.1 && <2.3 + , containers >= 0.1 && <0.6 + , pandoc-types >= 1.12.4.1 && < 1.13 + , yaml >= 0.8 && <0.9 + , data-default >= 0.4 && <0.6 + , bytestring >=0.9 && <0.11 + hs-source-dirs: ., src + default-language: Haskell2010 + +Test-Suite test-pandoc-crossref + Type: exitcode-stdio-1.0 + Main-Is: test-pandoc-crossref.hs + Build-Depends: base >=4.2 && <5 + , pandoc >= 1.13 && <1.14 + , mtl >= 1.1 && <2.3 + , containers >= 0.1 && <0.6 + , pandoc-types >= 1.12.4.1 && < 1.13 + , yaml >= 0.8 && <0.9 + , data-default >= 0.4 && <0.6 + , bytestring >=0.9 && <0.11 + , hspec + , process >=1 && <1.3 + Ghc-Options: -rtsopts -Wall -fno-warn-unused-do-bind -threaded + Default-Language: Haskell2010 diff --git a/pandoc-crossref.hs b/pandoc-crossref.hs new file mode 100644 --- /dev/null +++ b/pandoc-crossref.hs @@ -0,0 +1,23 @@ +import Text.Pandoc +import Text.Pandoc.JSON +import Text.Pandoc.Walk +import Control.Monad.State + +import References +import Util.Default.Settings +import Util.Options + +main :: IO () +main = toJSONFilter go + +go :: Maybe Format -> Pandoc -> IO Pandoc +go fmt (Pandoc meta bs) = do + dtv <- getDefaultSettings meta + let + st = defaultReferences{stMeta=meta, stDTV=dtv} + doWalk = + walkM (replaceBlocks opts) bs + >>= bottomUpM (replaceRefs opts) + >>= bottomUpM (listOf opts) + opts = getOptions meta dtv fmt + return $ Pandoc meta $ evalState doWalk st diff --git a/src/References.hs b/src/References.hs new file mode 100644 --- /dev/null +++ b/src/References.hs @@ -0,0 +1,7 @@ +module References ( module X ) where + +import References.Accessors as X +import References.Types as X +import References.Blocks as X +import References.Refs as X +import References.List as X diff --git a/src/References/Accessors.hs b/src/References/Accessors.hs new file mode 100644 --- /dev/null +++ b/src/References/Accessors.hs @@ -0,0 +1,18 @@ +module References.Accessors where + +import References.Types +import Util.Accessor +import Text.Pandoc.Definition (nullMeta) +import Data.Map (empty) + +imgRefs' :: Accessor References RefMap +imgRefs' new r@References{imgRefs=old} = (old, r{imgRefs=new}) + +eqnRefs' :: Accessor References RefMap +eqnRefs' new r@References{eqnRefs=old} = (old, r{eqnRefs=new}) + +tblRefs' :: Accessor References RefMap +tblRefs' new r@References{tblRefs=old} = (old, r{tblRefs=new}) + +defaultReferences :: References +defaultReferences = References empty empty empty 0 nullMeta (const Nothing) nullMeta diff --git a/src/References/Blocks.hs b/src/References/Blocks.hs new file mode 100644 --- /dev/null +++ b/src/References/Blocks.hs @@ -0,0 +1,75 @@ +module References.Blocks (replaceBlocks) where + +import Text.Pandoc.Definition +import Text.Pandoc.Shared (stringify) +import Control.Monad.State +import Data.List +import qualified Data.Map as M + +import Util.Accessor +import References.Types +import References.Accessors +import Util.Util +import Util.Options +import Util.Template + +replaceBlocks :: Options -> Block -> WS Block +replaceBlocks opts x@(Header 1 _ _) + | sepChapters opts + = do + modify (\r@References{curChap=cc} -> r{curChap=cc+1}) + return x +replaceBlocks opts (Para (Image alt img:c)) + | Just label <- getRefLabel "fig" c + = do + idxStr <- replaceAttr opts label alt imgRefs' + alt' <- case outFormat opts of + Just f | isFormat "latex" f -> return $ + RawInline (Format "tex") ("\\label{"++label++"}") : alt + _ -> figureTemplate opts >>= applyTemplate idxStr alt + return $ Para [Image alt' (fst img,"fig:")] +replaceBlocks opts (Para (Math DisplayMath eq:c)) + | Just label <- getRefLabel "eq" c + = case outFormat opts of + Just f | isFormat "latex" f -> + let eqn = "\\begin{equation}"++eq++"\\label{"++label++"}\\end{equation}" + in return $ Para [RawInline (Format "tex") eqn] + _ -> do + idxStr <- replaceAttr opts label [] eqnRefs' + let eq' = eq++"\\qquad("++stringify idxStr++")" + return $ Para [Math DisplayMath eq'] +replaceBlocks opts (Table title align widths header cells) + | not $ null title + , Just label <- getRefLabel "tbl" [last title] + = do + idxStr <- replaceAttr opts label (init title) tblRefs' + title' <- + case outFormat opts of + Just f | isFormat "latex" f -> return $ + RawInline (Format "tex") ("\\label{"++label++"}") : init title + _ -> tableTemplate opts >>= applyTemplate idxStr (init title) + return $ Table title' align widths header cells +replaceBlocks _ x = return x + +getRefLabel :: String -> [Inline] -> Maybe String +getRefLabel _ [] = Nothing +getRefLabel tag ils + | Str attr <- last ils + , all (==Space) (init ils) + , "}" `isSuffixOf` attr + , ("{#"++tag++":") `isPrefixOf` attr + = init `fmap` stripPrefix "{#" attr +getRefLabel _ _ = Nothing + +replaceAttr :: Options -> String -> [Inline] -> Accessor References RefMap -> WS [Inline] +replaceAttr o label title prop + = do + chap <- gets curChap + index <- (1+) `fmap` gets (M.size . getProp prop) + modify $ modifyProp prop $ M.insert label RefRec { + refIndex=(chap,index) + , refTitle=title + } + if sepChapters o + then return $ Str (show chap) : chapDelim o ++ [Str (show index)] + else return [Str (show index)] diff --git a/src/References/List.hs b/src/References/List.hs new file mode 100644 --- /dev/null +++ b/src/References/List.hs @@ -0,0 +1,30 @@ +module References.List (listOf) where + +import Text.Pandoc.Definition +import Control.Monad.State +import Data.List +import qualified Data.Map as M + +import References.Types +import Util.Util +import Util.Options + +listOf :: Options -> [Block] -> WS [Block] +listOf Options{outFormat=Just f} x | isFormat "latex" f = return x +listOf opts (Para [RawInline (Format "tex") "\\listoffigures"]:xs) + = gets imgRefs >>= makeList (lofTitle opts) xs +listOf opts (Para [RawInline (Format "tex") "\\listoftables"]:xs) + = gets tblRefs >>= makeList (lotTitle opts) xs +listOf _ x = return x + +makeList :: [Block] -> [Block] -> M.Map String RefRec -> WS [Block] +makeList title xs refs + = return $ + title ++ + OrderedList style (item `map` refsSorted) + : xs + where + refsSorted = sortBy compare' $ M.toList refs + compare' (_,RefRec{refIndex=i}) (_,RefRec{refIndex=j}) = compare i j + item = (:[]) . Plain . refTitle . snd + style = (1,DefaultStyle,DefaultDelim) diff --git a/src/References/Refs.hs b/src/References/Refs.hs new file mode 100644 --- /dev/null +++ b/src/References/Refs.hs @@ -0,0 +1,115 @@ +module References.Refs (replaceRefs) where + +import Text.Pandoc.Definition +import Text.Pandoc.Shared (normalizeInlines) +import Control.Monad.State +import Data.List +import Data.Maybe +import Data.Function +import qualified Data.Map as M + +import Util.Accessor +import References.Types +import References.Accessors +import Util.Util +import Util.Options + +replaceRefs :: Options -> [Inline] -> WS [Inline] +replaceRefs opts (Cite cits _:xs) + | Just prefix <- allCitsPrefix cits + = (++ xs) `fmap` replaceRefs' prefix opts cits + where + replaceRefs' = case outFormat opts of + Just f | isFormat "latex" f -> replaceRefsLatex + _ -> replaceRefsOther +replaceRefs _ x = return x + +-- accessors to state variables +accMap :: M.Map String (Accessor References RefMap) +accMap = M.fromList [("fig:",imgRefs') + ,("eq:" ,eqnRefs') + ,("tbl:",tblRefs') + ] + +-- accessors to options +prefMap :: M.Map String (Options -> [Inline]) +prefMap = M.fromList [("fig:",figPrefix) + ,("eq:" ,eqnPrefix) + ,("tbl:",tblPrefix) + ] + +prefixes :: [String] +prefixes = M.keys accMap + +getRefPrefix :: Options -> String -> [Inline] +getRefPrefix opts prefix | null refprefix = [] + | otherwise = refprefix ++ [Space] + where refprefix = lookupUnsafe prefix prefMap opts + +lookupUnsafe :: Ord k => k -> M.Map k v -> v +lookupUnsafe = (fromMaybe undefined .) . M.lookup + +allCitsPrefix :: [Citation] -> Maybe String +allCitsPrefix cits = foldl f Nothing prefixes + where + f x@(Just _) _ = x + f _ p | all (isPrefixOf p . citationId) cits = Just p + f _ _ = Nothing + +replaceRefsLatex :: String -> Options -> [Citation] -> WS [Inline] +replaceRefsLatex prefix opts cits = + return $ p ++ [texcit] + where + texcit = + RawInline (Format "tex") $ + if useCleveref opts then + " \\cref{"++listLabels prefix "" "" cits++"}" + else + listLabels prefix " \\ref{" "}" cits + p | useCleveref opts = [] + | otherwise = getRefPrefix opts prefix + +listLabels :: String -> String -> String -> [Citation] -> String +listLabels prefix p s = foldl' joinStr "" . mapMaybe (getLabel prefix) + where + joinStr acc i | null acc = p++i++s + | otherwise = acc++","++p++i++s + +getLabel :: String -> Citation -> Maybe String +getLabel prefix Citation{citationId=cid} + | prefix `isPrefixOf` cid = Just cid + | otherwise = Nothing + +replaceRefsOther :: String -> Options -> [Citation] -> WS [Inline] +replaceRefsOther prefix opts cits = do + indices <- mapM (getRefIndex prefix) cits + let + indices' = groupBy ((==) `on` fmap fst) (sort indices) + return $ getRefPrefix opts prefix ++ normalizeInlines (concatMap (makeIndices opts) indices') + +getRefIndex :: String -> Citation -> WS (Maybe (Int, Int)) +getRefIndex prefix Citation{citationId=cid} + | prefix `isPrefixOf` cid + = gets (fmap refIndex . M.lookup cid . getProp prop) + | otherwise = return Nothing + where + prop = lookupUnsafe prefix accMap + +makeIndices :: Options -> [Maybe (Int,Int)] -> [Inline] +makeIndices _ s | any isNothing s = [Str "??"] +makeIndices o s = intercalate sep $ reverse $ map f $ foldl' f2 [] $ catMaybes s + where + f2 [] i = [[i]] + f2 ([]:xs) i = [i]:xs + f2 l@(x@((_,hx):_):xs) i@(_,ni) + | ni-hx == 0 = l -- remove duplicates + | ni-hx == 1 = (i:x):xs -- group sequental + | otherwise = [i]:l -- new group + f [] = [] -- drop empty lists + f [w] = show' w -- single value + f [w1,w2] = show' w2 ++ sep ++ show' w1 -- two values + f (x:xs) = show' (last xs) ++ rangeDelim o ++ show' x -- shorten more than two values + sep = [Str ", "] + show' (c,n) = if sepChapters o && c>0 + then [Str $ show c] ++ chapDelim o ++ [Str $ show n] + else [Str $ show n] diff --git a/src/References/Types.hs b/src/References/Types.hs new file mode 100644 --- /dev/null +++ b/src/References/Types.hs @@ -0,0 +1,28 @@ +module References.Types ( References(..) + , WS + , RefRec(..) + , RefMap + ) where + +import qualified Data.Map as M +import Text.Pandoc.Definition +import Control.Monad.State + +data RefRec = RefRec { refIndex :: (Int, Int) + , refTitle :: [Inline] + } + +type RefMap = M.Map String RefRec + +-- state data type +data References = References { imgRefs :: RefMap + , eqnRefs :: RefMap + , tblRefs :: RefMap + , curChap :: Int + , stMeta :: Meta + , stTmplV :: String -> Maybe MetaValue + , stDTV :: Meta + } + +--state monad +type WS a = State References a diff --git a/src/Util/Accessor.hs b/src/Util/Accessor.hs new file mode 100644 --- /dev/null +++ b/src/Util/Accessor.hs @@ -0,0 +1,17 @@ +module Util.Accessor (Accessor, setProp, getProp, modifyProp) where + +-- from data-accessor http://www.haskell.org/haskellwiki/Record_access +-- Copyright (c) Henning Thielemann , Luke Palmer +-- Licensed under BSD3 -- see BSD3.md +type Accessor r a = a -> r -> (a, r) + +setProp :: Accessor r a -> a -> r -> r +setProp f x = snd . f x + +getProp :: Accessor r a -> r -> a +getProp f = fst . f undefined + +modifyProp :: Accessor r a -> (a -> a) -> r -> r +modifyProp f g rOld = + let (a,rNew) = f (g a) rOld + in rNew diff --git a/src/Util/Default/Default.hs b/src/Util/Default/Default.hs new file mode 100644 --- /dev/null +++ b/src/Util/Default/Default.hs @@ -0,0 +1,22 @@ +module Util.Default.Default where + +import Text.Pandoc.Definition +import qualified Data.Map as M + +defaultMeta :: Meta +defaultMeta = Meta $ M.fromList + [ ("figureTitle" , MetaInlines [Str "Figure"]) + , ("tableTitle" , MetaInlines [Str "Table"]) + , ("titleDelim" , MetaInlines [Str ":"]) + , ("chapDelim" , MetaInlines [Str "."]) + , ("rangeDelim" , MetaInlines [Str "-"]) + , ("figPrefix" , MetaInlines [Str "fig."]) + , ("eqnPrefix" , MetaInlines [Str "eq."]) + , ("tblPrefix" , MetaInlines [Str "tbl."]) + , ("lofTitle" , MetaBlocks [Header 1 nullAttr [Str "List of Figures"]]) + , ("lotTitle" , MetaBlocks [Header 1 nullAttr [Str "List of Tables"]]) + , ("figureTemplate" , MetaInlines [var "figureTitle",Space,var "i",var "titleDelim",Space,var "t"]) + , ("tableTemplate" , MetaInlines [var "tableTitle",Space,var "i",var "titleDelim",Space,var "t"]) + , ("crossrefYaml" , MetaString "pandoc-crossref.yaml") + ] + where var = Math DisplayMath diff --git a/src/Util/Default/Settings.hs b/src/Util/Default/Settings.hs new file mode 100644 --- /dev/null +++ b/src/Util/Default/Settings.hs @@ -0,0 +1,14 @@ +module Util.Default.Settings where + +import Text.Pandoc +import Control.Exception (handle,IOException) + +import Util.Meta (getMetaString) + +getDefaultSettings :: Meta -> IO Meta +getDefaultSettings meta = do + let handler :: IOException -> IO String + handler _ = return [] + yaml <- handle handler $ readFile (getMetaString "crossrefYaml" meta nullMeta) + let Pandoc dtve _ = readMarkdown def ("---\n" ++ yaml ++ "\n---") + return dtve diff --git a/src/Util/Meta.hs b/src/Util/Meta.hs new file mode 100644 --- /dev/null +++ b/src/Util/Meta.hs @@ -0,0 +1,45 @@ +module Util.Meta where + +import Text.Pandoc (readMarkdown,def) +import Text.Pandoc.Shared (stringify) +import Text.Pandoc.Definition +import Data.Maybe (fromMaybe) +import Util.Util (lookupDefault) + +getMetaBool :: String -> Meta -> Meta -> Bool +getMetaBool name meta defaults = fromMaybe False $ lookupDefault name meta defaults >>= toBool + +getMetaInlines :: String -> Meta -> Meta -> [Inline] +getMetaInlines name meta defaults = fromMaybe [] $ lookupDefault name meta defaults >>= toInlines + +getMetaBlock :: String -> Meta -> Meta -> [Block] +getMetaBlock name meta defaults = fromMaybe [] $ lookupDefault name meta defaults >>= toBlocks + +getMetaString :: String -> Meta -> Meta -> String +getMetaString name meta defaults = fromMaybe [] $ lookupDefault name meta defaults >>= toString + +toInlines :: MetaValue -> Maybe [Inline] +toInlines (MetaString s) = return $ getInlines $ readMarkdown def s + where getInlines (Pandoc _ bs) = concatMap getInline bs + getInline (Plain ils) = ils + getInline (Para ils) = ils + getInline _ = [] +toInlines (MetaInlines s) = return s +toInlines _ = Nothing + +toBool :: MetaValue -> Maybe Bool +toBool (MetaBool b) = return b +toBool _ = Nothing + +toBlocks :: MetaValue -> Maybe [Block] +toBlocks (MetaBlocks bs) = return bs +toBlocks (MetaInlines ils) = return [Plain ils] +toBlocks (MetaString s) = return $ getBlocks $ readMarkdown def s + where getBlocks (Pandoc _ bs) = bs +toBlocks _ = Nothing + +toString :: MetaValue -> Maybe String +toString (MetaString s) = Just s +toString (MetaBlocks b) = Just $ stringify b +toString (MetaInlines i) = Just $ stringify i +toString _ = Nothing diff --git a/src/Util/Options.hs b/src/Util/Options.hs new file mode 100644 --- /dev/null +++ b/src/Util/Options.hs @@ -0,0 +1,37 @@ +module Util.Options where + +import Text.Pandoc.Definition +import References.Types +import Util.Meta +import Util.Template + +data Options = Options { useCleveref :: Bool + , sepChapters :: Bool + , figPrefix :: [Inline] + , eqnPrefix :: [Inline] + , tblPrefix :: [Inline] + , chapDelim :: [Inline] + , rangeDelim :: [Inline] + , lofTitle :: [Block] + , lotTitle :: [Block] + , outFormat :: Maybe Format + , figureTemplate :: WS [Inline] + , tableTemplate :: WS [Inline] + } + +getOptions :: Meta -> Meta -> Maybe Format -> Options +getOptions meta dtv fmt = + Options { + useCleveref = getMetaBool "cref" meta dtv + , sepChapters = getMetaBool "chapters" meta dtv + , figPrefix = getMetaInlines "figPrefix" meta dtv + , eqnPrefix = getMetaInlines "eqnPrefix" meta dtv + , tblPrefix = getMetaInlines "tblPrefix" meta dtv + , chapDelim = getMetaInlines "chapDelim" meta dtv + , rangeDelim = getMetaInlines "rangeDelim" meta dtv + , lofTitle = getMetaBlock "lofTitle" meta dtv + , lotTitle = getMetaBlock "lotTitle" meta dtv + , outFormat = fmt + , figureTemplate = replaceTemplate $ getMetaInlines "figureTemplate" meta dtv + , tableTemplate = replaceTemplate $ getMetaInlines "tableTemplate" meta dtv + } diff --git a/src/Util/Template.hs b/src/Util/Template.hs new file mode 100644 --- /dev/null +++ b/src/Util/Template.hs @@ -0,0 +1,38 @@ +module Util.Template where + +import Text.Pandoc.Definition +import Text.Pandoc.Generic +import References.Types + +import Control.Monad.State +import Data.Maybe +import Util.Util +import Util.Meta + +replaceTemplate :: [Inline] -> WS [Inline] +replaceTemplate = bottomUpM replace + where + replace (x@(Math DisplayMath var):xs) = (++xs) `fmap` getTemplateMetaVar var [x] + replace x = return x + +getTemplateMetaVar :: String -> [Inline] -> WS [Inline] +getTemplateMetaVar var def' = do + meta <- gets stMeta + tmplv <- gets stTmplV + dtv <- gets stDTV + return + $ fromMaybe def' + $ (tmplv var `mplus` lookupDefault var meta dtv) >>= toInlines + +applyTemplate :: [Inline] -> [Inline] -> [Inline] -> WS [Inline] +applyTemplate i t tmpl = withTmplV internalVars $ replaceTemplate tmpl + where + withTmplV :: (String -> Maybe MetaValue) -> WS [Inline] -> WS [Inline] + withTmplV f g = do + modify $ \s -> s{stTmplV=f} + res <- g + modify $ \s -> s{stTmplV=const Nothing} + return res + internalVars "i" = Just $ MetaInlines i + internalVars "t" = Just $ MetaInlines t + internalVars _ = Nothing diff --git a/src/Util/Util.hs b/src/Util/Util.hs new file mode 100644 --- /dev/null +++ b/src/Util/Util.hs @@ -0,0 +1,13 @@ +module Util.Util where + +import Text.Pandoc.Definition +import Control.Monad (mplus) +import Util.Default.Default +import Data.Monoid + +lookupDefault :: String -> Meta -> Meta -> Maybe MetaValue +lookupDefault name meta defMap = + lookupMeta name meta `mplus` lookupMeta name (defMap `mappend` defaultMeta) + +isFormat :: String -> Format -> Bool +isFormat fmt (Format f) = takeWhile (`notElem` "+-") f == fmt diff --git a/test-pandoc-crossref.hs b/test-pandoc-crossref.hs new file mode 100644 --- /dev/null +++ b/test-pandoc-crossref.hs @@ -0,0 +1,18 @@ +import Test.Hspec +import Text.Pandoc +import System.Process +-- import Control.Exception (evaluate) + +main :: IO () +main = do + native <- read `fmap` readFile "demo.native" :: IO [Block] + parsed <- read `fmap` readProcess "cabal" [ + "exec", "--", "pandoc" + , "-F", "pandoc-crossref.hs" + , "-i", "demo.md" + , "-t", "native"] + "" + hspec $ + describe "pandoc-crossref.hs" $ + it "formats demo.md as demo.native" $ + parsed `shouldBe` native