packages feed

haskell-formatter (empty) → 0.1.0

raw patch · 43 files changed

+3082/−0 lines, 43 filesdep +basedep +containersdep +directorysetup-changed

Dependencies added: base, containers, directory, directory-tree, doctest, filemanip, filepath, haskell-formatter, haskell-src-exts, hlint, optparse-applicative, scientific, tasty, tasty-hunit, text, unordered-containers, yaml

Files

+ .gitignore view
@@ -0,0 +1,2 @@+dist+README.xhtml
+ HLint.hs view
@@ -0,0 +1,3 @@+import "hint" HLint.Default+import "hint" HLint.Dollar+import "hint" HLint.Generalise
+ LICENSE view
@@ -0,0 +1,674 @@+                    GNU GENERAL PUBLIC LICENSE+                       Version 3, 29 June 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++                            Preamble++  The GNU General Public License is a free, copyleft license for+software and other kinds of works.++  The licenses for most software and other practical works are designed+to take away your freedom to share and change the works.  By contrast,+the GNU General Public License is intended to guarantee your freedom to+share and change all versions of a program--to make sure it remains free+software for all its users.  We, the Free Software Foundation, use the+GNU General Public License for most of our software; it applies also to+any other work released this way by its authors.  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+them 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 prevent others from denying you+these rights or asking you to surrender the rights.  Therefore, you have+certain responsibilities if you distribute copies of the software, or if+you modify it: responsibilities to respect the freedom of others.++  For example, if you distribute copies of such a program, whether+gratis or for a fee, you must pass on to the recipients the same+freedoms that you received.  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.++  Developers that use the GNU GPL protect your rights with two steps:+(1) assert copyright on the software, and (2) offer you this License+giving you legal permission to copy, distribute and/or modify it.++  For the developers' and authors' protection, the GPL clearly explains+that there is no warranty for this free software.  For both users' and+authors' sake, the GPL requires that modified versions be marked as+changed, so that their problems will not be attributed erroneously to+authors of previous versions.++  Some devices are designed to deny users access to install or run+modified versions of the software inside them, although the manufacturer+can do so.  This is fundamentally incompatible with the aim of+protecting users' freedom to change the software.  The systematic+pattern of such abuse occurs in the area of products for individuals to+use, which is precisely where it is most unacceptable.  Therefore, we+have designed this version of the GPL to prohibit the practice for those+products.  If such problems arise substantially in other domains, we+stand ready to extend this provision to those domains in future versions+of the GPL, as needed to protect the freedom of users.++  Finally, every program is threatened constantly by software patents.+States should not allow patents to restrict development and use of+software on general-purpose computers, but in those that do, we wish to+avoid the special danger that patents applied to a free program could+make it effectively proprietary.  To prevent this, the GPL assures that+patents cannot be used to render the program non-free.++  The precise terms and conditions for copying, distribution and+modification follow.++                       TERMS AND CONDITIONS++  0. Definitions.++  "This License" refers to version 3 of the GNU General Public License.++  "Copyright" also means copyright-like laws that apply to other kinds of+works, such as semiconductor masks.++  "The Program" refers to any copyrightable work licensed under this+License.  Each licensee is addressed as "you".  "Licensees" and+"recipients" may be individuals or organizations.++  To "modify" a work means to copy from or adapt all or part of the work+in a fashion requiring copyright permission, other than the making of an+exact copy.  The resulting work is called a "modified version" of the+earlier work or a work "based on" the earlier work.++  A "covered work" means either the unmodified Program or a work based+on the Program.++  To "propagate" a work means to do anything with it that, without+permission, would make you directly or secondarily liable for+infringement under applicable copyright law, except executing it on a+computer or modifying a private copy.  Propagation includes copying,+distribution (with or without modification), making available to the+public, and in some countries other activities as well.++  To "convey" a work means any kind of propagation that enables other+parties to make or receive copies.  Mere interaction with a user through+a computer network, with no transfer of a copy, is not conveying.++  An interactive user interface displays "Appropriate Legal Notices"+to the extent that it includes a convenient and prominently visible+feature that (1) displays an appropriate copyright notice, and (2)+tells the user that there is no warranty for the work (except to the+extent that warranties are provided), that licensees may convey the+work under this License, and how to view a copy of this License.  If+the interface presents a list of user commands or options, such as a+menu, a prominent item in the list meets this criterion.++  1. Source Code.++  The "source code" for a work means the preferred form of the work+for making modifications to it.  "Object code" means any non-source+form of a work.++  A "Standard Interface" means an interface that either is an official+standard defined by a recognized standards body, or, in the case of+interfaces specified for a particular programming language, one that+is widely used among developers working in that language.++  The "System Libraries" of an executable work include anything, other+than the work as a whole, that (a) is included in the normal form of+packaging a Major Component, but which is not part of that Major+Component, and (b) serves only to enable use of the work with that+Major Component, or to implement a Standard Interface for which an+implementation is available to the public in source code form.  A+"Major Component", in this context, means a major essential component+(kernel, window system, and so on) of the specific operating system+(if any) on which the executable work runs, or a compiler used to+produce the work, or an object code interpreter used to run it.++  The "Corresponding Source" for a work in object code form means all+the source code needed to generate, install, and (for an executable+work) run the object code and to modify the work, including scripts to+control those activities.  However, it does not include the work's+System Libraries, or general-purpose tools or generally available free+programs which are used unmodified in performing those activities but+which are not part of the work.  For example, Corresponding Source+includes interface definition files associated with source files for+the work, and the source code for shared libraries and dynamically+linked subprograms that the work is specifically designed to require,+such as by intimate data communication or control flow between those+subprograms and other parts of the work.++  The Corresponding Source need not include anything that users+can regenerate automatically from other parts of the Corresponding+Source.++  The Corresponding Source for a work in source code form is that+same work.++  2. Basic Permissions.++  All rights granted under this License are granted for the term of+copyright on the Program, and are irrevocable provided the stated+conditions are met.  This License explicitly affirms your unlimited+permission to run the unmodified Program.  The output from running a+covered work is covered by this License only if the output, given its+content, constitutes a covered work.  This License acknowledges your+rights of fair use or other equivalent, as provided by copyright law.++  You may make, run and propagate covered works that you do not+convey, without conditions so long as your license otherwise remains+in force.  You may convey covered works to others for the sole purpose+of having them make modifications exclusively for you, or provide you+with facilities for running those works, provided that you comply with+the terms of this License in conveying all material for which you do+not control copyright.  Those thus making or running the covered works+for you must do so exclusively on your behalf, under your direction+and control, on terms that prohibit them from making any copies of+your copyrighted material outside their relationship with you.++  Conveying under any other circumstances is permitted solely under+the conditions stated below.  Sublicensing is not allowed; section 10+makes it unnecessary.++  3. Protecting Users' Legal Rights From Anti-Circumvention Law.++  No covered work shall be deemed part of an effective technological+measure under any applicable law fulfilling obligations under article+11 of the WIPO copyright treaty adopted on 20 December 1996, or+similar laws prohibiting or restricting circumvention of such+measures.++  When you convey a covered work, you waive any legal power to forbid+circumvention of technological measures to the extent such circumvention+is effected by exercising rights under this License with respect to+the covered work, and you disclaim any intention to limit operation or+modification of the work as a means of enforcing, against the work's+users, your or third parties' legal rights to forbid circumvention of+technological measures.++  4. Conveying Verbatim Copies.++  You may convey 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;+keep intact all notices stating that this License and any+non-permissive terms added in accord with section 7 apply to the code;+keep intact all notices of the absence of any warranty; and give all+recipients a copy of this License along with the Program.++  You may charge any price or no price for each copy that you convey,+and you may offer support or warranty protection for a fee.++  5. Conveying Modified Source Versions.++  You may convey a work based on the Program, or the modifications to+produce it from the Program, in the form of source code under the+terms of section 4, provided that you also meet all of these conditions:++    a) The work must carry prominent notices stating that you modified+    it, and giving a relevant date.++    b) The work must carry prominent notices stating that it is+    released under this License and any conditions added under section+    7.  This requirement modifies the requirement in section 4 to+    "keep intact all notices".++    c) You must license the entire work, as a whole, under this+    License to anyone who comes into possession of a copy.  This+    License will therefore apply, along with any applicable section 7+    additional terms, to the whole of the work, and all its parts,+    regardless of how they are packaged.  This License gives no+    permission to license the work in any other way, but it does not+    invalidate such permission if you have separately received it.++    d) If the work has interactive user interfaces, each must display+    Appropriate Legal Notices; however, if the Program has interactive+    interfaces that do not display Appropriate Legal Notices, your+    work need not make them do so.++  A compilation of a covered work with other separate and independent+works, which are not by their nature extensions of the covered work,+and which are not combined with it such as to form a larger program,+in or on a volume of a storage or distribution medium, is called an+"aggregate" if the compilation and its resulting copyright are not+used to limit the access or legal rights of the compilation's users+beyond what the individual works permit.  Inclusion of a covered work+in an aggregate does not cause this License to apply to the other+parts of the aggregate.++  6. Conveying Non-Source Forms.++  You may convey a covered work in object code form under the terms+of sections 4 and 5, provided that you also convey the+machine-readable Corresponding Source under the terms of this License,+in one of these ways:++    a) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by the+    Corresponding Source fixed on a durable physical medium+    customarily used for software interchange.++    b) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by a+    written offer, valid for at least three years and valid for as+    long as you offer spare parts or customer support for that product+    model, to give anyone who possesses the object code either (1) a+    copy of the Corresponding Source for all the software in the+    product that is covered by this License, on a durable physical+    medium customarily used for software interchange, for a price no+    more than your reasonable cost of physically performing this+    conveying of source, or (2) access to copy the+    Corresponding Source from a network server at no charge.++    c) Convey individual copies of the object code with a copy of the+    written offer to provide the Corresponding Source.  This+    alternative is allowed only occasionally and noncommercially, and+    only if you received the object code with such an offer, in accord+    with subsection 6b.++    d) Convey the object code by offering access from a designated+    place (gratis or for a charge), and offer equivalent access to the+    Corresponding Source in the same way through the same place at no+    further charge.  You need not require recipients to copy the+    Corresponding Source along with the object code.  If the place to+    copy the object code is a network server, the Corresponding Source+    may be on a different server (operated by you or a third party)+    that supports equivalent copying facilities, provided you maintain+    clear directions next to the object code saying where to find the+    Corresponding Source.  Regardless of what server hosts the+    Corresponding Source, you remain obligated to ensure that it is+    available for as long as needed to satisfy these requirements.++    e) Convey the object code using peer-to-peer transmission, provided+    you inform other peers where the object code and Corresponding+    Source of the work are being offered to the general public at no+    charge under subsection 6d.++  A separable portion of the object code, whose source code is excluded+from the Corresponding Source as a System Library, need not be+included in conveying the object code work.++  A "User Product" is either (1) a "consumer product", which means any+tangible personal property which is normally used for personal, family,+or household purposes, or (2) anything designed or sold for incorporation+into a dwelling.  In determining whether a product is a consumer product,+doubtful cases shall be resolved in favor of coverage.  For a particular+product received by a particular user, "normally used" refers to a+typical or common use of that class of product, regardless of the status+of the particular user or of the way in which the particular user+actually uses, or expects or is expected to use, the product.  A product+is a consumer product regardless of whether the product has substantial+commercial, industrial or non-consumer uses, unless such uses represent+the only significant mode of use of the product.++  "Installation Information" for a User Product means any methods,+procedures, authorization keys, or other information required to install+and execute modified versions of a covered work in that User Product from+a modified version of its Corresponding Source.  The information must+suffice to ensure that the continued functioning of the modified object+code is in no case prevented or interfered with solely because+modification has been made.++  If you convey an object code work under this section in, or with, or+specifically for use in, a User Product, and the conveying occurs as+part of a transaction in which the right of possession and use of the+User Product is transferred to the recipient in perpetuity or for a+fixed term (regardless of how the transaction is characterized), the+Corresponding Source conveyed under this section must be accompanied+by the Installation Information.  But this requirement does not apply+if neither you nor any third party retains the ability to install+modified object code on the User Product (for example, the work has+been installed in ROM).++  The requirement to provide Installation Information does not include a+requirement to continue to provide support service, warranty, or updates+for a work that has been modified or installed by the recipient, or for+the User Product in which it has been modified or installed.  Access to a+network may be denied when the modification itself materially and+adversely affects the operation of the network or violates the rules and+protocols for communication across the network.++  Corresponding Source conveyed, and Installation Information provided,+in accord with this section must be in a format that is publicly+documented (and with an implementation available to the public in+source code form), and must require no special password or key for+unpacking, reading or copying.++  7. Additional Terms.++  "Additional permissions" are terms that supplement the terms of this+License by making exceptions from one or more of its conditions.+Additional permissions that are applicable to the entire Program shall+be treated as though they were included in this License, to the extent+that they are valid under applicable law.  If additional permissions+apply only to part of the Program, that part may be used separately+under those permissions, but the entire Program remains governed by+this License without regard to the additional permissions.++  When you convey a copy of a covered work, you may at your option+remove any additional permissions from that copy, or from any part of+it.  (Additional permissions may be written to require their own+removal in certain cases when you modify the work.)  You may place+additional permissions on material, added by you to a covered work,+for which you have or can give appropriate copyright permission.++  Notwithstanding any other provision of this License, for material you+add to a covered work, you may (if authorized by the copyright holders of+that material) supplement the terms of this License with terms:++    a) Disclaiming warranty or limiting liability differently from the+    terms of sections 15 and 16 of this License; or++    b) Requiring preservation of specified reasonable legal notices or+    author attributions in that material or in the Appropriate Legal+    Notices displayed by works containing it; or++    c) Prohibiting misrepresentation of the origin of that material, or+    requiring that modified versions of such material be marked in+    reasonable ways as different from the original version; or++    d) Limiting the use for publicity purposes of names of licensors or+    authors of the material; or++    e) Declining to grant rights under trademark law for use of some+    trade names, trademarks, or service marks; or++    f) Requiring indemnification of licensors and authors of that+    material by anyone who conveys the material (or modified versions of+    it) with contractual assumptions of liability to the recipient, for+    any liability that these contractual assumptions directly impose on+    those licensors and authors.++  All other non-permissive additional terms are considered "further+restrictions" within the meaning of section 10.  If the Program as you+received it, or any part of it, contains a notice stating that it is+governed by this License along with a term that is a further+restriction, you may remove that term.  If a license document contains+a further restriction but permits relicensing or conveying under this+License, you may add to a covered work material governed by the terms+of that license document, provided that the further restriction does+not survive such relicensing or conveying.++  If you add terms to a covered work in accord with this section, you+must place, in the relevant source files, a statement of the+additional terms that apply to those files, or a notice indicating+where to find the applicable terms.++  Additional terms, permissive or non-permissive, may be stated in the+form of a separately written license, or stated as exceptions;+the above requirements apply either way.++  8. Termination.++  You may not propagate or modify a covered work except as expressly+provided under this License.  Any attempt otherwise to propagate or+modify it is void, and will automatically terminate your rights under+this License (including any patent licenses granted under the third+paragraph of section 11).++  However, if you cease all violation of this License, then your+license from a particular copyright holder is reinstated (a)+provisionally, unless and until the copyright holder explicitly and+finally terminates your license, and (b) permanently, if the copyright+holder fails to notify you of the violation by some reasonable means+prior to 60 days after the cessation.++  Moreover, your license from a particular copyright holder is+reinstated permanently if the copyright holder notifies you of the+violation by some reasonable means, this is the first time you have+received notice of violation of this License (for any work) from that+copyright holder, and you cure the violation prior to 30 days after+your receipt of the notice.++  Termination of your rights under this section does not terminate the+licenses of parties who have received copies or rights from you under+this License.  If your rights have been terminated and not permanently+reinstated, you do not qualify to receive new licenses for the same+material under section 10.++  9. Acceptance Not Required for Having Copies.++  You are not required to accept this License in order to receive or+run a copy of the Program.  Ancillary propagation of a covered work+occurring solely as a consequence of using peer-to-peer transmission+to receive a copy likewise does not require acceptance.  However,+nothing other than this License grants you permission to propagate or+modify any covered work.  These actions infringe copyright if you do+not accept this License.  Therefore, by modifying or propagating a+covered work, you indicate your acceptance of this License to do so.++  10. Automatic Licensing of Downstream Recipients.++  Each time you convey a covered work, the recipient automatically+receives a license from the original licensors, to run, modify and+propagate that work, subject to this License.  You are not responsible+for enforcing compliance by third parties with this License.++  An "entity transaction" is a transaction transferring control of an+organization, or substantially all assets of one, or subdividing an+organization, or merging organizations.  If propagation of a covered+work results from an entity transaction, each party to that+transaction who receives a copy of the work also receives whatever+licenses to the work the party's predecessor in interest had or could+give under the previous paragraph, plus a right to possession of the+Corresponding Source of the work from the predecessor in interest, if+the predecessor has it or can get it with reasonable efforts.++  You may not impose any further restrictions on the exercise of the+rights granted or affirmed under this License.  For example, you may+not impose a license fee, royalty, or other charge for exercise of+rights granted under this License, and you may not initiate litigation+(including a cross-claim or counterclaim in a lawsuit) alleging that+any patent claim is infringed by making, using, selling, offering for+sale, or importing the Program or any portion of it.++  11. Patents.++  A "contributor" is a copyright holder who authorizes use under this+License of the Program or a work on which the Program is based.  The+work thus licensed is called the contributor's "contributor version".++  A contributor's "essential patent claims" are all patent claims+owned or controlled by the contributor, whether already acquired or+hereafter acquired, that would be infringed by some manner, permitted+by this License, of making, using, or selling its contributor version,+but do not include claims that would be infringed only as a+consequence of further modification of the contributor version.  For+purposes of this definition, "control" includes the right to grant+patent sublicenses in a manner consistent with the requirements of+this License.++  Each contributor grants you a non-exclusive, worldwide, royalty-free+patent license under the contributor's essential patent claims, to+make, use, sell, offer for sale, import and otherwise run, modify and+propagate the contents of its contributor version.++  In the following three paragraphs, a "patent license" is any express+agreement or commitment, however denominated, not to enforce a patent+(such as an express permission to practice a patent or covenant not to+sue for patent infringement).  To "grant" such a patent license to a+party means to make such an agreement or commitment not to enforce a+patent against the party.++  If you convey a covered work, knowingly relying on a patent license,+and the Corresponding Source of the work is not available for anyone+to copy, free of charge and under the terms of this License, through a+publicly available network server or other readily accessible means,+then you must either (1) cause the Corresponding Source to be so+available, or (2) arrange to deprive yourself of the benefit of the+patent license for this particular work, or (3) arrange, in a manner+consistent with the requirements of this License, to extend the patent+license to downstream recipients.  "Knowingly relying" means you have+actual knowledge that, but for the patent license, your conveying the+covered work in a country, or your recipient's use of the covered work+in a country, would infringe one or more identifiable patents in that+country that you have reason to believe are valid.++  If, pursuant to or in connection with a single transaction or+arrangement, you convey, or propagate by procuring conveyance of, a+covered work, and grant a patent license to some of the parties+receiving the covered work authorizing them to use, propagate, modify+or convey a specific copy of the covered work, then the patent license+you grant is automatically extended to all recipients of the covered+work and works based on it.++  A patent license is "discriminatory" if it does not include within+the scope of its coverage, prohibits the exercise of, or is+conditioned on the non-exercise of one or more of the rights that are+specifically granted under this License.  You may not convey a covered+work if you are a party to an arrangement with a third party that is+in the business of distributing software, under which you make payment+to the third party based on the extent of your activity of conveying+the work, and under which the third party grants, to any of the+parties who would receive the covered work from you, a discriminatory+patent license (a) in connection with copies of the covered work+conveyed by you (or copies made from those copies), or (b) primarily+for and in connection with specific products or compilations that+contain the covered work, unless you entered into that arrangement,+or that patent license was granted, prior to 28 March 2007.++  Nothing in this License shall be construed as excluding or limiting+any implied license or other defenses to infringement that may+otherwise be available to you under applicable patent law.++  12. No Surrender of Others' Freedom.++  If 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 convey a+covered work so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you may+not convey it at all.  For example, if you agree to terms that obligate you+to collect a royalty for further conveying from those to whom you convey+the Program, the only way you could satisfy both those terms and this+License would be to refrain entirely from conveying the Program.++  13. Use with the GNU Affero General Public License.++  Notwithstanding any other provision of this License, you have+permission to link or combine any covered work with a work licensed+under version 3 of the GNU Affero General Public License into a single+combined work, and to convey the resulting work.  The terms of this+License will continue to apply to the part which is the covered work,+but the special requirements of the GNU Affero General Public License,+section 13, concerning interaction through a network will apply to the+combination as such.++  14. Revised Versions of this License.++  The Free Software Foundation may publish revised and/or new versions of+the GNU 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 that a certain numbered version of the GNU General+Public License "or any later version" applies to it, you have the+option of following the terms and conditions either of that numbered+version or of any later version published by the Free Software+Foundation.  If the Program does not specify a version number of the+GNU General Public License, you may choose any version ever published+by the Free Software Foundation.++  If the Program specifies that a proxy can decide which future+versions of the GNU General Public License can be used, that proxy's+public statement of acceptance of a version permanently authorizes you+to choose that version for the Program.++  Later license versions may give you additional or different+permissions.  However, no additional obligations are imposed on any+author or copyright holder as a result of your choosing to follow a+later version.++  15. Disclaimer of Warranty.++  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.++  16. Limitation of Liability.++  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS+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.++  17. Interpretation of Sections 15 and 16.++  If the disclaimer of warranty and limitation of liability provided+above cannot be given local legal effect according to their terms,+reviewing courts shall apply local law that most closely approximates+an absolute waiver of all civil liability in connection with the+Program, unless a warranty or assumption of liability accompanies a+copy of the Program in return for a fee.++                     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+state the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++    <one line to give the program's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    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 3 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, see <http://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++  If the program does terminal interaction, make it output a short+notice like this when it starts in an interactive mode:++    <program>  Copyright (C) <year>  <name of author>+    This program 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, your program's commands+might be different; for a GUI interface, you would use an "about box".++  You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU GPL, see+<http://www.gnu.org/licenses/>.++  The GNU 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.  But first, please read+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+ Makefile view
@@ -0,0 +1,22 @@+FORMATTED_FILES = Setup.hs src testsuite/src+FORMATTER_UTILITY = dist/build/haskell-formatter/haskell-formatter+FORMATTER_ARGUMENTS = --force --input {} --output {}+GENERATED_FILES = dist README.xhtml++all:+	cabal configure --enable-tests+	cabal build++	cabal test++	cabal haddock --internal+	rst2html --strict README.rst README.xhtml++#	Use "xargs" instead of "-exec", since+#	1. the call should fail if any "-exec" fails and+#	2. the behavior of multiple "{}" is undefined for a standard "find".+	find $(FORMATTED_FILES) -type f -name '*.hs' -print0 | \+		xargs -n 1 -0 -I {} $(FORMATTER_UTILITY) $(FORMATTER_ARGUMENTS)++clean:+	rm -fr $(GENERATED_FILES)
+ README.rst view
@@ -0,0 +1,93 @@+=================+Haskell Formatter+=================++Introduction+============++The Haskell Formatter formats Haskell source code. It is strict in that it fundamentally rearranges code.++Installation+============++::++    $ cabal install haskell-formatter++Usage+=====++Basics+------++For example, source code is read from ``Input.hs``, formatted, and written to ``Output.hs`` by++::++    $ haskell-formatter --input Input.hs --output Output.hs++If the input or output file is not given, it defaults to the corresponding standard stream.++For more help about the usage, call++::++    $ haskell-formatter --help++Style Configuration+-------------------++The formatting style can be configured with a file referred by the ``--style`` option. For instance, the call++::++    $ haskell-formatter --style my_style.yaml --input Input.hs --output Output.hs++uses ``my_style.yaml`` as a style file. Such a file generally follows the `YAML format <http://en.wikipedia.org/wiki/YAML>`_. The following is an `example style file <testsuite/resources/examples/default_style.yaml>`_, which at the same time shows the available keys with their default values.++.. GitHub does currently not allow to include files with the reStructuredText directive ``include`` (https://github.com/github/markup/issues/172).++   Thus, the file content is replicated here. There is a test which checks that the strings of both sources are equal.++.. code:: yaml++    # Lines should be no longer than this length in characters.+    line_length_limit: 80+    +    # How much to spread code over multiple lines instead of trying to fill a single+    # line. More precisely, this guides the ratio of "line_length_limit" to the+    # ribbon length (the number of characters on a line without leading and trailing+    # whitespace). Only the lowest value of 1 forces "line_length_limit" to be+    # applied strictly.+    # Reference: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.38.8777+    ribbons_per_line: 1+    +    # Indentation lengths in characters.+    indentations:+        class: 8     # "class" and "instance" declarations.+        do: 3        # "do" notation. +        case: 4      # Body of "case" expressions.+        let: 4       # Declarations in "let" expressions.+        where: 6     # Declarations in "where" clauses.+        onside: 2    # Continuation lines which would otherwise be offside.+    +    # Decides which parts of the code to sort.+    order:+        # Sequence of import declarations.+        import_declarations: true+    +        # Entities of import lists.+        import_entities: true++Related Projects+================++The following interesting projects aim at formatting Haskell code, too.++* `hindent <https://github.com/chrisdone/hindent>`_+* `stylish-haskell <https://github.com/jaspervdj/stylish-haskell>`_++License+=======++See the `LICENSE file <LICENSE>`_.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ haskell-formatter.cabal view
@@ -0,0 +1,121 @@+name:                  haskell-formatter+version:               0.1.0+synopsis:              Haskell source code formatter+homepage:              https://github.com/evolutics/haskell-formatter+bug-reports:           https://github.com/evolutics/haskell-formatter/issues+license:               GPL-3+license-file:          LICENSE+author:                Benjamin Fischer+maintainer:            Benjamin Fischer <benjamin.fischer@evolutics.info>+copyright:             (C) 2014 Benjamin Fischer+category:              Development+build-type:            Simple+cabal-version:         >= 1.8++description:+  The Haskell Formatter formats Haskell source code. It is strict in that it+  fundamentally rearranges code.++extra-source-files:+  .gitignore+  HLint.hs+  Makefile+  README.rst+  testsuite/resources/examples/default_style.yaml++extra-tmp-files:+  README.xhtml++library+  exposed-modules:+    Language.Haskell.Formatter,+    Language.Haskell.Formatter.Internal.MapTree,+    Language.Haskell.Formatter.Internal.Newline,+    Language.Haskell.Formatter.Internal.StyleFileFormat,+    Language.Haskell.Formatter.Internal.TreeFormat++  other-modules:+    Language.Haskell.Formatter.CommentCore,+    Language.Haskell.Formatter.Configuration,+    Language.Haskell.Formatter.Error,+    Language.Haskell.Formatter.ExactCode,+    Language.Haskell.Formatter.Location,+    Language.Haskell.Formatter.Main,+    Language.Haskell.Formatter.Process.AttachComments,+    Language.Haskell.Formatter.Process.Code,+    Language.Haskell.Formatter.Process.CodeOrdering,+    Language.Haskell.Formatter.Process.Control,+    Language.Haskell.Formatter.Process.DetachComments,+    Language.Haskell.Formatter.Process.FormatActualCode,+    Language.Haskell.Formatter.Process.FormatComments,+    Language.Haskell.Formatter.Process.Formatter,+    Language.Haskell.Formatter.Process.LineShifting,+    Language.Haskell.Formatter.Process.Note,+    Language.Haskell.Formatter.Result,+    Language.Haskell.Formatter.Source,+    Language.Haskell.Formatter.Style,+    Language.Haskell.Formatter.Toolkit.ListTool,+    Language.Haskell.Formatter.Toolkit.Splitter,+    Language.Haskell.Formatter.Toolkit.StreamName,+    Language.Haskell.Formatter.Toolkit.Visit++  build-depends:+    base == 4.6.*,+    containers == 0.5.*,+    haskell-src-exts == 1.15.*,+    scientific == 0.3.*,+    text == 1.1.*,+    unordered-containers == 0.2.*,+    yaml == 0.8.*++  hs-source-dirs:+    src/library++  ghc-options:         -Wall++executable haskell-formatter+  main-is:             Main.hs++  build-depends:+    base == 4.6.*,+    directory == 1.2.*,+    filepath == 1.3.*,+    haskell-formatter,+    optparse-applicative == 0.10.*++  hs-source-dirs:+    src/executable++  ghc-options:         -Wall++test-suite test+  type:                exitcode-stdio-1.0+  main-is:             Main.hs++  other-modules:+    Language.Haskell.Formatter.Internal.Tests,+    Language.Haskell.Formatter.Tests,+    Language.Haskell.Formatter.Toolkit.FileTesting,+    Language.Haskell.Formatter.Toolkit.FileTree,+    Language.Haskell.Formatter.Toolkit.TestTool++  build-depends:+    base == 4.6.*,+    containers == 0.5.*,+    directory-tree == 0.12.*,+    doctest == 0.9.*,+    filemanip == 0.3.*,+    filepath == 1.3.*,+    haskell-formatter,+    hlint == 1.9.*,+    tasty == 0.9.*,+    tasty-hunit == 0.9.*++  hs-source-dirs:+    testsuite/src++  ghc-options:         -Wall++source-repository head+  type:                git+  location:            https://github.com/evolutics/haskell-formatter.git
+ src/executable/Main.hs view
@@ -0,0 +1,192 @@+{-|+Description : Root of executable+-}+module Main (main) where+import qualified Data.Foldable as Foldable+import qualified Data.Function as Function+import qualified Data.List as List+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter as Formatter+import qualified Language.Haskell.Formatter.Internal.Newline as Newline+import qualified Language.Haskell.Formatter.Internal.StyleFileFormat+       as StyleFileFormat+import qualified Language.Haskell.Formatter.Internal.TreeFormat as TreeFormat+import qualified Options.Applicative as Applicative+import qualified System.Directory as Directory+import qualified System.Exit as Exit+import qualified System.FilePath as FilePath+import qualified System.IO as IO++data Arguments = Arguments{input :: Maybe FilePath, output :: Maybe FilePath,+                           force :: Bool, styleFile :: Maybe FilePath}+               deriving (Eq, Ord, Show)++main :: IO ()+main+  = do arguments <- Applicative.execParser utilityUsage+       maybeError <- formatWithUncheckedArguments arguments+       Foldable.mapM_ exitWithError maybeError+  where exitWithError errorMessage+          = putErrorLine errorMessage >> Exit.exitFailure+        putErrorLine = IO.hPutStrLn IO.stderr++utilityUsage :: Applicative.ParserInfo Arguments+utilityUsage = Applicative.info parserWithHelp modifier+  where parserWithHelp = Applicative.helper Applicative.<*> argumentParser+        modifier+          = Monoid.mconcat+              [Applicative.fullDesc, oneLineDescription, description]+        oneLineDescription+          = Applicative.header+              "Haskell Formatter – A Haskell source code formatter"+        description+          = Applicative.progDesc $+              createParagraphs+                [["The Haskell Formatter formats Haskell source code. ",+                  "It is strict in that it fundamentally rearranges code."],+                 ["The source code is read from INPUT, ",+                  "formatted, and written to OUTPUT."]]++argumentParser :: Applicative.Parser Arguments+argumentParser+  = Arguments Applicative.<$> inputOption Applicative.<*> outputOption+      Applicative.<*> forceOption+      Applicative.<*> styleOption+  where inputOption+          = Applicative.optional . Applicative.strOption $+              Monoid.mconcat+                [Applicative.short 'i', Applicative.long "input",+                 Applicative.metavar "INPUT",+                 Applicative.help+                   "Input source code file (default: standard input)"]+        outputOption+          = Applicative.optional . Applicative.strOption $+              Monoid.mconcat+                [Applicative.short 'o', Applicative.long "output",+                 Applicative.metavar "OUTPUT",+                 Applicative.help+                   "Output source code file (default: standard output)"]+        forceOption+          = Applicative.switch $+              Monoid.mconcat+                [Applicative.short forceStandardName, Applicative.long "force",+                 Applicative.help+                   "Allows the output file to overwrite the input file"]+        styleOption+          = Applicative.optional . Applicative.strOption $+              Monoid.mconcat+                [Applicative.short 's', Applicative.long "style",+                 Applicative.metavar "STYLE",+                 Applicative.help "Formatting style file"]++forceStandardName :: Char+forceStandardName = 'f'++createParagraphs :: [[String]] -> String+createParagraphs+  = Newline.joinSeparatedLines . List.intersperse emptyLine . fmap concat+  where emptyLine = ""++formatWithUncheckedArguments :: Arguments -> IO (Maybe String)+formatWithUncheckedArguments arguments+  = do maybeError <- checkArguments arguments+       case maybeError of+           Nothing -> formatWithCheckedArguments arguments+           Just errorMessage -> return $ Just errorMessage++checkArguments :: Arguments -> IO (Maybe String)+checkArguments arguments+  = case (maybeInput, maybeOutput) of+        (Just inputPath, Just outputPath) -> if forceOverwriting then+                                               return Nothing else+                                               do same <- sameExistentPaths+                                                            inputPath+                                                            outputPath+                                                  return $+                                                    if same then+                                                      Just overwritingError else+                                                      Nothing+          where overwritingError+                  = concat+                      ["The output path ", show outputPath,+                       " would overwrite the input path ", show inputPath, ". ",+                       "Either use unequal paths or apply the ",+                       show forceStandardName, " option, please."]+        _ -> return Nothing+  where maybeInput = input arguments+        maybeOutput = output arguments+        forceOverwriting = force arguments++{-| Do both file paths exist and refer to the same file or folder? -}+sameExistentPaths :: FilePath -> FilePath -> IO Bool+sameExistentPaths left right+  = do exist <- bothPathsExist+       if exist then+         liftedOn FilePath.equalFilePath Directory.canonicalizePath left right+         else return False+  where bothPathsExist = liftedOn (&&) pathExists left right+        liftedOn = Function.on . Applicative.liftA2+        pathExists path+          = Applicative.liftA2 (||) (Directory.doesFileExist path) $+              Directory.doesDirectoryExist path++formatWithCheckedArguments :: Arguments -> IO (Maybe String)+formatWithCheckedArguments arguments+  = do maybeConfiguration <- getConfiguration arguments+       case maybeConfiguration of+           Left errorMessage -> return $ Just errorMessage+           Right configuration -> formatWithConfiguration arguments+                                    configuration++getConfiguration :: Arguments -> IO (Either String Formatter.Configuration)+getConfiguration arguments+  = do maybeStyle <- getStyle arguments+       return $+         case maybeStyle of+             Left message -> Left message+             Right style -> Right configuration+               where configuration+                       = defaults{Formatter.configurationStyle = style}+  where defaults+          = Formatter.defaultConfiguration{Formatter.configurationStreamName =+                                             stream}+        stream+          = maybe Formatter.standardInput Formatter.createStreamName maybeInput+        maybeInput = input arguments++getStyle :: Arguments -> IO (Either String Formatter.Style)+getStyle arguments+  = case styleFile arguments of+        Nothing -> return $ Right defaultStyle+        Just file -> TreeFormat.parseYamlFile StyleFileFormat.treeFormat+                       defaultStyle+                       file+  where defaultStyle+          = Formatter.configurationStyle Formatter.defaultConfiguration++formatWithConfiguration ::+                        Arguments ->+                          Formatter.Configuration -> IO (Maybe String)+formatWithConfiguration arguments configuration+  = do inputString <- readInput+       case Formatter.format configuration inputString of+           Left libraryError -> return . Just $ showError libraryError+           Right outputString -> do evaluateString outputString $+                                      writeOutput outputString+                                    return Nothing+  where readInput = maybe getContents readFile maybeInput+        maybeInput = input arguments+        evaluateString string = seq $ length string+        writeOutput = maybe putStr writeFile maybeOutput+        maybeOutput = output arguments++showError :: Formatter.Error -> String+showError libraryError+  = if Formatter.isAssertionError libraryError then assertionError else rawError+  where assertionError+          = createParagraphs+              [["Oops, an error occurred. ", "Feel free to report this, ",+                "because it appears to be a bug. Thanks! ",+                "The specific error message follows."],+               [rawError]]+        rawError = show libraryError
+ src/library/Language/Haskell/Formatter.hs view
@@ -0,0 +1,14 @@+{-|+Description : Haskell source code formatter+-}+module Language.Haskell.Formatter+       (Configuration.Configuration(..), Configuration.defaultConfiguration,+        Error.Error, Error.isAssertionError, Main.defaultFormat, Main.format,+        StreamName.createStreamName, StreamName.standardInput,+        StreamName.StreamName, Style.Indentation, Style.Style(..))+       where+import qualified Language.Haskell.Formatter.Configuration as Configuration+import qualified Language.Haskell.Formatter.Error as Error+import qualified Language.Haskell.Formatter.Main as Main+import qualified Language.Haskell.Formatter.Style as Style+import qualified Language.Haskell.Formatter.Toolkit.StreamName as StreamName
+ src/library/Language/Haskell/Formatter/CommentCore.hs view
@@ -0,0 +1,46 @@+{-|+Description : Comments without location+-}+module Language.Haskell.Formatter.CommentCore+       (CommentCore, kind, content, Kind(..), DocumentationDisplacement(..),+        create, wrappedLineCount, documentationDisplacement)+       where+import qualified Data.Char as Char+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter.Internal.Newline as Newline++data CommentCore = CommentCore{kind :: Kind, content :: String}+                 deriving (Eq, Ord)++data Kind = Ordinary+          | Nested+          deriving (Eq, Ord, Show)++data DocumentationDisplacement = BeforeActualCode+                               | AfterActualCode+                               | None+                               deriving (Eq, Ord, Show)++instance Show CommentCore where+        show comment+          = case kind comment of+                Ordinary -> Monoid.mappend "--" rawContent+                Nested -> concat ["{-", rawContent, "-}"]+          where rawContent = content comment++create :: Kind -> String -> CommentCore+create rawKind rawContent = CommentCore{kind = rawKind, content = rawContent}++wrappedLineCount :: CommentCore -> Int+wrappedLineCount = length . Newline.splitSeparatedLines . show++documentationDisplacement :: CommentCore -> DocumentationDisplacement+documentationDisplacement comment+  = case unwrappedContent of+        ('|' : _) -> BeforeActualCode+        ('^' : _) -> AfterActualCode+        _ -> None+  where unwrappedContent+          = Monoid.mappend (dropWhile Char.isSpace deformable) rigid+        (deformable, rigid) = splitAt spaceLimit $ content comment+        spaceLimit = 1
+ src/library/Language/Haskell/Formatter/Configuration.hs view
@@ -0,0 +1,24 @@+{-|+Description : Overall configuration+-}+module Language.Haskell.Formatter.Configuration+       (Configuration(..), defaultConfiguration, check) where+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Style as Style+import qualified Language.Haskell.Formatter.Toolkit.StreamName as StreamName++data Configuration = Configuration{configurationStyle :: Style.Style,+                                   configurationStreamName ::+                                   StreamName.StreamName}+                   deriving (Eq, Ord, Show)++defaultConfiguration :: Configuration+defaultConfiguration+  = Configuration{configurationStyle = Style.defaultStyle,+                  configurationStreamName = stream}+  where stream = StreamName.createStreamName filename+        filename = Source.parseFilename Source.defaultParseMode++check :: Configuration -> Result.Result ()+check = Style.check . configurationStyle
+ src/library/Language/Haskell/Formatter/Error.hs view
@@ -0,0 +1,35 @@+{-|+Description : Errors for feedback to users+-}+module Language.Haskell.Formatter.Error+       (Error, createStyleFormatError, createParseError, createAssertionError,+        isAssertionError)+       where+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Source as Source++data Error = StyleFormatError String+           | ParseError Location.SrcLoc String+           | AssertionError String+           deriving (Eq, Ord)++instance Show Error where+        show (StyleFormatError message) = message+        show (ParseError position message)+          = concat [Source.prettyPrint position, separator, message]+          where separator = ": "+        show (AssertionError message) = message++createStyleFormatError :: String -> Error+createStyleFormatError = StyleFormatError++createParseError :: Location.SrcLoc -> String -> Error+createParseError = ParseError++createAssertionError :: String -> Error+createAssertionError = AssertionError++isAssertionError :: Error -> Bool+isAssertionError (StyleFormatError _) = False+isAssertionError (ParseError _ _) = False+isAssertionError (AssertionError _) = True
+ src/library/Language/Haskell/Formatter/ExactCode.hs view
@@ -0,0 +1,19 @@+{-|+Description : Exact syntax tree as parsed and printed by HSE+-}+module Language.Haskell.Formatter.ExactCode+       (ExactCode, actualCode, comments, create) where+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Source as Source++data ExactCode = ExactCode{actualCode :: Source.Module Location.SrcSpanInfo,+                           comments :: [Source.Comment]}++instance Show ExactCode where+        show exact = Source.exactPrint rawActualCode rawComments+          where rawActualCode = actualCode exact+                rawComments = comments exact++create :: Source.Module Location.SrcSpanInfo -> [Source.Comment] -> ExactCode+create rawActualCode rawComments+  = ExactCode{actualCode = rawActualCode, comments = rawComments}
+ src/library/Language/Haskell/Formatter/Internal/MapTree.hs view
@@ -0,0 +1,50 @@+{-|+Description : Trees with unique labels+-}+module Language.Haskell.Formatter.Internal.MapTree+       (MapTree(..), MapForest, isEmpty, summarizeLeaves, indentTree) where+import qualified Control.Applicative as Applicative+import qualified Data.Map.Strict as Map+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter.Internal.Newline as Newline++data MapTree k a = Leaf a+                 | Node (MapForest k a)+                 deriving (Eq, Ord, Show)++type MapForest k a = Map.Map k (MapTree k a)++instance Functor (MapTree k) where+        fmap function (Leaf value) = Leaf $ function value+        fmap function (Node forest) = Node $ fmap (fmap function) forest++isEmpty :: MapTree k a -> Bool+isEmpty (Leaf _) = False+isEmpty (Node forest) = Map.null forest++summarizeLeaves ::+                  (Ord k, Monoid.Monoid b) =>+                  MapForest k (Either a b) -> MapTree k (Either a (Map.Map k b))+summarizeLeaves = summarize Map.empty+  where summarize labels root+          = if Map.null lefts then+              if Map.null forests then Leaf . Right $ labels' else+                fromMap (summarize labels') forests+              else fromMap (Leaf . Left) lefts+          where (lefts, rights) = Map.mapEither id values+                (values, forests) = Map.mapEither distinguish root+                distinguish (Leaf value) = Left value+                distinguish (Node forest) = Right forest+                labels' = Map.unionWith Monoid.mappend labels rights+                fromMap function = Node . fmap function++indentTree :: MapTree String String -> String+indentTree = Newline.joinSeparatedLines . indentLines+  where indentLines (Leaf value) = Newline.splitSeparatedLines value+        indentLines (Node forest) = foldMapWithKey indentBinding forest+        foldMapWithKey create = (>>= uncurry create) . Map.toAscList+        indentBinding label tree = Monoid.mappend labelLines treeLines+          where labelLines = Newline.splitSeparatedLines label+                treeLines = indent Applicative.<$> indentLines tree+        indent = (indentation ++)+        indentation = "    "
+ src/library/Language/Haskell/Formatter/Internal/Newline.hs view
@@ -0,0 +1,37 @@+{-|+Description : Handling Unicode newlines+-}+module Language.Haskell.Formatter.Internal.Newline+       (newlines, joinSeparatedLines, splitSeparatedLines) where+import qualified Data.List as List+import qualified Language.Haskell.Formatter.Toolkit.Splitter as Splitter++{-| Unicode newline strings ordered by descending length. This corresponds to+    the set of newlines from+    <http://www.unicode.org/standard/reports/tr13/tr13-5.html>. -}+newlines :: [String]+newlines = ["\CR\LF", "\LF", "\VT", "\FF", "\CR", "\x85", "\x2028", "\x2029"]++{-| Concatenates strings with default newlines @\"\\n\"@ between.++    Unlike 'unlines', this does not append a newline to the last string.++    >>> joinSeparatedLines ["apple", "pine"]+    "apple\npine" -}+joinSeparatedLines :: [String] -> String+joinSeparatedLines = List.intercalate defaultNewline+  where defaultNewline = "\LF"++{-| Breaks a string up into its lines at 'newlines'. The resulting strings do+    not contain 'newlines'.++    Unlike 'lines', this interprets a newline as a separator, not a terminator.+    Thus, if the input string ends with a newline, the output list ends with the+    empty string.++    >>> splitSeparatedLines "0\n1\r2\r\n3\n\r4"+    ["0","1","2","3","","4"]++    prop> last (splitSeparatedLines $ s ++ "\LF") == "" -}+splitSeparatedLines :: String -> [String]+splitSeparatedLines = Splitter.separate newlines
+ src/library/Language/Haskell/Formatter/Internal/StyleFileFormat.hs view
@@ -0,0 +1,50 @@+{-|+Description : Sample format definition for a style file+-}+module Language.Haskell.Formatter.Internal.StyleFileFormat (treeFormat) where+import qualified Data.Map as Map+import qualified Language.Haskell.Formatter as Formatter+import qualified Language.Haskell.Formatter.Internal.MapTree as MapTree+import qualified Language.Haskell.Formatter.Internal.TreeFormat as TreeFormat++treeFormat :: TreeFormat.TreeFormat Formatter.Style+treeFormat+  = Map.fromList+      [("line_length_limit",+        MapTree.Leaf . TreeFormat.LimitedInteger $+          \ value style -> style{Formatter.lineLengthLimit = value}),+       ("ribbons_per_line",+        MapTree.Leaf . TreeFormat.SingleFloating $+          \ value style -> style{Formatter.ribbonsPerLine = value}),+       ("indentations",+        MapTree.Node $+          Map.fromList+            [("class",+              MapTree.Leaf . TreeFormat.LimitedInteger $+                \ value style -> style{Formatter.classIndentation = value}),+             ("do",+              MapTree.Leaf . TreeFormat.LimitedInteger $+                \ value style -> style{Formatter.doIndentation = value}),+             ("case",+              MapTree.Leaf . TreeFormat.LimitedInteger $+                \ value style -> style{Formatter.caseIndentation = value}),+             ("let",+              MapTree.Leaf . TreeFormat.LimitedInteger $+                \ value style -> style{Formatter.letIndentation = value}),+             ("where",+              MapTree.Leaf . TreeFormat.LimitedInteger $+                \ value style -> style{Formatter.whereIndentation = value}),+             ("onside",+              MapTree.Leaf . TreeFormat.LimitedInteger $+                \ value style -> style{Formatter.onsideIndentation = value})]),+       ("order",+        MapTree.Node $+          Map.fromList+            [("import_declarations",+              MapTree.Leaf . TreeFormat.Boolean $+                \ value style ->+                  style{Formatter.orderImportDeclarations = value}),+             ("import_entities",+              MapTree.Leaf . TreeFormat.Boolean $+                \ value style ->+                  style{Formatter.orderImportEntities = value})])]
+ src/library/Language/Haskell/Formatter/Internal/TreeFormat.hs view
@@ -0,0 +1,88 @@+{-|+Description : Parsing nested maps according to a format+-}+module Language.Haskell.Formatter.Internal.TreeFormat+       (TreeFormat, Leaf(..), parseYamlFile) where+import qualified Control.Arrow as Arrow+import qualified Data.HashMap.Strict as HashMap+import qualified Data.Map.Strict as Map+import qualified Data.Monoid as Monoid+import qualified Data.Scientific as Scientific+import qualified Data.Text as Text+import qualified Data.Yaml as Yaml+import qualified Language.Haskell.Formatter.Internal.MapTree as MapTree+import qualified Language.Haskell.Formatter.Internal.Newline as Newline++type TreeFormat a = MapTree.MapForest String (Leaf a)++data Leaf a = Boolean (RawLeaf Bool a)+            | LimitedInteger (RawLeaf Int a)+            | SingleFloating (RawLeaf Float a)++type RawLeaf a b = a -> b -> b++parseYamlFile :: TreeFormat a -> a -> FilePath -> IO (Either String a)+parseYamlFile format ball file+  = do maybeValue <- Yaml.decodeFileEither file+       let interpretation+             = case maybeValue of+                   Left exception -> Left $ show exception+                   Right value -> defaultInterpret format value ball+       return $ Arrow.left fileError interpretation+  where fileError message = Newline.joinSeparatedLines [introduction, message]+        introduction = Monoid.mappend file ":"++defaultInterpret :: TreeFormat a -> Yaml.Value -> a -> Either String a+defaultInterpret format value ball+  = if MapTree.isEmpty errors then Right interpretation else+      Left $ MapTree.indentTree errors+  where (errors, interpretation) = interpret format value ball++interpret ::+          TreeFormat a -> Yaml.Value -> a -> (MapTree.MapTree String String, a)+interpret formatMap (Yaml.Object rawValueMap) ball = (errorNode, ball')+  where errorNode = MapTree.Node $ Map.mapMaybe id errorTree+        (ball', errorTree) = Map.mapAccumWithKey move ball valueMap+        move ballPart key value = (ballPart', maybeErrors)+          where (maybeErrors, ballPart') = matchTree maybeFormat value ballPart+                maybeFormat = Map.lookup key formatMap+        valueMap = Map.mapKeys Text.unpack $ orderedMap rawValueMap+        orderedMap = Map.fromList . HashMap.toList+interpret _ value ball = (errorLeaf, ball)+  where errorLeaf = MapTree.Leaf $ unexpectedMessage "a map" value++matchTree ::+          Maybe (MapTree.MapTree String (Leaf a)) ->+            Yaml.Value -> a -> (Maybe (MapTree.MapTree String String), a)+matchTree Nothing _ ball = (Just $ MapTree.Leaf message, ball)+  where message = "Unexpected key."+matchTree (Just (MapTree.Leaf leaf)) value ball+  = case matchLeaf leaf value ball of+        Left message -> (Just $ MapTree.Leaf message, ball)+        Right ball' -> (Nothing, ball')+matchTree (Just (MapTree.Node node)) value ball = (maybeErrors, ball')+  where maybeErrors = if MapTree.isEmpty errors then Nothing else Just errors+        (errors, ball') = interpret node value ball++matchLeaf :: Leaf a -> Yaml.Value -> a -> Either String a+matchLeaf (Boolean go) (Yaml.Bool boolean) ball = Right $ go boolean ball+matchLeaf (LimitedInteger go) value@(Yaml.Number number) ball+  = case Scientific.toBoundedInteger number of+        Nothing -> Left message+          where message = unexpectedMessage "a limited integer" value+        Just integer -> Right $ go integer ball+matchLeaf (SingleFloating go) (Yaml.Number number) ball+  = Right $ go floating ball+  where floating = Scientific.toRealFloat number+matchLeaf format value _ = Left $ unexpectedMessage expected value+  where expected+          = case format of+                Boolean _ -> "a Boolean"+                LimitedInteger _ -> "a limited integer"+                SingleFloating _ -> "a single-precision floating-point number"++unexpectedMessage :: String -> Yaml.Value -> String+unexpectedMessage expected actualValue+  = Newline.joinSeparatedLines [introduction, actual]+  where introduction = concat ["Expected ", expected, ", but got:"]+        actual = show $ Yaml.encode actualValue
+ src/library/Language/Haskell/Formatter/Location.hs view
@@ -0,0 +1,129 @@+{-|+Description : Facade for the location handling of HSE++See also "Language.Haskell.Formatter.Source".+-}+module Language.Haskell.Formatter.Location+       (SrcLoc.SrcLoc, SrcLoc.SrcSpan, SrcLoc.SrcSpanInfo, base, plus, minus,+        Portioned(..), Line, Column, streamName, getLine, getColumn,+        createPosition, SrcLoc.getPointLoc, getEndPosition,+        replaceNestedPortionLines, stringPortion, getStartLine, getStartColumn,+        getEndLine, getEndColumn)+       where+import qualified Data.Function as Function+import qualified Language.Haskell.Exts.Annotated.Syntax as Syntax+import qualified Language.Haskell.Exts.Comments as Comments+import qualified Language.Haskell.Exts.SrcLoc as SrcLoc+import qualified Language.Haskell.Formatter.Internal.Newline as Newline+import qualified Language.Haskell.Formatter.Toolkit.ListTool as ListTool+import qualified Language.Haskell.Formatter.Toolkit.StreamName as StreamName+import Prelude hiding (getLine)++class (Enum a) => Natural a where++        base :: a++        plus :: (Integral b) => b -> a -> a+        plus difference natural+          = toEnum $ fromIntegral difference + fromEnum natural++        minus :: (Num b) => a -> a -> b+        minus minuend = fromIntegral . Function.on (-) fromEnum minuend++class Portioned a where++        getPortion :: a -> SrcLoc.SrcSpan++data Line = Line Int+          deriving (Eq, Ord, Show)++data Column = Column Int+            deriving (Eq, Ord, Show)++instance Enum Line where+        toEnum = Line+        fromEnum (Line line) = line++instance Enum Column where+        toEnum = Column+        fromEnum (Column column) = column++instance Natural Line where+        base = Line 1++instance Natural Column where+        base = Column 1++instance Portioned SrcLoc.SrcSpanInfo where+        getPortion = SrcLoc.srcInfoSpan++instance (Portioned a) => Portioned (Syntax.Module a) where+        getPortion = getPortion . Syntax.ann++instance Portioned Comments.Comment where+        getPortion (Comments.Comment _ commentPortion _) = commentPortion++streamName :: (SrcLoc.SrcInfo a) => a -> StreamName.StreamName+streamName = StreamName.createStreamName . SrcLoc.fileName++getLine :: SrcLoc.SrcLoc -> Line+getLine = Line . SrcLoc.srcLine++getColumn :: SrcLoc.SrcLoc -> Column+getColumn = Column . SrcLoc.srcColumn++createPosition :: StreamName.StreamName -> Line -> Column -> SrcLoc.SrcLoc+createPosition stream (Line line) (Column column)+  = SrcLoc.SrcLoc{SrcLoc.srcFilename = show stream, SrcLoc.srcLine = line,+                  SrcLoc.srcColumn = column}++getEndPosition :: SrcLoc.SrcSpan -> SrcLoc.SrcLoc+getEndPosition portion = createPosition stream line column+  where stream = streamName portion+        line = Line $ SrcLoc.srcSpanEndLine portion+        column = Column $ SrcLoc.srcSpanEndColumn portion++replaceNestedPortionLines ::+                          (Line -> Line) ->+                            SrcLoc.SrcSpanInfo -> SrcLoc.SrcSpanInfo+replaceNestedPortionLines function nestedPortion+  = nestedPortion{SrcLoc.srcInfoSpan = parent',+                  SrcLoc.srcInfoPoints = children'}+  where parent' = replace parent+        replace = replacePortionLines function+        parent = SrcLoc.srcInfoSpan nestedPortion+        children' = fmap replace children+        children = SrcLoc.srcInfoPoints nestedPortion++replacePortionLines :: (Line -> Line) -> SrcLoc.SrcSpan -> SrcLoc.SrcSpan+replacePortionLines function portion+  = portion{SrcLoc.srcSpanStartLine = start, SrcLoc.srcSpanEndLine = end}+  where Line start = function $ getStartLine portion+        Line end = function $ getEndLine portion++stringPortion :: SrcLoc.SrcLoc -> String -> SrcLoc.SrcSpan+stringPortion startPosition string = SrcLoc.mkSrcSpan startPosition endPosition+  where endPosition = createPosition stream endLine endColumn+        stream = streamName startPosition+        endLine = lastIndex lineCount startLine+        lastIndex difference = pred . plus difference+        lineCount = length stringLines+        stringLines = Newline.splitSeparatedLines string+        startLine = getStartLine startPosition+        endColumn = lastIndex lastLineLength lastLineStartColumn+        lastLineLength = maybe 0 length $ ListTool.maybeLast stringLines+        lastLineStartColumn = if hasSingleLine then startColumn else base+        hasSingleLine = lineCount == 1+        startColumn = getStartColumn startPosition++getStartLine :: (SrcLoc.SrcInfo a) => a -> Line+getStartLine = getLine . SrcLoc.getPointLoc++getStartColumn :: (SrcLoc.SrcInfo a) => a -> Column+getStartColumn = getColumn . SrcLoc.getPointLoc++getEndLine :: SrcLoc.SrcSpan -> Line+getEndLine = getLine . getEndPosition++getEndColumn :: SrcLoc.SrcSpan -> Column+getEndColumn = getColumn . getEndPosition
+ src/library/Language/Haskell/Formatter/Main.hs view
@@ -0,0 +1,36 @@+{-|+Description : Root of formatting+-}+module Language.Haskell.Formatter.Main (defaultFormat, format) where+import qualified Language.Haskell.Formatter.Configuration as Configuration+import qualified Language.Haskell.Formatter.Error as Error+import qualified Language.Haskell.Formatter.ExactCode as ExactCode+import qualified Language.Haskell.Formatter.Process.Control as Control+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Toolkit.StreamName as StreamName++defaultFormat :: String -> Either Error.Error String+defaultFormat = format Configuration.defaultConfiguration++format :: Configuration.Configuration -> String -> Either Error.Error String+format configuration = Result.toEither . tryFormat configuration++tryFormat :: Configuration.Configuration -> String -> Result.Result String+tryFormat configuration source+  = do Configuration.check configuration+       exact <- parse stream source+       exact' <- Control.format style exact+       return $ show exact'+  where stream = Configuration.configurationStreamName configuration+        style = Configuration.configurationStyle configuration++parse :: StreamName.StreamName -> String -> Result.Result ExactCode.ExactCode+parse stream source+  = case parseResult of+        Source.ParseFailed position message -> Result.fatalError parseError+          where parseError = Error.createParseError position message+        Source.ParseOk (actualCode, comments) -> return exact+          where exact = ExactCode.create actualCode comments+  where parseResult = Source.parseFileContentsWithComments mode source+        mode = Source.defaultParseMode{Source.parseFilename = show stream}
+ src/library/Language/Haskell/Formatter/Process/AttachComments.hs view
@@ -0,0 +1,132 @@+{-|+Description : Attaching comments to the annotations of the syntax tree++This is the first part of the process.+-}+module Language.Haskell.Formatter.Process.AttachComments (attachComments) where+import qualified Data.Foldable as Foldable+import qualified Data.Function as Function+import qualified Data.List as List+import qualified Data.Map.Strict as Map+import qualified Data.Monoid as Monoid+import qualified Data.Traversable as Traversable+import qualified Language.Haskell.Formatter.CommentCore as CommentCore+import qualified Language.Haskell.Formatter.ExactCode as ExactCode+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Process.Code as Code+import qualified Language.Haskell.Formatter.Process.Note as Note+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Style as Style++data Assignment = Assignment (Map.Map Location.SrcSpan Note.CommentNote)+                deriving (Eq, Ord, Show)++instance Monoid.Monoid Assignment where+        mempty = Assignment Map.empty+        mappend (Assignment left) (Assignment right) = Assignment merged+          where merged = Map.unionWith Monoid.mappend left right++attachComments ::+               Style.Style ->+                 ExactCode.ExactCode -> Result.Result Code.CommentableCode+attachComments _ exact+  = if Map.null unassigned then return commentable else+      Result.fatalAssertionError message+  where (Assignment unassigned, commentable) = spread assignment locatable+        assignment = assignForCode exact+        locatable = ExactCode.actualCode exact+        message = "Attaching the comments failed with an unassigned rest."++spread :: Assignment -> Code.LocatableCode -> (Assignment, Code.CommentableCode)+spread (Assignment assignment) locatable = (Assignment unassigned, commentable)+  where (unassigned, commentable)+          = Traversable.mapAccumL move assignment locatable+        move rest nestedPortion = (rest', note)+          where (maybeNote, rest') = Map.updateLookupWithKey remove portion rest+                remove = const . const Nothing+                portion = Location.getPortion nestedPortion+                note = Foldable.fold maybeNote++assignForCode :: ExactCode.ExactCode -> Assignment+assignForCode exact+  = Monoid.mappend (Monoid.mconcat untilLast) assignedAfterLast+  where ((maybeLast, afterLast), untilLast)+          = Traversable.mapAccumL move base orderedPortions+        move (maybeLower, rest) upper = ((Just upper, rest'), assignment)+          where (comments, rest') = span ((<= upper) . Location.getPortion) rest+                assignment = assignComments maybeLower upper boxes+                boxes = createComments comments+        base = (Nothing, orderedComments)+        (orderedPortions, orderedComments) = orderByStartEnd exact+        assignedAfterLast = Foldable.foldMap assignLast maybeLast+        assignLast = flip assignAfter lastBoxes+        lastBoxes = createComments afterLast++assignComments ::+               Maybe Location.SrcSpan ->+                 Location.SrcSpan -> [Note.CommentBox] -> Assignment+assignComments Nothing upper comments = assignBefore upper comments+assignComments (Just lower) upper comments+  = Monoid.mappend assignedAfter assignedBefore+  where assignedAfter = assignAfter lower after+        (after, _, before) = divideComments comments+        assignedBefore = assignBefore upper before++assignBefore :: Location.SrcSpan -> [Note.CommentBox] -> Assignment+assignBefore portion = flip (assignSingleton portion) []++assignSingleton ::+                Location.SrcSpan ->+                  [Note.CommentBox] -> [Note.CommentBox] -> Assignment+assignSingleton portion before after = Assignment $ Map.singleton portion note+  where note = Note.createCommentNote before after++assignAfter :: Location.SrcSpan -> [Note.CommentBox] -> Assignment+assignAfter portion = assignSingleton portion []++divideComments ::+               [Note.CommentBox] ->+                 ([Note.CommentBox], [Note.CommentBox], [Note.CommentBox])+divideComments = divide [] []+  where divide after spaces [] = (after, spaces, [])+        divide after spaces rest@(box@(Note.ActualComment comment) : unwrapped)+          = case (after, spaces) of+                (_ : _, []) -> ifAfter+                _ -> case displacement of+                         CommentCore.BeforeActualCode -> ifBefore+                         CommentCore.AfterActualCode -> ifAfter+                         CommentCore.None -> ifBefore+          where ifAfter = divide (concat [after, spaces, [box]]) [] unwrapped+                displacement = CommentCore.documentationDisplacement core+                core = Note.commentCore comment+                ifBefore = (after, spaces, rest)+        divide after spaces (Note.EmptyLine : unwrapped)+          = divide after (Monoid.mappend spaces [Note.EmptyLine]) unwrapped++createComments :: [Source.Comment] -> [Note.CommentBox]+createComments = concat . snd . Traversable.mapAccumL create Nothing+  where create maybeEndLine comment = (Just endLine', comments)+          where endLine' = Location.getEndLine portion+                portion = Location.getPortion comment+                comments = Monoid.mappend emptyLines actualComments+                emptyLines+                  = case maybeEndLine of+                        Nothing -> []+                        Just endLine -> replicate emptyLineCount Note.EmptyLine+                          where emptyLineCount = pred lineDistance+                                lineDistance+                                  = Location.minus startLine endLine :: Int+                startLine = Location.getStartLine portion+                actualComments = [Note.ActualComment indentedComment]+                indentedComment = Note.createIndentedComment core Location.base+                core = Source.commentCore comment++orderByStartEnd :: ExactCode.ExactCode -> ([Location.SrcSpan], [Source.Comment])+orderByStartEnd exact = (orderedPortions, orderedComments)+  where orderedPortions = fmap Location.getPortion nestedPortions+        nestedPortions = List.sort $ Foldable.toList actualCode+        actualCode = ExactCode.actualCode exact+        orderedComments+          = List.sortBy (Function.on compare Location.getPortion) comments+        comments = ExactCode.comments exact
+ src/library/Language/Haskell/Formatter/Process/Code.hs view
@@ -0,0 +1,40 @@+{-|+Description : Syntax tree types+-}+module Language.Haskell.Formatter.Process.Code+       (LocatableCode, CommentableCode, LocatableCommentableCode,+        tryZipLocationsComments, dropComments, dropLocations)+       where+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Process.Note as Note+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Toolkit.Visit as Visit++type LocatableCode = Source.Module Location.SrcSpanInfo++type CommentableCode = Source.Module Note.CommentNote++type LocatableCommentableCode = Source.Module Note.LocationCommentNote++tryZipLocationsComments ::+                        LocatableCode ->+                          CommentableCode ->+                            Result.Result LocatableCommentableCode+tryZipLocationsComments locatable commentable+  = case maybeZipped of+        Nothing -> Result.fatalAssertionError message+          where message = "The code notes could not be zipped."+        Just zipped -> return zipped+  where maybeZipped+          = if isActualCodeSame then maybeLocatableCommentable else Nothing+        isActualCodeSame = locatable Source.=~= commentable+        maybeLocatableCommentable+          = Visit.halfZipWith Note.createLocationCommentNote locatable+              commentable++dropComments :: LocatableCommentableCode -> LocatableCode+dropComments = fmap Note.locationNote++dropLocations :: LocatableCommentableCode -> CommentableCode+dropLocations = fmap Note.commentNote
+ src/library/Language/Haskell/Formatter/Process/CodeOrdering.hs view
@@ -0,0 +1,88 @@+{-|+Description : Sorting parts of code where the order is irrelevant+-}+module Language.Haskell.Formatter.Process.CodeOrdering+       (orderImportDeclarations, orderRootImportEntities,+        orderNestedImportEntities)+       where+import qualified Language.Haskell.Exts.Annotated.Syntax as Syntax+import qualified Language.Haskell.Formatter.Process.Code as Code+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Toolkit.Visit as Visit++orderImportDeclarations ::+                        Code.LocatableCommentableCode ->+                          Code.LocatableCommentableCode+orderImportDeclarations = replaceImportDeclarations $ Visit.orderByKey key+  where key+          (Syntax.ImportDecl _ moduleName isQualified isWithSource package alias+             entitiesList)+          = (moduleNameKey moduleName, isQualified, isWithSource, package,+             fmap moduleNameKey alias, fmap entitiesListKey entitiesList)+        moduleNameKey (Syntax.ModuleName _ name) = name+        entitiesListKey (Syntax.ImportSpecList _ isHiding entities)+          = (isHiding, fmap importEntityKey entities)++replaceImportDeclarations ::+                          ([Syntax.ImportDecl a] -> [Syntax.ImportDecl a]) ->+                            Source.Module a -> Source.Module a+replaceImportDeclarations function (Syntax.Module a h p importDeclarations d)+  = Syntax.Module a h p importDeclarations' d+  where importDeclarations' = function importDeclarations+replaceImportDeclarations _ xmlPage@(Syntax.XmlPage _ _ _ _ _ _ _) = xmlPage+replaceImportDeclarations function+  (Syntax.XmlHybrid a h p importDeclarations d xn xa me e)+  = Syntax.XmlHybrid a h p importDeclarations' d xn xa me e+  where importDeclarations' = function importDeclarations++importEntityKey :: Syntax.ImportSpec a -> [String]+importEntityKey (Syntax.IVar _ name) = rootNameKey name+importEntityKey (Syntax.IAbs _ name) = rootNameKey name+importEntityKey (Syntax.IThingAll _ name) = rootNameKey name+importEntityKey (Syntax.IThingWith _ name entities)+  = nameKey name : fmap nestedImportEntityKey entities++rootNameKey :: Syntax.Name a -> [String]+rootNameKey name = [nameKey name]++nameKey :: Syntax.Name a -> String+nameKey (Syntax.Ident _ name) = name+nameKey (Syntax.Symbol _ name) = name++nestedImportEntityKey :: Syntax.CName a -> String+nestedImportEntityKey (Syntax.VarName _ name) = nameKey name+nestedImportEntityKey (Syntax.ConName _ name) = nameKey name++orderRootImportEntities ::+                        Code.LocatableCommentableCode ->+                          Code.LocatableCommentableCode+orderRootImportEntities+  = replaceImportEntities $ Visit.orderByKey importEntityKey++replaceImportEntities ::+                      ([Syntax.ImportSpec a] -> [Syntax.ImportSpec a]) ->+                        Source.Module a -> Source.Module a+replaceImportEntities function+  = replaceImportDeclarations $ fmap replaceDeclaration+  where replaceDeclaration importDeclaration+          = importDeclaration{Syntax.importSpecs = entitiesList'}+          where entitiesList' = fmap replaceList entitiesList+                entitiesList = Syntax.importSpecs importDeclaration+        replaceList (Syntax.ImportSpecList annotation isHiding entities)+          = Syntax.ImportSpecList annotation isHiding entities'+          where entities' = function entities++orderNestedImportEntities ::+                          Code.LocatableCommentableCode ->+                            Code.LocatableCommentableCode+orderNestedImportEntities+  = replaceNestedImportEntities $ Visit.orderByKey nestedImportEntityKey++replaceNestedImportEntities ::+                            ([Syntax.CName a] -> [Syntax.CName a]) ->+                              Source.Module a -> Source.Module a+replaceNestedImportEntities function = replaceImportEntities $ fmap replace+  where replace (Syntax.IThingWith annotation name entities)+          = Syntax.IThingWith annotation name entities'+          where entities' = function entities+        replace entity = entity
+ src/library/Language/Haskell/Formatter/Process/Control.hs view
@@ -0,0 +1,31 @@+{-|+Description : Formatting process itself+-}+module Language.Haskell.Formatter.Process.Control (format) where+import qualified Language.Haskell.Formatter.ExactCode as ExactCode+import qualified Language.Haskell.Formatter.Process.AttachComments+       as AttachComments+import qualified Language.Haskell.Formatter.Process.DetachComments+       as DetachComments+import qualified Language.Haskell.Formatter.Process.FormatActualCode+       as FormatActualCode+import qualified Language.Haskell.Formatter.Process.FormatComments+       as FormatComments+import qualified Language.Haskell.Formatter.Process.Formatter as Formatter+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Style as Style++format ::+       Style.Style -> ExactCode.ExactCode -> Result.Result ExactCode.ExactCode+format style = Formatter.format $ createFormatter style++createFormatter :: Style.Style -> Formatter.Formatter+createFormatter style+  = Formatter.Formatter{Formatter.attachComments =+                          AttachComments.attachComments style,+                        Formatter.formatActualCode =+                          FormatActualCode.formatActualCode style,+                        Formatter.formatComments =+                          FormatComments.formatComments style,+                        Formatter.detachComments =+                          DetachComments.detachComments style}
+ src/library/Language/Haskell/Formatter/Process/DetachComments.hs view
@@ -0,0 +1,118 @@+{-|+Description : Detaching comments from the annotations of the syntax tree++This is the last part of the process.+-}+module Language.Haskell.Formatter.Process.DetachComments (detachComments) where+import qualified Data.Foldable as Foldable+import qualified Data.List as List+import qualified Data.Map.Strict as Map+import qualified Data.Maybe as Maybe+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter.CommentCore as CommentCore+import qualified Language.Haskell.Formatter.ExactCode as ExactCode+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Process.Code as Code+import qualified Language.Haskell.Formatter.Process.LineShifting as LineShifting+import qualified Language.Haskell.Formatter.Process.Note as Note+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Style as Style+import qualified Language.Haskell.Formatter.Toolkit.ListTool as ListTool+import qualified Language.Haskell.Formatter.Toolkit.StreamName as StreamName++data Reservation = Reservation (Map.Map Location.Line [Note.CommentBox])+                 deriving (Eq, Ord, Show)++instance Monoid.Monoid Reservation where+        mempty = Reservation Map.empty+        mappend (Reservation left) (Reservation right) = Reservation merged+          where merged = Map.unionWith merge left right+                merge before after = concat [before, between, after]+                  where between+                          = [Note.EmptyLine |+                             hasActualComment (ListTool.maybeLast before) &&+                               hasActualComment (Maybe.listToMaybe after)]+                hasActualComment maybeComment+                  = case maybeComment of+                        Nothing -> False+                        Just (Note.ActualComment _) -> True+                        Just Note.EmptyLine -> False++detachComments ::+               Style.Style ->+                 Code.LocatableCommentableCode ->+                   Result.Result ExactCode.ExactCode+detachComments _ locatableCommentable+  = return $ ExactCode.create locatable' comments+  where locatable' = LineShifting.shiftCode shifter locatable+        shifter = reservationShifter reservation+        reservation = reserveForCode locatableCommentable+        locatable = Code.dropComments locatableCommentable+        comments = createComments stream reservation+        stream = Location.streamName $ Location.getPortion locatable'++reservationShifter :: Reservation -> LineShifting.Shifter+reservationShifter (Reservation reservation)+  = LineShifting.createShifter $ fmap commentsShift reservation++commentsShift :: [Note.CommentBox] -> LineShifting.Shift+commentsShift = sum . fmap commentShift++commentShift :: Note.CommentBox -> LineShifting.Shift+commentShift (Note.ActualComment comment)+  = CommentCore.wrappedLineCount $ Note.commentCore comment+commentShift Note.EmptyLine = 1++reserveForCode :: Code.LocatableCommentableCode -> Reservation+reserveForCode = Foldable.foldMap reserveForNote++reserveForNote :: Note.LocationCommentNote -> Reservation+reserveForNote note = Monoid.mappend before after+  where before = singleton lineBefore $ Note.commentsBefore commentNote+        singleton line = Reservation . Map.singleton line+        lineBefore = Location.getStartLine portion+        portion = Location.getPortion note+        commentNote = Note.commentNote note+        after = singleton lineAfter $ Note.commentsAfter commentNote+        lineAfter = succ $ Location.getEndLine portion++createComments :: StreamName.StreamName -> Reservation -> [Source.Comment]+createComments stream = accumulateReservation create+  where create baseLine = snd . List.foldl' merge (baseLine, [])+        merge (startLine, comments) box = (followingLine, comments')+          where followingLine = Location.plus shift startLine+                shift = commentShift box+                comments' = Monoid.mappend comments commentsNow+                commentsNow+                  = case box of+                        Note.ActualComment comment -> [createComment stream+                                                         startLine+                                                         comment]+                        Note.EmptyLine -> []++accumulateReservation ::+                        (Monoid.Monoid m) =>+                        (Location.Line -> [Note.CommentBox] -> m) ->+                          Reservation -> m+accumulateReservation create (Reservation reservation) = accumulation+  where (_, accumulation) = Map.foldlWithKey' accumulate base reservation+        accumulate (absoluteShift, structure) line comments+          = (absoluteShift', structure')+          where absoluteShift' = absoluteShift + relativeShift+                relativeShift = commentsShift comments+                structure' = Monoid.mappend structure part+                part = create shiftedLine comments+                shiftedLine = Location.plus absoluteShift line+        base = (noShift, Monoid.mempty)+        noShift = 0++createComment ::+              StreamName.StreamName ->+                Location.Line -> Note.IndentedComment -> Source.Comment+createComment stream startLine comment = Source.createComment core portion+  where core = Note.commentCore comment+        portion = Location.stringPortion startPosition wrappedComment+        startPosition = Location.createPosition stream startLine startColumn+        startColumn = Note.commentStartColumn comment+        wrappedComment = show core
+ src/library/Language/Haskell/Formatter/Process/FormatActualCode.hs view
@@ -0,0 +1,78 @@+{-|+Description : Rearranging the actual code (not the comments)+-}+module Language.Haskell.Formatter.Process.FormatActualCode (formatActualCode)+       where+import qualified Control.Applicative as Applicative+import qualified Language.Haskell.Formatter.Process.Code as Code+import qualified Language.Haskell.Formatter.Process.CodeOrdering as CodeOrdering+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source+import qualified Language.Haskell.Formatter.Style as Style+import qualified Language.Haskell.Formatter.Toolkit.Visit as Visit++formatActualCode ::+                 Style.Style ->+                   Code.LocatableCommentableCode ->+                     Result.Result Code.LocatableCommentableCode+formatActualCode style locatableCommentable+  = do locatable <- prettyPrint style locatableCommentable'+       Code.tryZipLocationsComments locatable commentable+  where locatableCommentable' = prepare style locatableCommentable+        commentable = Code.dropLocations locatableCommentable'++prepare ::+        Style.Style ->+          Code.LocatableCommentableCode -> Code.LocatableCommentableCode+prepare style = Visit.compose preparations+  where preparations+          = [preparation | (isApplied, preparation) <- applications,+             isApplied style]+        applications+          = [(Style.orderImportDeclarations,+              CodeOrdering.orderImportDeclarations),+             (Style.orderImportEntities, orderImportEntities)]++orderImportEntities ::+                    Code.LocatableCommentableCode ->+                      Code.LocatableCommentableCode+orderImportEntities+  = CodeOrdering.orderRootImportEntities .+      CodeOrdering.orderNestedImportEntities++prettyPrint ::+            Style.Style ->+              Code.LocatableCommentableCode -> Result.Result Code.LocatableCode+prettyPrint style locatableCommentable+  = case parseResult of+        Source.ParseFailed _ _ -> Result.fatalAssertionError message+          where message = "Formatting the actual code failed to parse."+        Source.ParseOk possiblyChanged -> tryUnwrap maybeLocatable'+          where maybeLocatable'+                  = Visit.halfZipWith (flip const) locatable possiblyChanged+  where parseResult+          = Source.parseFileContents $ defaultPrettyPrint style locatable+        locatable = Code.dropComments locatableCommentable+        tryUnwrap maybeLocatable'+          = case maybeLocatable' of+                Nothing -> Result.fatalAssertionError message+                  where message = "Formatting the actual code failed to zip."+                Just locatable' -> return locatable'++defaultPrettyPrint :: (Source.Pretty a) => Style.Style -> a -> String+defaultPrettyPrint+  = Applicative.liftA2 Source.prettyPrintStyleMode renderingStyle mode++renderingStyle :: Style.Style -> Source.Style+renderingStyle style+  = Source.style{Source.lineLength = Style.lineLengthLimit style,+                 Source.ribbonsPerLine = Style.ribbonsPerLine style}++mode :: Style.Style -> Source.PPHsMode+mode style+  = Source.defaultMode{Source.classIndent = Style.classIndentation style,+                       Source.doIndent = Style.doIndentation style,+                       Source.caseIndent = Style.caseIndentation style,+                       Source.letIndent = Style.letIndentation style,+                       Source.whereIndent = Style.whereIndentation style,+                       Source.onsideIndent = Style.onsideIndentation style}
+ src/library/Language/Haskell/Formatter/Process/FormatComments.hs view
@@ -0,0 +1,43 @@+{-|+Description : Rearranging the comments+-}+module Language.Haskell.Formatter.Process.FormatComments (formatComments) where+import qualified Data.Function as Function+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Process.Code as Code+import qualified Language.Haskell.Formatter.Process.Note as Note+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Style as Style+import qualified Language.Haskell.Formatter.Toolkit.ListTool as ListTool+import qualified Language.Haskell.Formatter.Toolkit.Visit as Visit++formatComments ::+               Style.Style ->+                 Code.LocatableCommentableCode ->+                   Result.Result Code.LocatableCommentableCode+formatComments _ = return . indentToLineStart . mergeConsecutiveEmptyLines++indentToLineStart ::+                  Code.LocatableCommentableCode -> Code.LocatableCommentableCode+indentToLineStart locatableCommentable = locatableCommentable'+  where (_, locatableCommentable')+          = Visit.mapAccumulateLeftWithCreation move startPosition+              locatableCommentable+        move lineStart note = (lineStart', Note.replaceCommentNote replace note)+          where lineStart'+                  = if+                      Function.on (==) Location.getStartLine noteStart lineStart+                      then lineStart else noteStart+                noteStart = startPosition note+                replace = Note.replaceCommentStartColumn indent+                indent = const $ Location.getStartColumn lineStart'+        startPosition = Location.getPointLoc . Location.getPortion++mergeConsecutiveEmptyLines ::+                           Code.LocatableCommentableCode ->+                             Code.LocatableCommentableCode+mergeConsecutiveEmptyLines+  = fmap . Note.replaceCommentNote $ Note.replaceCommentBoxes merge+  where merge = ListTool.mergeConsecutiveElements isMerged+        isMerged (Note.ActualComment _) = False+        isMerged Note.EmptyLine = True
+ src/library/Language/Haskell/Formatter/Process/Formatter.hs view
@@ -0,0 +1,86 @@+{-|+Description : Invocation of the process parts with assertion checking+-}+module Language.Haskell.Formatter.Process.Formatter (Formatter(..), format)+       where+import qualified Control.Monad as Monad+import qualified Data.Function as Function+import qualified Language.Haskell.Formatter.ExactCode as ExactCode+import qualified Language.Haskell.Formatter.Process.Code as Code+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source++class Coded a where++        getCode :: a -> Source.Module ()++data Formatter = Formatter{attachComments ::+                           ExactCode.ExactCode ->+                             Result.Result Code.CommentableCode,+                           formatActualCode ::+                           Code.LocatableCommentableCode ->+                             Result.Result Code.LocatableCommentableCode,+                           formatComments ::+                           Code.LocatableCommentableCode ->+                             Result.Result Code.LocatableCommentableCode,+                           detachComments ::+                           Code.LocatableCommentableCode ->+                             Result.Result ExactCode.ExactCode}++instance Coded (Source.Module a) where+        getCode = Monad.void++instance Coded ExactCode.ExactCode where+        getCode = getCode . ExactCode.actualCode++format :: Formatter -> ExactCode.ExactCode -> Result.Result ExactCode.ExactCode+format formatter exact+  = do commentable <- checkedAttachComments formatter exact+       locatableCommentable <- Code.tryZipLocationsComments locatable+                                 commentable+       {- Formatting the actual code is allowed to change the code itself. -}+       locatableCommentable' <- formatActualCode formatter locatableCommentable+       locatableCommentable'' <- checkedFormatComments formatter+                                   locatableCommentable'+       exact' <- checkedDetachComments formatter locatableCommentable''+       return exact'+  where locatable = ExactCode.actualCode exact++checkedAttachComments ::+                      Formatter ->+                        ExactCode.ExactCode ->+                          Result.Result Code.CommentableCode+checkedAttachComments formatter+  = transformNotes (attachComments formatter) message+  where message = "Attaching the comments changed the code itself."++transformNotes ::+                 (Coded a, Coded b) =>+                 (a -> Result.Result b) -> String -> a -> Result.Result b+transformNotes transform = transformWithCheck transform assert+  where assert code code' = getCode code == getCode code'++transformWithCheck ::+                   (a -> Result.Result b) ->+                     (a -> b -> Bool) -> String -> a -> Result.Result b+transformWithCheck transform assert errorMessage input+  = do output <- transform input+       if assert input output then return output else+         Result.fatalAssertionError errorMessage++checkedFormatComments ::+                      Formatter ->+                        Code.LocatableCommentableCode ->+                          Result.Result Code.LocatableCommentableCode+checkedFormatComments formatter = transformWithCheck transform assert message+  where transform = formatComments formatter+        assert = Function.on (==) Code.dropComments+        message = "Formatting the comments changed more than just the comments."++checkedDetachComments ::+                      Formatter ->+                        Code.LocatableCommentableCode ->+                          Result.Result ExactCode.ExactCode+checkedDetachComments formatter+  = transformNotes (detachComments formatter) message+  where message = "Detaching the comments changed the code itself."
+ src/library/Language/Haskell/Formatter/Process/LineShifting.hs view
@@ -0,0 +1,37 @@+{-|+Description : Shifting lines of code+-}+module Language.Haskell.Formatter.Process.LineShifting+       (Shifter, Shift, createShifter, shiftCode) where+import qualified Data.Map.Strict as Map+import qualified Language.Haskell.Formatter.Location as Location+import qualified Language.Haskell.Formatter.Process.Code as Code++data Shifter = Shifter (Map.Map Location.Line Shift)+             deriving (Eq, Ord, Show)++type Shift = Int++createShifter :: Map.Map Location.Line Shift -> Shifter+createShifter relativeShifter = Shifter absoluteShifter+  where (_, absoluteShifter) = Map.mapAccum accumulate noShift relativeShifter+        accumulate absoluteShift relativeShift+          = (absoluteShift', absoluteShift')+          where absoluteShift' = absoluteShift + relativeShift++noShift :: Shift+noShift = 0++shiftCode :: Shifter -> Code.LocatableCode -> Code.LocatableCode+shiftCode shifter = fmap $ shiftNestedPortion shifter+  where shiftNestedPortion = Location.replaceNestedPortionLines . shiftLine++shiftLine :: Shifter -> Location.Line -> Location.Line+shiftLine shifter line = Location.plus shift line+  where shift = lookupShift line shifter++lookupShift :: Location.Line -> Shifter -> Shift+lookupShift line (Shifter shifter)+  = case Map.lookupLE line shifter of+        Nothing -> noShift+        Just (_, shift) -> shift
+ src/library/Language/Haskell/Formatter/Process/Note.hs view
@@ -0,0 +1,90 @@+{-|+Description : Annotations of syntax trees+-}+module Language.Haskell.Formatter.Process.Note+       (CommentNote, commentsBefore, commentsAfter, CommentBox(..),+        IndentedComment, commentCore, commentStartColumn, LocationCommentNote,+        locationNote, commentNote, createCommentNote, createIndentedComment,+        createLocationCommentNote, replaceCommentBoxes,+        replaceCommentStartColumn, replaceCommentNote)+       where+import qualified Data.Function as Function+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter.CommentCore as CommentCore+import qualified Language.Haskell.Formatter.Location as Location++data CommentNote = CommentNote{commentsBefore :: [CommentBox],+                               commentsAfter :: [CommentBox]}+                 deriving (Eq, Ord, Show)++data CommentBox = ActualComment IndentedComment+                | EmptyLine+                deriving (Eq, Ord, Show)++data IndentedComment = IndentedComment{commentCore :: CommentCore.CommentCore,+                                       commentStartColumn :: Location.Column}+                     deriving (Eq, Ord, Show)++data LocationCommentNote = LocationCommentNote{locationNote ::+                                               Location.SrcSpanInfo,+                                               commentNote :: CommentNote}+                         deriving (Eq, Ord, Show)++instance Monoid.Monoid CommentNote where+        mempty = createCommentNote [] []+        mappend left right = createCommentNote before after+          where before = merge commentsBefore+                merge getComments = Function.on (++) getComments left right+                after = merge commentsAfter++instance Location.Portioned LocationCommentNote where+        getPortion = Location.getPortion . locationNote++createCommentNote :: [CommentBox] -> [CommentBox] -> CommentNote+createCommentNote rawCommentsBefore rawCommentsAfter+  = CommentNote{commentsBefore = rawCommentsBefore,+                commentsAfter = rawCommentsAfter}++createIndentedComment ::+                      CommentCore.CommentCore ->+                        Location.Column -> IndentedComment+createIndentedComment rawCommentCore rawCommentStartColumn+  = IndentedComment{commentCore = rawCommentCore,+                    commentStartColumn = rawCommentStartColumn}++createLocationCommentNote ::+                          Location.SrcSpanInfo ->+                            CommentNote -> LocationCommentNote+createLocationCommentNote rawLocationNote rawCommentNote+  = LocationCommentNote{locationNote = rawLocationNote,+                        commentNote = rawCommentNote}++replaceCommentBoxes ::+                    ([CommentBox] -> [CommentBox]) -> CommentNote -> CommentNote+replaceCommentBoxes function note+  = note{commentsBefore = replace commentsBefore,+         commentsAfter = replace commentsAfter}+  where replace getComments = function $ getComments note++replaceCommentBox :: (CommentBox -> CommentBox) -> CommentNote -> CommentNote+replaceCommentBox function = replaceCommentBoxes $ fmap function++replaceIndentedComment ::+                       (IndentedComment -> IndentedComment) ->+                         CommentNote -> CommentNote+replaceIndentedComment function = replaceCommentBox partFunction+  where partFunction (ActualComment comment) = ActualComment $ function comment+        partFunction EmptyLine = EmptyLine++replaceCommentStartColumn ::+                          (Location.Column -> Location.Column) ->+                            CommentNote -> CommentNote+replaceCommentStartColumn function = replaceIndentedComment partFunction+  where partFunction comment+          = comment{commentStartColumn = function $ commentStartColumn comment}++replaceCommentNote ::+                   (CommentNote -> CommentNote) ->+                     LocationCommentNote -> LocationCommentNote+replaceCommentNote function note+  = note{commentNote = function $ commentNote note}
+ src/library/Language/Haskell/Formatter/Result.hs view
@@ -0,0 +1,31 @@+{-|+Description : Result with possible errors+-}+module Language.Haskell.Formatter.Result+       (Result, toEither, fatalError, fatalAssertionError) where+import qualified Control.Applicative as Applicative+import qualified Control.Monad as Monad+import qualified Language.Haskell.Formatter.Error as Error++data Result a = Result (Either Error.Error a)+              deriving (Eq, Ord, Show)++instance Functor Result where+        fmap = Monad.liftM++instance Applicative.Applicative Result where+        pure = return+        (<*>) = Monad.ap++instance Monad Result where+        return = Result . return+        Result result >>= action = Result $ result >>= toEither . action++toEither :: Result a -> Either Error.Error a+toEither (Result result) = result++fatalError :: Error.Error -> Result a+fatalError = Result . Left++fatalAssertionError :: String -> Result a+fatalAssertionError = fatalError . Error.createAssertionError
+ src/library/Language/Haskell/Formatter/Source.hs view
@@ -0,0 +1,40 @@+{-|+Description : Facade for HSE without location handling++See also "Language.Haskell.Formatter.Location".+-}+module Language.Haskell.Formatter.Source+       (Annotated.parseFileContents, Annotated.parseFileContentsWithComments,+        Comments.Comment, ExactPrint.exactPrint, Parser.defaultParseMode,+        Parser.parseFilename, Parser.ParseResult(..),+        module Language.Haskell.Exts.Pretty, (Syntax.=~=), Syntax.Module,+        createComment, commentCore)+       where+import qualified Language.Haskell.Exts.Annotated as Annotated+import qualified Language.Haskell.Exts.Annotated.ExactPrint as ExactPrint+import qualified Language.Haskell.Exts.Annotated.Syntax as Syntax+import qualified Language.Haskell.Exts.Comments as Comments+import qualified Language.Haskell.Exts.Parser as Parser+import Language.Haskell.Exts.Pretty+import qualified Language.Haskell.Formatter.CommentCore as CommentCore+import qualified Language.Haskell.Formatter.Location as Location++createComment :: CommentCore.CommentCore -> Location.SrcSpan -> Comments.Comment+createComment core portion = Comments.Comment isMultiLine portion content+  where isMultiLine+          = case CommentCore.kind core of+                CommentCore.Ordinary -> False+                CommentCore.Nested -> True+        content = CommentCore.content core++commentCore :: Comments.Comment -> CommentCore.CommentCore+commentCore comment = CommentCore.create kind content+  where kind = commentKind comment+        content = commentContent comment++commentKind :: Comments.Comment -> CommentCore.Kind+commentKind (Comments.Comment False _ _) = CommentCore.Ordinary+commentKind (Comments.Comment True _ _) = CommentCore.Nested++commentContent :: Comments.Comment -> String+commentContent (Comments.Comment _ _ content) = content
+ src/library/Language/Haskell/Formatter/Style.hs view
@@ -0,0 +1,94 @@+{-|+Description : Parametrization of formatting+-}+module Language.Haskell.Formatter.Style+       (Style(..), Indentation, defaultStyle, check) where+import qualified Data.Maybe as Maybe+import qualified Language.Haskell.Formatter.Error as Error+import qualified Language.Haskell.Formatter.Internal.Newline as Newline+import qualified Language.Haskell.Formatter.Result as Result+import qualified Language.Haskell.Formatter.Source as Source++data Style = Style{lineLengthLimit :: Int, ribbonsPerLine :: Float,+                   classIndentation :: Indentation,+                   doIndentation :: Indentation, caseIndentation :: Indentation,+                   letIndentation :: Indentation,+                   whereIndentation :: Indentation,+                   onsideIndentation :: Indentation,+                   orderImportDeclarations :: Bool, orderImportEntities :: Bool}+           deriving (Eq, Ord, Show)++data Check = Check (Maybe String)+           deriving (Eq, Ord, Show)++{-| Number of characters used to indent. -}+type Indentation = Int++defaultStyle :: Style+defaultStyle+  = Style{lineLengthLimit = 80, ribbonsPerLine = 1,+          classIndentation = Source.classIndent mode,+          doIndentation = Source.doIndent mode,+          caseIndentation = Source.caseIndent mode,+          letIndentation = Source.letIndent mode,+          whereIndentation = Source.whereIndent mode,+          onsideIndentation = Source.onsideIndent mode,+          orderImportDeclarations = True, orderImportEntities = True}+  where mode = Source.defaultMode++check :: Style -> Result.Result ()+check style+  = case maybeError of+        Nothing -> return ()+        Just message -> Result.fatalError $ Error.createStyleFormatError message+  where maybeError+          = case errorMessages of+                [] -> Nothing+                messages -> Just $ Newline.joinSeparatedLines messages+        errorMessages = Maybe.mapMaybe unwrap $ createChecks style+        unwrap (Check errorMessage) = errorMessage++createChecks :: Style -> [Check]+createChecks style+  = concat+      [[lineLengthLimitCheck, ribbonsPerLineCheck], indentationChecks,+       [onsideLessCheck]]+  where lineLengthLimitCheck+          = createCheck (rawLineLengthLimit > 0)+              ["The line length limit must be positive, but it is ",+               show rawLineLengthLimit, "."]+        rawLineLengthLimit = lineLengthLimit style+        ribbonsPerLineCheck+          = createCheck (rawRibbonsPerLine >= 1)+              ["The ribbons per line ratio must be at least 1, but it is ",+               show rawRibbonsPerLine, "."]+        rawRibbonsPerLine = ribbonsPerLine style+        indentationChecks = fmap checkIndentation indentations+        checkIndentation (indentation, name)+          = createCheck (indentation > 0)+              ["The ", name, " indentation must be positive, but it is ",+               show indentation, "."]+        indentations+          = [(rawClassIndentation, "class"), (rawDoIndentation, "do"),+             (rawCaseIndentation, "case"), (rawLetIndentation, "let"),+             (rawWhereIndentation, "where"), (rawOnsideIndentation, onsideName)]+        rawClassIndentation = classIndentation style+        rawDoIndentation = doIndentation style+        rawCaseIndentation = caseIndentation style+        rawLetIndentation = letIndentation style+        rawWhereIndentation = whereIndentation style+        rawOnsideIndentation = onsideIndentation style+        onsideName = "onside"+        onsideLessCheck+          = createCheck+              (and $ fmap (> rawOnsideIndentation) greaterOnsideIndentations)+              ["The ", onsideName,+               " indentation must be less than the other indentations, ",+               "but it is ", show rawOnsideIndentation, "."]+        greaterOnsideIndentations+          = [rawClassIndentation, rawDoIndentation, rawCaseIndentation,+             rawLetIndentation, rawWhereIndentation]++createCheck :: Bool -> [String] -> Check+createCheck False = Check . Just . concat+createCheck True = const $ Check Nothing
+ src/library/Language/Haskell/Formatter/Toolkit/ListTool.hs view
@@ -0,0 +1,67 @@+{-|+Description : List utilities+-}+module Language.Haskell.Formatter.Toolkit.ListTool+       (maybeLast, mergeConsecutiveElements, takeEvery, concatenateRuns,+        concatenateShiftedRuns)+       where+import qualified Data.List as List+import qualified Data.Maybe as Maybe+import qualified Data.Monoid as Monoid+import qualified Data.Word as Word++{-| The last element, or 'Nothing' if there is none.++    prop> maybeLast [] == Nothing+    prop> maybeLast (l ++ [e]) == Just e -}+maybeLast :: [a] -> Maybe a+maybeLast = Maybe.listToMaybe . reverse++{-| @mergeConsecutiveElements i l@ keeps only the first element of consecutive+    elements of @l@ satisfying the predicate @i@.++    >>> mergeConsecutiveElements Data.Char.isSpace " ab c  d\LF  e  "+    " ab c d\ne "+-}+mergeConsecutiveElements :: (a -> Bool) -> [a] -> [a]+mergeConsecutiveElements isMerged = snd . List.foldl' merge (False, [])+  where merge (isConsecutive, list) element = (isConsecutive', list')+          where isConsecutive' = isMerged element+                list' = Monoid.mappend list merged+                merged+                  = if isConsecutive' && isConsecutive then [] else [element]++{-| @takeEvery p l@ takes every @p@th element of @l@ from the first one.++    >>> takeEvery 2 "apple"+    "ape"++    prop> takeEvery 1 l == l -}+takeEvery :: Word.Word -> [a] -> [a]+takeEvery _ [] = []+takeEvery period list@(first : _)+  = first : takeEvery period (drop (fromIntegral period) list)++{-| @concatenateRuns p l@ repeatedly concatenates @p@ lists of @l@.++    >>> concatenateRuns 2 ["a", "b", "c", "d", "e"]+    ["ab","cd","e"] -}+concatenateRuns :: Word.Word -> [[a]] -> [[a]]+concatenateRuns _ [] = []+concatenateRuns period lists = concat run : concatenateRuns period rest+  where (run, rest) = splitAt (fromIntegral period) lists++{-| @concatenateShiftedRuns p s l@ first takes @s@ lists of @l@, followed by+    repeatedly concatenating @p@ lists.++    >>> concatenateShiftedRuns 2 1 ["a", "b", "c", "d", "e"]+    ["a","bc","de"]++    prop> p == 0 || concatenateShiftedRuns p 0 l == concatenateRuns p l -}+concatenateShiftedRuns :: Word.Word -> Word.Word -> [[a]] -> [[a]]+concatenateShiftedRuns period shift lists+  = case shift of+        0 -> concatenateUnshifted lists+        _ -> concat shifted : concatenateUnshifted unshifted+          where (shifted, unshifted) = splitAt (fromIntegral shift) lists+  where concatenateUnshifted = concatenateRuns period
+ src/library/Language/Haskell/Formatter/Toolkit/Splitter.hs view
@@ -0,0 +1,72 @@+{-|+Description : Splitting lists on sublists+-}+module Language.Haskell.Formatter.Toolkit.Splitter (separate) where+import qualified Control.Applicative as Applicative+import qualified Data.List as List+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter.Toolkit.ListTool as ListTool+import qualified Language.Haskell.Formatter.Toolkit.Visit as Visit++{-| Strategy to split a list on sublists. -}+data Splitter a = Splitter{delimiterPolicy :: DelimiterPolicy,+                           delimiterQueue :: [[a]]}+                deriving (Eq, Ord, Show)++{-| What to do with the delimiters? -}+data DelimiterPolicy = Drop+                     | Separate+                     | MergeLeft+                     | MergeRight+                     deriving (Eq, Ord, Show)++{-| @separate d l@ splits @l@ on the delimiters @d@, which are matched in the+    given order. The delimiters are not kept.++    >>> separate ["pineapple", "pine"] "0pineapple1"+    ["0","1"]+    >>> separate ["pine", "pineapple"] "0pineapple1"+    ["0","apple1"] -}+separate :: (Eq a) => [[a]] -> [a] -> [[a]]+separate = split . createSplitter Drop+  where createSplitter rawDelimiterPolicy rawDelimiterQueue+          = Splitter{delimiterPolicy = rawDelimiterPolicy,+                     delimiterQueue = rawDelimiterQueue}++{-| @split s l@ splits @l@ according to the strategy @s@. -}+split :: (Eq a) => Splitter a -> [a] -> [[a]]+split splitter list+  = case delimiterPolicy splitter of+        Drop -> ListTool.takeEvery period parts+        Separate -> parts+        MergeLeft -> ListTool.concatenateRuns period parts+        MergeRight -> ListTool.concatenateShiftedRuns period shift parts+          where shift = 1+  where period = 2+        parts = rawSplit (delimiterQueue splitter) list++{-| @rawSplit s l@ splits @l@ on the sublists @s@, keeping the separators.++    prop> odd . length $ separate ["apple", "pine"] l -}+rawSplit :: (Eq a) => [[a]] -> [a] -> [[a]]+rawSplit delimiters = move [] []+  where move parts left [] = Monoid.mappend parts [left]+        move parts left right@(first : rest)+          = case stripFirstPrefix delimiters right of+                Nothing -> move parts (Monoid.mappend left [first]) rest+                Just (delimiter, suffix) -> move+                                              (Monoid.mappend parts+                                                 [left, delimiter])+                                              []+                                              suffix++{-| @stripFirstPrefix p l@ returns the first element of @p@ which is a prefix of+    @l@ and the rest of @l@. It returns 'Nothing' if there is no such element.++    >>> stripFirstPrefix ["\LF", "\CR\LF", "\CR"] "\CR\LFpine"+    Just ("\r\n","pine")+    >>> stripFirstPrefix ["apple"] "pineapple"+    Nothing -}+stripFirstPrefix :: (Eq a) => [[a]] -> [a] -> Maybe ([a], [a])+stripFirstPrefix prefixes list = Visit.findJust strip prefixes+  where strip prefix = (,) prefix Applicative.<$> List.stripPrefix prefix list
+ src/library/Language/Haskell/Formatter/Toolkit/StreamName.hs view
@@ -0,0 +1,23 @@+{-|+Description : Naming data streams+-}+module Language.Haskell.Formatter.Toolkit.StreamName+       (StreamName, createStreamName, standardInput) where++{-| An informal reference to a data stream. For example, this could be the name+    of a file stream to be used in error messages. -}+data StreamName = StreamName String+                deriving (Eq, Ord)++instance Show StreamName where+        show (StreamName string) = string++{-| Creates a 'StreamName'. 'show' is guaranteed to return this string.++    prop> show (createStreamName s) == s -}+createStreamName :: String -> StreamName+createStreamName = StreamName++{-| The standard input stream (stdin). -}+standardInput :: StreamName+standardInput = createStreamName "<stdin>"
+ src/library/Language/Haskell/Formatter/Toolkit/Visit.hs view
@@ -0,0 +1,50 @@+{-|+Description : Container utilities+-}+module Language.Haskell.Formatter.Toolkit.Visit+       (findJust, orderByKey, compose, halfZipWith,+        mapAccumulateLeftWithCreation)+       where+import qualified Data.Foldable as Foldable+import qualified Data.List as List+import qualified Data.Maybe as Maybe+import qualified Data.Monoid as Monoid+import qualified Data.Ord as Ord+import qualified Data.Traversable as Traversable++{-| @findJust f c@ returns the first non-'Nothing' value of @c@ mapped with @f@,+    or 'Nothing' if there is none. -}+findJust :: (Functor t, Foldable.Foldable t) => (a -> Maybe b) -> t a -> Maybe b+findJust function = Foldable.asum . fmap function++{-| @compose f@ returns the function composition of the elements of @f@. -}+compose :: (Foldable.Foldable t) => t (a -> a) -> a -> a+compose = Monoid.appEndo . Foldable.foldMap Monoid.Endo++{-| @orderByKey k l@ orders @l@ by the sort keys generated by @k@. -}+orderByKey :: (Ord b) => (a -> b) -> [a] -> [a]+orderByKey = List.sortBy . Ord.comparing++{-| @halfZipWith m b e@ zips the elements of @b@ and @e@ with @m@, using the+    structure of @b@. 'Nothing' is returned if and only if @b@ does not have+    enough elements. -}+halfZipWith ::+              (Traversable.Traversable t, Foldable.Foldable f) =>+              (a -> b -> c) -> t a -> f b -> Maybe (t c)+halfZipWith merge base extension = Traversable.sequenceA zippedMaybe+  where (_, zippedMaybe) = Traversable.mapAccumL process extensionList base+        process [] _ = ([], Nothing)+        process (extensionElement : list) baseElement+          = (list, Just $ merge baseElement extensionElement)+        extensionList = Foldable.toList extension++{-| Like 'Traversable.mapAccumL', but with a function to create the base. -}+mapAccumulateLeftWithCreation ::+                                (Traversable.Traversable t) =>+                                (a -> b -> (a, c)) ->+                                  (b -> a) -> t b -> (Maybe a, t c)+mapAccumulateLeftWithCreation process createBase+  = Traversable.mapAccumL processMaybe Nothing+  where processMaybe maybeBefore element = (Just after, element')+          where (after, element') = process before element+                before = Maybe.fromMaybe (createBase element) maybeBefore
+ testsuite/resources/examples/default_style.yaml view
@@ -0,0 +1,27 @@+# Lines should be no longer than this length in characters.+line_length_limit: 80++# How much to spread code over multiple lines instead of trying to fill a single+# line. More precisely, this guides the ratio of "line_length_limit" to the+# ribbon length (the number of characters on a line without leading and trailing+# whitespace). Only the lowest value of 1 forces "line_length_limit" to be+# applied strictly.+# Reference: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.38.8777+ribbons_per_line: 1++# Indentation lengths in characters.+indentations:+    class: 8     # "class" and "instance" declarations.+    do: 3        # "do" notation. +    case: 4      # Body of "case" expressions.+    let: 4       # Declarations in "let" expressions.+    where: 6     # Declarations in "where" clauses.+    onside: 2    # Continuation lines which would otherwise be offside.++# Decides which parts of the code to sort.+order:+    # Sequence of import declarations.+    import_declarations: true++    # Entities of import lists.+    import_entities: true
+ testsuite/src/Language/Haskell/Formatter/Internal/Tests.hs view
@@ -0,0 +1,61 @@+{-|+Description : Tests for internal parts+-}+module Language.Haskell.Formatter.Internal.Tests (tests) where+import qualified Data.List as List+import qualified Language.Haskell.Formatter as Formatter+import qualified Language.Haskell.Formatter.Internal.StyleFileFormat+       as StyleFileFormat+import qualified Language.Haskell.Formatter.Internal.TreeFormat as TreeFormat+import qualified System.FilePath as FilePath+import qualified Test.Tasty as Tasty+import qualified Test.Tasty.HUnit as HUnit++tests :: IO Tasty.TestTree+tests = return testDefaultStyleFile++testDefaultStyleFile :: Tasty.TestTree+testDefaultStyleFile = Tasty.testGroup name defaultStyleFileTests+  where name = "Default style file"+        defaultStyleFileTests+          = [testDefaultStyleFileUsesDefaults,+             testReadmeContainsDefaultStyleFile]++testDefaultStyleFileUsesDefaults :: Tasty.TestTree+testDefaultStyleFileUsesDefaults = HUnit.testCase name assertion+  where name = "Uses defaults"+        assertion+          = do maybeStyle <- getStyle+               case maybeStyle of+                   Left errorMessage -> HUnit.assertFailure errorMessage+                   Right style -> style HUnit.@?= defaultStyle+        getStyle+          = TreeFormat.parseYamlFile StyleFileFormat.treeFormat defaultStyle+              defaultStyleFile+        defaultStyle+          = Formatter.configurationStyle Formatter.defaultConfiguration++defaultStyleFile :: FilePath+defaultStyleFile+  = "testsuite" FilePath.</> "resources" FilePath.</> "examples" FilePath.</>+      "default_style.yaml"++testReadmeContainsDefaultStyleFile :: Tasty.TestTree+testReadmeContainsDefaultStyleFile = HUnit.testCase name assertion+  where name = "Is contained in readme"+        assertion+          = do styleString <- readFile defaultStyleFile+               readme <- readFile readmeFile+               let isContained = isContainedInReadme styleString readme+               HUnit.assertBool message isContained+        readmeFile = "README.rst"+        message+          = concat+              [show readmeFile, " must contain ", show defaultStyleFile,+               ", but it does not."]++isContainedInReadme :: String -> String -> Bool+isContainedInReadme file = List.isInfixOf preparedFile+  where preparedFile = indent file+        indent = unlines . fmap (indentation ++) . lines+        indentation = "    "
+ testsuite/src/Language/Haskell/Formatter/Tests.hs view
@@ -0,0 +1,62 @@+{-|+Description : Tests for formatting based on source code files+-}+module Language.Haskell.Formatter.Tests (tests) where+import qualified Control.Applicative as Applicative+import qualified Control.Exception as Exception+import qualified Data.Map.Strict as Map+import qualified Data.Set as Set+import qualified Language.Haskell.Formatter as Formatter+import qualified Language.Haskell.Formatter.Toolkit.FileTesting as FileTesting+import qualified Language.Haskell.Formatter.Toolkit.TestTool as TestTool+import qualified System.FilePath as FilePath+import qualified Test.Tasty as Tasty+import qualified Test.Tasty.HUnit as HUnit++tests :: IO Tasty.TestTree+tests+  = Tasty.testGroup name Applicative.<$> FileTesting.fileTestForest create root+  where name = "Formatting files"+        root = "testsuite" FilePath.</> "resources" FilePath.</> "source"++create ::+       Either Exception.IOException (Map.Map FilePath String) ->+         [Tasty.TestTree]+create (Left exception) = [TestTool.testingError name $ show exception]+  where name = "I/O exception"+create (Right testMap)+  = if actualKeys == expectedKeys then fileTests input expectedOutput else+      [TestTool.testingError name message]+  where actualKeys = Map.keysSet testMap+        expectedKeys = Set.fromList [inputKey, outputKey]+        input = testMap Map.! inputKey+        expectedOutput = testMap Map.! outputKey+        name = "Set of filenames"+        message+          = concat+              ["The filenames are ", setString actualKeys, " instead of ",+               setString expectedKeys, "."]+        setString = show . Set.elems++inputKey :: FilePath+inputKey = "Input.hs"++outputKey :: FilePath+outputKey = "Output.hs"++fileTests :: String -> String -> [Tasty.TestTree]+fileTests input expectedOutput+  = [HUnit.testCase "Formatting once" base,+     HUnit.testCase "Idempotence" idempotence]+  where base = testFormatting inputKey input expectedOutput+        idempotence = testFormatting outputKey expectedOutput expectedOutput++testFormatting :: FilePath -> String -> String -> HUnit.Assertion+testFormatting inputFile input expectedOutput+  = case Formatter.format configuration input of+        Left unexpectedError -> HUnit.assertFailure $ show unexpectedError+        Right actualOutput -> actualOutput HUnit.@?= expectedOutput+  where configuration+          = Formatter.defaultConfiguration{Formatter.configurationStreamName =+                                             inputStream}+        inputStream = Formatter.createStreamName inputFile
+ testsuite/src/Language/Haskell/Formatter/Toolkit/FileTesting.hs view
@@ -0,0 +1,35 @@+{-|+Description : Test data based on file trees+-}+module Language.Haskell.Formatter.Toolkit.FileTesting (fileTestForest) where+import qualified Control.Exception as Exception+import qualified Data.Map.Strict as Map+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.Formatter.Internal.MapTree as MapTree+import qualified Language.Haskell.Formatter.Toolkit.FileTree as FileTree+import qualified Test.Tasty as Tasty++fileTestForest ::+               (Either Exception.IOException (Map.Map FilePath String) ->+                  [Tasty.TestTree])+                 -> FilePath -> IO [Tasty.TestTree]+fileTestForest = folderTestForest readFile++folderTestForest ::+                   (Monoid.Monoid a) =>+                   (FilePath -> IO a) ->+                     (Either Exception.IOException (Map.Map FilePath a) ->+                        [Tasty.TestTree])+                       -> FilePath -> IO [Tasty.TestTree]+folderTestForest create createTests rootFolder+  = do fileForest <- FileTree.collectFiles create rootFolder+       return . createTestForest $ MapTree.summarizeLeaves fileForest+  where createTestForest = testForest createTests++testForest ::+           (a -> [Tasty.TestTree]) ->+             MapTree.MapTree Tasty.TestName a -> [Tasty.TestTree]+testForest createTests (MapTree.Leaf value) = createTests value+testForest createTests (MapTree.Node forest)+  = Map.elems $ Map.mapWithKey testTree forest+  where testTree label = Tasty.testGroup label . testForest createTests
+ testsuite/src/Language/Haskell/Formatter/Toolkit/FileTree.hs view
@@ -0,0 +1,35 @@+{-|+Description : Creating trees from files and folders+-}+module Language.Haskell.Formatter.Toolkit.FileTree (collectFiles) where+import qualified Control.Applicative as Applicative+import qualified Control.Exception as Exception+import qualified Data.Map.Strict as Map+import qualified Language.Haskell.Formatter.Internal.MapTree as MapTree+import qualified System.Directory.Tree as Tree++collectFiles ::+             (FilePath -> IO a) ->+               FilePath ->+                 IO+                   (MapTree.MapForest FilePath (Either Exception.IOException a))+collectFiles create rootFolder+  = do rawTree <- Tree.dirTree Applicative.<$>+                    Tree.readDirectoryWith create rootFolder+       return $ transformRawTree rawTree++transformRawTree ::+                 Tree.DirTree a ->+                   MapTree.MapForest FilePath (Either Exception.IOException a)+transformRawTree root = transform [root]+  where transform = Map.fromList . fmap bind+        bind rawTree = (label, tree)+          where label = Tree.name rawTree+                tree+                  = case rawTree of+                        Tree.Failed{Tree.err = exception} -> MapTree.Leaf . Left+                                                               $ exception+                        Tree.File{Tree.file = value} -> MapTree.Leaf $+                                                          Right value+                        Tree.Dir{Tree.contents = forest} -> MapTree.Node $+                                                              transform forest
+ testsuite/src/Language/Haskell/Formatter/Toolkit/TestTool.hs view
@@ -0,0 +1,53 @@+{-|+Description : Testing utilities+-}+module Language.Haskell.Formatter.Toolkit.TestTool+       (testingError, standardSourceCodeTest, documentationTest) where+import qualified Data.List as List+import qualified Data.Monoid as Monoid+import qualified Language.Haskell.HLint as HLint+import qualified Test.DocTest as DocTest+import qualified Test.Tasty as Tasty+import qualified Test.Tasty.HUnit as HUnit++testingError :: Tasty.TestName -> String -> Tasty.TestTree+testingError name = HUnit.testCase name . HUnit.assertFailure++standardSourceCodeTest :: FilePath -> Tasty.TestTree+standardSourceCodeTest file = HUnit.testCase file assertion+  where assertion = sequence_ assertions+        assertions = [lineLengthAssertion file, codeHintAssertion file]++lineLengthAssertion :: FilePath -> HUnit.Assertion+lineLengthAssertion file = readFile file >>= test+  where test string = HUnit.assertBool message $ null indices+          where message+                  = concat+                      ["The following lines are longer than ", show lengthLimit,+                       " characters: ", show indices]+                indices+                  = [index | (line, index) <- indexedLines,+                     length line > lengthLimit]+                indexedLines = zip (lines string) [baseLine ..]+        lengthLimit = 80+        baseLine = 1 :: Integer++codeHintAssertion :: FilePath -> HUnit.Assertion+codeHintAssertion file+  = do errors <- HLint.hlint arguments+       HUnit.assertBool (showLines errors) $ null errors+  where arguments = [suppressFeedback, file]+        suppressFeedback = "--quiet"+        showLines = unlines . fmap show++documentationTest :: [FilePath] -> FilePath -> Tasty.TestTree+documentationTest searchFolders file = HUnit.testCase file assertion+  where assertion = DocTest.doctest arguments+        arguments = [searchPathAppendix, file]+        searchPathAppendix = Monoid.mappend "-i" appendedPaths+        appendedPaths+          = List.intercalate [pathSeparator] $ fmap escape searchFolders+        pathSeparator = ':'+        escape = (>>= replace)+        replace character = Monoid.mappend prefix [character]+          where prefix = ['\\' | character == pathSeparator]
+ testsuite/src/Main.hs view
@@ -0,0 +1,52 @@+{-|+Description : Root of test suite+-}+module Main (main) where+import qualified Control.Applicative as Applicative+import qualified Data.Set as Set+import qualified Language.Haskell.Formatter.Internal.Tests as Internal+import qualified Language.Haskell.Formatter.Tests as Formatter+import qualified Language.Haskell.Formatter.Toolkit.TestTool as TestTool+import qualified System.FilePath as FilePath+import qualified System.FilePath.Find as Find+import qualified Test.Tasty as Tasty++main :: IO ()+main = sequence tests >>= Tasty.defaultMain . Tasty.testGroup name+  where name = "Root"++tests :: [IO Tasty.TestTree]+tests+  = [sourceCodeStandardTests, documentationTests, Formatter.tests,+     Internal.tests]++sourceCodeStandardTests :: IO Tasty.TestTree+sourceCodeStandardTests+  = createTestTree TestTool.standardSourceCodeTest Find.always name+  where name = "Source code standard"++createTestTree ::+               (FilePath -> Tasty.TestTree) ->+                 Find.RecursionPredicate -> Tasty.TestName -> IO Tasty.TestTree+createTestTree test recurse rootName+  = do files <- concat Applicative.<$> mapM (collectSourceFiles recurse) roots+       return . Tasty.testGroup rootName $ fmap test files++collectSourceFiles :: Find.RecursionPredicate -> FilePath -> IO [FilePath]+collectSourceFiles recurse = Find.find recurse isSourceFile+  where isSourceFile = isFile Find.&&? hasSourceExtension+        isFile = Find.fileType Find.==? Find.RegularFile+        hasSourceExtension = fmap (`Set.member` sourceExtensions) Find.extension+        sourceExtensions = Set.fromList [".hs", ".lhs"]++roots :: [FilePath]+roots+  = ["src" FilePath.</> "library", "src" FilePath.</> "executable",+     "testsuite" FilePath.</> "src"]++documentationTests :: IO Tasty.TestTree+documentationTests+  = createTestTree (TestTool.documentationTest roots) noRecursion name+  where noRecursion = Find.depth Find.==? rootDepth+        rootDepth = 0+        name = "Documentation (doctest)"