merging with the org-babel repository

contrib/babel/.gitignore

@@ -0,0 +1,13 @@
+*~
+*.html
+doc/*
+*.css
+.Rhistory
+.Rdata
+data
+other
+# tangled files
+test-tangle.sh
+test-tangle-none.rb
+test-tangle-special.rb
+test-tangle-load.el

contrib/babel/COPYING

@@ -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>.

contrib/babel/README

@@ -0,0 +1,4 @@
+org-babel.el --- executable source code blocks in org-mode
+
+- for information on org see the http://org-mode.org
+- for information on org-babel see the http://eschulte.github.com/org-babel/

contrib/babel/intro.org

@@ -0,0 +1,39 @@
+
+* Introduction
+  [[http:orgmode.org][Emacs org-mode]] is an exceptionally rich emacs mode based around
+  hierachically-structured text documents. The environment that has
+  been designed around this central concept provides support for many
+  different usage modes. At a high level, important areas include note
+  taking, project planning and document publishing. Working with the
+  text files is made efficient by document navigation and editing
+  facilities which include creation, folding, restructuring and
+  repositioning of subtrees and list items, and a plain-text
+  spreadsheet for tabular data. Nevertheless, org is unobtrusive: an
+  org-mode buffer may make use of only the most basic features, or
+  even none at all. It is notoriously difficult to describe org
+  briefly: good starting points include [...].
+
+  Org therefore provides an ideal environment for literate
+  programming: chunks of source code in any language can be embedded
+  within the org-mode text file. The hierarchical structure of the
+  document may reflect, for example, the logic of the problem being
+  addressed or the structure of the project within which the problem
+  arises. Embedding source code within Org documents means that, for
+  example, the project-planning features of org-mode are immediately
+  available, and that the document may be published to HTML and LaTeX
+  with appropriate formatting of the code.
+
+  In addition to the standard org functionality, org provides
+  convenient switching between the org buffer with embedded code, and
+  a separate buffer in the native language mode. Thus literate
+  programming with org-mode does not impact upon language-specific
+  modes for working with source code in emacs. For example, when
+  working with [[http://www.r-project.org/][R]] code, you do not leave [[http://ess.r-project.org/][ess-mode]] until you flick back
+  from the code buffer to view it embedded within an org buffer, which
+  may also contain chunks of code in other languages.
+  
+* Org-Babel
+  Org-Babel provides several extensions to the above-described method of
+  working with source code in org mode:
+  1. Code block execution for interpreted languages (python, ruby, shell, R, perl)
+  2. [...]

contrib/babel/library-of-babel.org

@@ -0,0 +1,85 @@
+#+title:    The Library of Babel
+#+SEQ_TODO: TODO PROPOSED | DONE DEFERRED REJECTED
+#+OPTIONS:  H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:t -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:  odd hideblocks
+
+#+begin_html 
+  <div id="subtitle">
+    <p>
+      off-the-shelf functions for data analysis and plotting using <a href="org-babel-worg.html">org-babel</a><br/>
+      <a href="http://downlode.org/Etext/library_of_babel.html">Full text of the Borges short story</a>
+    </p>
+  </div>
+  <div id="logo">
+    <p>
+      <img src="images/library-of-babel.png"  alt="images/tower-of-babel.png" />
+      <div id="attr">
+        from <a href="http://www.poetryfoundation.org/harriet/2008/01/random-poetry-02/">poetryfoundation.org</a>
+      </div>
+    </p>  
+  </div>
+#+end_html
+
+* Introduction
+  The Library of Babel is an extensible collection of ready-made and
+  easily-shortcut-callable source-code blocks for handling common
+  tasks.  Org-babel comes pre-populated with the source-code blocks
+  located in this file. It is possible to add source-code blocks from
+  any org-mode file to the library by calling =(org-babel-lob-ingest
+  "path/to/file.org")=.
+
+* Plotting code
+
+** R
+  Plot column 2 (y axis) against column 1 (x axis). Columns 3 and beyond, if present, are ignored.
+
+#+srcname: R-plot(data=R-plot-example-data)
+#+begin_src R :session *R*
+plot(data)
+#+end_src
+
+#+tblname: R-plot-example-data
+| 1 |  2 |
+| 2 |  4 |
+| 3 |  9 |
+| 4 | 16 |
+| 5 | 25 |
+
+#+lob: R-plot(data=R-plot-example-data)
+
+#+resname: R-plot(data=R-plot-example-data)
+: nil
+
+** Gnuplot
+
+* Table/Matrix manipulation
+
+Elegant lisp code for transposing a matrix.
+
+#+tblname: transpose-example
+| 1 | 2 | 3 |
+| 4 | 5 | 6 |
+
+#+srcname: transpose
+#+begin_src emacs-lisp :var table=transpose-example
+  (apply #'mapcar* #'list table)
+#+end_src
+
+#+resname:
+| 1 | 4 |
+| 2 | 5 |
+| 3 | 6 |
+
+* Misc
+#+srcname: python-identity(a=1)
+#+begin_src python
+a
+#+end_src
+
+#+srcname: python-add(a=1, b=2)
+#+begin_src python
+a + b
+#+end_src
+
+
+

contrib/babel/lisp/langs/org-babel-R.el

@@ -0,0 +1,160 @@
+;;; org-babel-R.el --- org-babel functions for R code evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research, R, statistics
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating R code
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "R")
+
+(add-to-list 'org-babel-tangle-langs '("R" "r"))
+
+(defun org-babel-execute:R (body params)
+  "Execute a block of R code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing R source code block...")
+  (save-window-excursion
+    (let ((full-body (concat
+		      (mapconcat ;; define any variables
+		       (lambda (pair)
+			 (org-babel-R-assign-elisp (car pair) (cdr pair)))
+		       vars "\n") "\n" body "\n"))
+	  (session (org-babel-R-initiate-session session))
+	  (column-names-p (cdr (assoc :colnames params))))
+      (org-babel-R-evaluate session full-body result-type column-names-p))))
+
+(defun org-babel-prep-session:R (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-R-initiate-session session))
+         (vars (org-babel-ref-variables params)))
+    (mapc (lambda (pair) (org-babel-R-assign-elisp session (car pair) (cdr pair))) vars)))
+
+;; helper functions
+
+(defun org-babel-R-quote-tsv-field (s)
+  "Quote field S for export to R."
+  (if (stringp s)
+      (concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"") "\"")
+    (format "%S" s)))
+
+(defun org-babel-R-assign-elisp (name value)
+  "Read the elisp VALUE into a variable named NAME."
+  (if (listp value)
+      (let ((transition-file (make-temp-file "org-babel-R-import")))
+        ;; ensure VALUE has an orgtbl structure (depth of at least 2)
+        (unless (listp (car value)) (setq value (list value)))
+        (with-temp-file transition-file
+          (insert (orgtbl-to-tsv value '(:fmt org-babel-R-quote-tsv-field)))
+          (insert "\n"))
+        (format "%s <- read.table(\"%s\", header=%s, sep=\"\\t\", as.is=TRUE)"
+                name transition-file (if (eq (second value) 'hline) "TRUE" "FALSE")))
+    (format "%s <- %s" name (org-babel-R-quote-tsv-field value))))
+
+(defun org-babel-R-initiate-session (session)
+  "If there is not a current R process then create one."
+  (unless (string= session "none")
+    (setq session (or session "*R*"))
+    (if (org-babel-comint-buffer-livep session)
+        session
+      (save-window-excursion
+	(R)
+	(rename-buffer (if (bufferp session) (buffer-name session)
+			 (if (stringp session) session (buffer-name)))) (current-buffer)))))
+
+(defvar org-babel-R-eoe-indicator "'org_babel_R_eoe'")
+(defvar org-babel-R-eoe-output "[1] \"org_babel_R_eoe\"")
+(defvar org-babel-R-wrapper-method "main <- function ()\n{\n%s\n}
+write.table(main(), file=\"%s\", sep=\"\\t\", na=\"nil\",row.names=FALSE, col.names=%s, quote=FALSE)")
+
+(defun org-babel-R-evaluate (buffer body result-type column-names-p)
+  "Pass BODY to the R process in BUFFER.  If RESULT-TYPE equals
+'output then return a list of the outputs of the statements in
+BODY, if RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (if (not session)
+      ;; external process evaluation
+      (let ((in-tmp-file (make-temp-file "R-in-functional-results"))
+            (out-tmp-file (make-temp-file "R-out-functional-results")))
+        (case result-type
+          (output
+           (with-temp-file in-tmp-file (insert body))
+           (shell-command-to-string (format "R --slave --no-save < '%s' > '%s'"
+					    in-tmp-file out-tmp-file))
+	   (with-temp-buffer (insert-file-contents out-tmp-file) (buffer-string)))
+          (value
+           (with-temp-file in-tmp-file
+             (insert (format org-babel-R-wrapper-method
+			     body out-tmp-file (if column-names-p "TRUE" "FALSE"))))
+           (shell-command (format "R --no-save < '%s'" in-tmp-file))
+	   (org-babel-R-process-value-result
+	    (org-babel-import-elisp-from-file out-tmp-file) column-names-p))))
+    ;; comint session evaluation
+    (org-babel-comint-in-buffer buffer
+      (let* ((tmp-file (make-temp-file "org-babel-R"))
+	     (full-body
+	      (case result-type
+		(value
+		 (mapconcat #'org-babel-chomp (list body
+						    (format "write.table(.Last.value, file=\"%s\", sep=\"\\t\", na=\"nil\",row.names=FALSE, col.names=%s, quote=FALSE)" tmp-file (if column-names-p "TRUE" "FALSE"))
+						    org-babel-R-eoe-indicator) "\n"))
+		(output
+		 (mapconcat #'org-babel-chomp (list body org-babel-R-eoe-indicator) "\n"))))
+	     (raw (org-babel-comint-with-output buffer org-babel-R-eoe-output nil
+                    (insert full-body) (inferior-ess-send-input)))
+	     broke results)
+        (case result-type
+          (value (org-babel-R-process-value-result
+		  (org-babel-import-elisp-from-file tmp-file) column-names-p))
+          (output
+	   (flet ((extractor
+		   (el)
+		   (if (or broke
+			   (and (string-match (regexp-quote org-babel-R-eoe-output) el)
+				(setq broke t)))
+		       nil
+		     (if (= (length el) 0)
+			 nil
+		       (if (string-match comint-prompt-regexp el)
+			   (substring el (match-end 0))
+			 el)))))
+	     (mapconcat
+	      #'identity
+	      (delete nil (mapcar #'extractor (mapcar #'org-babel-chomp raw))) "\n"))))))))
+
+(defun org-babel-R-process-value-result (result column-names-p)
+  "R-specific processing of return value prior to return to org-babel.
+
+Currently, insert hline if column names in output have been requested."
+  (if column-names-p
+      (cons (car result) (cons 'hline (cdr result)))
+    result))
+  
+
+(provide 'org-babel-R)
+;;; org-babel-R.el ends here

contrib/babel/lisp/langs/org-babel-asymptote.el

@@ -0,0 +1,71 @@
+;;; org-babel-asymptote.el --- org-babel functions for asymptote evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating asymptote source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in asymptote
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments
+;;
+;; 4) there are no variables (at least for now)
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "asymptote")
+
+(add-to-list 'org-babel-tangle-langs '("asymptote" "asymptote"))
+
+(defvar org-babel-default-header-args:asymptote '((:results . "file") (:exports . "results"))
+  "Default arguments to use when evaluating a asymptote source block.")
+
+(defun org-babel-execute:asymptote (body params)
+  "Execute a block of Asymptote code with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (message "executing Asymptote source code block")
+  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
+         (out-file (cdr (assoc :file params)))
+         (format (or (and (string-match ".+\\.\\(.+\\)" out-file)
+                          (match-string 1 out-file))
+                     "pdf"))
+         (cmdline (cdr (assoc :cmdline params)))
+         (in-file (make-temp-file "org-babel-asymptote")))
+    (with-temp-file in-file (insert body))
+    (message (concat "asy -globalwrite -f " format " -o " out-file " " cmdline " " in-file))
+    (shell-command (concat "asy -globalwrite -f " format " -o " out-file " " cmdline " " in-file))
+    out-file))
+
+(defun org-babel-prep-session:asymptote (session params)
+  (error "Asymptote does not support sessions"))
+
+(provide 'org-babel-asymptote)
+;;; org-babel-asymptote.el ends here

contrib/babel/lisp/langs/org-babel-css.el

@@ -0,0 +1,50 @@
+;;; org-babel-css.el --- org-babel functions for css evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Since CSS can't be executed, this file exists solely for tangling
+;; CSS from org-mode files.
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "css")
+
+(add-to-list 'org-babel-tangle-langs '("css" "css" nil t))
+
+(defun org-babel-execute:css (body params)
+  "Execute a block of CSS code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing CSS source code block")
+  body)
+
+(defun org-babel-prep-session:css (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (error "CSS sessions are nonsensical"))
+
+(provide 'org-babel-css)
+;;; org-babel-css.el ends here

contrib/babel/lisp/langs/org-babel-ditaa.el

@@ -0,0 +1,71 @@
+;;; org-babel-ditaa.el --- org-babel functions for ditaa evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating ditaa source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in ditaa
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments
+;;
+;; 4) there are no variables (at least for now)
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "ditaa")
+
+(add-to-list 'org-babel-tangle-langs '("ditaa" "ditaa"))
+
+(defvar org-babel-default-header-args:ditaa
+  '((:results . "file") (:exports . "results"))
+  "Default arguments to use when evaluating a ditaa source block.")
+
+(defun org-babel-execute:ditaa (body params)
+  "Execute a block of Ditaa code with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (message "executing Ditaa source code block")
+  (let ((result-params (split-string (or (cdr (assoc :results params)) "")))
+        (out-file (cdr (assoc :file params)))
+        (cmdline (cdr (assoc :cmdline params)))
+        (in-file (make-temp-file "org-babel-ditaa")))
+    (unless (file-exists-p org-ditaa-jar-path)
+      (error (format "Could not find ditaa.jar at %s" org-ditaa-jar-path)))
+    (with-temp-file in-file (insert body))
+    (message (concat "java -jar " org-ditaa-jar-path " " cmdline " " in-file " " out-file))
+    (shell-command (concat "java -jar " org-ditaa-jar-path " " cmdline " " in-file " " out-file))
+    out-file))
+
+(defun org-babel-prep-session:ditaa (session params)
+  (error "Ditaa does not support sessions"))
+
+(provide 'org-babel-ditaa)
+;;; org-babel-ditaa.el ends here

contrib/babel/lisp/langs/org-babel-dot.el

@@ -0,0 +1,70 @@
+;;; org-babel-dot.el --- org-babel functions for dot evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating dot source code.
+;;
+;; For information on dot see http://www.graphviz.org/
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in dot
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments
+;;
+;; 4) there are no variables (at least for now)
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "dot")
+
+(add-to-list 'org-babel-tangle-langs '("dot" "dot"))
+
+(defvar org-babel-default-header-args:dot '((:results . "file") (:exports . "results"))
+  "Default arguments to use when evaluating a dot source block.")
+
+(defun org-babel-execute:dot (body params)
+  "Execute a block of Dot code with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (message "executing Dot source code block")
+  (let ((result-params (split-string (or (cdr (assoc :results params)) "")))
+        (out-file (cdr (assoc :file params)))
+        (cmdline (cdr (assoc :cmdline params)))
+        (in-file (make-temp-file "org-babel-dot")))
+    (with-temp-file in-file (insert body))
+    (message (concat "dot " in-file " " cmdline " -o " out-file))
+    (shell-command (concat "dot " in-file " " cmdline " -o " out-file))
+    out-file))
+
+(defun org-babel-prep-session:dot (session params)
+  (error "Dot does not support sessions"))
+
+(provide 'org-babel-dot)
+;;; org-babel-dot.el ends here

contrib/babel/lisp/langs/org-babel-gnuplot.el

@@ -0,0 +1,184 @@
+;;; org-babel-gnuplot.el --- org-babel functions for gnuplot evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating gnuplot source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) we are generally only going to return results of type "file"
+;;
+;; 2) we are adding the "file" and "cmdline" header arguments
+
+;;; Requirements:
+
+;; - gnuplot :: http://www.gnuplot.info/
+;; 
+;; - gnuplot-mode :: http://cars9.uchicago.edu/~ravel/software/gnuplot-mode.html
+
+;;; Code:
+(require 'org-babel)
+(require 'gnuplot)
+
+(org-babel-add-interpreter "gnuplot")
+
+(add-to-list 'org-babel-tangle-langs '("gnuplot" "gnuplot"))
+
+(defvar org-babel-default-header-args:gnuplot
+  '((:results . "file") (:exports . "results") (:session . nil))
+  "Default arguments to use when evaluating a gnuplot source block.")
+
+(defvar org-babel-gnuplot-timestamp-fmt nil)
+
+(defun org-babel-gnuplot-process-vars (params)
+  "Extract variables from PARAMS and process the variables
+dumping all vectors into files returning an association list of
+variable names and the value to be used in the gnuplot code."
+  (mapcar
+   (lambda (pair)
+     (cons
+      (car pair) ;; variable name
+      (if (listp (cdr pair)) ;; variable value
+          (org-babel-gnuplot-table-to-data
+           (cdr pair) (make-temp-file "org-babel-gnuplot") params)
+        (cdr pair))))
+   (org-babel-ref-variables params)))
+
+(defun org-babel-execute:gnuplot (body params)
+  "Execute a block of Gnuplot code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing Gnuplot source code block")
+  (let* ((vars (org-babel-gnuplot-process-vars params))
+         (out-file (cdr (assoc :file params)))
+         (term (or (cdr (assoc :term params))
+                   (when out-file (file-name-extension out-file))))
+         (cmdline (cdr (assoc :cmdline params)))
+         (in-file (make-temp-file "org-babel-ditaa"))
+	 (title (plist-get params :title))
+         (lines (plist-get params :line))
+	 (sets (plist-get params :set))
+	 (x-labels (plist-get params :xlabels))
+	 (y-labels (plist-get params :ylabels))
+	 (timefmt (plist-get params :timefmt))
+         (time-ind (or (plist-get params :timeind)
+                       (when timefmt 1))))
+    (flet ((add-to-body (text)
+                        (setq body (concat text "\n" body))))
+      ;; append header argument settings to body
+      (when title (add-to-body (format "set title '%s'" title))) ;; title
+      (when lines (mapc (lambda (el) (add-to-body el)) lines)) ;; line
+      (when sets
+        (mapc (lambda (el) (add-to-body (format "set %s" el))) sets))
+      (when x-labels
+        (add-to-body
+         (format "set xtics (%s)"
+                 (mapconcat (lambda (pair)
+                              (format "\"%s\" %d" (cdr pair) (car pair)))
+                            x-labels ", "))))
+      (when y-labels
+        (add-to-body
+         (format "set ytics (%s)"
+                 (mapconcat (lambda (pair)
+                              (format "\"%s\" %d" (cdr pair) (car pair)))
+                            y-labels ", "))))
+      (when time-ind
+        (add-to-body "set xdata time")
+        (add-to-body (concat "set timefmt \""
+                             (or timefmt
+                                 "%Y-%m-%d-%H:%M:%S") "\"")))
+      (when out-file (add-to-body (format "set output \"%s\"" out-file)))
+      (when term (add-to-body (format "set term %s" term)))
+      ;; insert variables into code body: this should happen last
+      ;; placing the variables at the *top* of the code in case their
+      ;; values are used later
+      (add-to-body (mapconcat
+                    (lambda (pair) (format "%s = \"%s\"" (car pair) (cdr pair)))
+                    vars "\n"))
+      ;; evaluate the code body with gnuplot
+      (if (string= session "none")
+          (let ((script-file (make-temp-file "org-babel-gnuplot-script")))
+            (with-temp-file script-file
+              (insert (concat body "\n")))
+            (message "gnuplot \"%s\"" script-file)
+            (message (shell-command-to-string (format "gnuplot \"%s\"" script-file))))
+        (with-temp-buffer
+          (insert (concat body "\n"))
+          (gnuplot-mode)
+          (gnuplot-send-buffer-to-gnuplot)))
+      out-file)))
+
+(defun org-babel-prep-session:gnuplot (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-gnuplot-initiate-session session))
+         (vars (org-babel-ref-variables params))
+         (var-lines (mapconc
+                     (lambda (pair) (format "%s = \"%s\"" (car pair) (cdr pair)))
+                     vars)))
+    (org-babel-comint-in-buffer session
+      (mapc (lambda (var-line)
+              (insert var-line) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)
+              (sit-for .1) (goto-char (point-max))) var-lines))))
+
+(defun org-babel-gnuplot-initiate-session (&optional session)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session.  The current
+`gnuplot-mode' doesn't provide support for multiple sessions."
+  (unless (string= session "none")
+    (save-window-excursion (gnuplot-send-string-to-gnuplot "" "line")
+                           (current-buffer))))
+
+(defun org-babel-gnuplot-quote-timestamp-field (s)
+  "Convert field S from timestamp to Unix time and export to gnuplot."
+  (format-time-string org-babel-gnuplot-timestamp-fmt (org-time-string-to-time s)))
+
+(defun org-babel-gnuplot-quote-tsv-field (s)
+  "Quote field S for export to gnuplot."
+  (unless (stringp s)
+    (setq s (format "%s" s)))
+  (if (string-match org-table-number-regexp s) s
+    (if (string-match org-ts-regexp3 s)
+	(org-babel-gnuplot-quote-timestamp-field s)
+      (concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"") "\""))))
+
+(defun org-babel-gnuplot-table-to-data (table data-file params)
+  "Export TABLE to DATA-FILE in a format readable by gnuplot.
+Pass PARAMS through to `orgtbl-to-generic' when exporting TABLE."
+  (with-temp-file data-file
+    (make-local-variable 'org-babel-gnuplot-timestamp-fmt)
+    (setq org-babel-gnuplot-timestamp-fmt (or
+                                           (plist-get params :timefmt)
+                                           "%Y-%m-%d-%H:%M:%S"))
+    (insert (orgtbl-to-generic
+	     table
+	     (org-combine-plists
+	      '(:sep "\t" :fmt org-babel-gnuplot-quote-tsv-field)
+	      params))))
+  data-file)
+
+(provide 'org-babel-gnuplot)
+;;; org-babel-gnuplot.el ends here

contrib/babel/lisp/langs/org-babel-haskell.el

@@ -0,0 +1,102 @@
+;;; org-babel-haskell.el --- org-babel functions for haskell evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating haskell source code.  This one will
+;; be sort of tricky because haskell programs must be compiled before
+;; they can be run, but haskell code can also be run through an
+;; interactive interpreter.
+;;
+;; For now lets only allow evaluation using the haskell interpreter.
+
+;;; Requirements:
+
+;; - haskell-mode :: http://www.iro.umontreal.ca/~monnier/elisp/#haskell-mode
+;;
+;; - inf-haskell :: http://www.iro.umontreal.ca/~monnier/elisp/#haskell-mode
+
+;;; Code:
+(require 'org-babel)
+(require 'haskell-mode)
+(require 'inf-haskell)
+
+(org-babel-add-interpreter "haskell")
+
+(add-to-list 'org-babel-tangle-langs '("haskell" "hs"))
+
+(defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"")
+
+(defun org-babel-execute:haskell (body params)
+  "Execute a block of Haskell code with org-babel.  This function
+is called by `org-babel-execute-src-block' with the following
+variables pre-set using `multiple-value-bind'.
+
+  (session vars result-params result-type)"
+  (message "executing haskell source code block")
+  (let* ((full-body (concat
+                     (mapconcat
+                      (lambda (pair) (format "let %s = %s;" (car pair) (cdr pair)))
+                      vars "\n") "\n" body "\n"))
+         (session (org-babel-prep-session:haskell session params))
+         (raw (org-babel-comint-with-output session org-babel-haskell-eoe t
+                (insert (org-babel-trim full-body))
+                (comint-send-input nil t)
+                (insert org-babel-haskell-eoe)
+                (comint-send-input nil t)))
+         (results (mapcar
+                   #'org-babel-haskell-read-string
+                   (cdr (member org-babel-haskell-eoe
+                                (reverse (mapcar #'org-babel-trim raw)))))))
+    (case result-type
+      (output (mapconcat #'identity (reverse (cdr results)) "\n"))
+      (value (org-babel-haskell-table-or-string (car results))))))
+
+(defun org-babel-haskell-read-string (string)
+  "Strip \\\"s from around haskell string"
+  (if (string-match "\"\\([^\000]+\\)\"" string)
+      (match-string 1 string)
+    string))
+
+(defun org-babel-prep-session:haskell (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (save-window-excursion (run-haskell) (current-buffer)))
+
+(defun org-babel-haskell-table-or-string (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (and (stringp results) (string-match "^\\[.+\\]$" results))
+       (org-babel-read
+        (replace-regexp-in-string
+         "\\[" "(" (replace-regexp-in-string
+                    "\\]" ")" (replace-regexp-in-string
+                               "," " " (replace-regexp-in-string
+                                         "'" "\"" results)))))
+     results)))
+
+(provide 'org-babel-haskell)
+;;; org-babel-haskell.el ends here

contrib/babel/lisp/langs/org-babel-lisp.el

@@ -0,0 +1,48 @@
+;;; org-babel-lisp.el --- org-babel functions for lisp code evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating lisp code
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "emacs-lisp")
+
+(add-to-list 'org-babel-tangle-langs '("emacs-lisp" "el"))
+
+(defun org-babel-execute:emacs-lisp (body params)
+  "Execute a block of emacs-lisp code with org-babel.  This
+function is called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing emacs-lisp code block...")
+  (save-window-excursion
+    (let ((print-level nil) (print-length nil))
+      (eval `(let ,(mapcar (lambda (var) `(,(car var) ',(cdr var))) vars)
+	       ,(read (concat "(progn " body ")")))))))
+
+(provide 'org-babel-lisp)
+;;; org-babel-lisp.el ends here

contrib/babel/lisp/langs/org-babel-ocaml.el

@@ -0,0 +1,121 @@
+;;; org-babel-ocaml.el --- org-babel functions for ocaml evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating ocaml source code.  This one will
+;; be sort of tricky because ocaml programs must be compiled before
+;; they can be run, but ocaml code can also be run through an
+;; interactive interpreter.
+;;
+;; For now lets only allow evaluation using the ocaml interpreter.
+
+;;; Requirements:
+
+;; - tuareg-mode :: http://www-rocq.inria.fr/~acohen/tuareg/
+
+;;; Code:
+(require 'org-babel)
+(require 'tuareg)
+
+(org-babel-add-interpreter "ocaml")
+
+(add-to-list 'org-babel-tangle-langs '("ocaml" "ml"))
+
+(defvar org-babel-ocaml-eoe-indicator "\"org-babel-ocaml-eoe\";;")
+(defvar org-babel-ocaml-eoe-output "org-babel-ocaml-eoe")
+
+(defun org-babel-execute:ocaml (body params)
+  "Execute a block of Ocaml code with org-babel.  This function
+is called by `org-babel-execute-src-block' with the following
+variables pre-set using `multiple-value-bind'.
+
+  (session vars result-params result-type)"
+  (message "executing ocaml source code block")
+  (let* ((full-body (concat
+                     (mapconcat
+                      (lambda (pair) (format "let %s = %s;" (car pair) (cdr pair)))
+                      vars "\n") "\n" body "\n"))
+         (session (org-babel-prep-session:ocaml session params))
+         (raw (org-babel-comint-with-output session org-babel-ocaml-eoe-output t
+                (insert (concat (org-babel-chomp full-body) " ;;"))
+                (comint-send-input nil t)
+                (insert org-babel-ocaml-eoe-indicator)
+                (comint-send-input nil t))))
+    (org-babel-ocaml-parse-output (org-babel-trim (car raw)))))
+
+(defun org-babel-prep-session:ocaml (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let ((tuareg-interactive-buffer-name (if (and (not (string= session "none"))
+                                                 (not (string= session "default"))
+                                                 (stringp session))
+                                            session
+                                          tuareg-interactive-buffer-name)))
+    (save-window-excursion (tuareg-run-caml)
+                           (get-buffer tuareg-interactive-buffer-name))))
+
+(defun org-babel-ocaml-parse-output (output)
+  (let ((regexp "%s = \\(.+\\)$"))
+    (cond
+     ((string-match (format regexp "string") output)
+      (org-babel-read (match-string 1 output)))
+     ((or (string-match (format regexp "int") output)
+          (string-match (format regexp "float") output))
+      (string-to-number (match-string 1 output)))
+     ((string-match (format regexp "list") output)
+      (org-babel-ocaml-read-list (match-string 1 output)))
+     ((string-match (format regexp "array") output)
+      (org-babel-ocaml-read-array (match-string 1 output)))
+     (t (message "don't recognize type of %s" output) output))))
+
+(defun org-babel-ocaml-read-list (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (and (stringp results) (string-match "^\\[.+\\]$" results))
+       (org-babel-read
+        (replace-regexp-in-string
+         "\\[" "(" (replace-regexp-in-string
+                    "\\]" ")" (replace-regexp-in-string
+                               "; " " " (replace-regexp-in-string
+                                         "'" "\"" results)))))
+     results)))
+
+(defun org-babel-ocaml-read-array (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (and (stringp results) (string-match "^\\[.+\\]$" results))
+       (org-babel-read
+        (replace-regexp-in-string
+         "\\[|" "(" (replace-regexp-in-string
+                    "|\\]" ")" (replace-regexp-in-string
+                               "; " " " (replace-regexp-in-string
+                                         "'" "\"" results)))))
+     results)))
+
+(provide 'org-babel-ocaml)
+;;; org-babel-ocaml.el ends here

contrib/babel/lisp/langs/org-babel-python.el

@@ -0,0 +1,180 @@
+;;; org-babel-python.el --- org-babel functions for python evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating python source code.
+
+;;; Code:
+(require 'org-babel)
+(require 'python)
+
+(org-babel-add-interpreter "python")
+
+(add-to-list 'org-babel-tangle-langs '("python" "py" "#!/usr/bin/env python"))
+
+(defun org-babel-execute:python (body params)
+  "Execute a block of Python code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing Python source code block")
+  (let ((full-body (concat
+		    (mapconcat ;; define any variables
+		     (lambda (pair)
+		       (format "%s=%s"
+			       (car pair)
+			       (org-babel-python-var-to-python (cdr pair))))
+		     vars "\n") "\n" (org-babel-trim body) "\n")) ;; then the source block body
+	(session (org-babel-python-initiate-session session)))
+    (org-babel-python-evaluate session full-body result-type)))
+
+(defun org-babel-prep-session:python (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-python-initiate-session session))
+         (vars (org-babel-ref-variables params))
+         (var-lines (mapcar ;; define any variables
+                     (lambda (pair)
+                       (format "%s=%s"
+                               (car pair)
+                               (org-babel-python-var-to-python (cdr pair))))
+                     vars)))
+    (org-babel-comint-in-buffer session
+      (mapc (lambda (var)
+              (move-end-of-line 1) (insert var) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)) var-lines))))
+
+;; helper functions
+
+(defun org-babel-python-var-to-python (var)
+  "Convert an elisp var into a string of python source code
+specifying a var of the same value."
+  (if (listp var)
+      (concat "[" (mapconcat #'org-babel-python-var-to-python var ", ") "]")
+    (format "%S" var)))
+
+(defun org-babel-python-table-or-string (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (string-match "^\\[.+\\]$" results)
+       (org-babel-read
+        (replace-regexp-in-string
+         "\\[" "(" (replace-regexp-in-string
+                    "\\]" ")" (replace-regexp-in-string
+                               ", " " " (replace-regexp-in-string
+                                         "'" "\"" results)))))
+     results)))
+
+(defvar org-babel-python-buffers '(:default . nil))
+
+(defun org-babel-python-session-buffer (session)
+  (cdr (assoc session org-babel-python-buffers)))
+
+(defun org-babel-python-initiate-session-by-key (&optional session)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session."
+  (save-window-excursion
+    (let* ((session (if session (intern session) :default))
+           (python-buffer (org-babel-python-session-buffer session)))
+      (run-python)
+      (setq org-babel-python-buffers (cons (cons session python-buffer)
+					   (assq-delete-all session org-babel-python-buffers)))
+      session)))
+
+(defun org-babel-python-initiate-session (&optional session)
+  (unless (string= session "none")
+    (org-babel-python-session-buffer (org-babel-python-initiate-session-by-key session))))
+
+(defvar org-babel-python-last-value-eval "_"
+  "When evaluated by Python this returns the return value of the last statement.")
+(defvar org-babel-python-eoe-indicator "'org_babel_python_eoe'"
+  "Used to indicate that evaluation is has completed.")
+(defvar org-babel-python-wrapper-method
+  "
+def main():
+%s
+
+open('%s', 'w').write( str(main()) )")
+
+(defun org-babel-python-evaluate (buffer body &optional result-type)
+  "Pass BODY to the Python process in BUFFER.  If RESULT-TYPE equals
+'output then return a list of the outputs of the statements in
+BODY, if RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (if (not session)
+      ;; external process evaluation
+      (save-window-excursion
+        (case result-type
+          (output
+           (with-temp-buffer
+             (insert body)
+             ;; (message "buffer=%s" (buffer-string)) ;; debugging
+             (shell-command-on-region (point-min) (point-max) "python" 'replace)
+             (buffer-string)))
+          (value
+           (let ((tmp-file (make-temp-file "python-functional-results")))
+             (with-temp-buffer
+               (insert
+		(format
+		 org-babel-python-wrapper-method
+		 (let ((lines (split-string
+			       (org-remove-indentation (org-babel-trim body)) "[\r\n]")))
+		   (concat
+		    (mapconcat
+		     (lambda (line) (format "\t%s" line))
+		     (butlast lines) "\n")
+		    (format "\n\treturn %s" (last lines))))
+		 tmp-file))
+               ;; (message "buffer=%s" (buffer-string)) ;; debugging
+               (shell-command-on-region (point-min) (point-max) "python"))
+             (org-babel-python-table-or-string
+	      (with-temp-buffer (insert-file-contents tmp-file) (buffer-string)))))))
+    ;; comint session evaluation
+    (org-babel-comint-in-buffer buffer
+      (let* ((raw (org-babel-comint-with-output buffer org-babel-python-eoe-indicator t
+                    ;; for some reason python is fussy, and likes enters after every input
+                    (mapc (lambda (statement) (insert statement) (comint-send-input nil t))
+                          (split-string (org-babel-trim full-body) "[\r\n]+"))
+                    (comint-send-input nil t) (comint-send-input nil t)
+                    (insert org-babel-python-last-value-eval)
+                    (comint-send-input nil t)
+                    (insert org-babel-python-eoe-indicator)
+                    (comint-send-input nil t)))
+             (results (delete org-babel-python-eoe-indicator
+                              (cdr (member org-babel-python-eoe-indicator
+                                           (reverse (mapcar #'org-babel-trim raw)))))))
+        (setq results (mapcar #'org-babel-python-read-string results))
+        (case result-type
+	  (output (org-babel-trim (mapconcat #'identity (reverse (cdr results)) "\n")))
+	  (value (org-babel-python-table-or-string (org-babel-trim (car results)))))))))
+
+(defun org-babel-python-read-string (string)
+  "Strip 's from around ruby string"
+  (if (string-match "'\\([^\000]+\\)'" string)
+      (match-string 1 string)
+    string))
+
+(provide 'org-babel-python)
+;;; org-babel-python.el ends here

contrib/babel/lisp/langs/org-babel-ruby.el

@@ -0,0 +1,171 @@
+;;; org-babel-ruby.el --- org-babel functions for ruby evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating ruby source code.
+
+;;; Requirements:
+
+;; - ruby and irb executables :: http://www.ruby-lang.org/
+;; 
+;; - ruby-mode :: Can be installed through ELPA, or from
+;;   http://github.com/eschulte/rinari/raw/master/util/ruby-mode.el
+;;   
+;; - inf-ruby mode :: Can be installed through ELPA, or from
+;;   http://github.com/eschulte/rinari/raw/master/util/inf-ruby.el
+
+;;; Code:
+(require 'org-babel)
+(require 'inf-ruby)
+
+(org-babel-add-interpreter "ruby")
+
+(add-to-list 'org-babel-tangle-langs '("ruby" "rb" "#!/usr/bin/env ruby"))
+
+(defun org-babel-execute:ruby (body params)
+  "Execute a block of Ruby code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing Ruby source code block")
+  (let ((full-body (concat
+		    (mapconcat ;; define any variables
+		     (lambda (pair)
+		       (format "%s=%s"
+			       (car pair)
+			       (org-babel-ruby-var-to-ruby (cdr pair))))
+		     vars "\n") "\n" body "\n")) ;; then the source block body
+	(session (org-babel-ruby-initiate-session session)))
+    (org-babel-ruby-evaluate session full-body result-type)))
+
+(defun org-babel-prep-session:ruby (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  ;; (message "params=%S" params) ;; debugging
+  (let* ((session (org-babel-ruby-initiate-session session))
+         (vars (org-babel-ref-variables params))
+         (var-lines (mapcar ;; define any variables
+                     (lambda (pair)
+                       (format "%s=%s"
+                               (car pair)
+                               (org-babel-ruby-var-to-ruby (cdr pair))))
+                     vars)))
+    ;; (message "vars=%S" vars) ;; debugging
+    (org-babel-comint-in-buffer session
+      (sit-for .5) (goto-char (point-max))
+      (mapc (lambda (var)
+              (insert var) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)
+              (sit-for .1) (goto-char (point-max))) var-lines))))
+
+;; helper functions
+
+(defun org-babel-ruby-var-to-ruby (var)
+  "Convert an elisp var into a string of ruby source code
+specifying a var of the same value."
+  (if (listp var)
+      (concat "[" (mapconcat #'org-babel-ruby-var-to-ruby var ", ") "]")
+    (format "%S" var)))
+
+(defun org-babel-ruby-table-or-string (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (and (stringp results) (string-match "^\\[.+\\]$" results))
+       (org-babel-read
+        (replace-regexp-in-string
+         "\\[" "(" (replace-regexp-in-string
+                    "\\]" ")" (replace-regexp-in-string
+                               ", " " " (replace-regexp-in-string
+                                         "'" "\"" results)))))
+     results)))
+
+(defun org-babel-ruby-initiate-session (&optional session)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session."
+  (unless (string= session "none")
+    (let ((session-buffer (save-window-excursion (run-ruby nil session) (current-buffer))))
+      (if (org-babel-comint-buffer-livep session-buffer)
+          session-buffer
+        (sit-for .5)
+        (org-babel-ruby-initiate-session session)))))
+
+(defvar org-babel-ruby-last-value-eval "_"
+  "When evaluated by Ruby this returns the return value of the last statement.")
+(defvar org-babel-ruby-eoe-indicator ":org_babel_ruby_eoe"
+  "Used to indicate that evaluation is has completed.")
+(defvar org-babel-ruby-wrapper-method
+  "
+def main()
+%s
+end
+results = main()
+File.open('%s', 'w'){ |f| f.write((results.class == String) ? results : results.inspect) }
+")
+
+(defun org-babel-ruby-evaluate (buffer body &optional result-type)
+  "Pass BODY to the Ruby process in BUFFER.  If RESULT-TYPE equals
+'output then return a list of the outputs of the statements in
+BODY, if RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (if (not session)
+      ;; external process evaluation
+      (save-window-excursion
+        (case result-type
+          (output
+           (with-temp-buffer
+             (insert body)
+             ;; (message "buffer=%s" (buffer-string)) ;; debugging
+             (shell-command-on-region (point-min) (point-max) "ruby" 'replace)
+             (buffer-string)))
+          (value
+           (let ((tmp-file (make-temp-file "ruby-functional-results")))
+             (with-temp-buffer
+               (insert (format org-babel-ruby-wrapper-method body tmp-file))
+               ;; (message "buffer=%s" (buffer-string)) ;; debugging
+               (shell-command-on-region (point-min) (point-max) "ruby"))
+             (org-babel-ruby-table-or-string
+	      (with-temp-buffer (insert-file-contents tmp-file) (buffer-string)))))))
+    ;; comint session evaluation
+    (let* ((full-body
+	    (mapconcat
+	     #'org-babel-chomp
+	     (list body org-babel-ruby-last-value-eval org-babel-ruby-eoe-indicator) "\n"))
+           (raw (org-babel-comint-with-output buffer org-babel-ruby-eoe-indicator t
+                  (insert full-body) (comint-send-input nil t)))
+           (results (cdr (member org-babel-ruby-eoe-indicator
+                                 (reverse (mapcar #'org-babel-ruby-read-string
+                                                  (mapcar #'org-babel-trim raw)))))))
+      (case result-type
+        (output (mapconcat #'identity (reverse (cdr results)) "\n"))
+        (value (org-babel-ruby-table-or-string (car results)))))))
+
+(defun org-babel-ruby-read-string (string)
+  "Strip \\\"s from around ruby string"
+  (if (string-match "\"\\([^\000]+\\)\"" string)
+      (match-string 1 string)
+    string))
+
+(provide 'org-babel-ruby)
+;;; org-babel-ruby.el ends here

contrib/babel/lisp/langs/org-babel-sass.el

@@ -0,0 +1,68 @@
+;;; org-babel-sass.el --- org-babel functions for the sass css generation language
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; For more information on sass see http://sass-lang.com/
+;;
+;; This accepts a 'file' header argument which is the target of the
+;; compiled sass.  The default output type for sass evaluation is
+;; either file (if a 'file' header argument was given) or scalar if no
+;; such header argument was supplied.
+;;
+;; A 'cmdline' header argument can be supplied to pass arguments to
+;; the sass command line.
+
+;;; Requirements:
+
+;; - sass-mode :: http://github.com/nex3/haml/blob/master/extra/sass-mode.el
+
+;;; Code:
+(require 'org-babel)
+(require 'sass-mode)
+
+(org-babel-add-interpreter "sass")
+
+(add-to-list 'org-babel-tangle-langs '("sass" "sass"))
+
+(defun org-babel-execute:sass (body params)
+  "Execute a block of Sass code with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (message "executing Sass source code block")
+  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
+         (file (cdr (assoc :file params)))
+         (out-file (or file (make-temp-file "org-babel-sass-out")))
+         (cmdline (cdr (assoc :cmdline params)))
+         (in-file (make-temp-file "org-babel-sass-in"))
+         (cmd (concat "sass " (or cmdline "") in-file " " out-file)))
+    (with-temp-file in-file (insert body)) (shell-command cmd)
+    (or file (with-temp-buffer (insert-file-contents out-file) (buffer-string)))))
+
+(defun org-babel-prep-session:sass (session params)
+  (error "Sass does not support sessions"))
+
+(provide 'org-babel-sass)
+;;; org-babel-sass.el ends here

contrib/babel/lisp/langs/org-babel-sh.el

@@ -0,0 +1,161 @@
+;;; org-babel-sh.el --- org-babel functions for shell evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating shell source code.
+
+;;; Code:
+(require 'org-babel)
+(require 'shell)
+
+(org-babel-add-interpreter "sh")
+
+(add-to-list 'org-babel-tangle-langs '("sh" "sh" "#!/usr/bin/env sh"))
+
+(defun org-babel-execute:sh (body params)
+  "Execute a block of Shell commands with org-babel.  This
+function is called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing Shell source code block")
+  (let* ((full-body (concat
+                     (mapconcat ;; define any variables
+                      (lambda (pair)
+                        (format "%s=%s"
+                                (car pair)
+                                (org-babel-sh-var-to-sh (cdr pair))))
+                      vars "\n") "\n" body "\n\n")) ;; then the source block body
+         (session (org-babel-sh-initiate-session session)))
+    (org-babel-sh-evaluate session full-body result-type)))
+
+(defun org-babel-prep-session:sh (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-sh-initiate-session session))
+         (vars (org-babel-ref-variables params))
+         (var-lines (mapcar ;; define any variables
+                     (lambda (pair)
+                       (format "%s=%s"
+                               (car pair)
+                               (org-babel-sh-var-to-sh (cdr pair))))
+                     vars)))
+    (org-babel-comint-in-buffer session
+      (mapc (lambda (var)
+              (insert var) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)) var-lines))))
+
+;; helper functions
+
+(defun org-babel-sh-var-to-sh (var)
+  "Convert an elisp var into a string of shell commands
+specifying a var of the same value."
+  (if (listp var)
+      (concat "[" (mapconcat #'org-babel-sh-var-to-sh var ", ") "]")
+    (format "%S" var)))
+
+(defun org-babel-sh-table-or-results (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (string-match "^\\[.+\\]$" results)
+       (org-babel-read
+        (replace-regexp-in-string
+         "\\[" "(" (replace-regexp-in-string
+                    "\\]" ")" (replace-regexp-in-string
+                               ", " " " (replace-regexp-in-string
+                                         "'" "\"" results)))))
+     results)))
+
+(defvar org-babel-sh-buffers '(:default . nil))
+
+(defun org-babel-sh-session-buffer (session)
+  (cdr (assoc session org-babel-sh-buffers)))
+
+(defun org-babel-sh-initiate-session-by-key (&optional session)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session."
+  (save-window-excursion
+    (let* ((session (if session (intern session) :default))
+           (sh-buffer (org-babel-sh-session-buffer session))
+           (newp (not (org-babel-comint-buffer-livep sh-buffer))))
+      (if (and sh-buffer (get-buffer sh-buffer) (not (buffer-live-p sh-buffer)))
+          (setq sh-buffer nil))
+      (shell sh-buffer)
+      (when newp
+        (setq sh-buffer (current-buffer))
+        (org-babel-comint-wait-for-output sh-buffer))
+      (setq org-babel-sh-buffers (cons (cons session sh-buffer)
+				       (assq-delete-all session org-babel-sh-buffers)))
+      session)))
+
+(defun org-babel-sh-initiate-session (&optional session)
+  (unless (string= session "none")
+    (org-babel-sh-session-buffer (org-babel-sh-initiate-session-by-key session))))
+
+(defvar org-babel-sh-eoe-indicator "echo 'org_babel_sh_eoe'"
+  "Used to indicate that evaluation is has completed.")
+(defvar org-babel-sh-eoe-output "org_babel_sh_eoe"
+  "Used to indicate that evaluation is has completed.")
+
+(defun org-babel-sh-evaluate (buffer body &optional result-type)
+  "Pass BODY to the Shell process in BUFFER.  If RESULT-TYPE equals
+'output then return a list of the outputs of the statements in
+BODY, if RESULT-TYPE equals 'value then return the value of the
+last statement in BODY."
+  (if (not session)
+      ;; external process evaluation
+      (save-window-excursion
+        (with-temp-buffer
+          (insert body)
+          ;; (message "buffer=%s" (buffer-string)) ;; debugging
+          (shell-command-on-region (point-min) (point-max) "sh" 'replace)
+	  (case result-type
+	    (output (buffer-string))
+	    (value ;; TODO: figure out how to return non-output values from shell scripts
+	     (let ((tmp-file (make-temp-file "org-babel-sh"))
+		   (results (buffer-string)))
+	       (with-temp-file tmp-file (insert results))
+	       (org-babel-import-elisp-from-file tmp-file))))))
+    ;; comint session evaluation
+    (let* ((tmp-file (make-temp-file "org-babel-sh"))
+	   (full-body (mapconcat #'org-babel-chomp
+                                 (list body org-babel-sh-eoe-indicator) "\n"))
+           (raw (org-babel-comint-with-output buffer org-babel-sh-eoe-output nil
+                  (insert full-body) (comint-send-input nil t)))
+           (results (cdr (member org-babel-sh-eoe-output
+                                 (reverse (mapcar #'org-babel-sh-strip-weird-long-prompt
+                                                  (mapcar #'org-babel-trim raw)))))))
+      ;; (message (replace-regexp-in-string "%" "%%" (format "processed-results=%S" results))) ;; debugging
+      (or (case result-type
+            (output (org-babel-trim (mapconcat #'org-babel-trim (reverse results) "\n")))
+            (value (with-temp-file tmp-file (insert (car results)))
+		   (org-babel-import-elisp-from-file tmp-file)))) "")))
+
+(defun org-babel-sh-strip-weird-long-prompt (string)
+  (while (string-match "^% +[\r\n$]+ *" string)
+    (setq string (substring string (match-end 0))))
+  string)
+
+(provide 'org-babel-sh)
+;;; org-babel-sh.el ends here

contrib/babel/lisp/langs/org-babel-sql.el

@@ -0,0 +1,80 @@
+;;; org-babel-sql.el --- org-babel functions for sql evaluation
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating sql source code.
+;;
+;; SQL is somewhat unique in that there are many different engines for
+;; the evaluation of sql (Mysql, PostgreSQL, etc...), so much of this
+;; file will have to be implemented engine by engine.
+;;
+;; Also SQL evaluation generally takes place inside of a database.
+;;
+;; For now lets just allow a generic ':cmdline' header argument.
+;;
+;; TODO:
+;;
+;; - support for sessions
+;; - add more useful header arguments (user, passwd, database, etc...)
+;; - support for more engines (currently only supports mysql)
+;; - what's a reasonable way to drop table data into SQL?
+;; 
+
+;;; Code:
+(require 'org-babel)
+
+(org-babel-add-interpreter "sql")
+
+(add-to-list 'org-babel-tangle-langs '("sql" "sql"))
+
+(defun org-babel-execute:sql (body params)
+  "Execute a block of Sql code with org-babel.  This function is
+called by `org-babel-execute-src-block' via multiple-value-bind."
+  (message "executing Sql source code block")
+  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
+         (cmdline (cdr (assoc :cmdline params)))
+         (engine (cdr (assoc :engine params)))
+         (in-file (make-temp-file "org-babel-sql-in"))
+         (out-file (or (cdr (assoc :out-file params))
+                       (make-temp-file "org-babel-sql-out")))
+         (command (case (intern engine)
+                    ('mysql (format "mysql %s -e \"source %s\" > %s"
+                                    (or cmdline "") in-file out-file))
+                    (t (error "no support for the %s sql engine")))))
+    (with-temp-file in-file (insert body))
+    (message command)
+    (shell-command command)
+    (with-temp-buffer
+      (org-table-import out-file nil)
+      (org-table-to-lisp))))
+
+(defun org-babel-prep-session:sql (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (error "sql sessions not yet implemented"))
+
+(provide 'org-babel-sql)
+;;; org-babel-sql.el ends here

contrib/babel/lisp/org-babel-comint.el

@@ -0,0 +1,112 @@
+;;; org-babel-comint.el --- org-babel functions for interaction with comint buffers
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research, comint
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; These functions build on comint to ease the sending and receiving
+;; of commands and results from comint buffers.
+;;
+;; Note that the buffers in this file are analogous to sessions in
+;; org-babel at large.
+
+;;; Code:
+(require 'org-babel)
+(require 'comint)
+
+(defun org-babel-comint-buffer-livep (buffer)
+  (let ((buffer (if buffer (get-buffer buffer))))
+    (and buffer (buffer-live-p buffer) (get-buffer-process buffer) buffer)))
+
+(defmacro org-babel-comint-in-buffer (buffer &rest body)
+  "Check BUFFER with `org-babel-comint-buffer-livep' then execute
+body inside the protection of `save-window-excursion' and
+`save-match-data'."
+  (declare (indent 1))
+  `(save-window-excursion
+     (save-match-data
+       (unless (org-babel-comint-buffer-livep ,buffer)
+         (error (format "buffer %s doesn't exist or has no process" ,buffer)))
+       (set-buffer ,buffer)
+       ,@body)))
+
+(defmacro org-babel-comint-with-output (buffer eoe-indicator remove-echo &rest body)
+  "Evaluate BODY in BUFFER, wait until EOE-INDICATOR appears in
+output, then return all process output.  This ensures that the
+filter is removed in case of an error or user `keyboard-quit'
+during execution of body."
+  (declare (indent 3))
+  `(org-babel-comint-in-buffer ,buffer
+     (let ((string-buffer ""))
+       (flet ((my-filt (text) (setq string-buffer (concat string-buffer text))))
+         ;; setup filter
+         (add-hook 'comint-output-filter-functions 'my-filt)
+         (unwind-protect
+             (progn
+               ;; pass FULL-BODY to process
+               (goto-char (process-mark (get-buffer-process (current-buffer))))
+               ,@body
+               ;; wait for end-of-evaluation indicator
+               (while (progn
+                        (goto-char comint-last-input-end)
+                        (not (save-excursion
+			       (and (re-search-forward comint-prompt-regexp nil t)
+				    (re-search-forward (regexp-quote ,eoe-indicator) nil t)))))
+                 (accept-process-output (get-buffer-process (current-buffer)))
+                 ;; ;; thought this would allow async background running, but I was wrong...
+                 ;; (run-with-timer .5 .5 'accept-process-output (get-buffer-process (current-buffer)))
+                 ))
+           ;; remove filter
+           (remove-hook 'comint-output-filter-functions 'my-filt)))
+       ;; remove echo'd FULL-BODY from input
+       (if (and ,remove-echo
+		(string-match
+		 (replace-regexp-in-string "\n" "\r\n" (regexp-quote ,full-body)) string-buffer))
+           (setq raw (substring string-buffer (match-end 0))))
+       (split-string string-buffer comint-prompt-regexp))))
+
+(defun org-babel-comint-input-command (buffer cmd)
+  "Pass CMD to BUFFER  The input will not be echoed."
+  (org-babel-comint-in-buffer buffer
+    (goto-char (process-mark (get-buffer-process buffer)))
+    (insert cmd)
+    (comint-send-input)
+    (org-babel-comint-wait-for-output buffer)))
+
+(defun org-babel-comint-wait-for-output (buffer)
+  "Wait until output arrives.  Note: this is only safe when
+waiting for the result of a single statement (not large blocks of
+code)."
+  (org-babel-comint-in-buffer buffer
+    (while (progn
+             (goto-char comint-last-input-end)
+             (not (and (re-search-forward comint-prompt-regexp nil t)
+                       (goto-char (match-beginning 0))
+                       (string= (face-name (face-at-point))
+                                "comint-highlight-prompt"))))
+      (accept-process-output (get-buffer-process buffer)))))
+
+(provide 'org-babel-comint)
+;;; org-babel-comint.el ends here

contrib/babel/lisp/org-babel-exp.el

@@ -0,0 +1,97 @@
+;;; org-babel-exp.el --- Exportation of org-babel source blocks
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; for more information see the comments in org-babel.el
+
+;;; Code:
+(require 'org-babel)
+(require 'org-exp-blocks)
+(org-export-blocks-add-block '(src org-babel-exp-src-blocks nil))
+(add-to-list 'org-export-interblocks '(src org-babel-exp-inline-src-blocks))
+
+(defun org-babel-exp-src-blocks (body &rest headers)
+  "Process src block for export.  Depending on the 'export'
+headers argument in replace the source code block with...
+
+both ---- display the code and the results
+
+code ---- the default, display the code inside the block but do
+          not process
+
+results - just like none only the block is run on export ensuring
+          that it's results are present in the org-mode buffer
+
+none ----- do not display either code or results upon export"
+  (interactive)
+  (unless headers (error "org-babel can't process a source block without knowing the source code"))
+  (message "org-babel-exp processing...")
+  (let* ((lang (car headers))
+         (lang-headers (intern (concat "org-babel-default-header-args:" lang)))
+         (params (org-babel-merge-params
+                  org-babel-default-header-args
+                  (org-babel-params-from-properties)
+                  (if (boundp lang-headers) (eval lang-headers) nil)
+                  (org-babel-parse-header-arguments
+                   (mapconcat #'identity (cdr headers) " ")))))
+    (org-babel-exp-do-export lang body params)))
+
+(defun org-babel-exp-inline-src-blocks (start end)
+  "Process inline src blocks between START and END for export.
+See `org-babel-exp-src-blocks' for export options, currently the
+options and are taken from `org-babel-defualt-inline-header-args'."
+  (interactive)
+  (save-excursion
+    (goto-char start)
+    (while (and (< (point) end) (re-search-forward org-babel-inline-src-block-regexp end t))
+      (let* ((info (save-match-data (org-babel-parse-inline-src-block-match)))
+             (replacement (save-match-data
+                            (org-babel-exp-do-export (first info) (second info) (third info) t))))
+        (setf end (+ end (- (length replacement)
+                            (+ 6 (length (first info)) (length (second info))))))
+        (replace-match replacement t t)))))
+
+(defun org-babel-exp-do-export (lang body params &optional inline)
+  (case (intern (or (cdr (assoc :exports params)) "code"))
+    ('none "")
+    ('code (org-babel-exp-code body lang params inline))
+    ('results (save-excursion
+                ;; org-exp-blocks places us at the end of the block
+                (re-search-backward org-babel-src-block-regexp nil t)
+                (org-babel-execute-src-block) ""))
+    ('both (concat (org-babel-exp-code body lang params inline)
+                   "\n\n"
+                   (org-babel-exp-results body lang params inline)))))
+
+(defun org-babel-exp-code (body lang params &optional inline)
+  (if inline
+      (format "=%s=" body)
+    (format "#+BEGIN_SRC %s\n%s%s\n#+END_SRC" lang body
+            (if (string-match "\n$" body) "" "\n"))))
+
+(provide 'org-babel-exp)
+;;; org-babel-exp.el ends here

contrib/babel/lisp/org-babel-init.el

@@ -0,0 +1,58 @@
+;;; org-babel-init.el --- loads org-babel
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; for more information see the comments in org-babel.el
+
+;;; Code:
+(require 'cl)
+(require 'org)
+(require 'org-exp-blocks)
+(require 'org-babel)
+(require 'org-babel-ref)
+(require 'org-babel-exp)
+(require 'org-babel-table)
+(require 'org-babel-comint)
+(require 'org-babel-lob)
+(require 'org-babel-tangle)
+
+;; language specific files
+(add-to-list 'load-path (expand-file-name "langs" (file-name-directory (or load-file-name buffer-file-name))))
+(require 'org-babel-lisp)
+(require 'org-babel-sh)
+
+;; Library of babel
+(defvar org-babel-lob-dir
+  (expand-file-name ".."
+                    (file-name-directory
+                     (or load-file-name buffer-file-name)))
+  "The directory holding the library-of-babel")
+(defun org-babel-load-library-of-babel ()
+  (org-babel-lob-ingest (expand-file-name "library-of-babel.org" org-babel-lob-dir)))
+
+(provide 'org-babel-init)
+;;; org-babel-init.el ends here

contrib/babel/lisp/org-babel-lob.el

@@ -0,0 +1,94 @@
+;;; org-babel-lob.el --- The Library of Babel: off-the-shelf functions for data analysis and plotting using org-babel
+
+;; Copyright (C) 2009 Dan Davison, Eric Schulte
+
+;; Author: Dan Davison, Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; See org-babel.org in the parent directory for more information
+
+;;; Code:
+(require 'org-babel)
+(require 'org-babel-table)
+
+(defvar org-babel-library-of-babel nil
+  "Library of source-code blocks.  This is an association list.
+Populate the library by adding files to `org-babel-lob-files'.")
+
+(defcustom org-babel-lob-files '()
+  "Files used to populate the `org-babel-library-of-babel'.  To
+add files to this list use the `org-babel-lob-ingest' command."
+  :group 'org-babel
+  :type 'list)
+
+(defun org-babel-lob-ingest (&optional file)
+  "Add all source-blocks defined in FILE to `org-babel-library-of-babel'."
+  (interactive "f")
+  (org-babel-map-source-blocks file
+    (let ((source-name (intern (org-babel-get-src-block-name)))
+          (info (org-babel-get-src-block-info)))
+      (when source-name
+        (setq org-babel-library-of-babel
+              (cons (cons source-name info)
+                    (assq-delete-all source-name org-babel-library-of-babel)))))))
+
+;; functions for executing lob one-liners
+
+(defvar org-babel-lob-one-liner-regexp "#\\+lob:[ \t]+\\([^\(\)\n]+\\)\(\\([^\n]*\\)\)[ \t]*\n")
+
+(defun org-babel-lob-execute-maybe ()
+  "Detect if this is context for a org-babel Library Of Babel
+src-block and if so then run the appropriate source block from
+the Library."
+  (interactive)
+  (let ((info (org-babel-lob-get-info)))
+    (if info (progn (org-babel-lob-execute info) t) nil)))
+
+(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-lob-execute-maybe)
+
+(defun org-babel-lob-get-info ()
+  "Return the function call supplied on the current Library of
+Babel line as a string.
+
+This function is analogous to org-babel-get-src-block-name. For
+both functions, after they are called, (match-string 1) matches
+the function name, and (match-string 2) matches the function
+arguments inside the parentheses. I think perhaps these functions
+should be renamed to bring out this similarity, perhaps involving
+the word 'call'."
+  (let ((case-fold-search t))
+    (save-excursion
+      (move-beginning-of-line 1)
+      (if (looking-at org-babel-lob-one-liner-regexp)
+          (org-babel-clean-text-properties 
+	   (format "%s(%s)" (match-string 1) (match-string 2)))))))
+
+(defun org-babel-lob-execute (info)
+  (let ((params (org-babel-merge-params
+		 org-babel-default-header-args
+		 (org-babel-parse-header-arguments (concat ":var results=" info)))))
+    (org-babel-execute-src-block nil (list "emacs-lisp" "results" params))))
+
+(provide 'org-babel-lob)
+;;; org-babel-lob.el ends here

contrib/babel/lisp/org-babel-ref.el

@@ -0,0 +1,172 @@
+;;; org-babel-ref.el --- org-babel functions for referencing external data
+
+;; Copyright (C) 2009 Eric Schulte, Dan Davison
+
+;; Author: Eric Schulte, Dan Davison
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Functions for referencing data from the header arguments of a
+;; org-babel block.  The syntax of such a reference should be
+;;
+;;   #+VAR: variable-name=file:resource-id
+;;
+;; - variable-name :: the name of the variable to which the value
+;;                    will be assigned
+;;                    
+;; - file :: path to the file containing the resource, or omitted if
+;;           resource is in the current file
+;;
+;; - resource-id :: the id or name of the resource
+;;
+;; So an example of a simple src block referencing table data in the
+;; same file would be
+;;
+;;  #+TBLNAME: sandbox
+;;  | 1 |       2 | 3 |
+;;  | 4 | org-babel | 6 |
+;;
+;;  #+begin_src emacs-lisp :var table=sandbox
+;;  (message table)
+;;  #+end_src
+;;
+
+;;; Code:
+(require 'org-babel)
+
+(defun org-babel-ref-variables (params)
+  "Takes a parameter alist, and return an alist of variable
+names, and the emacs-lisp representation of the related value."
+  (mapcar #'org-babel-ref-parse
+          (delq nil (mapcar (lambda (pair) (if (eq (car pair) :var) (cdr pair))) params))))
+
+(defun org-babel-ref-parse (assignment)
+  "Parse a variable ASSIGNMENT in a header argument.  If the
+right hand side of the assignment has a literal value return that
+value, otherwise interpret as a reference to an external resource
+and find it's value using `org-babel-ref-resolve-reference'.
+Return a list with two elements.  The first element of the list
+will be the name of the variable, and the second will be an
+emacs-lisp representation of the value of the variable."
+  (if (string-match
+       "[ \f\t\n\r\v]*\\(.+?\\)[ \f\t\n\r\v]*=[ \f\t\n\r\v]*\\(.+\\)[ \f\t\n\r\v]*" assignment)
+      (let ((var (match-string 1 assignment))
+            (ref (match-string 2 assignment)))
+        (cons (intern var)
+              (or (org-babel-ref-literal ref)
+                  (org-babel-ref-resolve-reference ref))))))
+
+(defun org-babel-ref-literal (ref)
+  "Determine if the right side of a header argument variable
+assignment is a literal value or is a reference to some external
+resource.  If REF is literal then return it's value, otherwise
+return nil."
+  (let ((out (org-babel-read ref)))
+    (if (equal out ref)
+        (if (string-match "\"\\(.+\\)\"" ref)
+            (read ref))
+      out)))
+
+(defun org-babel-ref-resolve-reference (ref)
+  "Resolve the reference and return its value"
+  (save-excursion
+    (let ((case-fold-search t)
+          type args new-refere new-referent result lob-info)
+      ;; assign any arguments to pass to source block
+      (when (string-match "^\\(.+?\\)\(\\(.*\\)\)$" ref)
+        (setq new-refere (match-string 1 ref))
+        (setq new-referent (match-string 2 ref))
+        ;; (message "new-refere=%S, new-referent=%S" new-refere new-referent) ;; debugging
+        (when (> (length new-refere) 0)
+          (if (> (length new-referent) 0)
+              (setq args (mapcar (lambda (ref) (cons :var ref))
+                                 (org-babel-ref-split-args new-referent))))
+          ;; (message "args=%S" args) ;; debugging
+          (setq ref new-refere)))
+      (when (string-match "\\(.+\\):\\(.+\\)" ref)
+        (find-file (match-string 1 ref))
+        (setf ref (match-string 2 ref)))
+      (goto-char (point-min))
+      (if (let ((result_regexp (concat "^#\\+\\(TBL\\|RES\\)NAME:[ \t]*"
+                                       (regexp-quote ref) "[ \t]*$"))
+                (regexp (concat "^#\\+SRCNAME:[ \t]*"
+                                (regexp-quote ref) "\\(\(.*\)\\)?" "[ \t]*$")))
+            ;; goto ref in the current buffer
+            (or (and (not args)
+                     (or (re-search-forward result_regexp nil t)
+                         (re-search-forward result_regexp nil t)))
+                (re-search-forward regexp nil t)
+                (re-search-backward regexp nil t)
+                ;; check the Library of Babel
+                (setq lob-info (cdr (assoc (intern ref) org-babel-library-of-babel)))))
+          (unless lob-info (goto-char (match-beginning 0)))
+        ;; ;; TODO: allow searching for names in other buffers
+        ;; (setq id-loc (org-id-find ref 'marker)
+        ;;       buffer (marker-buffer id-loc)
+        ;;       loc (marker-position id-loc))
+        ;; (move-marker id-loc nil)
+        (progn (message (format "reference '%s' not found in this buffer" ref))
+               (error (format "reference '%s' not found in this buffer" ref))))
+      (if lob-info
+          (setq type 'lob)
+        (while (not (setq type (org-babel-ref-at-ref-p)))
+          (forward-line 1)
+          (beginning-of-line)
+          (if (or (= (point) (point-min)) (= (point) (point-max)))
+              (error "reference not found"))))
+      ;; (message "type=%S" type) ;; debugging
+      (case type
+        ('results-line (org-babel-read-result))
+        ('table (org-babel-read-table))
+        ('source-block
+         (setq result (org-babel-execute-src-block t nil args))
+         (if (symbolp result) (format "%S" result) result))
+        ('lob (setq result (org-babel-execute-src-block t lob-info args)))))))
+
+(defun org-babel-ref-split-args (arg-string)
+  "Split ARG-STRING into top-level arguments of balanced parenthesis."
+  (let ((index 0) (depth 0) (buffer "") holder return)
+    ;; crawl along string, splitting at any ","s which are on the top level
+    (while (< index (length arg-string))
+      (setq holder (substring arg-string index (+ 1 index)))
+      (setq buffer (concat buffer holder))
+      (setq index (+ 1 index))
+      (cond
+       ((string= holder ",")
+        (when (= depth 0)
+          (setq return (reverse (cons (substring buffer 0 -1) return)))
+          (setq buffer "")))
+       ((string= holder "(") (setq depth (+ depth 1)))
+       ((string= holder ")") (setq depth (- depth 1)))))
+    (mapcar #'org-babel-trim (reverse (cons buffer return)))))
+
+(defun org-babel-ref-at-ref-p ()
+  "Return the type of reference located at point or nil if none
+of the supported reference types are found.  Supported reference
+types are tables and source blocks."
+  (cond ((org-at-table-p) 'table)
+        ((looking-at "^#\\+BEGIN_SRC") 'source-block)
+        ((looking-at "^#\\+RESNAME:") 'results-line)))
+
+(provide 'org-babel-ref)
+;;; org-babel-ref.el ends here

contrib/babel/lisp/org-babel-table.el

@@ -0,0 +1,92 @@
+;;; org-babel-table.el --- integration for calling org-babel functions from tables
+
+;; Copyright (C) 2009 Eric Schulte
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Should allow calling functions from org-mode tables using the
+;; function `sbe' as so...
+;; 
+;; #+begin_src emacs-lisp :results silent
+;; (defun fibbd (n) (if (< n 2) 1 (+ (fibbd (- n 1)) (fibbd (- n 2)))))
+;; #+end_src
+;; 
+;; #+srcname: fibbd
+;; #+begin_src emacs-lisp :var n=2 :results silent
+;; (fibbd n)
+;; #+end_src
+;; 
+;; | original | fibbd  |
+;; |----------+--------|
+;; |        0 |        |
+;; |        1 |        |
+;; |        2 |        |
+;; |        3 |        |
+;; |        4 |        |
+;; |        5 |        |
+;; |        6 |        |
+;; |        7 |        |
+;; |        8 |        |
+;; |        9 |        |
+;; #+TBLFM: $2='(sbe 'fibbd (n $1))
+
+;;; Code:
+(require 'org-babel)
+
+(defun org-babel-table-truncate-at-newline (string)
+  (if (and (stringp string) (string-match "[\n\r]" string))
+      (concat (substring string 0 (match-beginning 0)) "...")
+    string))
+
+(defmacro sbe (source-block &rest variables)
+  "Return the results of calling SOURCE-BLOCK with all assigning
+every variable in VARIABLES.  Each element of VARIABLES should be
+a two element list, whose first element is the name of the
+variable and second element is a string of its value.  The
+following call to `sbe' would be equivalent to the following
+source code block.
+
+ (sbe 'source-block (n 2) (m 3))
+
+#+begin_src emacs-lisp :var results=source-block(n=2, m=3) :results silent
+results
+#+end_src"
+  (unless (stringp source-block) (setq source-block (symbol-name source-block)))
+  (org-babel-table-truncate-at-newline ;; org-table cells can't be multi-line
+   (if (and source-block (> (length source-block) 0))
+       (let ((params
+	      (eval `(org-babel-parse-header-arguments
+		      (concat ":var results="
+			      ,source-block
+			      "("
+			      (mapconcat (lambda (var-spec)
+					   (format "%S=%s" (first var-spec) (second var-spec)))
+					 ',variables ", ")
+			      ")")))))
+         (org-babel-execute-src-block t (list "emacs-lisp" "results" params)))
+     "")))
+
+(provide 'org-babel-table)
+;;; org-babel-table.el ends here

contrib/babel/lisp/org-babel-tangle.el

@@ -0,0 +1,242 @@
+;;; org-babel-tangle.el --- Extract source code from org-mode files
+
+;; Copyright (C) 2009 Dan Davison, Eric Schulte
+
+;; Author: Dan Davison, Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; Extract the code from source blocks out into raw source-code files.
+
+;;; Code:
+(require 'org-babel)
+
+(defvar org-babel-tangle-langs nil
+  "Association list matching source-block languages.  The car of
+each element should be a string indicating the source block
+language, and the cdr should be a list containing the extension
+shebang(#!) line to use when writing out the language to file,
+and an optional flag indicating that the language is not
+commentable.")
+
+(defun org-babel-load-file (file)
+  "Load the contents of the Emacs Lisp source code blocks in the
+org-mode formatted FILE.  This function will first export the
+source code using `org-babel-tangle' and then load the resulting
+file using `load-file'."
+  (flet ((age (file)
+              (time-to-seconds
+               (time-subtract (current-time)
+                              (sixth (file-attributes file))))))
+    (let* ((base-name (file-name-sans-extension file))
+           (exported-file (concat base-name ".el")))
+      ;; tangle if the org-mode file is newer than the elisp file
+      (unless (and (file-exists-p exported-file) (> (age file) (age exported-file)))
+        (org-babel-tangle-file file base-name "emacs-lisp"))
+      (load-file exported-file)
+      (message "loaded %s" exported-file))))
+
+(defun org-babel-tangle-file (file &optional target-file lang)
+  "Extract the bodies of all source code blocks in FILE with
+`org-babel-tangle'.  Optional argument TARGET-FILE can be used to
+specify a default export file for all source blocks.  Optional
+argument LANG can be used to limit the exported source code
+blocks by language."
+  (save-window-excursion (find-file file) (org-babel-tangle target-file lang)))
+
+(defun org-babel-tangle (&optional target-file lang)
+  "Extract the bodies of all source code blocks from the current
+file into their own source-specific files.  Optional argument
+TARGET-FILE can be used to specify a default export file for all
+source blocks.  Optional argument LANG can be used to limit the
+exported source code blocks by language."
+  (interactive)
+  (save-excursion
+    (let ((block-counter 0)
+          path-collector)
+      (mapc ;; map over all languages
+       (lambda (by-lang)
+         (let* ((lang (car by-lang))
+                (specs (cdr by-lang))
+                (lang-f (intern (concat
+                                 (or (and (cdr (assoc lang org-src-lang-modes))
+                                          (symbol-name
+                                           (cdr (assoc lang org-src-lang-modes))))
+                                     lang)
+                                 "-mode")))
+                (lang-specs (cdr (assoc lang org-babel-tangle-langs)))
+                (ext (first lang-specs))
+                (she-bang (second lang-specs))
+                (commentable (not (third lang-specs))))
+           (mapc
+            (lambda (spec)
+              (let* ((tangle (cdr (assoc :tangle (third spec))))
+                     (base-name (or (cond
+                                     ((string= "yes" tangle)
+                                      (file-name-sans-extension (buffer-file-name)))
+                                     ((string= "no" tangle) nil)
+                                     ((> (length tangle) 0) tangle))
+                                    target-file))
+                     (file-name (when base-name
+                                  (if (string= base-name
+                                               (file-name-sans-extension base-name))
+                                      (concat base-name "." ext) base-name))))
+                ;; ;; debugging
+                ;; (message "tangle=%S base-name=%S file-name=%S"
+                ;;          tangle base-name file-name)
+                (when file-name
+                  ;; delete any old versions of file
+                  (when (and (file-exists-p file-name)
+                             (not (member file-name path-collector)))
+                    (delete-file file-name))
+                  ;; drop source-block to file
+                  (with-temp-buffer
+                    (funcall lang-f)
+                    (when she-bang (insert (concat she-bang "\n")))
+                    (when commentable
+                      (comment-region
+                       (point) (progn (insert "generated by org-babel-tangle") (point)))
+                      (move-end-of-line nil))
+                    (org-babel-spec-to-string spec)
+                    (append-to-file nil nil file-name))
+                  ;; update counter
+                  (setq block-counter (+ 1 block-counter))
+                  (add-to-list 'path-collector file-name))))
+            specs)))
+       (org-babel-tangle-collect-blocks lang))
+      (message "tangled %d code block%s" block-counter
+               (if (= block-counter 1) "" "s"))
+      path-collector)))
+
+(defun org-babel-tangle-clean ()
+  "Call this function inside of a source-code file generated by
+`org-babel-tangle' to remove all comments inserted automatically
+by `org-babel-tangle'.  Warning, this comment removes any lines
+containing constructs which resemble org-mode file links or noweb
+references."
+  (interactive)
+  (goto-char (point-min))
+  (while (or (re-search-forward "\\[\\[file:.*\\]\\[.*\\]\\]" nil t)
+             (re-search-forward "<<[^[:space:]]*>>" nil t))
+    (delete-region (save-excursion (move-beginning-of-line 1) (point))
+                   (save-excursion (move-end-of-line 1) (forward-char 1) (point)))))
+
+(defun org-babel-tangle-collect-blocks (&optional lang)
+  "Collect all source blocks in the current org-mode file.
+Return an association list of source-code block specifications of
+the form used by `org-babel-spec-to-string' grouped by language.
+Optional argument LANG can be used to limit the collected source
+code blocks by language."
+  (let ((block-counter 0) blocks)
+    (org-babel-map-source-blocks (buffer-file-name)
+      (setq block-counter (+ 1 block-counter))
+      (let* ((link (progn (call-interactively 'org-store-link)
+                          (org-babel-clean-text-properties (car (pop org-stored-links)))))
+             (source-name (intern (or (org-babel-get-src-block-name)
+                                      (format "block-%d" block-counter))))
+             (info (org-babel-get-src-block-info))
+             (src-lang (first info))
+             (body (org-babel-expand-noweb-references info))
+             (params (third info))
+             (spec (list link source-name params body (third (cdr (assoc src-lang org-babel-tangle-langs)))))
+             by-lang)
+        (unless (string= (cdr (assoc :tangle params)) "no") ;; maybe skip
+          (unless (and lang (not (string= lang src-lang))) ;; maybe limit by language
+            ;; add the spec for this block to blocks under it's language
+            (setq by-lang (cdr (assoc src-lang blocks)))
+            (setq blocks (delq (assoc src-lang blocks) blocks))
+            (setq blocks (cons (cons src-lang (cons spec by-lang)) blocks))))))
+    ;; ensure blocks in the correct order
+    (setq blocks
+          (mapcar (lambda (by-lang) (cons (car by-lang) (reverse (cdr by-lang)))) blocks))
+    ;; blocks should contain all source-blocks organized by language
+    ;; (message "blocks=%S" blocks) ;; debugging
+    blocks))
+
+(defun org-babel-spec-to-string (spec)
+  "Insert the source-code specified by SPEC into the current
+source code file.  This function uses `comment-region' which
+assumes that the appropriate major-mode is set.  SPEC has the
+form
+
+  (link source-name params body)"
+  (flet ((insert-comment (text)
+                         (when commentable
+                           (comment-region (point) (progn (insert text) (point)))
+                           (move-end-of-line nil))))
+    (let ((link (first spec))
+          (source-name (second spec))
+          (body (fourth spec))
+          (commentable (not (fifth spec))))
+      (insert "\n\n")
+      (insert-comment (format "[[%s][%s]]" (org-link-escape link) source-name))
+      (insert (format "\n%s\n" (org-babel-chomp body)))
+      (insert-comment (format "%s ends here" source-name))
+      (insert "\n"))))
+
+(defun org-babel-expand-noweb-references (&optional info parent-buffer)
+  "This function expands Noweb style references in the body of
+the current source-code block.  For example the following
+reference would be replaced with the body of the source-code
+block named 'example-block' (assuming the '#' character starts a
+comment) .
+
+# <<example-block>>
+
+This function must be called from inside of the buffer containing
+the source-code block which holds BODY."
+  (let* ((parent-buffer (or parent-buffer (current-buffer)))
+         (info (or info (org-babel-get-src-block-info)))
+         (lang (first info))
+         (body (second info))
+         (new-body "") index source-name)
+    (flet ((nb-add (text)
+                   (setq new-body (concat new-body text))))
+      (with-temp-buffer
+        (insert body) (goto-char (point-min))
+        (funcall (intern (concat (or (and (cdr (assoc lang org-src-lang-modes))
+                                          (symbol-name
+                                           (cdr (assoc lang org-src-lang-modes))))
+                                     lang) "-mode")))
+        (setq index (point))
+        (while (and (re-search-forward "<<\\(.+\\)>>" nil t))
+          (save-match-data (setf source-name (match-string 1)))
+          ;; add interval to new-body
+          (goto-char (match-end 0)) (move-end-of-line nil)
+          (nb-add (buffer-substring index (point)))
+          (setq index (point))
+          ;; if found, add body of referenced source-block
+          (nb-add (save-excursion
+                    (set-buffer parent-buffer)
+                    (let ((point (org-babel-find-named-block source-name)))
+                      (if point
+                          (save-excursion
+                            (goto-char point)
+                            (concat "\n" (org-babel-expand-noweb-references
+                                          (org-babel-get-src-block-info))))
+                        "")))))
+        (nb-add (buffer-substring index (point-max)))))
+    new-body))
+
+(provide 'org-babel-tangle)
+;;; org-babel-tangle.el ends here

contrib/babel/lisp/org-babel.el

@@ -0,0 +1,756 @@
+;;; org-babel.el --- facilitating communication between programming languages and people
+
+;; Copyright (C) 2009 Eric Schulte, Dan Davison
+
+;; Author: Eric Schulte, Dan Davison
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+;; Version: 0.01
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; See org-babel.org in the parent directory for more information
+
+;;; Code:
+(require 'org)
+
+(defun org-babel-execute-src-block-maybe ()
+  "Detect if this is context for a org-babel src-block and if so
+then run `org-babel-execute-src-block'."
+  (interactive)
+  (let ((info (org-babel-get-src-block-info)))
+    (if info (progn (org-babel-execute-src-block current-prefix-arg info) t) nil)))
+
+(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-execute-src-block-maybe)
+
+(defadvice org-edit-special (around org-babel-prep-session-for-edit activate)
+  "Prepare the current source block's session according to it's
+header arguments before editing in an org-src buffer.  This
+function is called when `org-edit-special' is called with a
+prefix argument from inside of a source-code block."
+  (when current-prefix-arg
+    (let* ((info (org-babel-get-src-block-info))
+           (lang (first info))
+           (params (third info))
+           (session (cdr (assoc :session params))))
+      (when (and info session) ;; if we are in a source-code block which has a session
+        (funcall (intern (concat "org-babel-prep-session:" lang)) session params))))
+  ad-do-it)
+
+(defadvice org-open-at-point (around org-babel-open-at-point activate)
+  "If `point' is on a source code block, then open that block's
+results with `org-babel-open-src-block-results', otherwise defer
+to `org-open-at-point'."
+  (interactive "P")
+  (or (call-interactively #'org-babel-open-src-block-result) ad-do-it))
+
+(defun org-babel-pop-to-session-maybe ()
+  "Detect if this is context for a org-babel src-block and if so
+then run `org-babel-pop-to-session'."
+  (interactive)
+  (let ((info (org-babel-get-src-block-info)))
+    (if info (progn (org-babel-pop-to-session current-prefix-arg info) t) nil)))
+
+(add-hook 'org-metadown-hook 'org-babel-pop-to-session-maybe)
+
+(defvar org-babel-default-header-args
+  '((:session . "none") (:results . "replace") (:exports . "code"))
+  "Default arguments to use when evaluating a source block.")
+
+(defvar org-babel-default-inline-header-args '((:results . "silent") (:exports . "code"))
+  "Default arguments to use when evaluating an inline source block.")
+
+(defvar org-babel-src-block-regexp nil
+  "Regexp used to test when inside of a org-babel src-block")
+
+(defvar org-babel-inline-src-block-regexp nil
+  "Regexp used to test when on an inline org-babel src-block")
+
+(defvar org-babel-min-lines-for-block-output 10
+  "If number of lines of output is equal to or exceeds this
+  value, the output is placed in a
+  #+begin_example...#+end_example block. Otherwise the output is
+  marked as literal by inserting colons at the starts of the
+  lines. This variable only takes effect if the :results output
+  option is in effect.")
+
+(defun org-babel-named-src-block-regexp-for-name (name)
+  "Regexp used to match named src block."
+  (concat "#\\+srcname:[ \t]*" (regexp-quote name) "[ \t\n]*"
+	  (substring org-babel-src-block-regexp 1)))
+
+(defun org-babel-set-interpreters (var value)
+  (set-default var value)
+  (setq org-babel-src-block-regexp
+	(concat "^[ \t]*#\\+begin_src \\("
+		(mapconcat 'regexp-quote value "\\|")
+		"\\)[ \t]*"
+                "\\([ \t]+\\([^\n]+\\)\\)?\n" ;; match header arguments
+                "\\([^\000]+?\\)#\\+end_src"))
+  (setq org-babel-inline-src-block-regexp
+	(concat "src_\\("
+		(mapconcat 'regexp-quote value "\\|")
+		"\\)"
+                "\\(\\|\\[\\(.*\\)\\]\\)"
+                "{\\([^\n]+\\)}")))
+
+(defun org-babel-add-interpreter (interpreter)
+  "Add INTERPRETER to `org-babel-interpreters' and update
+`org-babel-src-block-regexp' appropriately."
+  (unless (member interpreter org-babel-interpreters)
+    (setq org-babel-interpreters (cons interpreter org-babel-interpreters))
+    (org-babel-set-interpreters 'org-babel-interpreters org-babel-interpreters)))
+
+(defcustom org-babel-interpreters '()
+  "Interpreters allows for evaluation tags.
+This is a list of program names (as strings) that can evaluate code and
+insert the output into an Org-mode buffer.  Valid choices are
+
+R          Evaluate R code
+emacs-lisp Evaluate Emacs Lisp code and display the result
+sh         Pass command to the shell and display the result
+perl       The perl interpreter
+python     The python interpreter
+ruby       The ruby interpreter
+
+The source block regexp `org-babel-src-block-regexp' is updated
+when a new interpreter is added to this list through the
+customize interface.  To add interpreters to this variable from
+lisp code use the `org-babel-add-interpreter' function."
+  :group 'org-babel
+  :set 'org-babel-set-interpreters
+  :type '(set :greedy t
+              (const "R")
+	      (const "emacs-lisp")
+              (const "sh")
+	      (const "perl")
+	      (const "python")
+	      (const "ruby")))
+
+;;; functions
+(defun org-babel-execute-src-block (&optional arg info params)
+  "Execute the current source code block, and dump the results
+into the buffer immediately following the block.  Results are
+commented by `org-toggle-fixed-width-section'.  With optional
+prefix don't dump results into buffer but rather return the
+results in raw elisp (this is useful for automated execution of a
+source block).
+
+Optionally supply a value for INFO in the form returned by
+`org-babel-get-src-block-info'.
+
+Optionally supply a value for PARAMS which will be merged with
+the header arguments specified at the source code block."
+  (interactive)
+  ;; (message "supplied params=%S" params) ;; debugging
+  (let* ((info (or info (org-babel-get-src-block-info)))
+         (lang (first info))
+         (body (second info))
+         (params (org-babel-merge-params
+		  (third info) (org-babel-get-src-block-function-args) params))
+	 (processed-params (org-babel-process-params params))
+	 (result-params (third processed-params))
+	 (result-type (fourth processed-params))
+         (cmd (intern (concat "org-babel-execute:" lang)))
+         result)
+    ;; (message "params=%S" params) ;; debugging statement
+    (unless (member lang org-babel-interpreters)
+      (error "Language is not in `org-babel-interpreters': %s" lang))
+    (when arg (setq result-params (cons "silent" result-params)))
+    (setq result (multiple-value-bind (session vars result-params result-type) processed-params
+		   (funcall cmd body params)))
+    (if (eq result-type 'value)
+	(setq result (org-babel-process-value-result result result-params)))
+    (org-babel-insert-result result result-params)
+    (case result-type (output nil) (value result))))
+
+(defun org-babel-pop-to-session (&optional arg info)
+  "Pop to the session of the current source-code block.  If
+called with a prefix argument then evaluate the header arguments
+for the source block before entering the session.  Copy the body
+of the source block to the kill ring."
+  (interactive)
+  (let* ((info (or info (org-babel-get-src-block-info)))
+         (lang (first info))
+         (body (second info))
+         (params (third info))
+         (session (cdr (assoc :session params))))
+    (unless (member lang org-babel-interpreters)
+      (error "Language is not in `org-babel-interpreters': %s" lang))
+    ;; copy body to the kill ring
+    (with-temp-buffer (insert (org-babel-trim body)) (copy-region-as-kill (point-min) (point-max)))
+    ;; if called with a prefix argument, then process header arguments
+    (if arg (funcall (intern (concat "org-babel-prep-session:" lang)) session params))
+    ;; just to the session using pop-to-buffer
+    (pop-to-buffer (funcall (intern (format "org-babel-%s-initiate-session" lang)) session))
+    (move-end-of-line 1)))
+
+(defun org-babel-open-src-block-result (&optional re-run)
+  "If `point' is on a src block then open the results of the
+source code block, otherwise return nil.  With optional prefix
+argument RE-RUN the source-code block is evaluated even if
+results already exist."
+  (interactive "P")
+  (when (org-babel-get-src-block-info)
+    (save-excursion
+      ;; go to the results, if there aren't any then run the block
+      (goto-char (or (and (not re-run) (org-babel-where-is-src-block-result))
+                     (progn (org-babel-execute-src-block)
+                            (org-babel-where-is-src-block-result))))
+      (move-end-of-line 1) (forward-char 1)
+      ;; open the results
+      (if (looking-at org-bracket-link-regexp)
+          ;; file results
+          (org-open-at-point)
+        (let ((results (org-babel-read-result)))
+          (flet ((echo-res (result)
+                           (if (stringp result) result (format "%S" result))))
+            (pop-to-buffer (get-buffer-create "org-babel-results"))
+            (delete-region (point-min) (point-max))
+            (if (listp results)
+                ;; table result
+                (insert (orgtbl-to-generic results '(:sep "\t" :fmt echo-res)))
+              ;; scalar result
+              (insert (echo-res results))))))
+      t)))
+
+(defun org-babel-process-value-result (result result-params)
+  "Process returned value for insertion in buffer.
+
+Currently, this function forces to table output if :results
+vector has been supplied.
+
+  You can see below the various fragments of results-processing
+code that were present in the language-specific files. Out of
+those fragments, I've moved the org-babel-python-table-or-results
+and org-babel-import-elisp-from-file functionality into the
+org-babel-*-evaluate functions. I think those should only be used
+in the :results value case, as in the 'output case we are not
+concerned with creating elisp versions of results. "
+
+  (if (and (member "vector" result-params) (not (listp result)))
+      (list (list result))
+    result))
+
+(defun org-babel-execute-buffer (&optional arg)
+  "Replace EVAL snippets in the entire buffer."
+  (interactive "P")
+  (save-excursion
+    (goto-char (point-min))
+    (while (re-search-forward org-babel-src-block-regexp nil t)
+      (goto-char (match-beginning 0))
+      (org-babel-execute-src-block arg)
+      (goto-char (match-end 0)))))
+
+(defun org-babel-execute-subtree (&optional arg)
+  "Replace EVAL snippets in the entire subtree."
+  (interactive "P")
+  (save-excursion
+    (org-narrow-to-subtree)
+    (org-babel-execute-buffer)
+    (widen)))
+
+(defun org-babel-get-src-block-name ()
+  "Return the name of the current source block if one exists.
+
+This function is analogous to org-babel-lob-get-info. For both
+functions, after they are called, (match-string 1) matches the
+function name, and (match-string 3) matches the function
+arguments inside the parentheses. I think perhaps these functions
+should be renamed to bring out this similarity, perhaps involving
+the word 'call'.
+
+Currently the function `org-babel-get-src-block-function-args'
+relies on the match-data from a match in this function.  I think
+splitting a match and the use of it's data is bad form, and we
+should re-work these two functions, perhaps combining them into
+one function which returns more data than just the name. [Eric]"
+  (let ((case-fold-search t)
+	(head (org-babel-where-is-src-block-head)))
+    (if head
+	(save-excursion
+	  (goto-char head)
+	  (if (save-excursion
+		(forward-line -1)
+                ;; the second match of this regexp is used later to
+                ;; find arguments in the "functional" style, where
+                ;; they are passed as part of the source name line
+		(looking-at "#\\+srcname:[ \f\t\n\r\v]*\\([^ ()\f\t\n\r\v]+\\)\\(\(\\(.*\\)\)\\|\\)"))
+	      (org-babel-clean-text-properties (match-string 1)))))))
+
+(defun org-babel-get-src-block-info ()
+  "Return the information of the current source block as a list
+of the following form.  (language body header-arguments-alist)"
+  (let ((case-fold-search t) head)
+    (if (setq head (org-babel-where-is-src-block-head))
+        (save-excursion (goto-char head) (org-babel-parse-src-block-match))
+      (if (save-excursion ;; inline source block
+            (re-search-backward "[ \f\t\n\r\v]" nil t)
+            (forward-char 1)
+            (looking-at org-babel-inline-src-block-regexp))
+          (org-babel-parse-inline-src-block-match)
+        nil)))) ;; indicate that no source block was found
+
+(defun org-babel-get-src-block-function-args ()
+  (when (org-babel-get-src-block-name)
+    (mapcar (lambda (ref) (cons :var ref))
+	    (org-babel-ref-split-args (match-string 3)))))
+
+(defmacro org-babel-map-source-blocks (file &rest body)
+  "Evaluate BODY forms on each source-block in FILE."
+  (declare (indent 1))
+  `(let ((visited-p (get-buffer (file-name-nondirectory ,file))))
+     (save-window-excursion
+       (find-file ,file) (goto-char (point-min))
+       (while (re-search-forward org-babel-src-block-regexp nil t)
+         (goto-char (match-beginning 0))
+         (save-match-data ,@body)
+         (goto-char (match-end 0))))
+     (unless visited-p (kill-buffer (file-name-nondirectory file)))))
+
+(defun org-babel-params-from-properties ()
+  "Return an association list of any source block params which
+may be specified in the properties of the current outline entry."
+  (save-match-data
+    (delq nil
+          (mapcar
+           (lambda (header-arg)
+             (let ((val (org-entry-get (point) header-arg)))
+               (when val
+                 ;; (message "param-from-property %s=%s" header-arg val) ;; debugging statement
+                 (cons (intern (concat ":" header-arg)) val))))
+           '("results" "exports" "tangle" "var")))))
+
+(defun org-babel-parse-src-block-match ()
+  (let* ((lang (org-babel-clean-text-properties (match-string 1)))
+         (lang-headers (intern (concat "org-babel-default-header-args:" lang)))
+         (body (org-babel-clean-text-properties (match-string 4))))
+    (list lang
+          ;; get src block body removing properties, protective commas, and indentation
+          (with-temp-buffer
+            (save-match-data
+              (insert (org-babel-strip-protective-commas body))
+              (org-do-remove-indentation)
+              (buffer-string)))
+	  (org-babel-merge-params
+	   org-babel-default-header-args
+           (org-babel-params-from-properties)
+	   (if (boundp lang-headers) (eval lang-headers) nil)
+	   (org-babel-parse-header-arguments (org-babel-clean-text-properties (or (match-string 3) "")))))))
+
+(defun org-babel-parse-inline-src-block-match ()
+  (let* ((lang (org-babel-clean-text-properties (match-string 1)))
+         (lang-headers (intern (concat "org-babel-default-header-args:" lang))))
+    (list lang
+          (org-babel-strip-protective-commas (org-babel-clean-text-properties (match-string 4)))
+          (org-babel-merge-params
+           org-babel-default-inline-header-args
+           (org-babel-params-from-properties)
+           (if (boundp lang-headers) (eval lang-headers) nil)
+           (org-babel-parse-header-arguments (org-babel-clean-text-properties (or (match-string 3) "")))))))
+
+(defun org-babel-parse-header-arguments (arg-string)
+  "Parse a string of header arguments returning an alist."
+  (if (> (length arg-string) 0)
+      (delq nil
+	    (mapcar
+	     (lambda (arg)
+	       (if (string-match "\\([^ \f\t\n\r\v]+\\)[ \f\t\n\r\v]+\\([^ \f\t\n\r\v]+.*\\)" arg)
+		   (cons (intern (concat ":" (match-string 1 arg)))
+			 (org-babel-chomp (match-string 2 arg)))
+		 (cons (intern (concat ":" arg)) nil)))
+	     (split-string (concat " " arg-string) "[ \f\t\n\r\v]+:" t)))))
+
+(defun org-babel-process-params (params)
+  "Parse params and resolve references.
+
+Return a list (session vars result-params result-type). These are
+made available to the org-babel-execute:LANG functions via
+multiple-value-bind."
+  (let* ((session (cdr (assoc :session params)))
+	 (vars (org-babel-ref-variables params))
+	 (result-params (split-string (or (cdr (assoc :results params)) "")))
+	 (result-type (cond ((member "output" result-params) 'output)
+			    ((member "value" result-params) 'value)
+			    (t 'value))))
+    (list session vars result-params result-type)))
+
+(defun org-babel-where-is-src-block-head ()
+  "Return the point at the beginning of the current source
+block.  Specifically at the beginning of the #+BEGIN_SRC line.
+If the point is not on a source block then return nil."
+  (let ((initial (point)) top bottom)
+    (or
+     (save-excursion ;; on a #+srcname: line
+       (beginning-of-line 1)
+       (and (looking-at "#\\+srcname") (forward-line 1)
+            (looking-at org-babel-src-block-regexp)
+            (point)))
+     (save-excursion ;; on a #+begin_src line
+       (beginning-of-line 1)
+       (and (looking-at org-babel-src-block-regexp)
+            (point)))
+     (save-excursion ;; inside a src block
+       (and
+        (re-search-backward "#\\+begin_src" nil t) (setq top (point))
+        (re-search-forward "#\\+end_src" nil t) (setq bottom (point))
+        (< top initial) (< initial bottom)
+        (goto-char top) (looking-at org-babel-src-block-regexp)
+        (point))))))
+
+(defun org-babel-goto-named-source-block (&optional name)
+  "Go to a named source-code block."
+  (interactive "ssource-block name: ")
+  (let ((point (org-babel-find-named-block name)))
+    (if point
+        ;; taken from `org-open-at-point'
+        (progn (goto-char point) (org-show-context))
+      (message "source-code block '%s' not found in this buffer" name))))
+
+(defun org-babel-find-named-block (name)
+  "Find a named source-code block.
+Return the location of the source block identified by
+#+srcname NAME, or nil if no such block exists. Set match data
+according to org-babel-named-src-block-regexp."
+  (save-excursion
+    (let ((case-fold-search t)
+	  (regexp (org-babel-named-src-block-regexp-for-name name)) msg)
+      (goto-char (point-min))
+      (when (or (re-search-forward regexp nil t)
+                (re-search-backward regexp nil t))
+        (match-beginning 0)))))
+
+(defun org-babel-find-named-result (name)
+  "Return the location of the result named NAME in the current
+buffer or nil if no such result exists."
+  (save-excursion
+    (goto-char (point-min))
+    (when (re-search-forward ;; ellow end-of-buffer in following regexp?
+	   (concat "#\\+resname:[ \t]*" (regexp-quote name) "[ \t\n\f\v\r]") nil t)
+      (move-beginning-of-line 0) (point))))
+
+(defun org-babel-where-is-src-block-result (&optional insert)
+  "Return the point at the beginning of the result of the current
+source block.  Specifically at the beginning of the #+RESNAME:
+line.  If no result exists for this block then create a
+#+RESNAME: line following the source block."
+  (save-excursion
+    (let* ((on-lob-line (progn (beginning-of-line 1)
+			       (looking-at org-babel-lob-one-liner-regexp)))
+	   (name (if on-lob-line (org-babel-lob-get-info) (org-babel-get-src-block-name)))
+	   (head (unless on-lob-line (org-babel-where-is-src-block-head))) end)
+      (when head (goto-char head))
+      (or (and name (org-babel-find-named-result name))
+          (and (or on-lob-line (re-search-forward "#\\+end_src" nil t))
+               (progn (move-end-of-line 1)
+		      (if (eobp) (insert "\n") (forward-char 1))
+		      (setq end (point))
+                      (or (progn ;; either an unnamed #+resname: line already exists
+                            (re-search-forward "[^ \f\t\n\r\v]" nil t)
+                            (move-beginning-of-line 1) (looking-at "#\\+resname:"))
+                          ;; or (with optional insert) we need to back up and make one ourselves
+                          (when insert
+                            (goto-char end) (open-line 2) (forward-char 1)
+                            (insert (concat "#+resname:" (if name (concat " " name))))
+                            (move-beginning-of-line 1) t)))
+               (point))))))
+
+(defun org-babel-read-result ()
+  "Read the result at `point' into emacs-lisp."
+  (cond
+   ((org-at-table-p) (org-babel-read-table))
+   ((looking-at ": ")
+    (let ((result-string
+           (org-babel-trim
+            (mapconcat (lambda (line) (if (and (> (length line) 1)
+                                               (string= ": " (substring line 0 2)))
+                                          (substring line 2)
+                                        line))
+                       (split-string
+                        (buffer-substring (point) (org-babel-result-end)) "[\r\n]+")
+                       "\n"))))
+      (or (org-babel-number-p result-string) result-string)))
+   ((looking-at "^#\\+RESNAME:")
+    (save-excursion (forward-line 1) (org-babel-read-result)))))
+
+(defun org-babel-read-table ()
+  "Read the table at `point' into emacs-lisp."
+  (mapcar (lambda (row)
+            (if (and (symbolp row) (equal row 'hline)) row
+              (mapcar #'org-babel-read row)))
+          (org-table-to-lisp)))
+
+(defun org-babel-insert-result (result &optional insert)
+  "Insert RESULT into the current buffer after the end of the
+current source block.  With optional argument INSERT controls
+insertion of results in the org-mode file.  INSERT can take the
+following values...
+
+replace - (default option) insert results after the source block
+          replacing any previously inserted results
+
+silent -- no results are inserted
+
+file ---- the results are interpreted as a file path, and are
+          inserted into the buffer using the Org-mode file syntax
+
+raw ----- results are added directly to the org-mode file.  This
+          is a good option if you code block will output org-mode
+          formatted text.
+
+org ----- this is the same as the 'raw' option
+
+html ---- results are added inside of a #+BEGIN_HTML block.  This
+          is a good option if you code block will output html
+          formatted text.
+
+latex --- results are added inside of a #+BEGIN_LATEX block.
+          This is a good option if you code block will output
+          latex formatted text."
+  (if (stringp result)
+      (progn
+        (setq result (org-babel-clean-text-properties result))
+        (if (member "file" insert) (setq result (org-babel-result-to-file result))))
+    (unless (listp result) (setq result (format "%S" result))))
+  (if (and insert (member "replace" insert) (not (member "silent" insert)))
+      (org-babel-remove-result))
+  (if (= (length result) 0)
+      (if (member "value" result-params)
+	  (message "No result returned by source block")
+	(message "Source block produced no output"))
+    (if (and insert (member "silent" insert))
+        (progn (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result)
+      (when (and (stringp result) ;; ensure results end in a newline
+                 (not (or (string-equal (substring result -1) "\n")
+                          (string-equal (substring result -1) "\r"))))
+        (setq result (concat result "\n")))
+      (save-excursion
+	(let ((existing-result (org-babel-where-is-src-block-result t)))
+	  (when existing-result (goto-char existing-result) (forward-line 1)))
+        (if (stringp result) ;; assume the result is a table if it's not a string
+            (if (member "file" insert)
+                (insert result)
+              (if (member "html" insert)
+                  (insert (format "#+BEGIN_HTML\n%s#+END_HTML\n" result))
+                (if (member "latex" insert)
+                    (insert (format "#+BEGIN_LaTeX\n%s#+END_LaTeX\n" result))
+                  (if (or (member "raw" insert) (member "org" insert))
+                      (progn (save-excursion (insert result))
+                             (if (org-at-table-p) (org-cycle)))
+                    (org-babel-examplize-region (point) (progn (insert result) (point)))))))
+          (progn
+            (insert
+             (concat (orgtbl-to-orgtbl
+                      (if (and (listp (car result)) (listp (cdr (car result))))
+                          result (list result))
+                      '(:fmt (lambda (cell) (format "%S" cell)))) "\n"))
+            (forward-line -1)
+            (org-cycle))))
+      (message "finished"))))
+
+(defun org-babel-result-to-org-string (result)
+  "Return RESULT as a string in org-mode format.  This function
+relies on `org-babel-insert-result'."
+  (with-temp-buffer (org-babel-insert-result result) (buffer-string)))
+
+(defun org-babel-remove-result ()
+  "Remove the result of the current source block."
+  (interactive)
+  (save-excursion
+    (goto-char (org-babel-where-is-src-block-result t)) (forward-line 1)
+    (delete-region (save-excursion (move-beginning-of-line 0) (point)) (org-babel-result-end))))
+
+(defun org-babel-result-end ()
+  "Return the point at the end of the current set of results"
+  (save-excursion
+    (if (org-at-table-p)
+        (progn (goto-char (org-table-end)) (forward-line 1) (point))
+      (let ((case-fold-search t))
+        (cond
+         ((looking-at "#\\+begin_latex")
+          (search-forward "#+end_latex" nil t)
+          (forward-line 2))
+         ((looking-at "#\\+begin_html")
+          (search-forward "#+end_html" nil t)
+          (forward-line 2))
+         ((looking-at "#\\+begin_example")
+          (search-forward "#+end_example" nil t)
+          (forward-line 2))
+         (t (progn (while (looking-at "\\(: \\|\\[\\[\\)")
+                     (forward-line 1))
+                   (forward-line 1)))))
+      (point))))
+
+(defun org-babel-result-to-file (result)
+  "Return an `org-mode' link with the path being the value or
+RESULT, and the display being the `file-name-nondirectory' if
+non-nil."
+  (concat "[[file:" result "]]"))
+
+(defun org-babel-examplize-region (beg end)
+  "Comment out region using the ': ' org example quote."
+  (interactive "*r")
+  (let ((size (abs (- (line-number-at-pos end)
+		      (line-number-at-pos beg)))))
+    (save-excursion
+      (cond ((= size 0)
+	     (error "This should be impossible: a newline was appended to result if missing")
+	     (let ((result (buffer-substring beg end)))
+	       (delete-region beg end)
+	       (insert (concat ": " result))))
+	    ((< size org-babel-min-lines-for-block-output)
+	     (goto-char beg)
+	     (dotimes (n size)
+	       (move-beginning-of-line 1) (insert ": ") (forward-line 1)))
+	    (t
+	     (goto-char beg)
+	     (insert "#+begin_example\n")
+	     (forward-char (- end beg))
+	     (insert "#+end_example\n"))))))
+
+(defun org-babel-merge-params (&rest plists)
+  "Combine all parameter association lists in PLISTS.  Later
+elements of PLISTS override the values of previous element.  This
+takes into account some special considerations for certain
+parameters when merging lists."
+  (let (params results exports tangle vars var ref)
+    (flet ((e-merge (exclusive-groups &rest result-params)
+                    ;; maintain exclusivity of mutually exclusive parameters
+                    (let (output)
+                      (mapc (lambda (new-params)
+                              (mapc (lambda (new-param)
+                                      (mapc (lambda (exclusive-group)
+                                              (when (member new-param exclusive-group)
+                                                (mapcar (lambda (excluded-param)
+                                                          (setq output (delete excluded-param output)))
+                                                        exclusive-group)))
+                                            exclusive-groups)
+                                      (setq output (org-uniquify (cons new-param output))))
+                                    new-params))
+                            result-params)
+                      output)))
+      (mapc (lambda (plist)
+              (mapc (lambda (pair)
+                      (case (car pair)
+                        (:var
+                         ;; we want only one specification per variable
+                         (when (string-match "^\\([^= \f\t\n\r\v]+\\)[ \t]*=[ \t]*\\([^\f\n\r\v]+\\)$" (cdr pair))
+                           ;; TODO: When is this not true?
+                           (setq var (intern (match-string 1 (cdr pair)))
+                                 ref (match-string 2 (cdr pair))
+                                 vars (cons (cons var ref) (assq-delete-all var vars)))))
+                        (:results
+                         (setq results (e-merge
+                                        '(("file" "vector" "scalar" "raw" "org" "html" "latex")
+                                          ("replace" "silent")
+                                          ("output" "value"))
+                                        results (split-string (cdr pair)))))
+                        (:exports
+                         (setq exports (e-merge '(("code" "results" "both" "none"))
+                                                exports (split-string (cdr pair)))))
+                        (:tangle
+                         (setq tangle (e-merge '(("yes" "no"))
+                                               tangle (split-string (cdr pair)))))
+                        (t ;; replace: this covers e.g. :session
+                         (setq params (cons pair (assq-delete-all (car pair) params))))))
+                    plist))
+            plists))
+    (setq vars (mapcar (lambda (pair) (format "%s=%s" (car pair) (cdr pair))) vars))
+    (while vars (setq params (cons (cons :var (pop vars)) params)))
+    (cons (cons :tangle (mapconcat 'identity tangle " "))
+          (cons (cons :exports (mapconcat 'identity exports " "))
+                (cons (cons :results (mapconcat 'identity results " "))
+                      params)))))
+
+(defun org-babel-clean-text-properties (text)
+  "Strip all properties from text return."
+  (set-text-properties 0 (length text) nil text) text)
+
+(defun org-babel-strip-protective-commas (body)
+  "Strip protective commas from bodies of source blocks."
+  (replace-regexp-in-string "^,#" "#" body))
+
+(defun org-babel-read (cell)
+  "Convert the string value of CELL to a number if appropriate.
+Otherwise if cell looks like lisp (meaning it starts with a
+\"(\" or a \"'\") then read it as lisp, otherwise return it
+unmodified as a string.
+
+This is taken almost directly from `org-read-prop'."
+  (if (and (stringp cell) (not (equal cell "")))
+      (or (org-babel-number-p cell)
+          (if (or (equal "(" (substring cell 0 1))
+                  (equal "'" (substring cell 0 1)))
+              (read cell)
+            (progn (set-text-properties 0 (length cell) nil cell) cell)))
+    cell))
+
+(defun org-babel-number-p (string)
+  "Return t if STRING represents a number"
+  (if (and (string-match "^-?[[:digit:]]*\\.?[[:digit:]]*$" string)
+           (= (match-end 0) (length string)))
+      (string-to-number string)))
+
+(defun org-babel-import-elisp-from-file (file-name)
+  "Read the results located at FILE-NAME into an elisp table.  If
+the table is trivial, then return it as a scalar."
+  (let (result)
+    (with-temp-buffer
+      (condition-case nil
+          (progn
+            (org-table-import file-name nil)
+            (delete-file file-name)
+            (setq result (mapcar (lambda (row)
+                                   (mapcar #'org-babel-string-read row))
+                                 (org-table-to-lisp))))
+        (error nil)))
+    (if (null (cdr result)) ;; if result is trivial vector, then scalarize it
+	(if (consp (car result))
+	    (if (null (cdr (car result)))
+		(caar result)
+	      result)
+	  (car result))
+      result)))
+
+(defun org-babel-string-read (cell)
+  "Strip nested \"s from around strings in exported R values."
+  (org-babel-read (or (and (stringp cell)
+                           (string-match "\\\"\\(.+\\)\\\"" cell)
+                           (match-string 1 cell))
+                      cell)))
+
+(defun org-babel-reverse-string (string)
+  (apply 'string (reverse (string-to-list string))))
+
+(defun org-babel-chomp (string &optional regexp)
+  "Remove any trailing space or carriage returns characters from
+STRING.  Default regexp used is \"[ \f\t\n\r\v]\" but can be
+overwritten by specifying a regexp as a second argument."
+  (while (and (> (length string) 0) (string-match "[ \f\t\n\r\v]" (substring string -1)))
+    (setq string (substring string 0 -1)))
+  string)
+
+(defun org-babel-trim (string &optional regexp)
+  "Like `org-babel-chomp' only it runs on both the front and back of the string"
+  (org-babel-chomp (org-babel-reverse-string
+                    (org-babel-chomp (org-babel-reverse-string string) regexp)) regexp))
+
+(provide 'org-babel)
+;;; org-babel.el ends here

contrib/babel/org-babel-requirements.org

@@ -0,0 +1,726 @@
+#+TITLE: Org-Babel Requirements
+#+OPTIONS: toc:nil num:nil ^:nil
+
+This file contains the initial discussion of the requirements for
+org-babel.
+
+* Overview
+This project is basically about putting source code into org
+files. This isn't just code to look pretty as a source code example,
+but code to be evaluated. Org files have 3 main export targets: org,
+html and latex. Once we have implemented a smooth bi-directional flow
+of data between org-mode formats (including tables, and maybe lists
+and property values) and source-code blocks, we will be able to use
+org-mode's built in export to publish the results of evaluated source
+code in any org-supported format using org-mode as an intermediate
+format.  We have a current focus on R code, but we are regarding that
+more as a working example than as a defining feature of the project.
+
+The main objectives of this project are...
+
+# Lets start with this list and make changes as appropriate.  Please
+# try to make changes to this list, rather than starting any new
+# lists.
+
+- [[* evaluation of embedded source code][evaluation of embedded source code]]
+  - [[* execution on demand and on export][execution on demand and on export]]
+  - [[* source blocks][source blocks]]
+  - [[* header arguments][header arguments]]
+  - [[* inline source evaluation][inline source evaluation]]
+  - [[* included source file evaluation][included source file evaluation]] ?? maybe
+  - [[* caching of evaluation][caching of evaluation]]
+- [[* interaction with the source-code's process][interaction with the source-code's process]]
+- [[* output of code evaluation][output of code evaluation]]
+  - [[* textual/numeric output][textual/numeric output]]
+  - [[* graphical output][graphical output]]
+  - [[* file creation][non-graphics file creation]]
+  - [[* side effects][side effects]]
+- [[* reference to data and evaluation results][reference to data and evaluation results]]
+  - [[* reference format][reference format]]
+  - [[* source-target pairs][source-target pairs]]
+    - [[* source block output from org tables][source block output from org tables]]
+    - [[* source block outpt from other source block][source block outpt from other source block]]
+    - [[* source block output from org list][source block output from org list]] ?? maybe
+    - [[* org table from source block][org table from source block]]
+    - [[* org table from org table][org table from org table]]
+    - [[* org properties from source block][org properties from source block]]
+    - [[* org properties from org table][org properties from org table]]
+- [[* export][export]]
+
+
+* Objectives and Specs
+
+** evaluation of embedded source code
+
+*** execution on demand and on export
+    Let's use an asterisk to indicate content which includes the
+    *result* of code evaluation, rather than the code itself. Clearly
+    we have a requirement for the following transformation:
+
+    org \to org*
+
+    Let's say this transformation is effected by a function
+    `org-eval-buffer'. This transformation is necessary when the
+    target format is org (say you want to update the values in an org
+    table, or generate a plot and create an org link to it), and it
+    can also be used as the first step by which to reach html and
+    latex:
+    
+    org \to org* \to html
+
+    org \to org* \to latex
+
+    Thus in principle we can reach our 3 target formats with
+    `org-eval-buffer', `org-export-as-latex' and `org-export-as-html'.
+    
+    An extra transformation that we might want is
+    
+    org \to latex
+
+    I.e. export to latex without evaluation of code, in such a way that R
+    code can subsequently be evaluated using
+    =Sweave(driver=RweaveLatex)=, which is what the R community is
+    used to. This would provide a `bail out' avenue where users can
+    escape org mode and enter a workflow in which the latex/noweb file
+    is treated as source.
+
+**** How do we implement `org-eval-buffer'?
+    
+     AIUI The following can all be viewed as implementations of
+     org-eval-buffer for R code:
+
+     (see this question again posed in [[file:org-babel/org-babel-R.el::Maybe%20the%20following%20be%20replaced%20with%20a%20method%20using%20ess%20execute][org-babel-R.el]])
+    
+***** org-eval-light
+      This is the beginnings of a general evaluation mechanism, that
+      could evaluate python, ruby, shell, perl, in addition to R.
+      The header says it's based on org-eval
+
+      what is org-eval??
+      
+      org-eval was written by Carsten.  It lives in the
+      org/contrib/lisp directory because it is too dangerous to
+      include in the base.  Unlike org-eval-light org-eval evaluates
+      all source blocks in an org-file when the file is first opened,
+      which could be a security nightmare for example if someone
+      emailed you a pernicious file.
+      
+***** org-R
+      This accomplishes org \to org* in elisp by visiting code blocks
+      and evaluating code using ESS.
+
+***** RweaveOrg
+      This accomplishes org \to org* using R via
+      
+: Sweave("file-with-unevaluated-code.org", driver=RweaveOrg, syntax=SweaveSyntaxOrg)
+
+***** org-exp-blocks.el
+      Like org-R, this achieves org \to org* in elisp by visiting code
+      blocks and using ESS to evaluate R code.
+
+*** source blocks
+(see [[* Special editing and evaluation of source code][Special editing and evaluation of source code]])
+
+*** header arguments
+(see [[* block headers/parameters][block headers/parameters]])
+
+There are going to be many cases where we want to use header arguments
+to change the evaluation options of source code, to pass external
+information to a block of source code and control the inclusion of
+evaluation results.
+
+*** inline source evaluation
+*** included source file evaluation
+It may be nice to be able to include an entire external file of source
+code, and then evaluate and export that code as if it were in the
+file.  The format for such a file inclusion could optionally look like
+the following
+
+: #+include_src filename header_arguments
+
+*** caching of evaluation
+
+Any kind of code that can have a block evaluated could optionally define
+a function to write the output to a file, or to serialize the output of
+the function.  If a document or block is configured to cache input,
+write all cached blocks to their own files and either a) hash them, or
+b) let git and org-attach track them.  Before a block gets eval'd, we
+check to see if it has changed.  If a document or block is configured to
+cache output and a print/serialize function is available, write the
+output of each cached block to its own file.  When the file is eval'd
+and some sort of display is called for, only update the display if the
+output has changed.  Each of these would have an override, presumably
+something like (... & force) that could be triggered with a prefix arg
+to the eval or export function.
+
+For R, I would say
+
+#+begin_src emacs-lisp
+;; fake code that only pretends to work
+(add-hook 'rorg-store-output-hook 
+    '("r" lambda (block-environment block-label)
+        (ess-exec (concat "save.image("
+                          block-environment
+                          ", file = " block-label
+                          ".Rdata, compress=TRUE)"))))
+#+end_src
+
+The idea being that for r blocks that get eval'd, if output needs to be
+stored, you should write the entire environment that was created in that
+block to an Rdata file.
+
+(see [[* block scoping][block scoping]])
+
+** interaction with the source-code's process
+We should settle on a uniform API for sending code and receiving
+output from a source process.  Then to add a new language all we need
+to do is implement this API.
+
+for related notes see ([[* Interaction with the R process][Interaction with the R process]])
+
+** output of code evaluation
+*** textual/numeric output
+    We (optionally) incorporate the text output as text in the target
+    document
+*** graphical output
+    We either link to the graphics or (html/latex) include them
+    inline.
+    
+    I would say, if the block is being evaluated interactively then
+    lets pop up the image in a new window, and if it is being exported
+    then we can just include a link to the file which will be exported
+    appropriately by org-mode.
+    
+*** non-graphics files
+    ? We link to other file output
+*** side effects
+If we are using a continuous process in (for example an R process
+handled by ESS) then any side effects of the process (for example
+setting values of R variables) will be handled automatically
+
+Are there side-effects which need to be considered aside from those
+internal to the source-code evaluation process?
+
+** reference to data and evaluation results
+   I think this will be very important.  I would suggest that since we
+   are using lisp we use lists as our medium of exchange.  Then all we
+   need are functions going converting all of our target formats to and
+   from lists.  These functions are already provided by for org tables.
+
+   It would be a boon both to org users and R users to allow org tables
+   to be manipulated with the R programming language.  Org tables give R
+   users an easy way to enter and display data; R gives org users a
+   powerful way to perform vector operations, statistical tests, and
+   visualization on their tables.
+
+   This means that we will need to consider unique id's for source
+   blocks, as well as for org tables, and for any other data source or
+   target.
+
+*** Implementations
+**** naive
+     Naive implementation would be to use =(org-export-table "tmp.csv")=
+     and =(ess-execute "read.csv('tmp.csv')")=.  
+**** org-R
+     org-R passes data to R from two sources: org tables, or csv
+     files. Org tables are first exported to a temporary csv file
+     using [[file:existing_tools/org-R.el::defun%20org%20R%20export%20to%20csv%20csv%20file%20options][org-R-export-to-csv]].
+**** org-exp-blocks
+     org-exp-blocks uses [[org-interblock-R-command-to-string]] to send
+     commands to an R process running in a comint buffer through ESS.
+     org-exp-blocks has no support for dumping table data to R process, or
+     vice versa.
+
+**** RweaveOrg
+     NA
+
+*** reference format
+    This will be tricky, Dan has already come up with a solution for R, I
+    need to look more closely at that and we should try to come up with a
+    formats for referencing data from source-code in such a way that it
+    will be as source-code-language independent as possible.
+    
+    Org tables already have a sophisticated reference system in place
+    that allows referencing table ranges in other files, as well as
+    specifying constants in the header arguments of a table.  This is
+    described in [[info:org:References]].
+
+**** Dan: thinking aloud re: referencing data from R
+     Suppose in some R code, we want to reference data in an org
+     table. I think that requires the use of 'header arguments', since
+     otherwise, under pure evaluation of a code block without header
+     args, R has no way to locate the data in the org buffer. So that
+     suggests a mechanism like that used by org-R whereby table names
+     or unique entry IDs are used to reference org tables (and indeed
+     potentially row/column ranges within org tables, although that
+     subsetting could also be done in R).
+
+     Specifically what org-R does is write the table to a temp csv
+     file, and tell R the name of that file. However:
+
+     1. We are not limited to a single source of input; the same sort
+        of thing could be done for several sources of input
+
+     2. I don't think we even have to use temp files. An alternative
+        would be to have org pass the table contents as a csv-format
+        string to textConnection() in R, thus creating an arbitrary
+        number of input objects in the appropriate R environment
+        (scope) from which the R code can read data when necessary.
+
+	That suggests a header option syntax something like
+    
+#+begin_src emacs-lisp
+'(:R-obj-name-1 tbl-name-or-id-1 :R-obj-name-2 tbl-name-or-id-2)
+#+end_src
+
+As a result of passing that option, the code would be able to access
+the data referenced by table-name-or-id-2 via read.table(R-obj-name-1).
+
+An extension of that idea would be to allow remote files to be used as
+data sources. In this case one might need just the remote file (if
+it's a csv file), or if it's an org file then the name of the file
+plus a table reference within that org file. Thus maybe something like
+
+#+begin_src emacs-lisp
+'((R-obj-name-1 . (:tblref tbl-name-or-id-1 :file file-1))
+  (R-obj-name-2 . (:tblref tbl-name-or-id-2 :file file-2)))
+#+end_src emacs-lisp
+
+**** Eric: referencing data in general
+So here's some thoughts for referencing data (henceforth referred to
+as *resources*).  I think this is the next thing we need to tackle for
+implementation to move forward.  We don't need to implement everything
+below right off the bat, but I'd like to get these lists as full as
+possible so we don't make any implementation assumptions which
+preclude real needs.
+
+We need to reference resources of the following types...
+
+- table (list)
+- output from a source code block (list or hash)
+- property values of an outline header (hash)
+- list (list)
+- description list (hash)
+- more?...
+
+All of these resources will live in org files which could be
+
+- the current file (default)
+- another file on the same system (path)
+- another file on the web (url)
+- another file in a git repo (file and commit hash)
+
+What information should each of these resources be able to supply?
+I'm thinking (again not that we'll implement all of these but just to
+think of them)...
+
+- ranges or points of vector data
+- key/value pairs from a hash
+- when the object was last modified
+- commit info (author, date, message, sha, etc...)
+- pointers to the resources upon which the resource relies
+
+So we need a referencing syntax powerful enough to handle all of these
+alternatives.  Maybe something like =path:sha:name:range= where
+
+- path :: is empty for the current file, is a path for files on the
+          same system, and is a url otherwise
+- sha :: is an option git commit indicator
+- name :: is the table/header/source-block name or id for location
+          inside of the org file (this would not be optional)
+- range :: would indicate which information is requested from the
+           resource, so it could be a range to access parts of a
+           table, or the names of properties to be referenced from an
+           outline header
+
+Once we agree on how this should work, I'll try to stub out some code,
+so that we can get some simple subset of this functionality working,
+hopefully something complex enough to do the following...
+- [[* resource reference example][resource-reference-example]]
+
+***** questions
+****** multiple outputs
+Do we want things like a source code block to leave multiple outputs,
+or do we only want them to be able to output one vector or hash?
+
+****** environment (state and side-effects)
+This design assumes that any changes will explicitly pass data in a
+functional programming style.  This makes no assumptions about things
+like source code blocks changing state (in general state changes lead
+to more difficult debugging).
+
+- Do we want to take steps so ensure we do things like execute
+  consecutive R blocks in different environment, or do we want to
+  allow state changes?
+- Does this matter?
+
+****** passing arguments to resources
+So I(eric) may be getting ahead of myself here, but what do you think
+about the ability to pass arguments to resources.  I'm having visions
+of google map-reduce, processes spread out across multiple machines.
+
+Maybe we could do this by allowing the arguments to be specified?
+
+*** source-target pairs
+
+    The following can be used for special considerations based on
+    source-target pairs
+
+    Dan: I don't quite understand this subtree; Eric -- could you give
+    a little more explanation of this and of your comment above
+    regarding using [[lists as our medium of exchange]]?
+    
+**** source block output from org tables
+**** source block outpt from other source block
+**** source block output from org list
+**** org table from source block
+**** org table from org table
+**** org properties from source block
+**** org properties from org table
+     
+** export
+   once the previous objectives are met export should be fairly simple.
+   Basically it will consist of triggering the evaluation of source code
+   blocks with the org-export-preprocess-hook.
+
+   This block export evaluation will be aware of the target format
+   through the htmlp and latexp variables, and can then create quoted
+   =#+begin_html= and =#+begin_latex= blocks appropriately.
+   
+   There will also need to be a set of header arguments related to
+   code export.  These would be similar to the results header
+   arguments but would apply to how to handle execution and results
+   during export.
+
+
+* Notes
+** Block Formats
+   Unfortunately org-mode how two different block types, both useful.
+   In developing RweaveOrg, a third was introduced.
+
+   Eric is leaning towards using the =#+begin_src= blocks, as that is
+   really what these blocks contain: source code.  Austin believes
+   that specifying export options at the beginning of a block is
+   useful functionality, to be preserved if possible.
+
+   Note that upper and lower case are not relevant in block headings.
+
+*** PROPOSED block format
+I (Eric) propose that we use the syntax of source code blocks as they
+currently exist in org-mode with the addition of *evaluation*,
+*header-arguments*, *exportation*, *single-line-blocks*, and
+*references-to-table-data*.
+
+1) *evaluation*: These blocks can be evaluated through =\C-c\C-c= with
+   a slight addition to the code already present and working in
+   [[file:existing_tools/org-eval-light.el][org-eval-light.el]].  All we should need to add for R support would
+   be an appropriate entry in [[org-eval-light-interpreters]] with a
+   corresponding evaluation function.  For an example usinga
+   org-eval-light see [[* src block evaluation w/org-eval-light]].
+
+2) *header-arguments*: These can be implemented along the lines of
+   Austin's header arguments in [[file:existing_tools/RweaveOrg/org-sweave.el][org-sweave.el]].
+
+3) *exportation*: Should be as similar as possible to that done by
+   Sweave, and hopefully can re-use some of the code currently present
+   in [[file:existing_tools/exp-blocks/org-exp-blocks.el ][org-exp-blocks.el]].
+
+4) *single-line-blocks*: It seems that it is useful to be able to
+   place a single line of R code on a line by itself.  Should we add
+   syntax for this similar to Dan's =#+RR:= lines?  I would lean
+   towards something here that can be re-used for any type of source
+   code in the same manner as the =#+begin_src R= blocks, maybe
+   =#+src_R=? Dan: I'm fine with this, but don't think single-line
+   blocks are a priority. My =#+R= lines were something totally
+   different: an attempt to have users specify R code implicitly,
+   using org-mode option syntax.
+
+5) *references-to-table-data*: I get this impression that this is
+   vital to the efficient use of R code in an org file, so we should
+   come up with a way to reference table data from a single-line-block
+   or from an R source-code block.  It looks like Dan has already done
+   this in [[file:existing_tools/org-R.el][org-R.el]].
+
+Syntax
+
+Multi-line Block
+: #+begin_src lang header-arguments
+:  body
+: #+end
+- lang :: the language of the block (R, shell, elisp, etc...)
+- header-arguments :: a list of optional arguments which control how
+     the block is evaluated and exported, and how the results are handled
+- body :: the actual body of the block
+
+Single-line Block
+: #+begin_src lang body
+- It's not clear how/if we would include header-arguments into a
+  single line block.  Suggestions? Can we just leave them out?  Dan:
+  I'm not too worried about single line blocks to start off
+  with. Their main advantage seems to be that they save 2 lines.
+  Eric: Fair enough, lets not worry about this now, also I would guess
+  that any code simple enough to fit on one line wouldn't need header
+  arguments anyways.
+
+Include Block
+: #+include_src lang filename header-arguments
+- I think this would be useful, and should be much more work (Dan:
+  didn't get the meaning of that last clause!?).  Eric: scratch that,
+  I meant "*shouldn't* be too much work" :) That way whole external
+  files of source code could be evaluated as if they were an inline
+  block. Dan: again I'd say not a massive priority, as I think all the
+  languages we have in mind have facilities for doing this natively,
+  thus I think the desired effect can often be achieved from within a
+  #+begin_src block.  Eric: Agreed, while this would be a nice thing
+  to include we shouldn't wast too much effort on it in the beginning.
+
+What do you think?  Does this accomplish everything we want to be able
+to do with embedded R source code blocks?
+
+***** src block evaluation w/org-eval-light
+here's an example using org-eval-light.el
+
+first load the org-eval-light.el file
+
+[[elisp:(load (expand-file-name "org-eval-light.el" (expand-file-name "existing_tools" (file-name-directory buffer-file-name))))]]
+
+then press =\C-c\C-c= inside of the following src code snippet.  The
+results should appear in a comment immediately following the source
+code block.  It shouldn't be too hard to add R support to this
+function through the `org-eval-light-interpreters' variable.
+
+(Dan: The following causes error on export to HTML hence spaces inserted at bol)
+
+ #+begin_src shell
+date
+ #+end_src
+
+*** existing formats
+**** Source code blocks 
+    Org has an extremely useful method of editing source code and
+    examples in their native modes.  In the case of R code, we want to
+    be able to use the full functionality of ESS mode, including
+    interactive evaluation of code.
+
+    Source code blocks look like the following and allow for the
+    special editing of code inside of the block through
+    `org-edit-special'.
+
+#+BEGIN_SRC r
+
+,## hit C-c ' within this block to enter a temporary buffer in r-mode.
+
+,## while in the temporary buffer, hit C-c C-c on this comment to
+,## evaluate this block
+a <- 3
+a
+
+,## hit C-c ' to exit the temporary buffer
+#+END_SRC     
+
+**** dblocks
+    dblocks are useful because org-mode will automatically call
+    `org-dblock-write:dblock-type' where dblock-type is the string
+    following the =#+BEGIN:= portion of the line.
+
+    dblocks look like the following and allow for evaluation of the
+    code inside of the block by calling =\C-c\C-c= on the header of
+    the block.  
+
+#+BEGIN: dblock-type
+#+END:
+
+**** R blocks
+     In developing RweaveOrg, Austin created [[file:existing_tools/RweaveOrg/org-sweave.el][org-sweave.el]].  This
+     allows for the kind of blocks shown in [[file:existing_tools/RweaveOrg/testing.Rorg][testing.Rorg]].  These blocks
+     have the advantage of accepting options to the Sweave preprocessor
+     following the #+BEGIN_R declaration.
+
+*** block headers/parameters
+Regardless of the syntax/format chosen for the source blocks, we will
+need to be able to pass a list of parameters to these blocks.  These
+should include (but should certainly not be limited to)
+- label or id :: Label of the block, should we provide facilities for
+                 automatically generating a unique one of these?
+- file :: names of file to which graphical/textual/numerical/tabular output
+  should be written.  Do we need this, or should this be controlled
+  through the source code itself?
+- results :: indication of where the results should be placed, maybe
+             the following values...
+  - append :: *default* meaning just append to the current buffer
+              immediately following the current source block
+  - replace :: like append, but replace any results currently there
+  - file :: save the results in a new file, and place a link to the
+            file into the current buffer immediately following the
+            source code block
+  - table :: save the results into a table, maybe use a table id:range
+             to identify which table and where therein
+  - nil :: meaning just discard the results
+- not sure of a good name here :: flags for when/if the block should
+     be evaluated (on export etc...)
+- again can't thing of a concise name :: flags for how the results of
+     the export should be displayed/included
+- scope :: flag indicating whether the block should have a local or
+           global scope
+- flags specific to the language of the source block
+- etc...
+
+I think fleshing out this list is an important next step.
+
+** Interaction with the R process
+
+We should take care to implement this in such a way that all of the
+different components which have to interactive with R including:
+- evaluation of source code blocks
+- automatic evaluation on export
+- evaluation of \R{} snippets
+- evaluation of single source code lines
+- evaluation of included source code files
+- sending/receiving vector data
+
+I think we currently have two implementations of interaction with R
+processes; [[file:existing_tools/org-R.el][org-R.el]] and [[file:existing_tools/exp-blocks/org-exp-blocks.el ][org-exp-blocks.el]].  We should be sure to take
+the best of each of these approaches.
+
+More on the exchange of data at between org-mode and source code
+blocks at [[* reference to data and evaluation results][reference to data and evaluation results]].
+
+** block scoping
+(see [[* caching of evaluation][caching of evaluation]])
+
+This inadvertently raises the issue of scoping.  The pretend function
+pretends that we will create a block-local scope, and that we can save
+just the things in that scope.  Sweave takes the make-everything-global
+approach.  I can see advantages either way.  If we make block-local
+scopes, we can save each one independently, and generally speaking it
+seems like more granularity==more control.  If we make everything
+global, we can refer to entities declared in earlier blocks without
+having to explicitly import those entities into the current block.  I
+think this counts in the "need to think about it early on" category.
+
+If we did want block-local scopes, in R we can start every eval with
+something like
+
+;; fake code that pretends to create a new, empty environment
+(ess-exec (concat block-env " <- new.env()"))
+(ess-exec (concat "eval(" block-contents ", envir=" block-env ")"))
+
+If we decide we want block-scoping, I'm sure Dan and I can figure out
+the right way to do this in R, if he hasn't already.  I haven't thought
+at all about how these scope issues generalize to, say, bash blocks.
+
+Maybe this is something that should be controlled by a header
+argument?
+
+** =\C-c\C-c= evaluation
+
+With org-mode version at least 6.23, see the documentation for
+[[info:org:Context-sensitive%20commands][info:org:Context-sensitive commands]].
+
+** free explicit variables
+Maybe we should have some idea of variables independent of any
+particular type of source code or source block.  These could be
+variables that have a value inside of the scope of the org-mode file,
+and they could be used as a transport mechanism for information
+transfer between org-tables, org-lists, and different source-blocks.
+
+Each type of source code (and org-mode types like tables, lists,
+etc...) would need to implement functions for converting different
+types of data to and from these variables (which would be elisp
+variables).
+
+So for example say we want to read the values from a table into an R
+block, perform some calculations, and then write the results back into
+the table.  We could
+1) assign the table to a variable
+   - the table would be converted into a lisp vector (list of lists)
+   - the vector would be saved in the variable
+2) an R source block would reference the variable
+   - the variable would be instantiated into an R variable (through
+     mechanisms mentioned [[* Dan: thinking aloud re: referencing data from R][elsewhere]])
+   - the R code is executed, and the value of the variable *inside of
+     R* is updated
+   - when the R block finished the value of the variable *globally in
+     the org buffer* would be updated
+3) optionally the global value of the variable would be converted back
+   into an org-mode table and would be used to overwrite the existing
+   table.
+
+What do you think?
+
+This might not be too different from what we were already talking
+about, but I think the introduction of the idea of having variables
+existing independently of any tables or source code blocks is novel
+and probably has some advantages (and probably shortfalls).
+
+
+* COMMENT Commentary
+I'm seeing this as like commit notes, and a place for less formal
+communication of the goals of our changes.
+
+** Eric <2009-02-06 Fri 15:41>
+I think we're getting close to a comprehensive set of objectives
+(although since you two are the real R user's I leave that decision up
+to you).  Once we've agreed on a set of objectives and agreed on at
+least to broad strokes of implementation, I think we should start
+listing out and assigning tasks.
+
+** Eric <2009-02-09 Mon 14:25>
+I've done a fairly destructive edit of this file.  The main goal was
+to enforce a structure on the document that we can use moving forward,
+so that any future objective changes are all made to the main
+objective list.
+
+I apologize for removing sections written by other people.  I did this
+when they were redundant or it was not clear how to fit them into this
+structure.  Rest assured if the previous text wasn't persisted in git
+I would have been much more cautious about removing it.
+
+I hope that this outline structure should be able to remain stable
+through the process of fleshing out objectives, and cashing those
+objectives out into tasks.  That said, please feel free to make any
+changes that you see fit.
+
+** Dan <2009-02-12 Thu 10:23>
+   Good job Eric with major works on this file.
+
+** Eric <2009-02-22 Sun 13:17>
+So I skipped ahead and got started on the fun part.  Namely stubbing
+out some of the basic functionality.  Please don't take any of the
+decisions I've made so far (on things like names, functionality,
+design etc...) as final decisions, I'm of course open to and hoping
+for improvement.
+
+So far [[file:org-babel/org-babel.el][org-babel.el]] and [[file:org-babel/org-babel-script.el][org-babel-script.el]] can be used to evaluate source
+code blocks of simple scripting languages.  It shouldn't be too hard
+(any takers) to write a org-babel-R.el modeled after org-babel-script.el
+to use for evaluating R code files.
+
+See the [[* org-babel.el beginning functionality][Sandbox]] for evaluable examples.
+
+** Eric <2009-02-23 Mon 15:12>
+While thinking about how to implement the transfer of data between
+source blocks and the containing org-mode file, I decided it *might*
+be useful to explicitly support the existence of variables which exist
+independent of source blocks or tables.  I'd appreciate any
+feedback... (see [[free explicit variables][free explicit variables]])
+
+** Eric <2009-02-23 Mon 17:53>
+So as I start populating this file with source code blocks I figure I
+should share this... I don't know if you guys use [[http://code.google.com/p/smart-snippet/][yasnippet]] at all,
+but if you do you might find this [[file:block][block-snippet]] org-mode snippet
+useful (I use it all the time).
+
+** Dan <2009-05-14 Thu 19:13>
+   Please note that I am at an early stage of learning org-babel /
+   studying the code so I may be misunderstanding things.
+   1. removed prefix arg [[2. evaluate the transpose definition =\C-c\C-c= on the beginning of][here]]
+   2. changed :replace -> replace 
+   3. added some tasks and bugs
+      
+
+* Buffer Dictionary
+ LocalWords:  DBlocks dblocks org-babel el eric fontification
+
+
+

contrib/babel/org-babel-worg.org

@@ -0,0 +1,863 @@
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) 
+#+TITLE:      Org-babel
+#+AUTHOR:     Eric Schulte, Dan Davison
+#+EMAIL:      schulte.eric at gmail dot com, davison at stats dot ox dot ac dot uk
+#+LANGUAGE:   en
+#+CATEGORY:   worg
+
+# #+INFOJS_OPT: view:content
+
+#+begin_html
+  <div id="subtitle">
+    <p>executable source code blocks in org-mode</p>
+  </div>
+  <div id="logo">
+    <p>
+      <img src="images/tower-of-babel.png"  alt="images/tower-of-babel.png"/>
+      <div id="attr">
+        The Tower of Babel by
+        <a href="http://commons.wikimedia.org/wiki/Pieter_Brueghel_the_Elder" title="">
+          <b>Pieter Brueghel the Elder</b>
+        </a>
+      </div>
+      <p>
+        And the Lord said, Behold, the people is one, and they have all
+        one language; and this they begin to do; and now nothing will be
+        restrained from them, which they have imagined to do. Genesis
+        11:1-9
+      </p>
+    </p>
+  </div>
+#+end_html
+
+#+begin_html
+  <p>
+  </p>
+#+end_html
+
+* Introduction
+  :PROPERTIES:
+  :CUSTOM_ID: introduction
+  :END:
+  Org-babel is an extension to the very excellent [[http://orgmode.org/][Org-mode]], providing
+  the ability to execute source code in many different languages
+  within org-mode documents. The results of code execution --- text,
+  tables and graphics --- can be integrated into the powerful
+  publishing facilities of org-mode. Org-mode is an [[http://www.gnu.org/software/emacs/][Emacs]] major mode
+  for doing almost anything with plain text.  If you are not familiar
+  with Org-mode please take a moment to read [[http://orgmode.org/][the Org-mode homepage]]
+  before continuing.
+
+  Org-babel provides the following modifications to [[http://orgmode.org/manual/Literal-examples.html][the existing
+  support]] for blocks of source code examples in the org-mode core.
+
+  1. Interactive source code execution
+  2. Arguments to source code blocks
+  3. Exportation of source code blocks to files (literate programming)
+
+* Getting started
+  :PROPERTIES:
+  :CUSTOM_ID: getting-started
+  :END:
+
+  1) Grab the latest code from the git repo at [[http://github.com/eschulte/org-babel/tree/master][github/org-babel]]
+     #+begin_src sh
+     git clone git://github.com/eschulte/org-babel.git
+     #+end_src
+
+  2) Add the following lines to your .emacs, replacing the path as
+     appropriate. A good place to check that things are up and running
+     would the examples in [[* Basic org-babel functionality][Basic org-babel functionality]].
+     #+begin_src emacs-lisp
+       (add-to-list 'load-path "/path/to/org-babel/lisp")
+       (require 'org-babel-init)
+     #+end_src
+
+  3) Finally, activate the subset of supported Org-babel languages
+     which you want to be able to execute on your system. As an
+     example, the following activates python, ruby and R. For a full
+     list of languages, with notes on their dependencies see the
+     [[#reference-and-documentation][Reference / Documentation]] section below.
+     #+begin_src emacs-lisp
+       (require 'org-babel-python)
+       (require 'org-babel-ruby)
+       (require 'org-babel-R)
+       ;;
+       ;; Once you've activated languages, load the library of babel to
+       ;; make pre-built helper functions available in the languages you will be using.
+       (org-babel-load-library-of-babel)
+     #+end_src
+  
+* Basic org-babel functionality
+  :PROPERTIES:
+  :CUSTOM_ID: basic-functionality
+  :END:
+*** Source code blocks
+    :PROPERTIES:
+    :CUSTOM_ID: source-code-blocks
+    :END:
+
+    Org-babel is all about *source code blocks* in org mode. These are
+    blocks of code (in whatever language), that can occur anywhere in
+    an org-mode file. For example, the following is a source block
+    containing [[http://www.ruby-lang.org/][ruby]] code:
+
+: #+begin_src ruby
+: "This file was last evaluated on #{Date.today}"
+: #+end_src
+
+If you are unfamiliar with the notion of a source code block in
+org-mode, please have a look at the [[http://orgmode.org/manual/Literal-examples.html][relevant manual section]] before
+proceding.
+
+Note that above is what the source block looks like in the org-mode
+file. We had to take [[http://orgmode.org/manual/Literal-examples.html#Literal-examples][special steps]] to make it look that way in the
+HTML output. Normally, when exported to HTML, source blocks are
+fontified according to their language, and the begin_src...end_src
+mark-up is omitted, like this:
+
+#+begin_src ruby
+"This file was last evaluated on #{Date.today}"
+#+end_src
+
+From now on, if you are viewing the HTML version, you will see the
+HTML output only. However, much of this document consists of
+interactive examples, and therefore in order to get a feeling for the
+mechanics of Org-babel it might make most sense to grab the plain text
+version of this file
+#+HTML: <a href="org-babel-worg.org">org-babel-worg.org</a>
+and work through it in Emacs. Alternatively the htmlized
+version of the plain text of this file at
+#+HTML: <a href="org-babel-worg.org.html">org-babel-worg.html</a>
+allows the plain text version to be viewed (non-interactively) in a web browser.
+*** Source code execution
+    :PROPERTIES:
+    :CUSTOM_ID: source-code-execution
+    :END:
+For interpreted languages such as shell, python, R, etc, org-babel
+allows source blocks to be executed: the code is passed to the
+interpreter and you have control over what is done with the results of
+execution. Here are three examples of code blocks in three different
+languages, followed by their output. If you are viewing the plain text
+version of this document in emacs, place point anywhere inside the
+blocks and use =C-c C-c= to run the code[fn:1] (and feel free to alter
+it!).
+
+**** Ruby
+#+begin_src ruby
+"This file was last evaluated on #{Date.today}"
+#+end_src
+
+#+resname:
+: This file was last evaluated on 2009-08-09
+
+**** [[http://www.r-project.org/][R]] 
+#+begin_src R :results value
+matrix(rnorm(6), nrow=2)
+#+end_src
+
+#+resname:
+| -0.138279734486552 |   -2.2476234005706 | -0.0839549402407832 |
+| 0.0730510956002737 | 0.0634015508602321 |   0.174013159381603 |
+
+**** [[http://ditaa.sourceforge.net/][ditaa]]
+#+begin_src ditaa :file images/blue.png :cmdline -r
++---------+
+| cBLU    |
+|         |
+|    +----+
+|    |cPNK|
+|    |    |
++----+----+
+#+end_src
+
+#+resname:
+[[file:images/blue.png]]
+
+*** Source code block syntax
+
+The basic syntax of source-code blocks in Org-babel is as follows:
+
+: #+srcname: name(arguments)
+: #+begin_src language header-arguments
+: body
+: #+end_src
+
+- name :: This name is associated with the source-code block.  This is
+     similar to the =#+tblname= lines which can be used to name tables
+     in org-mode files.  By referencing the srcname of a source-code
+     block it is possible to evaluate the block from other places,
+     files, or from inside tables.
+- arguments :: Code blocks can have arguments (see [[#arguments-to-source-code-blocks][below]]) which are
+               provided using a familiar function-call syntax similar
+               to (e.g.)  python or R.
+- language :: The language of the code in the source-code block. Valid
+     values must be members of `org-babel-interpreters'.
+- header-arguments :: Header arguments control many facets of the
+     evaluation and output of source-code blocks.  See the [[* Header Arguments][Header
+     Arguments]] section for a complete review of available header
+     arguments.
+- body :: The actual source code which will be evaluated.  An
+          important key-binding to become familiar with is =C-c
+          '=. This calls `org-edit-special' which brings up an edit
+          buffer containing the code using the emacs major mode
+          appropriate to the language.
+
+*** What happens to the results?
+    :PROPERTIES:
+    :CUSTOM_ID: results
+    :END:
+    Org-babel provides two fundamentally different modes for capturing
+    the results of code evaluation, specified by the =:results= header
+    argument.
+**** =:results value= (functional mode)
+     This means that the 'result' of code evaluation is defined to be
+     the *value* of the last statement in the block. Thus with this
+     setting, one can view the code block as a function with a return
+     value. And not only can you view it that way, but you can
+     actually use the return value of one source block as input for
+     another (see [[meta-programming-language]]). This setting is the
+     default.
+     
+     As an example, consider the following block of python code and its
+     output.
+
+#+begin_src python :results value
+import time
+print("Hello, today's date is %s" % time.ctime())
+print('Two plus two is')
+2 + 2
+#+end_src
+
+#+resname:
+: 4
+
+Notice that in functional mode, the output consists of the value of
+the last statement, and nothing else.
+
+**** =:results output= (scripting mode)
+     With this setting, org-babel captures all the text output of the
+     code block and places it in the org buffer. One can think of this
+     as a 'scripting' mode: the code block contains a series of
+     commands, and you get the output of all the commands. Unlike in
+     the 'functional' mode, the code block has no return value. (This
+     mode will be more familiar to Sweave users).
+
+     Now consider the result of evaluating the same source block as
+     before, but under scripting mode.
+
+#+srcname: name
+#+begin_src python :results output
+import time
+print("Hello, today's date is %s" % time.ctime())
+print('Two plus two is')
+2 + 2
+#+end_src
+
+#+resname: name
+: Hello, today's date is Fri Sep  4 19:49:06 2009
+: Two plus two is
+
+Again, we got what we asked for: all the text output (stdout) from
+python. Since we didn't print the last value (2 + 2), we didn't get it
+in our output.
+
+*** Arguments to source code blocks
+    :PROPERTIES:
+    :CUSTOM_ID: arguments-to-source-code-blocks
+    :END:
+    In addition to evaluation of code blocks, org-babel allows them to
+    be parameterised (i.e. have arguments). Thus source code blocks
+    now have the status of *functions*. Arguments to code blocks can
+    be used in both functional and scripting mode.
+
+**** Simple example of using a source block as a function
+
+     First let's look at a very simple example. The following source
+     block defines an org-babel function that will square its input.
+
+#+srcname: square(x)
+#+begin_src python
+x*x
+#+end_src
+
+In the org-mode file that looks like this:
+: #+srcname: square(x)
+: #+begin_src python
+: x*x
+: #+end_src
+
+
+Now we use the source block:
+
+: #+lob: square(x=6)
+(/for information on the/ =lob= /syntax see [[library-of-babel]]/)
+
+#+lob: square(x=6)
+
+#+resname: square(x=6)
+: 36
+
+**** A more complex example: using an org-table as input
+
+     In this example we're going to define a function to compute a
+     Fibonacci sequence, and we're going to make it take its input
+     from a table in the org-mode buffer.
+
+     Here are the inputs for fibonacci-seq:
+
+#+tblname: fibonacci-inputs
+| 1 | 2 | 3 | 4 |  5 |  6 |  7 |  8 |  9 | 10 |
+| 2 | 4 | 6 | 8 | 10 | 12 | 14 | 16 | 18 | 20 |
+
+in the Org-mode buffer this looks like
+: #+tblname: fibonacci-inputs
+: | 1 | 2 | 3 | 4 |  5 |  6 |  7 |  8 |  9 | 10 |
+: | 2 | 4 | 6 | 8 | 10 | 12 | 14 | 16 | 18 | 20 |
+
+[[http://www.gnu.org/software/emacs/manual/elisp.html][Emacs Lisp]] source code
+#+srcname: fibonacci-seq(fib-inputs=fibonacci-inputs)
+#+begin_src emacs-lisp
+  (defun fibonacci (n)
+    (if (or (= n 0) (= n 1))
+        n
+      (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))
+  
+  (mapcar (lambda (row)
+            (mapcar #'fibonacci row)) fib-inputs)
+#+end_src
+
+in the Org-mode buffer this looks like
+: #+srcname: fibonacci-seq(fib-inputs=fibonacci-inputs)
+: #+begin_src emacs-lisp
+:   (defun fibonacci (n)
+:     (if (or (= n 0) (= n 1))
+:         n
+:       (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))
+:   
+:   (mapcar (lambda (row)
+:             (mapcar #'fibonacci row)) fib-inputs)
+: #+end_src
+
+Results of Emacs Lisp code evaluation
+#+resname:
+| 1 | 1 | 2 |  3 |  5 |   8 |  13 |  21 |   34 |   55 |
+| 1 | 3 | 8 | 21 | 55 | 144 | 377 | 987 | 2584 | 6765 |
+
+* A meta-programming language for org-mode
+  :PROPERTIES:
+  :CUSTOM_ID: meta-programming-language
+  :END:
+
+Since information can pass freely between source-code blocks and
+org-mode tables you can mix and match languages using each language
+for those tasks to which it is suited.  This makes Org-mode files with
+Org-babel into a kind of meta-functional programming language in which
+functions from many languages can work together.
+
+As an example, lets take some system diagnostics in the shell, and
+then graph them with R.
+
+1. First we create a code block containing shell code creating a list
+   of the directories in our home directory, together with their
+   sizes. Org-babel automatically converts the output into an org
+   table.
+   
+#+srcname: directories
+   #+begin_src bash :results replace
+   cd ~ && du -sc * |grep -v total
+   #+end_src
+   
+#+resname: directories
+|       72 | "Desktop"   |
+| 12156104 | "Documents" |
+|  3482440 | "Downloads" |
+|  2901720 | "Library"   |
+|    57344 | "Movies"    |
+| 16548024 | "Music"     |
+|      120 | "News"      |
+|  7649472 | "Pictures"  |
+|        0 | "Public"    |
+|   152224 | "Sites"     |
+|        8 | "System"    |
+|       56 | "bin"       |
+|  3821872 | "mail"      |
+| 10605392 | "src"       |
+|     1264 | "tools"     |
+2. Now we use a single line of R code to plot the data as a
+   pie-chart. Note the way that this source block uses the =srcname=
+   of the previous source block to obtain the data.
+#+srcname: directory-pie-chart(dirs = directories)
+   #+begin_src R :session R-pie-example
+   pie(dirs[,1], labels = dirs[,2])
+   #+end_src
+ [[file:images/dirs.png]]
+
+* Multilingual spreadsheet plugins for org-mode
+  :PROPERTIES:
+  :CUSTOM_ID: spreadsheet
+  :END:
+Not only can Org-babel pass entire tables of data to source code
+blocks (see [[arguments-to-source-code-blocks]]), Org-babel can also be
+used to call source code blocks from *within* tables using the
+Org-mode's [[http://orgmode.org/manual/The-spreadsheet.html#The-spreadsheet][existing spreadsheet functionality]].
+
+*** Example 1: data summaries using R
+As a simple example, we'll fill in a cell in an org-table with the
+average value of a few numbers. First, let's make some data. The
+following source block creates an org table filled with five random
+numbers between 0 and 1.
+
+#+srcname: tbl-example-data()
+#+begin_src R 
+runif(n=5, min=0, max=1)
+#+end_src
+
+#+resname: tbl-example-data
+| 0.850250755203888 |
+| 0.745323235634714 |
+| 0.845673063071445 |
+| 0.761818468105048 |
+| 0.525476417969912 |
+
+Now we define a source block to do the calculation we want.
+#+srcname: R-mean(x)
+#+begin_src R 
+mean(x)
+#+end_src
+
+Finally we create the table which is going to make use of the R
+code. This is done using the =sbe= ('source block evaluate') macro in
+the table formula line.
+#+tblname: summaries
+|              mean |
+|-------------------|
+| 0.533130449522286 |
+#+TBLFM: @2$1='(sbe "R-mean" (x "generate-data()"))
+
+To recalculate the table formula, use =C-u C-c C-c= in the
+table. Notice that as things stand the calculated value doesn't
+change, because the data (held in the table above named
+"tbl-example-data") are static. However, if you delete that data table
+then the reference will be interpreted as a reference to the source
+block responsible for generating the data; each time the table formula
+is recalculated the source block will be evaluated again, and
+therefore the calculated average value will change.
+
+*** Example 2: Org-babel test suite
+While developing Org-babel, we have used a suite of tests implemented
+as a large Org-mode table.  To run the entire test suite you simply
+evaluate the table with =C-u C-c C-c=, and all of the tests are run,
+the results are compared with expectations, and the table is updated
+with results and pass/fail statistics.
+
+Here's a sample of our test suite.
+
+#+TBLNAME: org-babel-tests
+| functionality    | block        | arg |    expected |     results | pass |
+|------------------+--------------+-----+-------------+-------------+------|
+| basic evaluation |              |     |             |             | pass |
+|------------------+--------------+-----+-------------+-------------+------|
+| emacs lisp       | basic-elisp  |   2 |           4 |           4 | pass |
+| shell            | basic-shell  |     |           6 |           6 | pass |
+| ruby             | basic-ruby   |     |   org-babel |   org-babel | pass |
+| python           | basic-python |     | hello world | hello world | pass |
+| R                | basic-R      |     |          13 |          13 | pass |
+#+TBLFM: $5='(if (= (length $3) 1) (sbe $2 (n $3)) (sbe $2)) :: $6='(if (string= $4 $5) "pass" (format "expected %S but was %S" $4 $5))
+
+**** code blocks for tests
+
+#+srcname: basic-elisp(n)
+#+begin_src emacs-lisp
+(* 2 n)
+#+end_src
+
+#+srcname: basic-shell
+#+begin_src sh :results silent
+expr 1 + 5
+#+end_src
+
+#+srcname: date-simple
+#+begin_src sh :results silent
+date
+#+end_src
+
+#+srcname: basic-ruby
+#+begin_src ruby :results silent
+"org-babel"
+#+end_src
+
+#+srcname: basic-python
+#+begin_src python :results silent
+'hello world'
+#+end_src
+
+#+srcname: basic-R
+#+begin_src R :results silent
+b <- 9
+b + 4
+#+end_src
+
+* The Library of Babel
+  :PROPERTIES:
+  :CUSTOM_ID: library-of-babel
+  :END:
+#+begin_html 
+  <div id="logo">
+    <p>
+      <img src="images/library-of-babel-clayette.png" />
+      <div id="attr">
+        The Library of Babel, by Pierre Clayette
+        <p>
+        <a href="http://downlode.org/Etext/library_of_babel.html">Full text of the Borges short story</a>
+        </p>
+      </div>
+    </p>  
+  </div>
+#+end_html
+
+  As we saw above with the [[*Simple%20example%20of%20using%20a%20source%20block%20as%20a%20function][=square=]] example, once a source block
+  function has been defined it can be called using the following short
+  =lob= notation:
+
+  : #+lob: square(x=6)
+
+  But what about those source code blocks which are so useful you want
+  to have them available in every org-mode buffer?
+
+  In addition to the current buffer, Org-babel searches for
+  pre-defined source block functions in the Library of Babel. This is
+  a user-extensible collection of ready-made source-code blocks for
+  handling common tasks.  One use for the LoB (not yet done!) will be
+  to provide a choice of data graphing procedures for data held in
+  org-mode tables, using languages such as R, gnuplot, asymptote,
+  etc. If you implement something that might be of use to other org
+  users, please consider adding it to the LoB; similarly, feel free to
+  request help solving a problem using external code via org-babel --
+  there's always a chance that other org users will be able to
+  contribute some helpful code. Org-mode demonstrates that an enormous
+  amount can be achieved using plain text and emacs lisp; the LoB is
+  intended to fill in the gaps.
+
+  Org-babel comes pre-populated with the source-code blocks located in
+  the [[file:library-of-babel.org][library-of-babel.org]] file. It is possible to add source-code
+  blocks from any org-mode file to the library by calling
+
+  #+srcname: add-file-to-lob
+  #+begin_src emacs-lisp 
+  (org-babel-lob-ingest "path/to/file.org")
+  #+end_src
+
+  Note that it is also possible to pass table values or the output of
+  a source-code block to lob functions, and it is possible to
+  reference lob functions in source block arguments.
+
+* Reproducible Research
+  :PROPERTIES:
+  :CUSTOM_ID: reproducable-research
+  :END:
+#+begin_quote 
+An article about computational science in a scientific publication is
+not the scholarship itself, it is merely advertising of the
+scholarship. The actual scholarship is the complete software
+development environment and the complete set of instructions which
+generated the figures.
+
+-- D. Donoho
+#+end_quote
+
+[[http://reproducibleresearch.net/index.php/Main_Page][Reproducible Research]] (RR) is the practice of distributing along with
+an article of research all data, code, and tools required to reproduce
+the results discussed in the paper.  As such the paper becomes not
+only a document describing the research but a complete laboratory in
+which the research can be reproduced and extended.
+
+Org-mode already has exceptional support for [[http://orgmode.org/manual/Exporting.html#Exporting][exporting to html and
+LaTeX]].  Org-babel makes Org-mode a tool for RR by *activating* the
+data and source code embedded into Org-mode documents making the
+entire document executable.  This makes it not only possible, but
+natural to distribute research in a format that encourages readers to
+recreate your results, and perform their own analysis.
+
+One notable existing RR tool is [[http://en.wikipedia.org/wiki/Sweave][Sweave]] which provides for the
+embedding of [[http://www.r-project.org/][R]] code into LaTeX documents.  While Sweave is a mature
+and very useful tool, we believe that Org-babel has several
+advantages:
+ - It supports multiple languages (we're not aware of other RR tools that do this)
+ - The [[http://orgmode.org/manual/Exporting.html#Exporting][export process]] is flexible and powerful, including HTML as a target in addition to LaTeX
+ - The document can make native use of all the features of Org-mode,
+   such as those for [[http://orgmode.org/manual/Agenda-Views.html#Agenda-Views][project planning]] and [[http://orgmode.org/manual/TODO-Items.html#TODO-Items][task management]]
+
+* Literate programming
+  :PROPERTIES:
+  :CUSTOM_ID: literate-programming
+  :END:
+
+#+begin_quote 
+Let us change our traditional attitude to the construction of
+programs: Instead of imagining that our main task is to instruct a
+/computer/ what to do, let us concentrate rather on explaining to
+/human beings/ what we want a computer to do.
+
+The practitioner of literate programming can be regarded as an
+essayist, whose main concern is with exposition and excellence of
+style. Such an author, with thesaurus in hand, chooses the names of
+variables carefully and explains what each variable means. He or she
+strives for a program that is comprehensible because its concepts have
+been introduced in an order that is best for human understanding,
+using a mixture of formal and informal methods that reinforce each
+other.
+
+ -- Donald Knuth
+#+end_quote
+
+Org-babel supports [[http://en.wikipedia.org/wiki/Literate_programming][Literate Programming]] (LP) by allowing the act of
+programming to take place inside of Org-mode documents.  The Org-mode
+file can then be exported (*woven* in LP speak) to html or LaTeX for
+consumption by a human, and the embedded source code can be extracted
+(*tangled* in LP speak) into structured source code files for
+consumption by a computer.
+
+To support these operations Org-babel relies on Org-mode's [[http://orgmode.org/manual/Exporting.html#Exporting][existing
+exporting functionality]] for *weaving* of documentation, and on the
+=org-babel-tangle= function which makes use of [[http://www.cs.tufts.edu/~nr/noweb/][Noweb]] [[reference-expansion][reference syntax]]
+for *tangling* of code files.
+
+The [[literate-programming-example][following example]] demonstrates the process of *tangling* in
+Org-babel.
+
+*** Simple Literate Programming Example (Noweb syntax)
+    :PROPERTIES:
+    :CUSTOM_ID: literate-programming-example
+    :END:
+
+Tangling functionality is controlled by the =tangle= family of
+[[header-arguments]].  These arguments can be used to turn tangling on or
+off (the default) on the source code block, or the outline heading
+level.
+
+The following demonstrates the combination of three source code blocks
+into a single source code file using =org-babel-tangle=.
+
+The following two blocks will not be tangled by default since they
+have no =tangle= header arguments.
+
+#+srcname: hello-world-prefix
+#+begin_src sh :exports none
+  echo "/-----------------------------------------------------------\\"
+#+end_src
+
+: #+srcname: hello-world-prefix
+: #+begin_src sh :exports none
+:   echo "/-----------------------------------------------------------\\"
+: #+end_src
+
+#+srcname: hello-world-postfix
+#+begin_src sh :exports none
+  echo "\-----------------------------------------------------------/"
+#+end_src
+
+: #+srcname: hello-world-postfix
+: #+begin_src sh :exports none
+:   echo "\-----------------------------------------------------------/"
+: #+end_src
+
+
+The third block does have a =tangle= header argument indicating the
+name of the file to which it should be written.  It also has [[http://www.cs.tufts.edu/~nr/noweb/][Noweb]]
+style references to the two previous source code blocks which will be
+expanded during tangling to include them in the output file as well.
+
+#+srcname: hello-world
+#+begin_src sh :tangle hello :exports none
+  # <<hello-world-prefix>>
+  echo "|                       hello world                         |"
+  # <<hello-world-postfix>>
+#+end_src
+
+: #+srcname: hello-world
+: #+begin_src sh :tangle hello :exports none
+:   # <<hello-world-prefix>>
+:   echo "|                       hello world                         |"
+:   # <<hello-world-postfix>>
+: #+end_src
+
+Calling =org-babel-tangle= will result in the following being written
+to the =hello.sh= file.
+
+#+srcname: hello-world-output
+#+begin_src sh 
+  #!/usr/bin/env sh
+  # generated by org-babel-tangle
+  
+  # [[file:~/src/org-babel/org-babel-worg.org::#literate-programming-example][block-16]]
+  # <<hello-world-prefix>>
+  echo "/-----------------------------------------------------------\\"
+  
+  echo "|                       hello world                         |"
+  # <<hello-world-postfix>>
+  echo "\-----------------------------------------------------------/"
+  # block-16 ends here
+#+end_src
+
+*** Emacs Initialization with Org-babel
+Org-babel has special support for embedding your emacs initialization
+into Org-mode files.  The =org-babel-load-file= function can be used
+to load the emacs lisp embedded in a literate Org-mode file in the
+same way that you might load a regular elisp file.
+
+This allows you to have all the niceness of Org-mode (folding, tags,
+notes, html export, etc...) available in your emacs initialization.
+
+To try this out either see the simple [[literate-emacs-init][Literate Emacs Initialization]]
+example directly below, or check out the Org-babel Literate
+Programming version of Phil Hagelberg's excellent [[http://github.com/technomancy/emacs-starter-kit/tree/master][emacs-starter-kit]]
+available at [[http://github.com/eschulte/emacs-starter-kit/tree/master][Org-babel-emacs-starter-kit]].
+
+***** Literate Emacs Initialization
+      :PROPERTIES:
+      :CUSTOM_ID: literate-emacs-init
+      :END:
+
+For a simple example of usage follow these 4 steps.
+
+1) create a directory named =.emacs.d= in the base of your home
+   directory.
+   #+begin_src sh 
+   mkdir ~/.emacs.d
+   #+end_src
+2) checkout the latest versions of Org-mode and Org-babel into the src
+   subdirectory of this new directory
+   #+begin_src sh
+   cd ~/.emacs.d
+   mkdir src
+   cd src
+   git clone git://repo.or.cz/org-mode.git
+   git clone git://github.com/eschulte/org-babel.git
+   #+end_src
+3) place the following in a file called =init.el= in your emacs
+   initialization directory (=~/.emacs.d=).
+   #+srcname: emacs-init
+   #+begin_src emacs-lisp 
+     ;;; init.el --- Where all the magic begins
+     ;;
+     ;; This file loads both
+     ;; - Org-mode : http://orgmode.org/ and
+     ;; - Org-babel: http://eschulte.github.com/org-babel/
+     ;;
+     ;; It then loads the rest of our Emacs initialization from Emacs lisp
+     ;; embedded in literate Org-mode files.
+     
+     ;; Load up Org Mode and Org Babel for elisp embedded in Org Mode files
+     (setq dotfiles-dir (file-name-directory (or (buffer-file-name) load-file-name)))
+     (add-to-list 'load-path (expand-file-name
+                              "lisp" (expand-file-name
+                                      "org" (expand-file-name
+                                             "src" dotfiles-dir))))
+     (add-to-list 'load-path (expand-file-name
+                              "lisp" (expand-file-name
+                                      "org-babel" (expand-file-name
+                                                   "src" dotfiles-dir))))
+     (require 'org-babel-init)
+     
+     ;; load up all literate org-mode files in this directory
+     (mapc #'org-babel-load-file (directory-files dotfiles-dir t "\\.org$"))
+     
+     ;;; init.el ends here
+   #+end_src
+4) Implement all of your emacs customizations inside of elisp
+   source-code blocks located in Org-mode files in this directory.
+   They will be loaded by emacs on startup.
+
+* Reference / Documentation
+  :PROPERTIES:
+  :CUSTOM_ID: reference-and-documentation
+  :END:
+*** Languages
+    The following can be added to your .emacs and used to activate
+    languages.  It includes a brief list of the requirements for each
+    language.  *Note*: this also serves as the list of languages
+    currently supported by Org-babel.
+     #+begin_src emacs-lisp 
+       ;; Uncomment each of the following require lines if you want org-babel
+       ;; to support that language.  Each language has a comment explaining
+       ;; it's dependencies.  See the related files in lisp/langs for more
+       ;; detailed explanations of requirements.
+       ;; (require 'org-babel-R)         ;; R and ess-mode
+       ;; (require 'org-babel-asymptote) ;; asymptote
+       ;; (require 'org-babel-css)       ;; none
+       ;; (require 'org-babel-ditaa)     ;; ditaa
+       ;; (require 'org-babel-dot)       ;; dot
+       ;; (require 'org-babel-gnuplot)   ;; gnuplot, and gnuplot-mode
+       ;; (require 'org-babel-haskell)   ;; haskell, haskell-mode, inf-haskell
+       ;; (require 'org-babel-ocaml)     ;; ocaml, and tuareg-mode
+       ;; (require 'org-babel-python)    ;; python, and python-mode
+       ;; (require 'org-babel-ruby)      ;; ruby, irb, ruby-mode, and inf-ruby
+       ;; (require 'org-babel-sass)      ;; sass, sass-mode
+       ;; (require 'org-babel-sql)       ;; none
+     #+end_src
+
+*** Header Arguments
+     :PROPERTIES:
+     :CUSTOM_ID: header-arguments
+     :END:
+
+- results :: results arguments specify what should be done with the
+             output of source-code blocks
+  - The following options are mutually exclusive, and specify how the
+    results should be collected from the source-code block
+    - value ::
+    - output :: 
+  - The following options are mutually exclusive and specify what type
+    of results the code block will return
+    - vector :: specifies that the results should be interpreted as a
+                multidimensional vector (even if the vector is
+                trivial), and will be inserted into the org-mode file
+                as a table
+    - scalar :: specifies that the results should be interpreted as a
+                scalar value, and will be inserted into the org-mode
+                file as quoted text
+    - file :: specifies that the results should be interpreted as the
+              path to a file, and will be inserted into the org-mode
+              file as a link
+  - The following options specify how the results should be inserted
+    into the org-mode file
+    - replace :: the current results replace any previously inserted
+                 results from the code block
+    - silent :: rather than being inserted into the org-mode file the
+                results are echoed into the message bar
+- exports :: exports arguments specify what should be included in html
+             or latex exports of the org-mode file
+  - code :: the body of code is included into the exported file
+  - results :: the results of evaluating the code is included in the
+               exported file
+  - both :: both the code and results are included in the exported
+            file
+  - none :: nothing is included in the exported file
+- tangle :: tangle arguments specify whether or not the source-code
+            block should be included in tangled extraction of
+            source-code files
+  - yes :: the source-code block is exported to a source-code file
+           named after the basename (name w/o extension) of the
+           org-mode file
+  - no :: (default) the source-code block is not exported to a
+          source-code file
+  - other :: any other string passed to the =tangle= header argument
+             is interpreted as a file basename to which the block will
+             be exported
+
+*** Noweb reference syntax
+The [[http://www.cs.tufts.edu/~nr/noweb/][Noweb]] Literate Programming system allows named blocks of code to
+be referenced by using a =<<code-block-name>>= syntax.  When a
+document is tangled these references are replaced with the named code.
+An example is provided in the [[literate-programming-example]] in this
+document.
+
+* Footnotes
+
+[fn:1] Calling =C-c C-o= on a source-code block will open the
+block's results in a separate buffer.
+

contrib/babel/org-babel.org

@@ -0,0 +1,5142 @@
+#+TITLE: org-babel --- facilitating communication between programming languages and people
+#+SEQ_TODO: PROPOSED TODO STARTED | DONE DEFERRED REJECTED
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:t -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP: oddeven hideblocks
+
+#+begin_html 
+  <div id="subtitle">
+    <p>executable source code blocks in org-mode</p>
+  </div>
+  <div id="logo">
+    <p>
+      <img src="images/tower-of-babel.png"  alt="images/tower-of-babel.png" />
+      <div id="attr">from <a href="http://www.flickr.com/photos/23379658@N05/" title=""><b>Martijn Streefkerk</b></a></div>
+    </p>  
+  </div>
+#+end_html
+
+Org-Babel makes source-code blocks in Org-Mode executable and allows
+data to pass seamlessly between different programming languages,
+Org-Mode constructs (tables, file links, example text) and interactive
+comint buffers.
+
+In this document:
+- The [[* Introduction][Introduction]] :: provides a brief overview of the design and use
+     of Org-Babel including tutorials and examples.
+- In [[* Getting started][Getting Started]] :: find instructions for installing org-babel
+     into your emacs configuration.
+- The [[* Tasks][Tasks]] :: section contains current and past tasks roughly ordered
+     by TODO state, then importance or date-completed.  This would be
+     a good place to suggest ideas for development.
+- The [[* Bugs][Bugs]] :: section contains bug reports.
+- The [[* Tests][Tests]] :: section consists of a large table which can be
+     evaluated to run Org-Babel's functional test suite.  This
+     provides a good overview of the current functionality with
+     pointers to example source blocks.
+- The [[* Sandbox][Sandbox]] :: demonstrates much of the early/basic functionality
+     through commented source-code blocks.
+
+Also see the [[file:library-of-babel.org][Library of Babel]], an extensible collection of ready-made
+and easily-shortcut-callable source-code blocks for handling common
+tasks.
+
+* Introduction
+
+Org-Babel enables *communication* between programming languages and
+between people.
+
+Org-Babel provides:
+- communication between programs :: Data passes seamlessly between
+     different programming languages, Org-Mode constructs (tables,
+     file links, example text) and interactive comint buffers.
+- communication between people :: Data and calculations are embedded
+     in the same document as notes explanations and reports.
+
+** communication between programs
+
+Org-Mode supports embedded blocks of source code (in any language)
+inside of Org documents.  Org-Babel allows these blocks of code to be
+executed from within Org-Mode with natural handling of their inputs
+and outputs.
+
+*** simple execution
+with both scalar, file, and table output
+
+*** reading information from tables
+
+*** reading information from other source blocks (disk usage in your home directory)
+
+This will work for Linux and Mac users, not so sure about shell
+commands for windows users.
+
+To run place the cursor on the =#+begin_src= line of the source block
+labeled directory-pie and press =\C-c\C-c=.
+
+#+srcname: directories
+#+begin_src bash :results replace
+cd ~ && du -sc * |grep -v total
+#+end_src
+
+#+resname: directories
+|       64 | "Desktop"   |
+| 11882808 | "Documents" |
+|  8210024 | "Downloads" |
+|   879800 | "Library"   |
+|    57344 | "Movies"    |
+|  7590248 | "Music"     |
+|  5307664 | "Pictures"  |
+|        0 | "Public"    |
+|      152 | "Sites"     |
+|        8 | "System"    |
+|       56 | "bin"       |
+|  3274848 | "mail"      |
+|  5282032 | "src"       |
+|     1264 | "tools"     |
+
+#+srcname: directory-pie
+#+begin_src R :var dirs = directories :session R-pie-example
+pie(dirs[,1], labels = dirs[,2])
+#+end_src
+
+
+
+
+
+
+*** operations in/on tables
+
+#+tblname: grades-table
+| student | grade | letter |
+|---------+-------+--------|
+|       1 |    99 | A      |
+|       2 |    59 | F      |
+|       3 |    75 | C      |
+|       4 |    15 | F      |
+|       5 |     7 | F      |
+|       6 |    13 | F      |
+#+TBLFM: $2='(sbe random-score-generator)::$3='(sbe assign-grade (score $2))
+
+#+srcname: assign-grade
+#+begin_src ruby :var score=99
+case score
+   when 0..59: "F"
+   when 60..69: "D"
+   when 70..79: "C"
+   when 80..89: "B"
+   when 90..100: "A"
+   else "Invalid Score"
+end
+#+end_src
+
+#+srcname: random-score-generator
+#+begin_src ruby 
+rand(100)
+#+end_src
+
+#+srcname: show-distribution
+#+begin_src R :var grades=grades-table :session *R*
+hist(grades$grade)
+#+end_src
+
+
+
+
+
+** communication between people
+Quick overview of Org-Mode's exportation abilities, with links to the
+online Org-Mode documentation, a focus on source-code blocks, and the
+exportation options provided by Org-Babel.
+
+*** Interactive tutorial
+This would demonstrate applicability to Reproducible Research, and
+Literate Programming.
+
+*** Tests embedded in documentation
+org-babels own functional tests are contained in a large org-mode
+table, allowing the test suite to be run be evaluation of the table
+and the results to be collected in the same table.
+
+*** Emacs initialization files stored in Org-Mode buffers
+Using `org-babel-tangle' it is possible to embed your Emacs
+initialization into org-mode files.  This allows for folding,
+note-taking, todo's etc... embedded with the source-code of your Emacs
+initialization, and through org-mode's publishing features aids in
+sharing your customizations with others.
+
+It may be worthwhile to create a fork of Phil Hagelberg's
+[[http://github.com/technomancy/emacs-starter-kit/tree/master][emacs-starter-kit]] which uses literate org-mode files for all of the
+actual elisp customization.  These org-mode files could then be
+exported to html and used to populate the repositories wiki on [[http://github.com/][github]].
+
+
+** features
+
+*** code evaluation (comint buffer sessions and external processes)
+There are two main ways to evaluate source blocks with org-babel.
+
+- external :: By default (if the =:session= header argument is not
+              present) all source code blocks are evaluated in
+              external processes.  In these cases an external process
+              is used to evaluate the source-code blocks.
+- session :: Session based evaluation uses persistent sessions in
+             comint buffers.  Sessions can be used across multiple
+             source blocks setting and accessing variables in the
+             global environment.
+
+             Evaluating source blocks in sessions also allows for
+             interaction with the code.  To jump to the session of a
+             source block use the `org-babel-pop-to-session' command
+             or press =M-[down]= while inside of a source code block.
+             When called with a prefix argument
+             `org-babel-pop-to-session' will evaluate all header
+             arguments before jumping to the source-code block.
+
+*** results (values and outputs)
+Either the *value* or the *output* of source code blocks can be
+collected after evaluation.
+
+- value :: The default way to collect results from a source-code block
+           is to return the value of the last statement in the block.
+           This can be thought of as the return value of the block.
+           In this case any printed output of the block is ignored.
+           This can be though of a similar to a "functional" value of
+           evaluation.
+- output :: Another way of generating results from a source-code block
+            is to collect the output generated by the execution of the
+            block.  In this case all printed output is collected
+            throughout the execution of the block.  This can be
+            thought of as similar to a "script" style of evaluation.
+
+
+* Getting started
+Add the following lines to your .emacs, replacing the path as
+appropriate. A good place to check that things are up and running
+would then be [[#sandbox][the sandbox]].
+#+begin_src emacs-lisp
+  (add-to-list 'load-path "/path/to/org-babel/lisp")
+  (require 'org-babel-init)
+#+end_src
+
+  
+* Tasks [46/65]
+** TODO allow tangle to be called on a single source block
+this should have a reasonable binding
+
+** STARTED share org-babel [1/7]
+how should we share org-babel?
+*** DONE post to org-mode
+*** TODO post to ess mailing list
+    I'd like to not rush in to this, get some feedback from the org
+    list first and let my R usage of org-babel settle down. [DD]
+*** STARTED create a org-babel page on worg
+**** TODO Getting hold of it instructions
+     - What about non-git users?
+     - Are we moving/copying to contrib/?
+**** TODO Fixed width HTML output created by =...= is ugly!
+*** TODO create a short screencast demonstrating org-babel in action
+*** PROPOSED a peer-reviewed publication?
+
+    The following notes are biased towards statistics-oriented
+    journals because ESS and Sweave are written by people associated
+    with / in statistics departments. But I am sure there are suitable
+    journals out there for an article on using org mode for
+    reproducible research (and literate programming etc).
+
+    Clearly, we would invite Carsten to be involved with this.
+
+     ESS is described in a peer-reviewed journal article:
+     Emacs Speaks Statistics: A Multiplatform, Multipackage Development Environment for Statistical Analysis  [Abstract]
+     Journal of Computational & Graphical Statistics 13(1), 247-261
+     Rossini, A.J, Heiberger, R.M., Sparapani, R.A., Maechler, M., Hornik, K. (2004) 
+     [[http://www.amstat.org/publications/jcgs.cfm][Journal of Computational and Graphical Statistics]]
+
+     Also [[http://www.amstat.org/publications/jss.cfm][Journal of Statistical Software]] Established in 1996, the
+     Journal of Statistical Software publishes articles, book reviews,
+     code snippets, and software reviews. The contents are freely
+     available online. For both articles and code snippets, the source
+     code is published along with the paper.
+
+    Sweave has a paper: 
+
+    Friedrich Leisch and Anthony J. Rossini. Reproducible statistical
+    research. Chance, 16(2):46-50, 2003. [ bib ]
+
+    also
+
+    Friedrich Leisch. Sweave: Dynamic generation of statistical reports
+    using literate data analysis. In Wolfgang Härdle and Bernd Rönz,
+    editors, Compstat 2002 - Proceedings in Computational Statistics,
+    pages 575-580. Physica Verlag, Heidelberg, 2002. ISBN 3-7908-1517-9.
+
+    also
+
+    We could also look at the Journals publishing these [[http://www.reproducibleresearch.net/index.php/RR_links#Articles_about_RR_.28chronologically.29][Reproducible
+    Research articles]].
+    
+*** PROPOSED an article in [[http://journal.r-project.org/][The R Journal]]
+This looks good.  It seems that their main topic to software tools for
+use by R programmers, and Org-babel is certainly that.
+
+*** existing similar tools
+try to collect pointers to similar tools 
+
+Reproducible Research
+- [[http://en.wikipedia.org/wiki/Sweave][Sweave]]
+
+Literate Programming
+- [[http://www.cs.tufts.edu/~nr/noweb/][Noweb]]
+- [[http://www-cs-faculty.stanford.edu/~knuth/cweb.html][Cweb]]
+- [[http://www.lri.fr/~filliatr/ocamlweb/][OCamlWeb]]
+
+Meta Functional Programming
+- ?
+
+Programmable Spreadsheet
+- ?
+
+*** examples
+we need to think up some good examples
+
+**** interactive tutorials
+This could be a place to use [[* org-babel assertions][org-babel assertions]].
+
+for example the first step of a tutorial could assert that the version
+of the software-package (or whatever) is equal to some value, then
+source-code blocks could be used with confidence (and executed
+directly from) the rest of the tutorial.
+
+**** answering a text-book question w/code example
+org-babel is an ideal environment enabling both the development and
+demonstrationg of the code snippets required as answers to many
+text-book questions.
+
+**** something using tables
+maybe something along the lines of calculations from collected grades
+
+**** file sizes
+Maybe something like the following which outputs sizes of directories
+under the home directory, and then instead of the trivial =emacs-lisp=
+block we could use an R block to create a nice pie chart of the
+results.
+
+#+srcname: sizes
+#+begin_src bash :results replace
+du -sc ~/*
+#+end_src
+
+#+begin_src emacs-lisp :var sizes=sizes :results replace
+(mapcar #'car sizes)
+#+end_src
+*** Answer to question on list
+From: Hector Villafuerte <hectorvd@gmail.com>
+Subject: [Orgmode] Merge tables
+Date: Wed, 19 Aug 2009 10:08:40 -0600
+To: emacs-orgmode@gnu.org
+
+Hi,
+I've just discovered Org and are truly impressed with it; using it for
+more and more tasks.
+
+Here's what I want to do: I have 2 tables with the same number of rows
+(one row per subject). I would like to make just one big table by
+copying the second table to the right of the first one. This is a
+no-brainer in a spreadsheet but my attempts in Org have failed. Any
+ideas?
+
+By the way, thanks for this great piece of software!
+-- 
+ hector
+
+**** Suppose the tables are as follows
+#+tblname: tab1
+| a | b | c |
+|---+---+---|
+| 1 | 2 | 3 |
+| 7 | 8 | 9 |
+
+#+tblname: tab2
+|  d |  e |  f |
+|----+----+----|
+|  4 |  5 |  6 |
+| 10 | 11 | 12 |
+
+**** Here is an answer using R in org-babel
+
+#+srcname: column-bind(a=tab1, b=tab2)
+#+begin_src R :colnames t
+cbind(a, b)
+#+end_src
+
+#+resname: column-bind
+| "a" | "b" | "c" | "d" | "e" | "f" |
+|-----+-----+-----+-----+-----+-----|
+|   1 |   2 |   3 |   4 |   5 |   6 |
+|   7 |   8 |   9 |  10 |  11 |  12 |
+
+
+**** Alternatively
+     Use org-table-export, do it in external spreadsheet software,
+     then org-table-import
+** TODO sha1 hash based caching
+   :PROPERTIES:
+   :CUSTOM_ID: sha1-caching
+   :END:
+
+#+begin_quote 
+I wonder if we should consider some cashing of images, also for
+export.  I think we could have an alist with sha1 hashes as keys and
+image files as values.  The sha1 hash could be made from the entire
+code and the command that is used to create the image..
+
+-- Carsten
+#+end_quote
+
+
+#+begin_quote 
+(sha1 stuff) seems to work.
+
+org-feed.el has a (require 'sha1) and org-publish.el uses it too.
+
+-- Bernt
+#+end_quote
+
+** TODO support for working with =*Org Edit Src Example*= buffers [4/7]
+*** STARTED Patch against org source. 
+    I've worked on several related changes to source code edit buffer
+    behaviour in the org core.  My current patch (below) does the
+    following. Detailed explanation / working notes are below.
+    - C-x s offers to save edit buffers
+    - C-x C-c offers to save edit buffers
+    - C-x k warns that you're killing an edit buffer
+    - If you do kill an edit buffer, the overlay in the parent buffer is removed
+    - Edit buffers are named *Org Src <orgbuf>[<lang>]*, where
+      <orgbuf> is the name of the org-mode buffer containing this
+      source code block, and lang is the language major mode. The
+      latter might be unnecessary?
+
+    These changes were added to the main org repository in commit
+    4b6988bf36cb458c9d113ee4332e016990c1eb04
+    
+**** Detailed working notes to go with that patch
+***** Recap of current org-src-mode
+      
+      If you use C-c ' to work on code in a begin_source block, the code
+      buffer is put in minor mode org-src-mode, which features the
+      following two useful key-bindings:
+
+      | C-x s | org-edit-src-save | save the code in the source code block in the parent org file |
+      | C-c ' | org-edit-src-exit | return to the parent org file with new code                   |
+
+      Furthermore, while the edit buffer is alive, the originating code
+      block is subject to a special overlay which links to the edit
+      buffer when you click on it.
+
+      This is all excellent, and I use it daily, but I think there's
+      still a couple of improvements that we should make.
+
+***** Proposed bug I
+      C-x k kills the buffer without questions; the overlay remains, but
+      now links to a deleted buffer.
+***** Proposed bug II
+      C-x C-c kills a modified edit buffer silently, without offering to
+      save your work. I have lost work like that a number of times
+      recently.
+***** Proposed bug III
+      C-x s does not offer to save a modified edit buffer
+***** Notes on solution
+****** write-contents-functions
+       A good start seems to be to use org-src-mode-hook to add
+       org-edit-src-save to the write-contents-functions list. This
+       means that when it comes to saving, org-edit-src-save will be
+       called and no subsequent attempt will be made to save the buffer
+       in the normal way. (This should obviate the remapping of C-x C-s
+       to org-edit-src-save in org-src.el)
+****** buffer-offer-save
+       We also want to set this to t.
+
+****** Where does this get us?
+
+       - C-x s still does *not* offer to save the edit buffer. That's
+	 because buffer-file-name is nil.
+       
+       - C-x C-c does ask us whether we want to save the
+	 edit buffer. However, since buffer-file-name is nil it asks us
+	 for a file name. The check in org-edit-src-exit throws an error
+	 unless the buffer is named '* Org Edit '...
+
+       - C-x k kills the buffer silently, leaving a broken overlay
+	 link. If buffer-file-name were set, it would have warned that
+	 the buffer was modified.
+
+****** buffer-file-name
+       So, that all suggests that we need to set buffer-file-name, even
+       though we don't really want to associate this buffer with a file
+       in the normal way. As for the file name, my current suggestion
+       is parent-org-filename[edit-buffer-name].
+       
+       [I had to move the (org-src-mode) call to the end of
+       org-edit-src-code to make sure that the required variables were
+       defined when the hook was called.]
+       
+****** And so where are we now?
+       - C-x s *does* offer to save the edit buffer, but in saving
+	 produces a warning that the edit buffer is modified.
+       - C-x k now gives a warning that the edit buffer is modified
+	 (even if it's not).
+       - C-x C-c is working as desired, except that again we get
+	 warnings that the edit buffer is modified, once when we save,
+	 and again just before exiting emacs.
+       - And C-c ' now issues a warning that the edit buffer is
+	 modified when we leave it, which we don't want.
+****** So, we need to get rid of the buffer modification warnings.
+       I've made buffer-file-name nil inside the let binding in
+       org-edit-src-exit.
+****** And?
+       - C-x s behaves as desired, except that as was already the case,
+	 the edit buffer is always considered modified, and so repeated
+	 invocations keep saving it.
+       - As was already the case, C-x k always gives a warning that the
+	 edit buffer has been modified.
+       - C-x C-c is as desired (offers to save the edit buffer) except
+	 that it warns of the modified buffer just before exiting.
+       - C-c ' is as it should be (silent)
+***** Conclusion
+      We've got the desired behaviour, at the cost of being forced to
+      assign a buffer-file-name to the edit buffer. The consequence is
+      that the edit buffer is considered to always be modified, since
+      a file of that name is never actually written to (doesn't even
+      exist). I couldn't see a way to trick emacs into believing that
+      the buffer was unmodified since last save. But in any case, I
+      think there's an argument that these modifications warnings are
+      a good thing, because one should not leave active edit buffers
+      around: you should always have exited with C-c ' first.
+
+**** TODO Doesn't currently work with ess-load-file
+     ess-load-file contains these two lines
+#+begin_src emacs-lisp
+  (let ((source-buffer (get-file-buffer filename)))
+    (if (ess-check-source filename)
+	(error "Buffer %s has not been saved" (buffer-name source-buffer)))
+#+end_src
+
+which have the effect of, in the course of saving, deleting the buffer
+`source-buffer', and then attempting to use it subsequently. The only
+solution I have thought of so far is submitting a patch to ess which
+would, e.g. reverse the order of those two lines (perform the error
+check outside the let binding).
+
+In fact, even after doing that there are further problems generated by
+the fact that the edit buffer has an associated filename for which the
+file doesn't exist. I think this worked OK in the past when the edit
+buffer had no associated filename. So this is a problem which needs
+addressing. Maybe defadvice could be used on ess functions where
+necessary to make org/org-babel play nicely with ess?
+
+**** TODO C-x s steals focus
+     With two modified edit buffers open, make one of them the current
+     buffer and issue C-x s. It will offer to save both of them, but
+     the second one to be saved will become the current buffer at the
+     end.
+*** DONE name edit buffer according to #+srcname (and language?)
+    See above patch agains org.
+*** DONE optionally evaluate header references when we switch to =*Org Edit Src*= buffer
+That seems to imply that the header references need to be evaluated
+and transformed into the target language object when we hit C-c ' to
+enter the *Org Edit Src* buffer [DED]
+
+Good point, I heartily agree that this should be supported [Eric]
+
+(or at least before the first time we attempt to evaluate code in that
+buffer -- I suppose there might be an argument for lazy evaluation, in
+case someone hits C-c ' but is "just looking" and not actually
+evaluating anything.) Of course if evaluating the reference is
+computationally intensive then the user might have to wait before they
+get the *Org Edit Src* buffer. [DED]
+
+I fear that it may be hard to anticipate when the references will be
+needed, some major-modes do on-the-fly evaluation while the buffer is
+being edited.  I think that we should either do this before the buffer
+is opened or not at all, specifically I think we should resolve
+references if the user calls C-c ' with a prefix argument.  Does that
+sound reasonable? [Eric]
+
+Yes [Dan]
+
+[Dan] So now that we have org-src-mode and org-src-mode-hook, I guess
+org-babel should do this by using the hook to make sure that, when C-c
+C-' is issued on a source block, any references are resolved and
+assignments are made in the appropriate session.
+
+#+tblname: my-little-table
+| 1 | 2 |
+| 3 | 4 |
+
+#+srcname: resolve-vars-on-edit
+#+begin_src ruby :var table=my-little-table :results silent :session test
+  table.size.times.do |n|
+    puts n
+  end
+#+end_src
+
+*** TODO set buffer-local-process variables appropriately [DED]
+    I think something like this would be great. You've probably
+already thought of this, but just to note it down: it would be really
+nice if org-babel's notion of a buffer's 'session/process' played
+nicely with ESS's notion of the buffer's session/process. ESS keeps
+the current process name for a buffer in a buffer-local variable
+ess-local-process-name. So one thing we will probably want to do is
+make sure that the *Org Edit Src Example* buffer sets that variable
+appropriately. [DED]
+
+I had not thought of that, but I agree whole heartedly. [Eric]
+
+Once this is done every variable should be able to dump regions into
+their inferior-process buffer using major-mode functions.
+*** REJECTED send code to inferior process
+Another thought on this topic: I think we will want users to send
+chunks of code to the interpreter from within the *Org Edit Src*
+buffer, and I think that's what you have in mind already. In ESS that
+is done using the ess-eval-* functions. [DED]
+
+I think we can leave this up to the major-mode in the source code
+buffer, as almost every source-code major mode will have functions for
+doing things like sending regions to the inferior process.  If
+anything we might need to set the value of the buffer local inferior
+process variable. [Eric]
+
+*** DONE some possible requests/proposed changes for Carsten [4/4]
+    While I remember, some possible requests/proposed changes for Carsten
+    come to mind in that regard:
+
+**** DONE Remap C-x C-s to save the source to the org buffer?
+     I've done this personally and I find it essential. I'm using 
+#+begin_src emacs-lisp
+(defun org-edit-src-save ()
+  "Update the parent org buffer with the edited source code, save
+the parent org-buffer, and return to the source code edit
+buffer."
+  (interactive)
+  (let ((p (point)))
+    (org-edit-src-exit)
+    (save-buffer)
+    (org-edit-src-code)
+    (goto-char p)))
+
+(define-key org-exit-edit-mode-map "\C-x\C-s" 'org-edit-src-save)
+#+end_src     
+    which seems to work.
+
+I think this is great, but I think it should be implemented in the
+org-mode core
+
+**** DEFERRED Rename buffer and minor mode?
+     Something shorter than *Org Edit Src Example* for the buffer
+     name. org-babel is bringing org's source code interaction to a
+     level of maturity where the 'example' is no longer
+     appropriate. And if further keybindings are going to be added to
+     the minor mode then maybe org-edit-src-mode is a better name than
+     org-exit-edit-mode.
+
+     Maybe we should name the buffer with a combination of the source
+     code and the session.  I think that makes sense.
+
+     [ES] Are you also suggesting a new org-edit-src minor mode?
+     [DED] org-exit-edit-mode is a minor mode that already exists:
+
+     Minor mode installing a single key binding, "C-c '" to exit special edit.
+
+     org-edit-src-save now has a binding in that mode, so I guess all
+     I'm saying at this stage is that it's a bit of a misnomer. But
+     perhaps we will also have more functionality to add to that minor
+     mode, making it even more of a misnomer. Perhaps something like
+     org-src-mode would be better.
+**** DONE Changed minor mode name and added hooks
+     
+**** DONE a hook called when the src edit buffer is created
+     This should be implemented in the org-mode core
+** TODO resolve references to other org buffers/files
+   This would allow source blocks to call upon tables, source-blocks,
+   and results in other org buffers/files.
+   
+   See...
+   - [[file:lisp/org-babel-ref.el::TODO%20allow%20searching%20for%20names%20in%20other%20buffers][org-babel-ref.el:searching-in-other-buffers]]
+   - [[file:lisp/org-babel.el::defun%20org-babel%20find%20named%20result%20name][org-babel.el#org-babel-find-named-result]]
+** TODO resolve references to other non-org files
+   - tabular data in .csv, .tsv etc format
+   - files of interpreted code: anything stopping us giving such files
+     similar status to a source code block?
+   - Would be nice to allow org and non-org files to be remote
+** TODO Finalise behaviour regarding vector/scalar output
+*** DONE Stop spaces causing vector output
+This simple example of multilingual chaining produces vector output if
+there are spaces in the message and scalar otherwise.
+
+[Not any more]
+
+#+srcname: msg-from-R(msg=msg-from-python)
+#+begin_src R
+paste(msg, "und R", sep=" ")
+#+end_src
+
+#+resname:
+: org-babel speaks elisp y python und R
+
+#+srcname: msg-from-python(msg=msg-from-elisp)
+#+begin_src python
+msg + " y python"
+#+end_src
+
+#+srcname: msg-from-elisp(msg="org-babel speaks")
+#+begin_src emacs-lisp
+(concat msg " elisp")
+#+end_src
+** TODO command line execution
+Allow source code blocks to be called form the command line.  This
+will be easy using the =sbe= function in [[file:lisp/org-babel-table.el][org-babel-table.el]].
+
+This will rely upon [[* resolve references to other buffers][resolve references to other buffers]].
+
+** TODO inline source code blocks [3/5]
+   Like the =\R{ code }= blocks
+
+   not sure what the format should be, maybe just something simple
+   like =src_lang[]{}= where lang is the name of the source code
+   language to be evaluated, =[]= is optional and contains any header
+   arguments and ={}= contains the code.
+
+   (see [[* (sandbox) inline source blocks][the-sandbox]])
+
+*** DONE evaluation with \C-c\C-c
+Putting aside the header argument issue for now we can just run these
+with the following default header arguments
+- =:results= :: silent
+- =:exports= :: results
+
+*** DONE inline exportation
+Need to add an interblock hook (or some such) through org-exp-blocks
+*** DONE header arguments
+We should make it possible to use header arguments.
+
+*** TODO fontification
+we should color these blocks differently
+
+*** TODO refine html exportation
+should use a span class, and should show original source in tool-tip
+** TODO LoB: re-implement plotting and analysis functions from org-R
+   I'll do this soon, now that we things are a bit more settled and we
+   have column names in R.
+** TODO Improved error checking
+   E.g. when trying to execute sass block, I did not have sass
+   installed, and so shell-command returned code 127, but org-babel
+   did not warn me that anything had gone wrong.
+*** DEFERRED figure out how to handle errors during evaluation
+    I expect it will be hard to do this properly, but ultimately it
+    would be nice to be able to specify somewhere to receive STDERR,
+    and to be warned if it is non-empty.
+
+    Probably simpler in non-session evaluation than session? At least
+    the mechanism will be different I guess.
+
+    R has a try function, with error handling, along the lines of
+    python. I bet ruby does too. Maybe more of an issue for functional
+    style; in my proposed scripting style the error just gets dumped to
+    the org buffer and the user is thus alerted.
+
+    For now I think the current behavior of returning any error
+    messages generated by the source language is sufficient.
+** PROPOSED Control precision of numerical output
+   Does org have an option controlling precision of numbers in tables?
+** PROPOSED allow `anonymous' function block with function call args?
+   My question here is simply whether we're going to allow
+#+begin_src python(arg=ref)
+# whatever
+#+end_src
+
+but with preference given to
+#+srcname blockname(arg=ref)
+** PROPOSED allow :result as synonym for :results?
+** PROPOSED allow 'output mode to return stdout as value?
+   Maybe we should allow this. In fact, if block x is called
+   with :results output, and it references blocks y and z, then
+   shouldn't the output of x contain a concatenation of the outputs of
+   y and z, together with x's own output? That would raise the
+   question of what happens if y is defined with :results output and z
+   with :results value. I guess z's (possibly vector/tabular) output
+   would be inside a literal example block containing the whole lot.
+** PROPOSED make tangle files read-only?
+   With a file-local variable setting, yea that makes sense.  Maybe
+   the header should reference the related org-mode file.
+** PROPOSED Creating presentations
+   The [[mairix:t:@@9854.1246500519@gamaville.dokosmarshall.org][recent thread]] containing posts by Nick Dokos and Sebastian
+   Vaubán on exporting to beamer looked very interesting, but I
+   haven't had time to try it out yet. I would really like it if,
+   eventually, we can generate a presentation (with graphics generated
+   by code blocks) from the same org file that contains all the notes
+   and code etc. I just wanted that to be on record in this document;
+   I don't have anything more profound to say about it at the moment,
+   and I'm not sure to what extent it is an org-babel issue.
+** PROPOSED conversion between org-babel and noweb (e.g. .Rnw) format
+   I haven't thought about this properly. Just noting it down. What
+   Sweave uses is called "R noweb" (.Rnw).
+   
+   I found a good description of noweb in the following article (see
+   the [[http://www.cs.tufts.edu/~nr/pubs/lpsimp.pdf][pdf]]).
+   
+   I think there are two parts to noweb, the construction of
+   documentation and the extraction of source-code (with notangle).
+
+   *documentation*: org-mode handles all of our documentation needs in
+   a manner that I believe is superior to noweb.
+   
+   *source extraction* At this point I don't see anyone writing large
+   applications with 100% of the source code contained in org-babel
+   files, rather I see org-babel files containing things like
+   - notes with active code chunks
+   - interactive tutorials
+   - requirements documents with code running test suites
+   - and of course experimental reports with the code to run the
+     experiment, and perform analysis
+
+   Basically I think the scope of the programs written in org-babel
+   (at least initially) will be small enough that it wont require the
+   addition of a tangle type program to extract all of the source code
+   into a running application.
+
+   On the other hand, since we already have named blocks of source
+   code which reference other blocks on which they rely, this
+   shouldn't be too hard to implement either on our own, or possibly
+   relying on something like noweb/notangle.
+
+** PROPOSED support for passing paths to files between source blocks
+Maybe this should be it's own result type (in addition to scalars and
+vectors).  The reason being that some source-code blocks (for example
+ditaa or anything that results in the creation of a file) may want to
+pass a file path back to org-mode which could then be inserted into
+the org-mode buffer as a link to the file...
+
+This would allow for display of images upon export providing
+functionality similar to =org-exp-blocks= only in a more general
+manner.
+** DEFERRED optional timestamp for output
+   *DEFERRED*: I'm deferring this in deference to the better caching
+   system proposed by Carsten. (see [[sha1-caching]])
+
+   Add option to place an (inactive) timestamp at the #+resname, to
+   record when that output was generated.
+
+*** source code block timestamps (optional addition)
+    [Eric] If we did this would we then want to place a timestamp on the
+    source-code block, so that we would know if the results are
+    current or out of date?  This would have the effect of caching the
+    results of calculations and then only re-running if the
+    source-code has changed.  For the caching to work we would need to
+    check not only the timestamp on a source-code block, but also the
+    timestamps of any tables or source-code blocks referenced by the
+    original source-code block.
+
+    [Dan] I do remember getting frustrated by Sweave always having to
+    re-do everything, so this could be desirable, as long as it's easy
+    to over-ride of course. I'm not sure it should be the default
+    behaviour unless we are very confident that it works well.
+
+**** maintaining source-code block timestamps
+     It may make sense to add a hook to `org-edit-special' which could
+     update the source-code blocks timestamp.  If the user edits the
+     contents of a source-code block directly I can think of no
+     efficient way of maintaining the timestamp.
+** DEFERRED source-name visible in LaTeX and html exports
+Maybe this should be done in backend specific manners.
+
+The listings package may provide for naming a source-code block...
+
+Actually there is no obvious simple and attractive way to implement
+this.  Closing this issue for now.
+** DEFERRED Support rownames and other org babel table features?
+
+   The full org table features are detailed in the manual [[http://orgmode.org/manual/Advanced-features.html#Advanced-features][here]].
+
+*** rownames
+   Perhaps add a :rownames header arg. This would be an integer
+    (usually 1) which would have the effect of post-processing all the
+    variables created in the R session in the following way: if the
+    integer is j, set the row names to the contents of column j and
+    delete column j. Perhaps it is artificial to allow this integer to
+    take any value other than 1. The default would be nil which would
+    mean no such behaviour.
+
+    Actually I don't know about that. If multiple variables are passed
+    in, it's not appropriate to alter them all in the same way. The
+    rownames specification would normally refer to just one of the
+    variables. For now maybe just say this has to be done in R. E.g.
+
+#+TBLNAME: sample-sizes
+  | collection      | size | exclude | include | exclude2 | include2 |
+  |-----------------+------+---------+---------+----------+----------|
+  | 58C             | 2936 |       8 |    2928 |      256 |     2680 |
+  | MS              | 5852 |     771 |    5081 |      771 |     5081 |
+  | NBS             | 2929 |      64 |    2865 |      402 |     2527 |
+  | POBI            | 2717 |       1 |    2716 |        1 |     2716 |
+  | 58C+MS+NBS+POBI |      |         |   13590 |          |    13004 |
+#+TBLFM: @2$4=@2$2 - @2$3::@2$6=@2$2 - @2$5::@3$4=@3$2-@3$3::@3$6=@3$2 - @3$5::@4$4=@4$2 - @4$3::@4$6=@4$2 - @4$5::@5$4=@5$2-@5$3::@5$6=@5$2 - @5$5::@6$4=vsum(@2$4..@5$4)::@6$6=vsum(@2$6..@5$6)
+
+#+srcname: make-size-table(size=sample-sizes)
+#+begin_src R 
+  rownames(size) <- size[,1]
+  size <- size[,-1]
+#+end_src
+
+
+*** Old notes
+    [I don't think it's as problematic as this makes out]
+    This is non-trivial, but may be worth doing, in particular to
+    develop a nice framework for sending data to/from R.
+**** Notes
+    In R, indexing vector elements, and rows and columns, using
+    strings rather than integers is an important part of the
+    language.
+ - elements of a vector may have names
+ - matrices and data.frames may have "column names" and "row names"
+   which can be used for indexing
+ - In a data frame, row names *must* be unique
+Examples
+#+begin_example
+> # a named vector
+> vec <- c(a=1, b=2)
+> vec["b"]
+b 
+2 
+> mat <- matrix(1:4, nrow=2, ncol=2, dimnames=list(c("r1","r2"), c("c1","c2")))
+> mat
+   c1 c2
+r1  1  3
+r2  2  4
+> # The names are separate from the data: they do not interfere with operations on the data
+> mat * 3
+   c1 c2
+r1  3  9
+r2  6 12
+> mat["r1","c2"]
+[1] 3
+> df <- data.frame(var1=1:26, var2=26:1, row.names=letters)
+> df$var2
+ [1] 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1
+> df["g",]
+  var1 var2
+g    7   20
+#+end_example
+
+ So it's tempting to try to provide support for this in org-babel. For example
+ - allow R to refer to columns of a :var reference by their names
+ - When appropriate, results from R appear in the org buffer with "named
+   columns (and rows)"
+
+   However none (?) of the other languages we are currently supporting
+   really have a native matrix type, let alone "column names" or "row
+   names". Names are used in e.g. python and perl to refer to entries
+   in dicts / hashes.
+
+   It currently seems to me that support for this in org-babel would
+   require setting rules about when org tables are considered to have
+   named columns/fields, and ensuring that (a) languages with a notion
+   of named columns/fields use them appropriately and (b) languages
+   with no such notion do not treat then as data.
+
+ - Org allows something that *looks* like column names to be separated
+   by a hline
+ - Org also allows a row to *function* as column names when special
+   markers are placed in the first column. An hline is unnecessary
+   (indeed hlines are purely cosmetic in org [correct?]
+ - Org does not have a notion of "row names" [correct?]
+    
+   The full org table functionality exeplified [[http://orgmode.org/manual/Advanced-features.html#Advanced-features][here]] has features that
+   we would not support in e.g. R (like names for the row below).
+   
+**** Initial statement: allow tables with hline to be passed as args into R
+   This doesn't seem to work at the moment (example below). It would
+   also be nice to have a natural way for the column names of the org
+   table to become the column names of the R data frame, and to have
+   the option to specify that the first column is to be used as row
+   names in R (these must be unique). But this might require a bit of
+   thinking about.
+
+
+#+TBLNAME: egtable
+| col1 | col2    | col3 |
+|------+---------+------|
+|    1 | 2       |    3 |
+|    4 | schulte |    6 |
+
+#+TBLNAME: egtable2
+| 1 |         2 | 3 |
+| 4 | schulte   | 6 |
+
+#+begin_src R :var tabel=egtable :colnames t
+tabel
+#+end_src
+
+#+resname:
+| "col1" | "col2"    | "col3" |
+|--------+-----------+--------|
+|      1 | 2         |      3 |
+|      4 | "schulte" |      6 |
+
+
+Another example is in the [[*operations%20in%20on%20tables][grades example]].
+** DEFERRED use textConnection to pass tsv to R?
+   When passing args from the org buffer to R, the following route is
+   used: arg in buffer -> elisp -> tsv on file -> data frame in R. I
+   think it would be possible to avoid having to write to file by
+   constructing an R expression in org-babel-R-assign-elisp, something
+   like this
+
+#+begin_src emacs-lisp
+(org-babel-R-input-command
+ (format  "%s <- read.table(textConnection(\"%s\"), sep=\"\\t\", as.is=TRUE)"
+	  name (orgtbl-to-tsv value '(:sep "\t" :fmt org-babel-R-quote-tsv-field))))
+#+end_src
+
+   I haven't tried to implement this yet as it's basically just
+   fiddling with something that works. The only reason for it I can
+   think of would be efficiency and I haven't tested that.
+
+   This Didn't work after an initial test.  I still think this is a
+   good idea (I also think we should try to do something similar when
+   writing out results frmo R to elisp) however as it wouldn't result
+   in any functional changes I'm bumping it down to deferred for
+   now. [Eric]
+
+for quick tests
+
+#+tblname: quick-test
+| 1 | 2 | 3 |
+
+#+srcname: quick-test-src-blk
+#+begin_src R :var vec=quick-test
+mean(mean(vec))
+#+end_src
+
+#+resname:
+: 2
+
+
+: 2
+
+** DEFERRED Rework Interaction with Running Processes [2/5]
+*** DONE robust to errors interrupting execution
+
+#+srcname: long-runner-ruby
+#+begin_src ruby :results silent
+  sleep(10)
+  :patton_is_an_grumpy
+#+end_src
+
+*** DEFERRED use =C-g= keyboard-quit to push processing into the background
+This may be possible using the `run-with-timer' command.
+
+I have no idea how this could work...
+
+#+srcname: long-runner-ruby
+#+begin_src ruby :results silent
+  sleep(10)
+  :patton_is_an_grumpy
+#+end_src
+
+*** TODO ability to select which of multiple sessions is being used
+    Increasingly it is looking like we're going to want to run all
+    source code blocks in comint buffer (sessions).  Which will have
+    the benefits of
+    1) allowing background execution
+    2) maintaining state between source-blocks
+       - allowing inline blocks w/o header arguments 
+
+**** R sessions
+     (like ess-switch-process in .R buffers)
+     
+     Maybe this could be packaged into a header argument, something
+     like =:R_session= which could accept either the name of the
+     session to use, or the string =prompt=, in which case we could use
+     the =ess-switch-process= command to select a new process.
+     
+*** TODO evaluation of shell code as background process? 
+    After C-c C-c on an R code block, the process may appear to
+    block, but C-g can be used to reclaim control of the .org buffer,
+    without interrupting the R evalution. However I believe this is not
+    true of bash/sh evaluation. [Haven't tried other languages] Perhaps
+    a solution is just to background the individual shell commands.
+
+    The other languages (aside from emacs lisp) are run through the
+    shell, so if we find a shell solution it should work for them as
+    well.
+    
+    Adding an ampersand seems to be a supported way to run commands in
+    the background (see [[http://www.emacswiki.org/emacs/ExecuteExternalCommand#toc4][external-commands]]).  Although a more extensible
+    solution may involve the use of the [[elisp:(progn (describe-function 'call-process-region) nil)][call-process-region]] function.
+    
+    Going to try this out in a new file [[file:lisp/org-babel-proc.el][org-babel-proc.el]].  This should
+    contain functions for asynchronously running generic shell commands
+    in the background, and then returning their input.
+
+**** partial update of org-mode buffer
+    The sleekest solution to this may be using a comint buffer, and
+    then defining a filter function which would incrementally interpret
+    the results as they are returned, including insertion into the
+    org-mode buffer.  This may actually cause more problems than it is
+    worth, what with the complexities of identifying the types of
+    incrementally returned results, and the need for maintenance of a
+    process marker in the org buffer.
+
+**** 'working' spinner
+     It may be nice and not too difficult to place a spinner on/near the
+     evaluating source code block
+
+*** TODO conversion of output from interactive shell, R (and python) sessions to org-babel buffers
+    [DED] This would be a nice feature I think. Although an org-babel
+    purist would say that it's working the wrong way round... After
+    some interactive work in a *R* buffer, you save the buffer, maybe
+    edit out some lines, and then convert it to org-babel format for
+    posterity. Same for a shell session either in a *shell* buffer, or
+    pasted from another terminal emulator. And python of course.
+** DEFERRED improve the source-block snippet
+any real improvement seems somewhat beyond the ability of yasnippet
+for now.
+
+[[file:~/src/emacs-starter-kit/src/snippets/text-mode/rst-mode/chap::name%20Chapter%20title][file:~/src/emacs-starter-kit/src/snippets/text-mode/rst-mode/chap::name Chapter title]]
+#+begin_example
+,#name : Chapter title
+,# --
+${1:Chapter}
+${1:$(make-string (string-width text) ?\=)}
+
+$0
+#+end_example
+
+[[file:snippets/org-mode/sb][sb -- snippet]]
+
+waiting for guidance from those more familiar with yasnippets
+
+** REJECTED re-implement R evaluation using ess-command or ess-execute
+   I don't have any complaints with the current R evaluation code or
+   behaviour, but I think it would be good to use the ESS functions
+   from a political point of view. Plus of course it has the normal
+   benefits of an API (insulates us from any underlying changes etc). [DED]
+
+   I'll look into this.  I believe that I looked at and rejected these
+   functions initially but now I can't remember why.  I agree with
+   your overall point about using API's where available.  I will take
+   a look back at these and either switch to using the ess commands,
+   or at least articulate under this TODO the reasons for using our
+   custom R-interaction commands. [Eric]
+
+   ess-execute
+
+   Lets just replace =org-babel-R-input-command= with =ess-execute=.
+
+   I tried this, and although it works in some situations, I find that
+   =ess-command= will often just hang indefinitely without returning
+   results.  Also =ess-execute= will occasionally hang, and pops up
+   the buffer containing the results of the command's execution, which
+   is undesirable.  For now these functions can not be used.  Maybe
+   someone more familiar with the ESS code can recommend proper usage
+   of =ess-command= or some other lower-level function which could be
+   used in place of [[file:lisp/org-babel-R.el::defun%20org-babel%20R%20input%20command%20command][org-babel-R-input-command]].
+
+*** ess functions
+   
+#+begin_quote ess-command
+(ess-command COM &optional BUF SLEEP NO-PROMPT-CHECK)
+
+Send the ESS process command COM and delete the output
+from the ESS process buffer.  If an optional second argument BUF exists
+save the output in that buffer. BUF is erased before use.
+COM should have a terminating newline.
+Guarantees that the value of .Last.value will be preserved.
+When optional third arg SLEEP is non-nil, `(sleep-for (* a SLEEP))'
+will be used in a few places where `a' is proportional to `ess-cmd-delay'.
+#+end_quote
+
+#+begin_quote ess-execute
+(ess-execute COMMAND &optional INVERT BUFF MESSAGE)
+
+Send a command to the ESS process.
+A newline is automatically added to COMMAND.  Prefix arg (or second arg
+INVERT) means invert the meaning of
+`ess-execute-in-process-buffer'.  If INVERT is 'buffer, output is
+forced to go to the process buffer.  If the output is going to a
+buffer, name it *BUFF*.	 This buffer is erased before use.  Optional
+fourth arg MESSAGE is text to print at the top of the buffer (defaults
+to the command if BUFF is not given.)
+#+end_quote
+
+*** out current setup
+
+    1) The body of the R source code block is wrapped in a function
+    2) The function is called inside of a =write.table= function call
+       writing the results to a table
+    3) The table is read using =org-table-import=
+** DONE figure out how to handle graphic output
+   
+This is listed under [[* graphical output][graphical output]] in out objectives.
+
+This should take advantage of the =:results file= option, and
+languages which almost always produce graphical output should set
+=:results file= to true by default (this is currently done for the
+gnuplot and ditaa languages).  That would handle placing these results
+in the buffer.  Then if there is a combination of =silent= and =file=
+=:results= headers we could drop the results to a temp buffer and pop
+open that buffer...
+
+Display of file results is addressed in the [[* =\C-c \C-o= to open results of source block][open-results-task]].
+
+I think this is done for now.  With the ability of the file option it
+is now possible to save images directly to a file.  Then calling
+=\C-c\C-o= with point on the source block will open the related
+results.
+
+*** R graphics to screen means session evaluation
+    If R graphical output is going to screen then evaluation must be
+    in a session, otherwise the graphics will disappear as soon as the
+    R process dies.
+
+*** Adding to a discussion started in email
+    I'm not deeply wedded to these ideas, just noting them down. I'm
+    probably just thinking of R and haven't really thought about how
+    this fits with the other graphics-generating languages.
+Dan:
+> I used the approach below to get graphical file output
+> today, which is one idea at least. Maybe it could be linked up with
+> your :results file variable. (Or do we need a :results image for R?)
+>
+Eric:
+I don't think we need a special image results variable, but I may be
+missing what the code below accomplishes.  Would the task I added about
+adding org-open-at-point functionality to source code blocks take care
+of this need?
+
+Dan: I'm not sure. I think the ability for a script to generate both
+text and graphical output might be a natural expectation, at least for
+R users.
+
+>
+> Dan
+>
+> #+srcname: cohort-scatter-plots-2d(org_babel_graphical_output_file="cohort-scatter-plots-2d.png")
+> #+begin_src R 
+>   if(exists("org_babel_output_file"))
+>       png(filename=org_babel_graphical_output_file, width=1000, height=1000)
+>   ## plotting code in here
+>   if(exists("org_babel_graphical_output_file")) dev.off()
+> #+end_src
+
+Dan: Yes, the results :file option is nice for dealing with graphical
+output, and that could well be enough. Something based on the scheme
+above would have a couple of points in its favour:
+1. It's easy to switch between output going to on-screen graphics and
+   output going to file: Output will go to screen unless a string variable
+   with a standard name (e.g. ""org_babel_graphical_output_file"")
+   exists in which case it will go to the file indicated by the value
+   of that variable.
+2. The block can return a result / script output, as well as produce
+   graphical output.
+
+In interactive use we might want to allow the user to choose between
+screen and file output. In non-interactive use such as export, it
+would be file output (subject to the :exports directives).
+** DONE new results types (org, html, latex)
+   Thanks to Tom Short for this recommendation.
+
+   - raw or org :: in which case the results are implemented raw, unquoted
+                   into the org-mode file.  This would also handle links as
+                   source block output.
+   - html :: the results are inserted inside of a #+BEGIN_HTML block
+   - latex :: the results are inserted inside of a #+BEGIN_LATEX block
+
+   It might look like:
+: #+begin_src R :session *R* :results org
+: cat("***** This is a table\n")
+: cat("| 1 | 2 | 3 |\n")
+: cat("[[http://google.com][Google it here]]\n"
+: #+end_src
+:        
+: #+resname:
+: ***** This is a table
+: | 1 | 2 | 3 |
+[[http://google.com][: Google it here]]
+
+We actually might want to remove the =#+resname= line if the results
+type is org-mode, not sure...  Either way I don't think there is a
+good way to capture/remove org type results.
+
+*** LaTeX
+#+srcname: latex-results
+#+begin_src emacs-lisp :results latex
+"this should be inside of a LaTeX block"
+#+end_src
+
+#+resname:
+#+BEGIN_LaTeX
+this should be inside of a LaTeX block
+#+END_LaTeX
+
+*** Html
+#+srcname: html-results
+#+begin_src emacs-lisp :results html
+"this should be inside of a HTML block
+
+
+
+and more
+
+
+
+is long"
+#+end_src
+
+#+resname:
+#+BEGIN_HTML
+this should be inside of a HTML block
+
+
+
+and more
+
+
+
+is long
+#+END_HTML
+
+*** raw
+
+Added a =raw= results header argument, which will insert the results
+of a source-code block into an org buffer un-escaped.  Also, if the
+results look like a table, then the table will be aligned.
+
+#+srcname: raw-table-demonstration
+#+begin_src ruby :results output raw
+  puts "| root | square |"
+  puts "|---"
+  10.times do |n|
+    puts "| #{n} | #{n*n} |"
+  end
+#+end_src
+
+#+resname:
+| root | square |
+|------+--------|
+|    0 |      0 |
+|    1 |      1 |
+|    2 |      4 |
+|    3 |      9 |
+|    4 |     16 |
+|    5 |     25 |
+|    6 |     36 |
+|    7 |     49 |
+|    8 |     64 |
+|    9 |     81 |
+
+Not sure how/if this would work, but it may be desirable.
+** DONE org-bable-tangle: no default extension if one already exists
+** DONE take default values for header args from properties
+   Use file-wide and subtree wide properties to set default values for
+   header args.
+   
+   [DED] One thing I'm finding when working with R is that an org file
+   may contain many source blocks, but that I just want to evaluate a
+   subset of them. Typically this is in order to take up where I left
+   off: I need to recreate a bunch of variables in the session
+   environment. I'm thinking maybe we want to use a tag-based
+   mechanism similar to :export: and :noexport: to control evaluation
+   on a per-subtree basis.
+
+*** test-header with properties
+    :PROPERTIES:
+    :tangle:   yes
+    :var:      def=8
+    :END:
+
+Ahh... as is so often the case, just had to wrap
+`org-babel-params-from-properties' in a `save-match-data' form.
+
+#+tblname: why-def-props-cause-probs
+| 1 | 2 | 3 | 4 |
+
+#+srcname: default-props-implementation
+#+begin_src emacs-lisp :tangle no :var my-lis=why-def-props-cause-probs :results silent
+(+ (length my-lis) def)
+#+end_src
+
+** DONE new reference syntax *inside* source code blocks
+This is from an email discussion on the org-mode mailing list with
+Sébastien.  The goal here is to mimic the source-block reference style
+of Noweb.  Upon export and/or tangle these references could be
+replaced with the actual body of the referenced source-code block.
+
+See the following for an example.
+
+#+srcname: ems-ruby-print-header
+#+begin_src ruby 
+puts "---------------------------header---------------------------"
+#+end_src
+
+#+srcname: emacs-ruby-print-footer
+#+begin_src ruby 
+puts "---------------------------footer---------------------------"
+#+end_src
+
+#+srcname: ems-ruby-print-message
+#+begin_src ruby :file ruby-noweb.rb
+  # <<ems-ruby-print-header>>
+  puts "                            Ruby                            "
+  # <<ems-ruby-print-footer>>
+#+end_src
+
+Upon export the previous source-code block would result in a file
+being generated at =ruby-noweb.rb= with the following contents
+
+: puts "---------------------------header---------------------------"
+: puts "                            Ruby                            "
+: puts "---------------------------footer---------------------------"
+
+the body of a source-code block with all =<<src-name>>= references
+expanded can now be returned by `org-babel-expand-noweb-references'.
+This function is now called by default on all source-code blocks on
+export.
+
+** DONE re-work tangling system
+Sometimes when tangling a file (e.g. when extracting elisp from a
+org-mode file) we want to get nearly every source-code block.
+
+Sometimes we want to only extract those source-code blocks which
+reference a indicate that they should be extracted (e.g. traditional
+literate programming along the Noweb model)
+
+I'm not sure how we can devise a single simple tangling system that
+naturally fits both of these use cases.
+
+*** new setup
+the =tangle= header argument will default to =no= meaning source-code
+blocks will *not* be exported by default.  In order for a source-code
+block to be tangled it needs to have an output file specified.  This
+can happen in two ways...
+
+1) a file-wide default output file can be passed to `org-babel-tangle'
+   which will then be used for all blocks
+2) if the value of the =tangle= header argument is anything other than
+   =no= or =yes= then it is used as the file name
+
+#+srcname: test-new-tangling
+#+begin_src emacs-lisp 
+  (org-babel-load-file "test-tangle.org")
+  (if (string= test-tangle-advert "use org-babel-tangle for all your emacs initialization files!!")
+      "succeed"
+    "fail")
+#+end_src
+
+#+resname:
+: succeed
+
+** DONE =\C-c \C-o= to open results of source block
+by adding a =defadvice= to =org-open-at-point= we can use the common
+=\C-c \C-o= keybinding to open the results of a source-code block.
+This would be especially useful for source-code blocks which generate
+graphical results and insert a file link as the results in the
+org-mode buffer.  (see [[* figure out how to handle graphic output][TODO figure out how to handle graphic output]]).
+This could also act reasonably with other results types...
+
+- file :: use org-open-at-point to open the file
+- scalar :: open results unquoted in a new buffer
+- tabular :: export the table to a new buffer and open that buffer
+
+when called with a prefix argument the block is re-run
+
+#+srcname: task-opening-results-of-blocks
+#+begin_src ditaa :results replace :file blue.png :cmdline -r
++---------+
+| cBLU    |
+|         |
+|    +----+
+|    |cPNK|
+|    |    |
++----+----+
+#+end_src
+
+#+resname:
+[[file:blue.png][blue.png]]
+
+#+srcname: task-open-vector
+#+begin_src emacs-lisp
+'((1 2) (3 4))
+#+end_src
+
+#+resname:
+| 1 | 2 |
+| 3 | 4 |
+
+#+srcname: task-open-scalar
+#+begin_src ruby :results output
+  8.times do |n|
+    puts "row #{n}"
+  end
+#+end_src
+
+#+resname:
+: row 0
+: row 1
+: row 2
+: row 3
+: row 4
+: row 5
+: row 6
+: row 7
+
+** DONE Stop spaces causing vector output
+This simple example of multilingual chaining produces vector output if
+there are spaces in the message and scalar otherwise.
+
+[Not any more]
+
+#+srcname: msg-from-R(msg=msg-from-python)
+#+begin_src R
+paste(msg, "und R", sep=" ")
+#+end_src
+
+#+resname:
+: org-babel speaks elisp y python und R
+
+#+srcname: msg-from-python(msg=msg-from-elisp)
+#+begin_src python
+msg + " y python"
+#+end_src
+
+#+srcname: msg-from-elisp(msg="org-babel speaks")
+#+begin_src emacs-lisp
+(concat msg " elisp")
+#+end_src
+
+** DONE add =:tangle= family of header arguments
+values are
+- no :: don't include source-code block when tangling
+- yes :: do include source-code block when tangling
+
+this is tested in [[file:test-tangle.org::*Emacs%20Lisp%20initialization%20stuff][test-tangle.org]]
+
+** DONE extensible library of callable source blocks
+*** Current design
+    This is covered by the [[file:library-of-babel.org][Library of Babel]], which will contain
+    ready-made source blocks designed to carry out useful common tasks.
+*** Initial statement [Eric]
+    Much of the power of org-R seems to be in it's helper functions for
+    the quick graphing of tables.  Should we try to re-implement these
+    functions on top of org-babel?
+
+    I'm thinking this may be useful both to add features to org-babel-R and
+    also to potentially suggest extensions of the framework.  For example
+    one that comes to mind is the ability to treat a source-code block
+    like a function which accepts arguments and returns results. Actually
+    this can be it's own TODO (see [[* source blocks as functions][source blocks as functions]]).
+*** Objectives [Dan]
+    - We want to provide convenient off-the-shelf actions
+      (e.g. plotting data) that make use of our new code evaluation
+      environment but do not require any actual coding.
+*** Initial Design proposal [Dan]
+    - *Input data* will be specified using the same mechanism as :var
+      references, thus the input data may come from a table, or
+      another source block, and it is initially available as an elisp
+      data structure.
+    - We introduce a new #+ line, e.g.  #+BABELDO. C-c C-c on that
+      line will apply an *action* to the referenced data.
+    - *Actions correspond to source blocks*: our library of available
+      actions will be a library of org-babel source blocks. Thus the
+      code for executing an action, and the code for dealing with the
+      output of the action will be the same code as for executing
+      source blocks in general
+    - Optionally, the user can have the relevant source block inserted
+      into the org buffer after the (say) #+BABELDO line. This will
+      allow the user to fine tune the action by modifying the code
+      (especially useful for plots).
+    - So maybe a #+BABELDO line will have header args
+      - :data (a reference to a table or source code block)
+      - :action (or should that be :srcname?) which will be something
+        like :action pie-chart, referring to a source block which will
+        be executed with the :data referent passed in using a :var arg.
+      - :showcode or something controlling whether to show the code
+      
+*** Modification to design
+    I'm implementing this, at least initially, as a new interpreter
+    named 'babel', which has an empty body. 'babel' blocks take
+    a :srcname header arg, and look for the source-code block with
+    that name. They then execute the referenced block, after first
+    appending their own header args on to the target block's header
+    args.
+
+    If the target block is in the library of babel (a.o.t. e.g. the
+    current buffer), then the code in the block will refer to the
+    input data with a name dictated by convention (e.g. __data__
+    (something which is syntactically legal in all languages...). Thus
+    the babel block will use a :var __data__ = whatever header arg to
+    reference the data to be plotted.
+
+** DONE Column names in R input/output
+   This has been implemented: Automatic on input to R; optional in
+   output. Note that this equates column names with the header row in
+   an org table; whereas org actually has a mechanism whereby a row
+   with a '!' in the first field defines column names. I have not
+   attempted to support these org table mechanisms yet. See [[*Support%20rownames%20and%20other%20org%20babel%20table%20features][this
+   DEFERRED todo item]].
+** DONE use example block for large amounts of stdout output?
+   We're currently `examplizing' with : at the beginning of the line,
+   but should larger amounts of output be in a
+   \#+begin_example...\#+end_example block? What's the cutoff? > 1
+   line?  This would be nice as it would allow folding of lengthy
+   output. Sometimes one will want to see stdout just to check
+   everything looks OK, and then fold it away.
+
+   I'm addressing this in branch 'examplizing-output'.
+   Yea, that makes sense.  (either that or allow folding of large
+   blocks escaped with =:=).
+
+   Proposed cutoff of 10 lines, we can save this value in a user
+   customizable variable.
+*** DONE add ability to remove such results
+** DONE exclusive =exports= params
+   
+#+srcname: implement-export-exclusivity
+#+begin_src ruby 
+:this_is_a_test
+#+end_src
+
+#+resname:
+: :this_is_a_test
+** DONE LoB: allow output in buffer
+** DONE allow default header arguments by language
+org-babel-default-header-args:lang-name
+
+An example of when this is useful is for languages which always return
+files as their results (e.g. [[*** ditaa][ditaa]], and [[*** gnuplot][gnuplot]]).
+** DONE singe-function tangling and loading elisp from literate org-mode file [3/3]
+
+This function should tangle the org-mode file for elisp, and then call
+`load-file' on the resulting tangled file.
+
+#+srcname: test-loading-embedded-emacs-lisp
+#+begin_src emacs-lisp :results replace
+  (setq test-tangle-advert nil)
+  (setq test-tangle-loading nil)
+  (setq results (list :before test-tangle-loading test-tangle-advert))
+  (org-babel-load-file "test-tangle.org")
+  (setq results (list (list :after test-tangle-loading test-tangle-advert) results))
+  (delete-file "test-tangle.el")
+  (reverse results)
+#+end_src
+
+#+resname: test-loading-embedded-emacs-lisp
+| :before | nil                 | nil                                                              |
+| :after  | "org-babel tangles" | "use org-babel-tangle for all your emacs initialization files!!" |
+
+*** DONE add optional language limiter to org-babel-tangle
+This should check to see if there is any need to re-export
+
+*** DONE ensure that org-babel-tangle returns the path to the tangled file(s)
+
+#+srcname: test-return-value-of-org-babel-tangle
+#+begin_src emacs-lisp :results replace
+  (mapcar #'file-name-nondirectory (org-babel-tangle-file "test-tangle.org" "emacs-lisp"))
+#+end_src
+
+#+resname:
+| "test-tangle.el" |
+
+*** DONE only tangle the file if it's actually necessary
+** DONE add a function to jump to a source-block by name
+   I've had an initial stab at that in org-babel-find-named-block
+   (library-of-babel branch).
+
+   At the same time I introduced org-babel-named-src-block-regexp, to
+   match src-blocks with srcname.
+
+   This is now working with the command
+   `org-babel-goto-named-source-block', all we need is a good key
+   binding.
+
+** DONE add =:none= session argument (for purely functional execution) [4/4]
+This would allow source blocks to be run in their own new process
+
+- These blocks could then also be run in the background (since we can
+  detach and just wait for the process to signal that it has terminated)
+- We wouldn't be drowning in session buffers after running the tests
+- we can re-use much of the session code to run in a more /functional/
+  mode
+
+While session provide a lot of cool features, like persistent
+environments, [[* DONE function to bring up inferior-process buffer][pop-to-session]], and hints at exportation for
+org-babel-tangle, they also have some down sides and I'm thinking that
+session-based execution maybe shouldn't be the default behavior.
+
+Down-sides to sessions
+- *much* more complicated than functional evaluation
+  - maintaining the state of the session has weird issues
+  - waiting for evaluation to finish
+  - prompt issues like [[* TODO weird escaped characters in shell prompt break shell evaluation][shell-prompt-escapes-bug]]
+- can't run in background
+- litter emacs with session buffers
+
+*** DONE ruby
+
+#+srcname: ruby-task-no-session
+#+begin_src ruby :results replace output
+puts :eric
+puts :schulte
+[1, 2, 3]
+#+end_src
+
+#+resname: ruby-task-no-session
+| "eric"    |
+| "schulte" |
+*** DONE python
+
+#+srcname: task-python-none-session
+#+begin_src python :session none :results replace value
+print 'something'
+print 'output'
+[1, 2, 3]
+#+end_src
+
+#+resname: task-python-none-session
+| 1 | 2 | 3 |
+
+*** DONE sh
+
+#+srcname: task-session-none-sh
+#+begin_src sh :results replace
+echo "first"
+echo "second"
+#+end_src
+
+#+resname: task-session-none-sh
+| "first"  |
+| "second" |
+
+*** DONE R
+
+#+srcname: task-no-session-R
+#+begin_src R :results replace output
+a <- 8
+b <- 9
+a + b
+b - a
+#+end_src
+
+#+resname: task-no-session-R
+| "[1]" | 17 |
+| "[1]" |  1 |
+
+** DONE fully purge org-babel-R of direct comint interaction
+try to remove all code under the [[file:lisp/org-babel-R.el::functions%20for%20evaluation%20of%20R%20code][;; functions for evaluation of R code]] line
+
+** DONE Create objects in top level (global) environment [5/5]
+*sessions*
+
+*** initial requirement statement [DED]
+   At the moment, objects created by computations performed in the
+   code block are evaluated in the scope of the
+   code-block-function-body and therefore disappear when the code
+   block is evaluated {unless you employ some extra trickery like
+   assign('name', object, env=globalenv()) }. I think it will be
+   desirable to also allow for a style wherein objects that are
+   created in one code block persist in the R global environment and
+   can be re-used in a separate block.
+
+   This is what Sweave does, and while I'm not saying we have to be
+   the same as Sweave, it wouldn't be hard for us to provide the same
+   behaviour in this case; if we don't, we risk undeservedly being
+   written off as an oddity by some.
+
+   IOW one aspect of org-babel is that of a sort of functional
+   meta-programming language. This is crazy, in a very good
+   way. Nevertheless, wrt R I think there's going to be a lot of value
+   in providing for a working style in which the objects are stored in
+   the R session, rather than elisp/org buffer. This will be a very
+   familiar working style to lots of people.
+
+   There are no doubt a number of different ways of accomplishing
+   this, the simplest being a hack like adding
+
+#+begin_src R
+for(objname in ls())
+    assign(objname, get(objname), envir=globalenv())
+#+end_src
+
+to the source code block function body. (Maybe wrap it in an on.exit() call).
+
+However this may deserve to be thought about more carefully, perhaps
+with a view to having a uniform approach across languages. E.g. shell
+code blocks have the same semantics at the moment (no persistence of
+variables across code blocks), because the body is evaluated in a new
+bash shell process rather than a running shell. And I guess the same
+is true for python. However, in both these cases, you could imagine
+implementing the alternative in which the body is evaluated in a
+persistent interactive session. It's just that it's particularly
+natural for R, seeing as both ESS and org-babel evaluate commands in a
+single persistent R session.
+
+*** sessions [Eric]
+
+Thanks for bringing this up.  I think you are absolutely correct that we
+should provide support for a persistent environment (maybe called a
+*session*) in which to evaluate code blocks.  I think the current setup
+demonstrates my personal bias for a functional style of programming
+which is certainly not ideal in all contexts.
+
+While the R function you mention does look like an elegant solution, I
+think we should choose an implementation that would be the same across
+all source code types.  Specifically I think we should allow the user to
+specify an optional *session* as a header variable (when not present we
+assume a default session for each language).  The session name could be
+used to name a comint buffer (like the *R* buffer) in which all
+evaluation would take place (within which variables would retain their
+values --at least once I remove some of the functional method wrappings
+currently in place-- ).
+
+This would allow multiple environments to be used in the same buffer,
+and once this setup was implemented we should be able to fairly easily
+implement commands for jumping between source code blocks and the
+related session buffers, as well as for dumping the last N commands from
+a session into a new or existing source code block.
+
+Please let me know if you foresee any problems with this proposed setup,
+or if you think any parts might be confusing for people coming from
+Sweave.  I'll hopefully find some time to work on this later in the
+week.
+
+*** can functional and interpreted/interactive models coexist?
+
+Even though both of these use the same =*R*= buffer the value of =a=
+is not preserved because it is assigned inside of a functional
+wrapper.
+
+#+srcname: task-R-sessions
+#+begin_src R 
+a <- 9
+b <- 21
+a + b
+#+end_src
+
+#+srcname: task-R-same-session
+#+begin_src R 
+a
+#+end_src
+
+This functional wrapper was implemented in order to efficiently return
+the results of the execution of the entire source code block.  However
+it inhibits the evaluation of source code blocks in the top level,
+which would allow for persistence of variable assignment across
+evaluations.  How can we allow *both* evaluation in the top level, and
+efficient capture of the return value of an entire source code block
+in a language independent manner?
+
+Possible solutions...
+1) we can't so we will have to implement two types of evaluation
+   depending on which is appropriate (functional or imperative)
+2) we remove the functional wrapper and parse the source code block
+   into it's top level statements (most often but not always on line
+   breaks) so that we can isolate the final segment which is our
+   return value.
+3) we add some sort of "#+return" line to the code block
+4) we take advantage of each languages support for meta-programming
+   through =eval= type functions, and use said to evaluate the entire
+   blocks in such a way that their environment can be combined with the
+   global environment, and their results are still captured.
+5) I believe that most modern languages which support interactive
+   sessions have support for a =last_result= type function, which
+   returns the result of the last input without re-calculation.  If
+   widely enough present this would be the ideal solution to a
+   combination of functional and imperative styles.
+
+None of these solutions seem very desirable, but for now I don't see
+what else would be possible.
+
+Of these options I was leaning towards (1) and (4) but now believe
+that if it is possible option (5) will be ideal.
+
+**** (1) both functional and imperative evaluation
+Pros
+- can take advantage of built in functions for sending regions to the
+  inferior process
+- retains the proven tested and working functional wrappers
+
+Cons
+- introduces the complication of keeping track of which type of
+  evaluation is best suited to a particular context
+- the current functional wrappers may require some changes in order to
+  include the existing global context
+
+**** (4) exploit language meta-programming constructs to explicitly evaluate code
+Pros
+- only one type of evaluation
+
+Cons
+- some languages may not have sufficient meta-programming constructs
+
+**** (5) exploit some =last_value= functionality if present
+
+Need to ensure that most languages have such a function, those without
+will simply have to implement their own similar solution...
+
+| language   | =last_value= function       |
+|------------+-----------------------------|
+| R          | .Last.value                 |
+| ruby       | _                           |
+| python     | _                           |
+| shell      | see [[* last command for shells][last command for shells]] |
+| emacs-lisp | see [[* emacs-lisp will be a special case][special-case]]            |
+
+#+srcname: task-last-value
+#+begin_src ruby
+82 + 18
+#+end_src
+
+***** last command for shells
+Do this using the =tee= shell command, and continually pipe the output
+to a file.
+
+Got this idea from the following [[http://linux.derkeiler.com/Mailing-Lists/Fedora/2004-01/0898.html][email-thread]].
+
+suggested from mailing list
+
+#+srcname: bash-save-last-output-to-file
+#+begin_src sh 
+while read line 
+do 
+  bash -c "$line" | tee /tmp/last.out1 
+  mv /tmp/last.out1 /tmp/last.out 
+done
+#+end_src
+
+another proposed solution from the above thread
+
+#+srcname: bash-save-in-variable
+#+begin_src sh 
+#!/bin/bash 
+# so - Save Output. Saves output of command in OUT shell variable. 
+OUT=`$*` 
+echo $OUT 
+#+end_src
+
+and another
+
+#+begin_quote
+.inputrc: 
+"^[k": accept-line 
+"^M": " | tee /tmp/h_lastcmd.out ^[k" 
+
+.bash_profile: 
+export __=/tmp/h_lastcmd.out 
+
+If you try it, Alt-k will stand for the old Enter; use "command $__" to 
+access the last output. 
+
+Best, 
+
+--
+
+Herculano de Lima Einloft Neto
+#+end_quote
+
+***** emacs-lisp will be a special case
+While it is possible for emacs-lisp to be run in a console type
+environment (see the =elim= function) it is *not* possible to run
+emacs-lisp in a different *session*.  Meaning any variable set top
+level of the console environment will be set *everywhere* inside
+emacs.  For this reason I think that it doesn't make any sense to
+worry about session support for emacs-lisp.
+
+*** Further thoughts on 'scripting' vs. functional approaches
+
+    These are just thoughts, I don't know how sure I am about this.
+    And again, perhaps I'm not saying anything very radical, just that
+    it would be nice to have some options supporting things like
+    receiving text output in the org buffer.
+
+    I can see that you've already gone some way down the road towards
+    the 'last value' approach, so sorry if my comments come rather
+    late. I am concerned that we are not giving sufficient attention
+    to stdout / the text that is returned by the interpreters. In
+    contrast, many of our potential users will be accustomed to a
+    'scripting' approach, where they are outputting text at various
+    points in the code block, not just at the end. I am leaning
+    towards thinking that we should have 2 modes of evaluation:
+    'script' mode, and 'functional' mode.
+
+    In script mode, evaluation of a code block would result in *all*
+    text output from that code block appearing as output in the org
+    buffer, presumably as an #+begin_example...#+end_example. There
+    could be an :echo option controlling whether the input commands
+    also appear in the output. [This is like Sweave].
+
+    In functional mode, the *result* of the code block is available as
+    an elisp object, and may appear in the org buffer as an org
+    table/string, via the mechanisms you have developed already.
+
+    One thing I'm wondering about is whether, in script mode, there
+    simply should not be a return value. Perhaps this is not so
+    different from what exists: script mode would be new, and what
+    exists currently would be functional mode.
+
+    I think it's likely that, while code evaluation will be exciting
+    to people, a large majority of our users in a large majority of
+    their usage will not attempt to actually use the return value from
+    a source code block in any meaningful way. In that case, it seems
+    rather restrictive to only allow them to see output from the end
+    of the code block.
+
+    Instead I think the most accessible way to introduce org-babel to
+    people, at least while they are learning it, is as an immensely
+    powerful environment in which to embed their 'scripts', which now
+    also allows them to 'run' their 'scripts'. Especially as such
+    people are likely to be the least capable of the user-base, a
+    possible design-rule would be to make the scripting style of usage
+    easy (default?), perhaps requiring a special option to enable a
+    functional style. Those who will use the functional style won't
+    have a problem understanding what's going on, whereas the 'skript
+    kiddies' might not even know the syntax for defining a function in
+    their language of choice. And of course we can allow the user to
+    set a variable in their .emacs controlling the preference, so that
+    functional users are not inconveniennced by having to provide
+    header args the whole time.
+
+    Please don't get the impression that I am down-valuing the
+    functional style of org-babel. I am constantly horrified at the
+    messy 'scripts' that my colleagues produce in perl or R or
+    whatever! Nevertheless that seems to be how a lot of people work.
+    
+    I think you were leaning towards the last-value approach because
+    it offered the possibility of unified code supporting both the
+    single evaluation environment and the functional style. If you
+    agree with any of the above then perhaps it will impact upon this
+    and mean that the code in the two branches has to differ a bit. In
+    that case, functional mode could perhaps after all evaluate each
+    code block in its own environment, thus (re)approaching 'true'
+    functional programming (side-effects are hard to achieve).
+
+#+begin_src sh
+ls > files
+echo "There are `wc -l files` files in this directory"
+
+#+end_src
+
+*** even more thoughts on evaluation, results, models and options
+
+Thanks Dan, These comments are invaluable.
+
+What do you think about this as a new list of priorities/requirements
+for the execution of source-code blocks.
+
+- Sessions
+   1)  we want the evaluation of the source code block to take place in a
+       session which can persist state (variables, current directory,
+       etc...).
+   2)  source code blocks can specify their session with a header argument
+   3)  each session should correspond to an Emacs comint buffer so that the
+       user can drop into the session and experiment with live code
+       evaluation.
+- Results
+  1) each source-code block generates some form of results which (as
+     we have already implemented) is transfered into emacs-lisp
+     after which it can be inserted into the org-mode buffer, or
+     used by other source-code blocks
+  2) when the results are translated into emacs-lisp, forced to be
+     interpreted as a scalar (dumping their raw values into the
+     org-mode buffer), as a vector (which is often desirable with R
+     code blocks), or interpreted on the fly (the default option).
+     Note that this is very nearly currently implemented through the
+     [[* DONE results-type header (vector/file)][results-type-header]].
+  3) there should be *two* means of collecting results from the
+     execution of a source code block.  *Either* the value of the
+     last statement of the source code block, or the collection of
+     all that has been passed to STDOUT during the evaluation.
+
+**** header argument or return line (*header argument*)
+
+   Rather than using a header argument to specify how the return value
+   should be passed back, I'm leaning towards the use of a =#+RETURN=
+   line inside the block.  If such a line *is not present* then we
+   default to using STDOUT to collect results, but if such a line *is
+   present* then we use it's value as the results of the block.  I
+   think this will allow for the most elegant specification between
+   functional and script execution.  This also cleans up some issues
+   of implementation and finding which statement is the last
+   statement.
+
+   Having given this more thought, I think a header argument is
+   preferable.  The =#+return:= line adds new complicating syntax for
+   something that does little more than we would accomplish through
+   the addition of a header argument.  The only benefit being that we
+   know where the final statement starts, which is not an issue in
+   those languages which contain 'last value' operators.
+
+   new header =:results= arguments
+   - script :: explicitly states that we want to use STDOUT to
+               initialize our results
+   - return_last :: stdout is ignored instead the *value* of the final
+                    statement in the block is returned
+   - echo :: means echo the contents of the source-code block along
+             with the results (this implies the *script* =:results=
+             argument as well)
+
+*** DONE rework evaluation lang-by-lang [4/4]
+
+This should include...
+- functional results working with the comint buffer
+- results headers
+  - script :: return the output of STDOUT
+    - write a macro which runs the first redirection, executes the
+      body, then runs the second redirection
+  - last :: return the value of the last statement
+    - 
+
+- sessions in comint buffers
+
+**** DONE Ruby [4/4]
+- [X] functional results working with comint
+- [X] script results
+- [X] ensure scalar/vector results args are taken into consideration
+- [X] ensure callable by other source block
+
+#+srcname: ruby-use-last-output
+#+begin_src ruby :results replace
+a = 2
+b = 4
+c = a + b
+[a, b, c, 78]
+#+end_src
+
+#+resname: ruby-use-last-output
+| 2 | 4 | 6 | 78 |
+
+#+srcname: task-call-use-last-output
+#+begin_src ruby :var last=ruby-use-last-output :results replace
+last.flatten.size + 1
+#+end_src
+
+#+resname: task-call-use-last-output
+: 5
+
+***** ruby sessions
+
+#+srcname: first-ruby-session-task
+#+begin_src ruby :session schulte :results silent
+schulte = 27
+#+end_src
+
+#+srcname: second-ruby-session-task
+#+begin_src ruby :session schulte :results silent
+schulte + 3
+#+end_src
+
+#+srcname: without-the-right-session
+#+begin_src ruby :results silent
+schulte
+#+end_src
+
+**** DONE R [4/4]
+
+- [X] functional results working with comint
+- [X] script results
+- [X] ensure scalar/vector results args are taken into consideration
+- [X] ensure callable by other source block
+
+To redirect output to a file, you can use the =sink()= command.
+
+#+srcname: task_R_B
+#+begin_src R :results value vector silent
+a <- 9
+b <- 10
+b - a
+a + b
+#+end_src
+
+#+srcname: task-R-use-other-output
+#+begin_src R :var twoentyseven=task_R_B() :results replace value
+83
+twoentyseven + 9
+#+end_src
+
+#+resname: task-R-use-other-output
+: 28
+
+**** DONE Python [4/4]
+- [X] functional results working with comint
+- [X] script results
+- [X] ensure scalar/vector results args are taken into consideration
+- [X] ensure callable by other source block
+
+#+srcname: task-new-eval-for-python
+#+begin_src python :results silent output scalar
+8
+9
+10
+#+end_src
+
+#+srcname: task-use-new-eval
+#+begin_src python :var tasking=task-new-eval-for-python() :results replace
+tasking + 2
+#+end_src
+
+#+resname: task-use-new-eval
+: 12
+
+**** DONE Shells [4/4]
+- [X] functional results working with comint
+- [X] script results
+- [X] ensure scalar/vector results args are taken into consideration
+- [X] ensure callable by other source block
+
+#+srcname: task-shell-new-evaluation
+#+begin_src sh :results silent value scalar
+echo 'eric'
+date
+#+end_src
+
+#+srcname: task-call-other-shell
+#+begin_src sh :var other=task-shell-new-evaluation() :results replace  scalar
+echo $other ' is the old date'
+#+end_src
+
+#+resname: task-call-other-shell
+: $ Fri Jun 12 13:08:37 PDT 2009  is the old date
+
+*** DONE implement a *session* header argument [4/4]
+=:session= header argument to override the default *session* buffer
+
+**** DONE ruby
+
+#+srcname: task-ruby-named-session
+#+begin_src ruby :session schulte :results replace
+schulte = :in_schulte
+#+end_src
+
+#+resname: task-ruby-named-session
+: :in_schulte
+
+#+srcname: another-in-schulte
+#+begin_src ruby :session schulte 
+schulte
+#+end_src
+
+#+resname: another-in-schulte
+: :in_schulte
+: :in_schulte
+: :in_schulte
+
+**** DONE python
+
+#+srcname: python-session-task
+#+begin_src python :session what :results silent
+what = 98
+#+end_src
+
+#+srcname: python-get-from-session
+#+begin_src python :session what :results replace
+what
+#+end_src
+
+#+resname: python-get-from-session
+: 98
+
+**** DONE shell
+
+#+srcname: task-shell-sessions
+#+begin_src sh :session what
+WHAT='patton'
+#+end_src
+
+#+srcname: task-shell-sessions-what
+#+begin_src sh :session what :results replace
+echo $WHAT
+#+end_src
+
+#+resname: task-shell-sessions-what
+: patton
+
+**** DONE R
+
+#+srcname: task-R-session
+#+begin_src R :session what :results replace
+a <- 9
+b <- 8
+a + b
+#+end_src
+
+#+resname: task-R-session
+: 17
+
+#+srcname: another-task-R-session
+#+begin_src R :session what :results replace
+a + b
+#+end_src
+
+*** DONE function to bring up inferior-process buffer [4/4]
+
+This should be callable from inside of a source-code block in an
+org-mode buffer.  It should evaluate the header arguments, then bring
+up the inf-proc buffer using =pop-to-buffer=.
+
+For lack of a better place, lets add this to the `org-metadown-hook'
+hook.
+
+To give this a try, place the cursor on a source block with variables,
+(optionally git a prefix argument) then hold meta and press down.
+
+**** DONE ruby
+
+#+srcname: task-ruby-pop-to-session
+#+begin_src ruby :var num=9 :var another="something else"
+num.times{|n| puts another}
+#+end_src
+
+**** DONE python
+
+#+srcname: task-python-pop-to-session
+#+begin_src python :var num=9 :var another="something else"
+another * num
+#+end_src
+**** DONE R
+
+#+srcname: task-R-pop-to-session
+#+begin_src R :var a=9 :var b=8
+a * b
+#+end_src
+
+**** DONE shell
+
+#+srcname: task-shell-pop-sessions
+#+begin_src sh :var NAME="eric"
+echo $NAME
+#+end_src
+
+*** DEFERRED function to dump last N lines from inf-proc buffer into the current source block
+
+Callable with a prefix argument to specify how many lines should be
+dumped into the source-code buffer.
+
+*** REJECTED comint notes
+
+Implementing comint integration in [[file:lisp/org-babel-comint.el][org-babel-comint.el]].
+
+Need to have...
+- handling of outputs
+  - split raw output from process by prompts
+  - a ring of the outputs, buffer-local, `org-babel-comint-output-ring'
+  - a switch for dumping all outputs to a buffer
+- inputting commands
+
+Lets drop all this language specific stuff, and just use
+org-babel-comint to split up our outputs, and return either the last
+value of an execution or the combination of values from the
+executions.
+
+**** comint filter functions
+: ;;  comint-input-filter-functions	hook	process-in-a-buffer
+: ;;  comint-output-filter-functions	hook	function modes.
+: ;;  comint-preoutput-filter-functions   hook
+: ;;  comint-input-filter			function ...
+
+#+srcname: obc-filter-ruby
+#+begin_src ruby :results last
+1
+2
+3
+4
+5
+#+end_src
+
+** DONE Remove protective commas from # comments before evaluating
+   org inserts protective commas in front of ## comments in language
+   modes that use them. We need to remove them prior to sending code
+   to the interpreter.
+
+#+srcname: testing-removal-of-protective-comas
+#+begin_src ruby
+,# this one might break it??
+:comma_protection
+#+end_src
+
+** DONE pass multiple reference arguments into R
+   Can we do this? I wasn't sure how to supply multiple 'var' header
+   args. Just delete this if I'm being dense.
+
+   This should be working, see the following example...
+
+#+srcname: two-arg-example
+#+begin_src R :var n=2 :var m=8
+n + m
+#+end_src
+
+#+resname: two-arg-example
+: 10
+
+** DONE ensure that table ranges work
+when a table range is passed to org-babel as an argument, it should be
+interpreted as a vector.
+
+| 1 | 2 | simple       |
+| 2 | 3 | Fixnum:1     |
+| 3 | 4 | Array:123456 |
+| 4 | 5 |              |
+| 5 | 6 |              |
+| 6 | 7 |              |
+#+TBLFM: @1$3='(sbe simple-sbe-example (n 4))::@2$3='(sbe task-table-range (n @1$1..@6$1))::@3$3='(sbe task-table-range (n (@1$1..@6$1)))
+
+#+srcname: simple-sbe-example
+#+begin_src emacs-lisp 
+"simple"
+#+end_src
+
+#+srcname: task-table-range
+#+begin_src ruby :var n=simple-sbe-example
+"#{n.class}:#{n}"
+#+end_src
+
+#+srcname: simple-results
+#+begin_src emacs-lisp :var n=task-table-range(n=(1 2 3))
+n
+#+end_src
+
+#+resname: simple-results
+: Array:123
+
+#+srcname: task-arr-referent
+#+begin_src ruby :var ar=(1 2 3)
+ar.size
+#+end_src
+
+#+resname: task-arr-referent
+: 3
+
+** DONE global variable indicating default to vector output
+how about an alist... =org-babel-default-header-args= this may already
+exist... just execute the following and all source blocks will default
+to vector output
+
+#+begin_src emacs-lisp 
+(setq org-babel-default-header-args '((:results . "vector")))
+#+end_src
+
+** DONE name named results if source block is named
+currently this isn't happening although it should be
+
+#+srcname: test-naming-named-source-blocks
+#+begin_src emacs-lisp 
+:namer
+#+end_src
+
+#+resname: test-naming-named-source-blocks
+: :namer
+** DONE (simple caching) check for named results before source blocks
+see the TODO comment in [[file:lisp/org-babel-ref.el::TODO%20This%20should%20explicitly%20look%20for%20resname%20lines%20before][org-babel-ref.el#org-babel-ref-resolve-reference]]
+** DONE set =:results silent= when eval with prefix argument
+
+#+begin_src emacs-lisp
+'silentp
+#+end_src
+** DONE results-type header (vector/file) [3/3]
+   In response to a point in Dan's email.  We should allow the user to
+   force scalar or vector results.  This could be done with a header
+   argument, and the default behavior could be controlled through a
+   configuration variable.
+   
+#+srcname: task-trivial-vector
+#+begin_src ruby :results replace vector
+:scalar
+#+end_src
+
+#+resname:
+| ":scalar" |
+
+   since it doesn't make sense to turn a vector into a scalar, lets
+   just add a two values...
+   
+   - vector :: forces the results to be a vector (potentially 1 dimensional)
+   - file :: this throws an error if the result isn't a string, and
+             tries to treat it as a path to a file.
+
+   I'm just going to cram all of these into the =:results= header
+   argument.  Then if we allow multiple header arguments it should
+   work out, for example one possible header argument string could be
+   =:results replace vector file=, which would *replace* any existing
+   results forcing the results into an org-mode table, and
+   interpreting any strings as file paths.
+
+*** DONE multiple =:results= headers
+
+#+srcname: multiple-result-headers
+#+begin_src ruby :results replace silent
+:schulte
+#+end_src
+
+#+resname:
+
+*** DONE file result types
+When inserting into an org-mode buffer create a link with the path
+being the value, and optionally the display being the
+=file-name-nondirectory= if it exists.
+
+#+srcname: task-file-result
+#+begin_src python :results replace file
+"something"
+#+end_src
+
+#+resname:
+[[something][something]]
+
+
+This will be useful because blocks like =ditaa= and =dot= can return
+the string path of their files, and can add =file= to their results
+header.
+
+*** DONE vector result types
+
+#+srcname: task-force-results
+#+begin_src emacs-lisp :results vector
+8
+#+end_src
+
+#+resname:
+| 8 |
+
+** DONE results name
+    In order to do this we will need to start naming our results.
+    Since the source blocks are named with =#+srcname:= lines we can
+    name results with =#+resname:= lines (if the source block has no
+    name then no name is given to the =#+resname:= line on creation,
+    otherwise the name of the source block is used).
+
+    This will have the additional benefit of allowing results and
+    source blocks to be located in different places in a buffer (and
+    eventually in different buffers entirely).
+
+#+srcname: developing-resnames
+#+begin_src emacs-lisp  :results silent
+'schulte
+#+end_src
+
+    Once source blocks are able to find their own =#+resname:= lines
+    we then need to...
+
+#+srcname: sbe-w-new-results
+#+begin_src emacs-lisp :results replace
+(sbe "developing-resnames")
+#+end_src
+
+#+resname:
+: schulte
+
+*** TODO change the results insertion functions to use these lines
+
+*** TODO teach references to resolve =#+resname= lines.
+
+** DONE org-babel tests org-babel [1/1]
+since we are accumulating this nice collection of source-code blocks
+in the sandbox section we should make use of them as unit tests.
+What's more, we should be able to actually use org-babel to run these
+tests.
+
+We would just need to cycle over every source code block under the
+sandbox, run it, and assert that the return value is equal to what we
+expect.
+
+I have the feeling that this should be possible using only org-babel
+functions with minimal or no additional elisp.  It would be very cool
+for org-babel to be able to test itself.
+
+This is now done, see [[* Tests]].
+
+*** DEFERRED org-babel assertions (may not be necessary)
+These could be used to make assertions about the results of a
+source-code block.  If the assertion fails then the point could be
+moved to the block, and error messages and highlighting etc... could
+ensue
+
+** DONE make C-c C-c work anywhere within source code block?
+   This seems like it would be nice to me, but perhaps it would be
+   inefficient or ugly in implementation? I suppose you could search
+   forward, and if you find #+end_src before you find #+begin_src,
+   then you're inside one. [DED]
+
+   Agreed, I think inside of the =#+srcname: line= would be useful as
+   well.
+
+#+srcname: testing-out-cc
+#+begin_src emacs-lisp
+'schulte
+#+end_src
+
+** DONE integration with org tables
+We should make it easy to call org-babel source blocks from org-mode
+table formulas.  This is practical now that it is possible to pass
+arguments to org-babel source blocks.
+
+See the related [[* (sandbox) integration w/org tables][sandbox]] header for tests/examples.
+
+*** digging in org-table.el
+In the past [[file:~/src/org/lisp/org-table.el::org%20table%20el%20The%20table%20editor%20for%20Org%20mode][org-table.el]] has proven difficult to work with.
+
+Should be a hook in [[file:~/src/org/lisp/org-table.el::defun%20org%20table%20eval%20formula%20optional%20arg%20equation][org-table-eval-formula]].
+
+Looks like I need to change this [[file:~/src/org/lisp/org-table.el::if%20lispp][if statement]] (line 2239) into a cond
+expression.
+
+** DONE source blocks as functions
+
+Allow source code blocks to be called like functions, with arguments
+specified.  We are already able to call a source-code block and assign
+it's return result to a variable.  This would just add the ability to
+specify the values of the arguments to the source code block assuming
+any exist.  For an example see 
+
+When a variable appears in a header argument, how do we differentiate
+between it's value being a reference or a literal value?  I guess this
+could work just like a programming language.  If it's escaped or in
+quotes, then we count it as a literal, otherwise we try to look it up
+and evaluate it.
+
+** DONE folding of code blocks? [2/2]
+   [DED] In similar way to using outline-minor-mode for folding function
+   bodies, can we fold code blocks?  #+begin whatever statements are
+   pretty ugly, and in any case when you're thinking about the overall
+   game plan you don't necessarily want to see the code for each Step.
+
+*** DONE folding of source code block
+    Sounds good, and wasn't too hard to implement.  Code blocks should
+    now be fold-able in the same manner as headlines (by pressing TAB
+    on the first line).
+
+*** REJECTED folding of results
+    So, lets do a three-stage tab cycle... First fold the src block,
+    then fold the results, then unfold.
+    
+    There's no way to tell if the results are a table or not w/o
+    actually executing the block which would be too expensive of an
+    operation.
+
+** DONE selective export of text, code, figures
+   [DED] The org-babel buffer contains everything (code, headings and
+   notes/prose describing what you're up to, textual/numeric/graphical
+   code output, etc). However on export to html / LaTeX one might want
+   to include only a subset of that content. For example you might
+   want to create a presentation of what you've done which omits the
+   code.
+
+   [EMS] So I think this should be implemented as a property which can
+   be set globally or on the outline header level (I need to review
+   the mechanics of org-mode properties).  And then as a source block
+   header argument which will apply only to a specific source code
+   block.  A header argument of =:export= with values of
+   
+   - =code= :: just show the code in the source code block
+   - =none= :: don't show the code or the results of the evaluation
+   - =results= :: just show the results of the code evaluation (don't
+                  show the actual code)
+   - =both= :: show both the source code, and the results
+
+this will be done in [[* (sandbox) selective export][(sandbox) selective export]].
+
+** DONE a header argument specifying silent evaluation (no output)
+This would be useful across all types of source block.  Currently
+there is a =:replace t= option to control output, this could be
+generalized to an =:output= option which could take the following
+options (maybe more)
+
+- =t= :: this would be the default, and would simply insert the
+         results after the source block
+- =replace= :: to replace any results which may already be there
+- =silent= :: this would inhibit any insertion of the results
+
+This is now implemented see the example in the [[* silent evaluation][sandbox]]
+
+** DONE assign variables from tables in R
+This is now working (see [[* (sandbox table) R][(sandbox-table)-R]]).  Although it's not that
+impressive until we are able to print table results from R.
+
+** DONE insert 2-D R results as tables
+everything is working but R and shell
+
+*** DONE shells
+
+*** DONE R
+
+This has already been tackled by Dan in [[file:existing_tools/org-R.el::defconst%20org%20R%20write%20org%20table%20def][org-R:check-dimensions]].  The
+functions there should be useful in combination with [[http://cran.r-project.org/doc/manuals/R-data.html#Export-to-text-files][R-export-to-csv]]
+as a means of converting multidimensional R objects to emacs lisp.
+
+It may be as simple as first checking if the data is multidimensional,
+and then, if so using =write= to write the data out to a temporary
+file from which emacs can read the data in using =org-table-import=.
+
+Looking into this further, is seems that there is no such thing as a
+scalar in R [[http://tolstoy.newcastle.edu.au/R/help/03a/3733.html][R-scalar-vs-vector]]  In that light I am not sure how to
+deal with trivial vectors (scalars) in R.  I'm tempted to just treat
+them as vectors, but then that would lead to a proliferation of
+trivial 1-cell tables...
+
+** DONE allow variable initialization from source blocks
+Currently it is possible to initialize a variable from an org-mode
+table with a block argument like =table=sandbox= (note that the
+variable doesn't have to named =table=) as in the following example
+
+#+TBLNAME: sandbox
+| 1 |       2 | 3 |
+| 4 | schulte | 6 |
+
+#+begin_src emacs-lisp :var table=sandbox :results replace
+(message (format "table = %S" table))
+#+end_src
+
+: "table = ((1 2 3) (4 \"schulte\" 6))"
+
+It would be good to allow initialization of variables from the results
+of other source blocks in the same manner.  This would probably
+require the addition of =#+SRCNAME: example= lines for the naming of
+source blocks, also the =table=sandbox= syntax may have to be expanded
+to specify whether the target is a source code block or a table
+(alternately we could just match the first one with the given name
+whether it's a table or a source code block).
+
+At least initially I'll try to implement this so that there is no need
+to specify whether the reference is to a table or a source-code block.
+That seems to be simpler both in terms of use and implementation.
+
+This is now working for emacs-lisp, ruby and python (and mixtures of
+the three) source blocks.  See the examples in the [[* (sandbox) referencing other source blocks][sandbox]].
+
+This is currently working only with emacs lisp as in the following
+example in the [[* emacs lisp source reference][emacs lisp source reference]].
+
+
+** TODO Add languages [11/16]
+I'm sure there are many more that aren't listed here.  Please add
+them, and bubble any that you particularly care about up to the top.
+
+Any new language should be implemented in a org-babel-lang.el file.
+Follow the pattern set by [[file:lisp/org-babel-script.el][org-babel-script.el]], [[file:lisp/org-babel-shell.el][org-babel-shell.el]] and
+[[file:lisp/org-babel-R.el][org-babel-R.el]].
+
+*** STARTED Haskell
+#+begin_src haskell
+"hello Haskell"
+#+end_src
+
+#+resname:
+: hello Haskell
+
+#+begin_src haskell
+  let fac n = if n == 0 then 1 else n * fac (n - 1)
+  fac 4
+#+end_src
+
+#+resname:
+: 24
+
+#+begin_src haskell
+[1, 2, 3, 4, 5]
+#+end_src
+
+#+resname:
+| 1 | 2 | 3 | 4 | 5 |
+
+**** allow non-interactive evaluation
+
+*** STARTED ocaml [2/3]
+
+- [X] Working for the simple case (no arguments, simple output)
+- [X] correct handling of vector/list output
+- [ ] ability to import arguments
+
+#+begin_src ocaml
+let rec fib x =
+  match x with
+    | 0 -> 1
+    | 1 -> 1
+    | n -> fib(n - 1) + fib(n - 2) in
+  fib 12
+#+end_src
+
+#+resname:
+: 233
+
+#+begin_src ocaml
+"string"
+#+end_src
+
+#+resname:
+: "string"
+
+#+begin_src ocaml
+[1; 2; 3; 4]
+#+end_src
+
+#+resname:
+| 1 | 2 | 3 | 4 |
+
+#+begin_src ocaml
+[|"ocaml"; "array"|]
+#+end_src
+
+#+resname:
+| "ocaml" | "array" |
+
+*** TODO perl
+This could probably be added to [[file:lisp/org-babel-script.el][org-babel-script.el]]
+*** TODO java
+*** STARTED SQL
+Things left to do
+- support for sessions
+- add more useful header arguments (user, passwd, database, etc...)
+- support for more engines (currently only supports mysql)
+- what's a reasonable way to drop table data into SQL?
+
+#+srcname: sql-example
+#+begin_src sql :engine mysql
+  show databases
+#+end_src
+
+#+resname:
+| "Database"           |
+| "information_schema" |
+| "test"               |
+
+*** DONE SASS
+Sass is a very nice extension of CSS, which is much nicer to read and
+write (see [[http://sass-lang.com/][sass-lang]]).
+
+#+srcname: sass-example
+#+begin_src sass :file stylesheet.css :results file
+  #me
+    position: absolute
+    top: 1em
+    left: 1em
+    .head
+      text-align: center
+#+end_src
+
+#+resname:
+[[file:stylesheet.css][stylesheet.css]]
+
+*** DONE CSS
+trivial [[file:lisp/langs/org-babel-css.el][org-babel-css.el]]
+
+*** DONE ditaa
+(see [[* file result types][file result types]])
+
+#+srcname: implementing-ditaa
+#+begin_src ditaa :results replace :file blue.png :cmdline -r
++---------+
+| cBLU    |
+|         |
+|    +----+
+|    |cPNK|
+|    |    |
++----+----+
+#+end_src
+
+#+resname: implementing-ditaa
+[[file:blue.png][blue.png]]
+
+*** DONE gnuplot [7/7]
+(see [[* file result types][file result types]])
+
+#+PLOT: title:"Citas" ind:1 deps:(3) type:2d with:histograms set:"yrange [0:]"
+#+TBLNAME: gnuplot-data
+| independent var | first dependent var | second dependent var |
+|-----------------+---------------------+----------------------|
+|             0.1 |               0.425 |                0.375 |
+|             0.2 |              0.3125 |               0.3375 |
+|             0.3 |          0.24999993 |           0.28333338 |
+|             0.4 |               0.275 |              0.28125 |
+|             0.5 |                0.26 |                 0.27 |
+|             0.6 |          0.25833338 |           0.24999993 |
+|             0.7 |          0.24642845 |           0.23928553 |
+|             0.8 |             0.23125 |               0.2375 |
+|             0.9 |          0.23333323 |            0.2333332 |
+|               1 |              0.2225 |                 0.22 |
+|             1.1 |          0.20909075 |           0.22272708 |
+|             1.2 |          0.19999998 |           0.21458333 |
+|             1.3 |          0.19615368 |           0.21730748 |
+
+#+srcname: implementing-gnuplot
+#+begin_src gnuplot :var data=gnuplot-data :results silent
+set title "Implementing Gnuplot"
+plot data using 1:2 with lines
+#+end_src
+
+**** DONE add variables
+     gnuplot 4.2 and up support user defined variables.  This is how
+     we will handle variables with org-babel (meaning we will need to
+     require gnuplot 4.2 and up for variable support, which can be
+     install using [[http://www.macports.org/install.php][macports]] on Mac OSX).
+
+     - scalar variables should be replaced in the body of the gnuplot code
+     - vector variables should be exported to tab-separated files, and
+       the variable names should be replaced with the path to the files
+
+**** DONE direct plotting w/o session
+**** DEFERRED gnuplot support for column/row names
+This should be implemented along the lines of the [[* STARTED Column (and row) names of tables in R input/output][R-colname-support]].
+
+We can do something similar to the :labels param in org-plot, we just
+have to be careful to ensure that each label is aligned with the
+related data file.
+
+This may be walking too close to an entirely prebuilt plotting tool
+rather than straight gnuplot code evaluation.  For now I think this
+can wait.
+
+**** DONE a =file= header argument
+to specify a file holding the results
+
+#+srcname: gnuplot-to-file-implementation
+#+begin_src gnuplot :file plot.png :var data=gnuplot-data
+plot data using 1:2, data using 1:3 with lines
+#+end_src
+
+#+resname:
+[[file:plot.png][plot.png]]
+
+**** DONE helpers from org-plot.el
+There are a variety of helpers in org-plot which can be fit nicely
+into custom gnuplot header arguments.
+
+These should all be in place by now.
+
+**** DEFERRED header argument specifying 3D data
+
+#+tblname: org-grid
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+| 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 |
+| 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 |
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+
+#+srcname: implementing-gnuplot-grid-plots
+#+begin_src gnuplot :vars data=org-grid
+
+#+end_src
+
+**** DONE gnuplot sessions
+Working on this, we won't support multiple sessions as `gnuplot-mode'
+isn't setup for such things.
+
+Also we can't display results with the default :none session, so for
+gnuplot we really want the default behavior to be :default, and to
+only run a :none session when explicitly specified.
+
+#+srcname: implementing-gnuplot-sessions
+#+begin_src gnuplot :var data=gnuplot-data :session none :file session.png
+set title "Implementing Gnuplot Sessions"
+plot data using 1:2 with lines
+#+end_src
+
+#+resname:
+[[file:session.png][session.png]]
+
+*** DONE dot
+(see [[* file result types][file result types]])
+
+#+srcname: implementing-dot-support
+#+begin_src dot :file test-dot.png :cmdline -Tpng
+digraph data_relationships {
+  "data_requirement" [shape=Mrecord, label="{DataRequirement|description\lformat\l}"]
+  "data_product" [shape=Mrecord, label="{DataProduct|name\lversion\lpoc\lformat\l}"]
+  "data_requirement" -> "data_product"
+}
+#+end_src
+
+#+resname:
+[[file:test-dot.png][test-dot.png]]
+
+*** DONE asymptote
+(see [[* file result types][file result types]])
+
+for information on asymptote see http://asymptote.sourceforge.net
+
+#+begin_src asymptote :file asymptote-test.png
+import graph;
+
+size(0,4cm);
+
+real f(real t) {return 1+cos(t);}
+
+path g=polargraph(f,0,2pi,operator ..)--cycle;
+filldraw(g,pink);
+
+xaxis("$x$",above=true);
+yaxis("$y$",above=true);
+
+dot("$(a,0)$",(1,0),N);
+dot("$(2a,0)$",(2,0),N+E);
+#+end_src
+
+#+resname:
+[[file:asymptote-test.png][asymptote-test.png]]
+
+*** DONE ruby
+*** DONE python
+*** DONE R
+*** DONE emacs-lisp
+*** DONE sh
+
+
+* Bugs [39/44]
+** TODO blank srcname takes srcname from next line
+#+srcname: 
+#+begin_src R :session *R*
+5
+#+end_src
+
+#+resname: #+begin_src
+: 5
+
+** DONE stripping indentation from source-code blocks
+This is a problem in [[file:lisp/org-babel-exp.el][org-babel-exp.el]].
+
+** DONE failing to write srcname to resname when evaluating a named block
+
+#+srcname: please-name-my-result
+#+begin_src emacs-lisp 
+"I'm the result"
+#+end_src
+
+#+resname: please-name-my-result
+: I'm the result
+
+** DONE Python session evaluation bug
+   The following block evaluates correctly with :session none
+   (set :results to output), but fails with session-based evaluation
+   (with :results value, as below, you see the error message)
+
+   I edebug'ed it and it seems fine until [[file:lisp/langs/org-babel-python.el::comint%20session%20evaluation%20org%20babel%20comint%20in%20buffer%20buffer%20let%20full%20body][we go to comint]].
+
+#+begin_src python :session pysession :results value
+  import os
+  from subprocess import *
+  
+  chunk = 10000
+  format = '.gen.gz'
+  
+  cc = [('58C','NBS'),
+        ('58C','POBI'),
+        ('NBS','POBI')]
+  
+  for outdir in ['none', 'noscots', 'lax', 'strict']:
+      outdir = os.path.join('exclusion-study', outdir)
+      for case, control in cc:
+          outfile = os.path.join(outdir, '%s-vs-%s-direct' % (case, control))
+          cmd = 'snptest %s -frequentist 1 -hwe ' % ('-gen_gz' if format == '.gen.gz' else '')
+          cmd += '-cases %s %s ' % (case + format, case + '.sample')
+
+          cmd += '-controls %s %s ' % (control + format, control + '.sample')
+          cmd += '-exclude_samples %s ' % os.path.join(outdir, 'exclusions')
+          cmd += '-o %s ' % outfile
+          cmd += '-chunk %d ' % chunk
+          cmd += '> %s' % outfile + '.log'
+          # os.system(cmd)
+          print(cmd)
+#+end_src
+
+#+resname:
+#+begin_example
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls NBS.gen.gz NBS.sample -exclude_samples exclusion-study/none/exclusions -o exclusion-study/none/58C-vs-NBS-direct -chunk 10000 > exclusion-study/none/58C-vs-NBS-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/none/exclusions -o exclusion-study/none/58C-vs-POBI-direct -chunk 10000 > exclusion-study/none/58C-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases NBS.gen.gz NBS.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/none/exclusions -o exclusion-study/none/NBS-vs-POBI-direct -chunk 10000 > exclusion-study/none/NBS-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls NBS.gen.gz NBS.sample -exclude_samples exclusion-study/noscots/exclusions -o exclusion-study/noscots/58C-vs-NBS-direct -chunk 10000 > exclusion-study/noscots/58C-vs-NBS-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/noscots/exclusions -o exclusion-study/noscots/58C-vs-POBI-direct -chunk 10000 > exclusion-study/noscots/58C-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases NBS.gen.gz NBS.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/noscots/exclusions -o exclusion-study/noscots/NBS-vs-POBI-direct -chunk 10000 > exclusion-study/noscots/NBS-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls NBS.gen.gz NBS.sample -exclude_samples exclusion-study/lax/exclusions -o exclusion-study/lax/58C-vs-NBS-direct -chunk 10000 > exclusion-study/lax/58C-vs-NBS-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/lax/exclusions -o exclusion-study/lax/58C-vs-POBI-direct -chunk 10000 > exclusion-study/lax/58C-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases NBS.gen.gz NBS.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/lax/exclusions -o exclusion-study/lax/NBS-vs-POBI-direct -chunk 10000 > exclusion-study/lax/NBS-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls NBS.gen.gz NBS.sample -exclude_samples exclusion-study/strict/exclusions -o exclusion-study/strict/58C-vs-NBS-direct -chunk 10000 > exclusion-study/strict/58C-vs-NBS-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases 58C.gen.gz 58C.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/strict/exclusions -o exclusion-study/strict/58C-vs-POBI-direct -chunk 10000 > exclusion-study/strict/58C-vs-POBI-direct.log
+snptest -gen_gz -frequentist 1 -hwe -cases NBS.gen.gz NBS.sample -controls POBI.gen.gz POBI.sample -exclude_samples exclusion-study/strict/exclusions -o exclusion-study/strict/NBS-vs-POBI-direct -chunk 10000 > exclusion-study/strict/NBS-vs-POBI-direct.log
+#+end_example
+
+** DONE require users to explicitly turn on each language
+As we continue to add more languages to org-babel, many of which will
+require new major-modes we need to re-think how languages are added to
+org-babel.
+
+Currently we are requiring all available languages in the
+[[file:lisp/org-babel-init.el][org-babel-init.el]] file.  I think we need to change this to a user
+setting so that only the language which have their requirements met
+(in terms of system executables and emacs major modes) are loaded.  It
+is one more step for install, but it seems to me to be the only
+solution.  Thoughts?
+
+*** proposed
+
+we add something like the following to the instillation instructions  
+
+#+begin_src emacs-lisp
+;; Uncomment each of the following require lines if you want org-babel
+;; to support that language.  Each language has a comment explaining
+;; it's dependencies.  See the related files in lisp/langs for more
+;; detailed explanations of requirements.
+;; 
+;; (require 'org-babel-R)         ;; ess-mode
+;; (require 'org-babel-asymptote) ;; asymptote be installed on your system
+;; (require 'org-babel-css)       ;; none
+;; (require 'org-babel-ditaa)     ;; ditaa be installed on your system
+;; (require 'org-babel-dot)       ;; dot be installed on your system
+;; (require 'org-babel-gnuplot)   ;; gnuplot-mode
+;; (require 'org-babel-python)    ;; python-mode
+;; (require 'org-babel-ruby)      ;; inf-ruby mode, ruby and irb must be installed on your system
+;; (require 'org-babel-sql)       ;; none
+#+end_src
+
+note that =org-babel-sh=, =org-babel-emacs-lisp= are not included in
+the list as they can safely be assumed to work on any system.
+
+*** impetus
+we should come up with a way to gracefully degrade when support for a
+specific language is missing
+
+> To demonstrate creation of documents, open the "test-export.org" file in
+> the base of the org-babel directory, and export it as you would any
+> other org-mode file.  The "exports" header argument controls how
+> source-code blocks are exported, with the following options
+>
+> - none :: no part of the source-code block is exported in the document
+> - results :: only the output of the evaluated block is exported
+> - code :: the code itself is exported
+> - both :: both the code and results are exported
+
+I have this error showing up:
+
+executing Ruby source code block
+apply: Searching for program: no such file or directory, irb
+
+** DONE problem with newlines in output when :results value
+
+#+begin_src python :results value
+'\n'.join(map(str, range(4)))
+#+end_src
+
+#+resname:
+: 0
+: 1
+: 2
+: 3
+
+Whereas I was hoping for
+
+| 0 |
+| 1 |
+| 2 |
+| 3 |
+
+*Note*: to generate the above you can try using the new =raw= results
+header.
+
+#+begin_src python :results value raw
+'|'+'|\n|'.join(map(str, range(4)))+'|'
+#+end_src
+
+#+resname:
+| 0 |
+| 1 |
+| 2 |
+| 3 |
+
+This is now working, it doesn't return as a table because the value
+returned is technically a string.  To return the table mentioned above
+try something like the following.
+
+#+begin_src python
+[[0], [1], [2], [3]]
+#+end_src
+
+#+resname:
+| 0 |
+| 1 |
+| 2 |
+| 3 |
+
+This is some sort of non-printing char / quoting issue I think. Note
+that
+
+#+begin_src python :results value
+'\\n'.join(map(str, range(4)))
+#+end_src
+
+#+resname:
+: 0\n1\n2\n3
+
+Also, note that
+#+begin_src python :results output
+print('\n'.join(map(str, range(4))))
+#+end_src
+
+#+resname:
+: 0
+: 1
+: 2
+: 3
+
+*** collapsing consecutive newlines in string output
+    
+    This is an example of the same bug
+
+#+srcname: multi-line-string-output
+#+begin_src ruby :results output
+"the first line ends here
+
+
+     and this is the second one
+
+even a third"
+#+end_src
+
+This doesn't produce anything at all now. I believe that's because
+I've changed things so that :results output really does *not* get the
+value of the block, only the STDOUT. So if we add a print statement
+this works OK.
+
+#+srcname: multi-line-string-output
+#+begin_src ruby :results output
+print "the first line ends here
+
+
+     and this is the second one
+
+even a third"
+#+end_src
+
+#+resname:
+: the first line ends here
+: 
+: 
+:      and this is the second one
+: 
+: even a third
+
+However, the behaviour with :results value is wrong
+
+#+srcname: multi-line-string-value
+#+begin_src ruby
+"the first line ends here
+
+
+     and this is the second one
+
+even a third"
+#+end_src
+
+#+resname:
+: 0
+
+** TODO prompt characters appearing in output with R
+#+begin_src R :session *R* :results output
+  x <- 6
+  y <- 8
+  3
+#+end_src      
+
+#+resname:
+: > [1] 3
+
+** TODO o-b-execute-subtree overwrites heading when subtree is folded
+*** Example
+    Try M-x org-babel-execute-subtree with the subtree folded and
+    point at the beginning of the heading line.
+#+begin_src sh
+size=5
+#+end_src
+** DONE non-orgtbl formatted lists
+for example
+
+#+srcname: this-doesn't-match-orgtbl
+#+begin_src emacs-lisp :results replace
+'((:results . "replace"))
+#+end_src
+
+#+resname:
+| (:results . "replace") |
+
+#+srcname: this-probably-also-wont-work
+#+begin_src emacs-lisp :results replace
+'(eric schulte)
+#+end_src
+
+#+resname:
+| eric | schulte |
+
+** PROPOSED allow un-named arguments
+
+#+srcname: f(x)
+#+begin_src python 
+x
+#+end_src
+
+#+lob: f(5)
+
+## produces no output
+
+ It's not essential but would be nice for this to work. To do it
+properly, would mean that we'd have to specify rules for how a string
+of supplied arguments (some possibly named) interact with the
+arguments in the definition (some possibly with defaults) to give
+values to the variables in the funbction body.
+** PROPOSED external shell execution can't isolate return values
+I have no idea how to do this as of yet.  The result is that when
+shell functions are run w/o a session there is no difference between
+the =output= and =value= result arguments.
+
+Yea, I don't know how to do this either.  I searched extensively on
+how to isolate the *last* output of a series of shell commands (see
+[[* last command for
+ shells][last command for shells]]).  The results of the search were basically
+that it was not possible (or at least not accomplish-able with a
+reasonable amount of effort).
+
+That fact combined with the tenancy to all ways use standard out in
+shell scripts led me to treat these two options (=output= and =value=)
+as identical in shell evaluation.  Not ideal but maybe good enough for
+the moment.
+
+In the `results' branch I've changed this so that they're not quite
+identical: output results in raw stdout contents, whereas value
+converts it to elisp, perhaps to a table if it looks tabular. This is
+the same for the other languages. [Dan]
+   
+** DONE adding blank line when source-block produces no output
+
+#+srcname: show-org-babel-trim
+#+begin_src sh
+find . \( -path \*/SCCS -o -path \*/RCS -o -path \*/CVS -o -path \*/MCVS -o -path \*/.svn -o -path \*/.git -o -path \*/.hg -o -path \*/.bzr -o -path \*/_MTN -o -path \*/_darcs -o -path \*/\{arch\} \) -prune -o  -type f \( -iname \*.el \) -exec grep -i -nH -e org-babel-trim {} \;
+#+end_src
+
+** DONE Allow source blocks to be recognised when #+ are not first characters on the line
+   I think Carsten has recently altered the core so that #+ can have
+   preceding whitespace, at least for literal/code examples. org-babel
+   should support this.
+
+#+srcname: testing-indentation
+   #+begin_src emacs-lisp :results silent
+   (message "i'm indented")
+   #+end_src
+
+#+srcname: testing-non-indentation
+#+begin_src emacs-lisp :results silent
+(message "I'm not indented")
+#+end_src
+
+#+srcname: i-resolve-references-to-the-indented
+#+begin_src emacs-lisp :var speech=testing-indentation :results silent
+(message "I said %s" speech)
+#+end_src
+
+** DONE are the org-babel-trim s necessary?
+   at the end of e.g. org-babel-R-evaluate, org-babel-python-evaluate, but
+   not org-babel-ruby-evaluate
+   
+   I think it depends on the language, if we find that extra blank
+   lines are being inserted in a particular language that is a good
+   indication that the trim or chomp functions may be appropriate.
+
+   org-babel-trim and the related org-babel-chomp are use throughout
+   org-babel...
+
+#+srcname: show-org-babel-trim-usage
+#+begin_src sh :results output
+find lisp/ \( -path \*/SCCS -o -path \*/RCS -o -path \*/CVS -o -path \*/MCVS -o -path \*/.svn -o -path \*/.git -o -path \*/.hg -o -path \*/.bzr -o -path \*/_MTN -o -path \*/_darcs -o -path \*/\{arch\} \) -prune -o  -type f \( -iname \*.el \) -exec grep -i -nH org-babel-trim {} \;
+#+end_src
+
+#+resname:
+#+begin_example
+lisp//langs/org-babel-python.el:49:		     vars "\n") "\n" (org-babel-trim body) "\n")) ;; then the source block body
+lisp//langs/org-babel-python.el:143:			       (org-remove-indentation (org-babel-trim body)) "[\r\n]")))
+lisp//langs/org-babel-python.el:158:	       #'org-babel-trim
+lisp//langs/org-babel-python.el:166:                                           (reverse (mapcar #'org-babel-trim raw)))))))
+lisp//langs/org-babel-python.el:169:	  (output (org-babel-trim (mapconcat #'identity (reverse (cdr results)) "\n")))
+lisp//langs/org-babel-python.el:170:	  (value (org-babel-python-table-or-string (org-babel-trim (car results)))))))))
+lisp//langs/org-babel-ruby.el:149:                                                  (mapcar #'org-babel-trim raw)))))))
+lisp//langs/org-babel-sh.el:148:                                                  (mapcar #'org-babel-trim raw)))))))
+lisp//langs/org-babel-sh.el:151:            (output (org-babel-trim (mapconcat #'org-babel-trim (reverse results) "\n")))
+lisp//org-babel-ref.el:161:    (mapcar #'org-babel-trim (reverse (cons buffer return)))))
+lisp//org-babel.el:198:    (with-temp-buffer (insert (org-babel-trim body)) (copy-region-as-kill (point-min) (point-max)))
+lisp//org-babel.el:465:           (org-babel-trim
+lisp//org-babel.el:706:(defun org-babel-trim (string &optional regexp)
+#+end_example
+
+#+srcname: show-org-babel-chomp-usage
+#+begin_src sh :results output
+find lisp/ \( -path \*/SCCS -o -path \*/RCS -o -path \*/CVS -o -path \*/MCVS -o -path \*/.svn -o -path \*/.git -o -path \*/.hg -o -path \*/.bzr -o -path \*/_MTN -o -path \*/_darcs -o -path \*/\{arch\} \) -prune -o  -type f \( -iname \*.el \) -exec grep -i -nH org-babel-chomp {} \;
+#+end_src
+
+#+resname:
+#+begin_example
+lisp//langs/org-babel-R.el:122:             (full-body (mapconcat #'org-babel-chomp
+lisp//langs/org-babel-R.el:143:	      (delete nil (mapcar #'extractor (mapcar #'org-babel-chomp raw))) "\n"))))))))
+lisp//langs/org-babel-ruby.el:143:	     #'org-babel-chomp
+lisp//langs/org-babel-sh.el:142:	   (full-body (mapconcat #'org-babel-chomp
+lisp//org-babel-tangle.el:163:      (insert (format "\n%s\n" (org-babel-chomp body)))
+lisp//org-babel.el:362:			 (org-babel-chomp (match-string 2 arg)))
+lisp//org-babel.el:698:(defun org-babel-chomp (string &optional regexp)
+lisp//org-babel.el:707:  "Like `org-babel-chomp' only it runs on both the front and back of the string"
+lisp//org-babel.el:708:  (org-babel-chomp (org-babel-reverse-string
+lisp//org-babel.el:709:                    (org-babel-chomp (org-babel-reverse-string string) regexp)) regexp))
+#+end_example
+
+** DONE LoB is not populated on startup
+   org-babel-library-of-babel is nil for me on startup. I have to
+   evaluate the [[file:lisp/org-babel-lob.el::][org-babel-lob-ingest]] line manually.
+
+#+tblname: R-plot-example-data
+| 1 |  2 |
+| 2 |  4 |
+| 3 |  9 |
+| 4 | 16 |
+| 5 | 25 |
+
+#+lob: R-plot(data=R-plot-example-data)
+
+
+
+   I've added a section to [[file:lisp/org-babel-init.el][org-babel-init.el]] which will load the
+   library of babel on startup.
+
+   Note that this needs to be done in [[file:lisp/org-babel-init.el][org-babel-init.el]] rather than in
+   [[file:lisp/org-babel-lob.el][org-babel-lob.el]], not entirely sure why, something about it being
+   required directly?
+
+   Also, I'm now having the file closed if it wasn't being visited by
+   a buffer before being loaded.
+
+** DONE use new merge function [[file:lisp/org-babel-ref.el::t%20nil%20org%20combine%20plists%20args%20nil][here]]?
+   And at other occurrences of org-combine-plists?
+** DONE creeping blank lines
+   There's still inappropriate addition of blank lines in some circumstances. 
+
+   Hmm, it's a bit confusing. It's to do with o-b-remove-result. LoB
+   removes the entire (#+resname and result) and starts from scratch,
+   whereas #+begin_src only removes the result. I haven't worked out
+   what the correct fix is yet. Maybe the right thing to do is to make
+   sure that those functions (o-b-remove-result et al.) are neutral
+   with respect to newlines. Sounds easy, but...
+
+   E.g.
+
+#+begin_src sh
+b=5
+#+end_src
+
+
+
+   Compare the results of
+#+lob: adder(a=5, b=17)
+
+#+resname: python-add(a=5, b=17)
+: 22
+--------------------------------
+
+#+begin_src python
+23
+#+end_src
+
+#+resname:
+: 23
+---------------------
+** DONE #+srcname arg parsing bug
+#+srcname: test-zz(arg=adder(a=1, b=1))
+#+begin_src python 
+arg
+#+end_src
+
+#+resname: test-zz
+: 2
+
+
+#+srcname: test-zz-nasty(arg=adder(a=adder(a=19,b=adder(a=5,b=2)),b=adder(a=adder(a=1,b=9),b=adder(a=1,b=3))))
+#+begin_src python 
+arg
+#+end_src
+
+#+resname: test-zz-nasty
+: 40
+
+
+
+#+srcname: test-zz-hdr-arg
+#+begin_src python :var arg=adder(a=adder(a=19,b=adder(a=5,b=2)),b=adder(a=adder(a=1,b=9),b=adder(a=1,b=3)))
+arg
+#+end_src
+
+#+resname:
+: 40
+
+** DONE Fix nested evaluation and default args
+   The current parser / evaluator fails with greater levels of nested
+   function block calls (example below).
+
+*** Initial statement [ded]
+    If we want to overcome this I think we'd have to redesign some of
+    the evaluation mechanism. Seeing as we are also facing issues like
+    dealing with default argument values, and seeing as we now know
+    how we want the library of babel to behave in addition to the
+    source blocks, now might be a good time to think about this. It
+    would be nice to do the full thing at some point, but otoh we may
+    not consider it a massive priority.
+    
+    AIui, there are two stages: (i) construct a parse tree, and (ii)
+    evaluate it and return the value at the root. In the parse tree
+    each node represents an unevaluated value (either a literal value
+    or a reference). Node v may have descendent nodes, which represent
+    values upon which node v's evaluation depends. Once that tree is
+    constructed, then we evaluate the nodes from the tips towards the
+    root (a post-order traversal).
+
+    [This would also provide a solution for concatenating the STDOUTs
+    of called blocks, which is a [[*allow%20output%20mode%20to%20return%20stdout%20as%20value][task below]]; we concatenate them in
+    whatever order the traversal is done in.]
+
+    In addition to the variable references (i.e. daughter nodes), each
+    node would contain the information needed to evaluate that node
+    (e.g. lang body). Then we would pass a function postorder over the
+    tree which would call o-b-execute-src-block at each node, finally
+    returning the value at the root.
+
+    Fwiw I made a very tentative small start at stubbing this out in
+    org-babel-call.el in the 'evaluation' branch. And I've made a start
+    at sketching a parsing algorithm below.
+**** Parse tree algorithm
+    Seeing as we're just trying to parse a string like
+    f(a=1,b=g(c=2,d=3)) it shouldn't be too hard. But of course there
+    are 'proper' parsers written in elisp out there,
+    e.g. [[http://cedet.sourceforge.net/semantic.shtml][Semantic]]. Perhaps we can find what we need -- our syntax is
+    pretty much the same as python and R isn't it?
+
+    Or, a complete hack, but maybe it would be we easy to transform it
+    to XML and then parse that with some existing tool?
+    
+    But if we're doing it ourselves, something very vaguely like this?
+    (I'm sure there're lots of problems with this)
+
+#+srcname: org-babel-call-parse(call)
+#+begin_src python 
+  ## we are currently reading a reference name: the name of the root function
+  whereami = "refname"
+  node = root = Node()
+  for c in call_string:
+      if c == '(':
+          varnum = 0
+          whereami = "varname" # now we're reading a variable name
+      if c == '=':
+          new = Node()
+          node.daughters = [node.daughters, new]
+          new.parent = node
+          node = new
+          whereami = "refname"
+      if c == ',':
+          whereami = "varname"
+          varnum += 1
+      elif c == ')':
+          node = node.parent
+      elif c == ' ':
+          pass
+      else:
+          if whereami = "varname":
+              node.varnames[varnum] += c
+          elif whereami = "refname":
+              node.name += c
+#+end_src
+    
+*** discussion / investigation
+I believe that this issue should be addressed as a bug rather than as
+a point for new development.   The code in [[file:lisp/org-babel-ref.el][org-babel-ref.el]] already
+resolves variable references in a recursive manner which *should* work
+in the same manner regardless of the depth of the number of nested
+function calls.  This recursive evaluation has the effect of
+implicitly constructing the parse tree that your are thinking of
+constructing explicitly.
+
+Through using some of the commented out debugging statements in
+[[file:lisp/org-babel-ref.el][org-babel-ref.el]] I have looked at what may be going wrong in the
+current evaluation setup, and it seems that nested variables are being
+set using the =:var= header argument, and these variables are being
+overridden by the *default* variables which are being entered through
+the new functional syntax (see the demonstration header below).
+
+I believe that once this bug is fixed we should be back to fully
+resolution of nested arguments.  We should capture this functionality
+in a test to ensure that we continue to test it as we move forward.  I
+can take a look at implementing this once I get a chance.
+
+Looks like the problem may be in [[file:lisp/org-babel.el::defun%20org%20babel%20merge%20params%20rest%20plists][org-babel-merge-params]], which seems
+to be trampling the provided :vars values.
+
+Nope, now it seems that we are actually looking up the results line,
+rather than the actual source-code block, which would make sense given
+that the results-line will return the same value regardless of the
+arguments supplied.  See the output of this [[file:lisp/org-babel-ref.el::message%20type%20S%20type%20debugging][debug-statement]].
+
+We need to be sure that we don't read from a =#+resname:= line when we
+have a non-nil set of arguments.
+
+**** demonstration
+After uncommenting the debugging statements located [[file:lisp/org-babel-ref.el::message%20format%20first%20second%20S%20S%20new%20refere%20new%20referent%20debugging][here]] and more
+importantly [[file:lisp/org-babel-ref.el::message%20nested%20args%20S%20args%20debugging][here]], we can see that the current reference code does
+evaluate the references correctly, and it uses the =:var= header
+argument to set =a=8=, however the default variables specified using
+the functional syntax in =adder(a=3, b=2)= is overriding this
+specification.
+
+***** doesn't work with functional syntax
+
+#+srcname: adder-func(a=3, b=2)
+#+begin_src python 
+a + b
+#+end_src
+
+#+resname: adder-func
+: 5
+
+#+srcname: after-adder-func(arg=adder-func(a=8))
+#+begin_src python 
+arg
+#+end_src
+
+#+resname: after-adder-func
+: 5
+
+***** still does work with =:var= syntax
+
+so it looks like regardless of the syntax used we're not overriding
+the default argument values.
+
+#+srcname: adder-header
+#+begin_src python :var a=3 :var b=2
+a + b
+#+end_src
+
+#+resname: adder-header
+: 5
+
+#+srcname: after-adder-header
+#+begin_src python :var arg=adder-header(a=8, b=0)
+arg
+#+end_src
+
+#+resname: after-adder-header
+: 5
+
+*** Set of test cases
+**** Both defaults provided in definition
+#+srcname: adder1(a=10,b=20)
+#+begin_src python
+a+b
+#+end_src
+
+#+resname: adder1
+: 30
+****** DONE Rely on defaults
+#+lob: adder1()
+
+#+resname: adder1()
+: 30
+
+## should be 30
+## OK, but
+******* DONE empty parens () not recognised as lob call
+	E.g. remove spaces between parens above
+
+        updated [[file:lisp/org-babel-lob.el::defvar%20org%20babel%20lob%20one%20liner%20regexp%20lob%20t%20n%20n%20t%20n][org-babel-lob-one-liner-regexp]]
+
+****** DONE One supplied, one default
+#+lob: adder1(a=0)
+
+#+resname: adder1(a=0)
+: 20
+
+## should be 20
+
+#+lob: adder1(b=0)
+
+#+resname: adder1(b=0)
+## should be 10
+: 10
+
+****** DONE Both supplied
+#+lob: adder1(a=1,b=2)
+
+#+resname: adder1(a=1,b=2)
+
+: 3
+**** One arg lacks default in definition
+#+srcname: adder2(a=10,b)
+#+begin_src python
+a+b
+#+end_src
+****** DEFERRED Rely on defaults (one of which is missing)
+#+lob: adder2( )
+
+[no output]
+
+## should be error: b has no default
+
+Maybe we should let the programming language handle this case.  For
+example python spits out an error in the =#+lob= line above.  Maybe
+rather than catching these errors our-selves we should raise an error
+when the source-block returns an error.  I'll propose a [[* PROPOSED raise elisp error when source-blocks return errors][task]] for this
+idea, I'm not sure how/if it would work...
+
+****** DEFERRED Default over-ridden
+#+lob: adder2(a=1)
+
+See the above [[* DEFERRED Rely on defaults (one of which is missing)][deferred]] and the new proposed [[* PROPOSED raise elisp error when source-blocks return errors][task]], I think it may be
+more flexible to allow the source block language to handle the error.
+
+[no output ]
+## should be error: b has no default
+
+****** DONE Missing default supplied
+#+lob: adder2(b=1)
+
+#+resname: adder2(b=1)
+: 11
+
+
+## should be 11
+## OK
+
+****** DONE One over-ridden, one supplied
+#+lob: adder2(a=1,b=2)
+
+#+resname: adder2(a=1,b=2)
+: 3
+
+## should be 3
+
+*** Example that fails
+    
+#+srcname: adder(a=0, b=99)
+#+begin_src python 
+a+b
+#+end_src
+
+
+
+#+srcname: one()
+#+begin_src python
+1
+#+end_src
+
+**** nesting
+#+srcname: level-one-nesting()
+#+begin_src python :var arg=adder(a=one(),b=one())
+arg
+#+end_src
+
+#+resname: level-one-nesting
+
+: nil
+
+#+srcname: level-one-nesting()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()),b=adder(a=one(),b=one()))
+arg
+#+end_src
+
+#+resname:
+: 12
+
+*** DONE deeply nested arguments still fails
+
+#+srcname: deeply-nested-args-bug
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()),b=adder(a=one(),b=one()))
+arg
+#+end_src
+
+#+resname:
+: 4
+
+**** Used to result in this error
+: supplied params=nil
+: new-refere="adder", new-referent="a=adder(a=one(),b=one()),b=adder(a=one(),b=one())"
+: args=((:var . "a=adder(a=one()") (:var . "b=one())") (:var . "b=adder(a=one()") (:var . "b=one())"))
+: type=source-block
+: supplied params=((:var . "a=adder(a=one()") (:var . "b=one())") (:var . "b=adder(a=one()") (:var . "b=one())"))
+: new-refere="adder", new-referent="a=one("
+: args=((:var . "a=one("))
+: type=source-block
+: supplied params=((:var . "a=one("))
+: reference 'one(' not found in this buffer
+
+Need to change the regexp in [[file:lisp/org-babel-ref.el::assign%20any%20arguments%20to%20pass%20to%20source%20block][org-babel-ref-resolve-reference]] so that
+it only matches when the parenthesis are balanced.  Maybe look at
+[[http://www.gnu.org/software/emacs/elisp/html_node/List-Motion.html][this]].
+
+*** DONE Still some problems with deeply nested arguments and defaults
+**** sandbox
+**** DONE Parsing / defaults bug
+     Try inserting a space between 'a=0,' and 'b=0' and comparing results
+#+srcname: parsing-defaults-bug()
+#+begin_src python :var arg=adder(a=adder(a=0,b=0))
+arg
+#+end_src
+
+#+resname: parsing-defaults-bug
+
+: 99
+
+#+srcname: deeply-nested-args-bug-orig()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()),b=adder(a=adder(a=3, b=4),b=one()))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-orig
+
+: 10
+
+
+**** DONE Nesting problem II
+     This generates parsing errors
+
+     Fixed: c2bef96b7f644c05be5a38cad6ad1d28723533aa
+
+#+srcname: deeply-nested-args-bug-II-1()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=adder(a=2,b=4)))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-II-1
+
+: 106
+
+#+srcname: deeply-nested-args-bug-II-original()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()),b=adder(a=one(),b=adder(a=1,b=4)))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-II-original
+: 8
+
+
+
+**** DONE Why does this give 8?
+     It was picking up the wrong definition of adder
+#+srcname: deeply-nested-args-bug-2()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-2
+
+: 101
+
+**** DONE Problem with empty argument list
+     This gives empty list with () and 'no output' with ( )
+
+     I think this is OK now.
+
+#+srcname: x
+#+begin_src python :var arg=adder( )
+arg
+#+end_src
+
+#+resname:
+: 99
+
+#+srcname: deeply-nested-args-bug-orig()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()),b=adder(a=adder(a=3, b=4),b=one()))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-orig
+
+: 10
+
+
+**** DONE Nesting problem II
+     This generates parsing errors
+
+     Fixed: c2bef96b7f644c05be5a38cad6ad1d28723533aa
+
+#+srcname: deeply-nested-args-bug-II-1()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=adder(a=2,b=4)))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-II-1
+
+: 106
+
+#+srcname: deeply-nested-args-bug-II-original()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()),b=adder(a=one(),b=adder(a=1,b=4)))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-II-original
+: 8
+
+
+
+**** DONE Why does this give 8?
+     It was picking up the wrong definition of adder
+#+srcname: deeply-nested-args-bug-2()
+#+begin_src python :var arg=adder(a=adder(a=one(),b=one()))
+arg
+#+end_src
+
+#+resname: deeply-nested-args-bug-2
+
+: 101
+
+**** DONE Problem with empty argument list
+     This gives empty list with () and 'no output' with ( )
+
+     I think this is OK now.
+
+#+srcname: x
+#+begin_src python :var arg=adder( )
+arg
+#+end_src
+
+#+resname:
+: 99
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#+srcname: test-zz(arg=adder(a=adder(a=19,b=adder(a=5,b=2)),b=adder(a=adder(a=1,b=9),b=adder(a=1,b=3))))
+#+begin_src python 
+arg
+#+end_src
+
+
+*** DONE Arg lacking default
+   This would be good thing to address soon. I'm imagining that
+   e.g. here, the 'caller' block would return the answer 30. I believe
+   there's a few issues here: i.e. the naked 'a' without a reference
+   is not understood; the default arg b=6 is not understood.
+
+#+srcname: adder-with-arg-lacking-default(a, b=6)
+#+begin_src python 
+a+b
+#+end_src
+
+
+
+#+srcname: caller(var=adder-with-arg-lacking-default(a=24))
+#+begin_src python :results silent
+var
+#+end_src
+
+** DONE allow srcname to omit function call parentheses
+   Someone needs to revisit those regexps. Is there an argument for
+   moving some of the regexps used to match function calls into
+   defvars? (i.e. in o-b.el and o-b-ref.el)
+
+   This seems to work now. It still might be a good idea to separate
+   out some of the key regexps into defvars at some point.
+
+#+srcname: omit-parens-test
+#+begin_src ruby :results output
+3.times {puts 'x'}
+#+end_src
+
+#+resname:
+: x
+: x
+: x
+
+** DONE avoid stripping whitespace from output when :results output
+   This may be partly solved by using o-b-chomp rather than o-b-trim
+   in the o-b-LANG-evaluate functions.
+** DEFERRED weird escaped characters in shell prompt break shell evaluation
+   E.g. this doesn't work. Should the shell sessions set a sane prompt
+   when they start up? Or is it a question of altering
+   comint-prompt-regexp? Or altering org-babel regexps?
+   
+#+begin_src sh   
+   black=30 ; red=31 ; green=32 ; yellow=33 ; blue=34 ; magenta=35 ; cyan=36 ; white=37
+   prompt_col=$red
+   prompt_char='>'
+   export PS1="\[\033[${prompt_col}m\]\w${prompt_char} \[\033[0m\]"
+#+end_src
+
+   I just pushed a good amount of changes, could you see if your shell
+   problems still exist?
+
+   The problem's still there. Specifically, aIui, at [[file:lisp/langs/org-babel-sh.el::raw%20org%20babel%20comint%20with%20output%20buffer%20org%20babel%20sh%20eoe%20output%20nil%20insert%20full%20body%20comint%20send%20input%20nil%20t][this line]] of
+   org-babel-sh.el, raw gets the value
+
+("" " Sun Jun 14 19:26:24 EDT 2009\n" " org_babel_sh_eoe\n" " ")
+
+   and therefore (member org-babel-sh-eoe-output ...) fails
+
+   I think that `comint-prompt-regexp' needs to be altered to match
+   the shell prompt.  This shouldn't be too difficult to do by hand,
+   using the `regexp-builder' command and should probably be part of
+   the user's regular emacs init.  I can't think of a way for us to
+   set this automatically, and we are SOL without a regexp to match
+   the prompt.
+** DONE function calls in #+srcname: refs
+   
+   My srcname references don't seem to be working for function
+   calls. This needs fixing.
+   
+#+srcname: called()
+#+begin_src python 
+59
+#+end_src
+
+srcname function call doesn't work for calling a source block
+#+srcname: caller(var1=called())
+#+begin_src python
+var1
+#+end_src
+
+#+resname: caller
+: 59
+
+
+
+
+
+
+They do work for a simple reference
+#+srcname: caller2(var1=56)
+#+begin_src python 
+var1
+#+end_src
+
+#+resname: caller2
+: 59
+
+
+and they do work for :var header arg
+#+srcname: caller3
+#+begin_src python :var var1=called() 
+var1
+#+end_src
+
+#+resname:
+: 58
+** DONE LoB: with output to buffer, not working in buffers other than library-of-babel.org
+*** Initial report
+   I haven't fixed this yet. org-babel-ref-resolve-reference moves
+   point around, inside a save-excursion. Somehow when it comes to
+   inserting the results (after possible further recursive calls to
+   org-babel-ref-resolve-reference), point hasn't gone back to the
+   lob line.
+
+#+tblname: test-data
+| 1 |    1 |
+| 2 |   .5 |
+| 3 | .333 |
+
+#+lob: R-plot(data=test-data)
+
+#+lob: python-add(a=2, b=9)
+
+#+resname: python-add(a=2, b=9)
+: 11
+
+*** Now
+    I think this got fixed in the bugfixes before merging results into master.
+
+** DONE cursor movement when evaluating source blocks
+   E.g. the pie chart example. Despite the save-window-excursion in
+   org-babel-execute:R. (I never learned how to do this properly: org-R
+   jumps all over the place...)
+
+   I don't see this now [ded]
+
+** DONE LoB: calls fail if reference has single character name
+   commit 21d058869df1ff23f4f8cc26f63045ac9c0190e2
+**** This doesn't work
+#+lob: R-plot(data=X)
+
+#+tblname: X
+| 1 |     1 |
+| 2 |    .5 |
+| 3 | .3333 |
+| 4 |   .25 |
+| 5 |    .2 |
+| 6 | .1666 |
+
+**** But this is OK
+#+tblname: XX
+| 1 |     1 |
+| 2 |    .5 |
+| 3 | .3333 |
+| 4 |   .25 |
+| 5 |    .2 |
+| 6 | .1666 |
+
+#+lob: R-plot(data=XX)
+
+** DONE make :results replace the default?
+   I'm tending to think that appending results to pre-existing results
+   creates mess, and that the cleaner `replace' option should be the
+   default. E.g. when a source block creates an image, we would want
+   that to be updated, rather than have a new one be added.
+   
+   I agree.
+
+** DONE ruby evaluation not working under ubuntu emacs 23
+   With emacs 23.0.91.1 on ubuntu, for C-h f run-ruby I have the
+   following, which seems to conflict with [[file:lisp/langs/org-babel-ruby.el::let%20session%20buffer%20save%20window%20excursion%20run%20ruby%20nil%20session%20current%20buffer][this line]] in org-babel-ruby.el.
+
+#+begin_example
+run-ruby is an interactive compiled Lisp function.
+
+(run-ruby cmd)
+
+Run an inferior Ruby process, input and output via buffer *ruby*.
+If there is a process already running in `*ruby*', switch to that buffer.
+With argument, allows you to edit the command line (default is value
+of `ruby-program-name').  Runs the hooks `inferior-ruby-mode-hook'
+(after the `comint-mode-hook' is run).
+(Type C-h m in the process buffer for a list of commands.)
+#+end_example
+
+   So, I may have a non-standard inf-ruby.el.  Here's my version of
+   run-ruby.
+
+#+begin_example 
+run-ruby is an interactive Lisp function in `inf-ruby.el'.
+
+(run-ruby &optional COMMAND NAME)
+
+Run an inferior Ruby process, input and output via buffer *ruby*.
+If there is a process already running in `*ruby*', switch to that buffer.
+With argument, allows you to edit the command line (default is value
+of `ruby-program-name').  Runs the hooks `inferior-ruby-mode-hook'
+(after the `comint-mode-hook' is run).
+(Type C-h m in the process buffer for a list of commands.)
+#+end_example
+
+   It seems we could either bundle my version of inf-ruby.el (as it's
+   the newest).  Or we could change the use of `run-ruby' so that it
+   is robust across multiple distributions.  I think I'd prefer the
+   former, unless the older version of inf-ruby is actually bundled
+   with emacs, in which case maybe we should go out of our way to
+   support it.  Thoughts?
+
+   I think for now I'll just include the latest [[file:util/inf-ruby.el][inf-ruby.el]] in the
+   newly created utility directory.  I doubt anyone would have a
+   problem using the latest version of this file.
+** DONE test failing forcing vector results with =test-forced-vector-results= ruby code block
+Note that this only seems to happen the *second* time the test table
+is evaluated
+
+#+srcname: bug-trivial-vector
+#+begin_src emacs-lisp :results vector silent
+8
+#+end_src
+
+#+srcname: bug-forced-vector-results
+#+begin_src ruby :var triv=test-trivial-vector :results silent
+triv.class.name
+#+end_src
+
+mysteriously this seems to be fixed...
+** DONE defunct R sessions
+Sometimes an old R session will turn defunct, and newly inserted code
+will not be evaluated (leading to a hang).
+
+This seems to be fixed by using `inferior-ess-send-input' rather than `comint-send-input'.
+** DONE ruby fails on first call to non-default session
+
+#+srcname: bug-new-session
+#+begin_src ruby :session is-new
+:patton
+#+end_src
+
+** DONE when reading results from =#+resname= line
+
+Errors when trying to read from resname lines.
+
+#+resname: bug-in-resname
+: 8
+
+#+srcname: bug-in-resname-reader
+#+begin_src emacs-lisp :var buggy=bug-in-resname() :results silent
+buggy
+#+end_src
+
+** DONE R-code broke on "org-babel" rename
+
+#+srcname: bug-R-babels
+#+begin_src R 
+8 * 2
+#+end_src
+
+** DONE error on trivial R results
+
+So I know it's generally not a good idea to squash error without
+handling them, but in this case the error almost always means that
+there was no file contents to be read by =org-table-import=, so I
+think it's ok.
+
+#+srcname: bug-trivial-r1
+#+begin_src R :results replace
+pie(c(1, 2, 3), labels = c(1, 2, 3))
+#+end_src
+
+#+srcname: bug-trivial-r2
+#+begin_src R :results replace
+8
+#+end_src
+
+#+resname: bug-trivial-r2
+: 8
+
+#+srcname: bug-trivial-r3
+#+begin_src R :results replace
+c(1,2,3)
+#+end_src
+
+#+resname: bug-trivial-r3
+| 1 |
+| 2 |
+| 3 |
+
+** DONE ruby new variable creation (multi-line ruby blocks)
+Actually it looks like we were dropping all but the last line.
+
+#+srcname: multi-line-ruby-test
+#+begin_src ruby :var table=bug-numerical-table :results replace
+total = 0
+table.each{|n| total += n}
+total/table.size
+#+end_src
+
+#+resname:
+: 2
+
+** DONE R code execution seems to choke on certain inputs
+Currently the R code seems to work on vertical (but not landscape)
+tables
+
+#+srcname: little-fake
+#+begin_src emacs-lisp 
+"schulte"
+#+end_src
+
+
+#+begin_src R :var num=little-fake
+num
+#+end_src
+
+#+resname:
+: schulte
+
+#+srcname: set-debug-on-error
+#+begin_src emacs-lisp :results silent
+(setq debug-on-error t)
+#+end_src
+
+#+srcname: bug-numerical-table
+#+begin_src emacs-lisp :results silent
+'(1 2 3)
+#+end_src
+
+
+
+
+#+srcname: bug-R-number-evaluation
+#+begin_src R :var table=bug-numerical-table
+mean(mean(table))
+#+end_src
+
+#+resname:
+: 2
+
+
+
+#+tblname: bug-vert-table
+| 1 |
+| 2 |
+| 3 |
+
+#+srcname: bug-R-vertical-table
+#+begin_src R :var table=bug-vert-table :results silent
+mean(table)
+#+end_src
+
+** DONE org bug/request: prevent certain org behaviour within code blocks
+   E.g. [[]] gets recognised as a link (when there's text inside the
+   brackets). This is bad for R code at least, and more generally
+   could be argued to be inappropriate. Is it difficult to get org to
+   ignore text in code blocks? [DED]
+   
+   I believe Carsten addressed this recently on the mailing list with
+   the comment that it was indeed a difficult issue.  I believe this
+   may be one area where we could wait for an upstream (org-mode) fix.
+
+   [Dan] Carsten has fixed this now in the core.
+
+** DONE with :results replace, non-table output doesn't replace table output
+   And vice versa. E.g. Try this first with table and then with len(table) [DED]
+#+begin_src python :var table=sandbox :results replace
+table
+#+end_src
+
+| 1 |         2 | 3 |
+| 4 | "schulte" | 6 |
+: 2
+
+Yes, this is certainly a problem.  I fear that if we begin replacing
+anything immediately following a source block (regardless of whether
+it matches the type of our current results) we may accidentally delete
+hand written portions of the user's org-mode buffer.
+
+I think that the best solution here would be to actually start
+labeling results with a line that looks something like...
+
+#+results: name
+
+This would have a couple of benefits...
+1) we wouldn't have to worry about possibly deleting non-results
+   (which is currently an issue)
+2) we could reliably replace results even if there are different types
+3) we could reference the results of a source-code block in variable
+   definitions, which would be useful if for example we don't wish to
+   re-run a source-block every time because it is long-running.
+
+Thoughts?  If no-one objects, I believe I will implement the labeling
+of results.
+
+** DONE extra quotes for nested string
+Well R appears to be reading the tables without issue...
+
+these *should* be quoted
+#+srcname: ls
+#+begin_src sh :results replace
+ls
+#+end_src
+
+| "COPYING"          |
+| "README.markdown"  |
+| "block"            |
+| "examples.org"     |
+| "existing_tools"   |
+| "intro.org"        |
+| "org-babel"          |
+| "rorg.org"         |
+| "test-export.html" |
+| "test-export.org"  |
+
+#+srcname: test-quotes
+#+begin_src ruby :var tab=ls
+tab[1][0]
+#+end_src
+
+: README.markdown
+
+#+srcname: test-quotes
+#+begin_src R :var tab=ls
+as.matrix(tab[2,])
+#+end_src
+
+: README.markdown
+
+** DONE simple ruby arrays not working
+
+As an example eval the following.  Adding a line to test
+
+#+tblname: simple-ruby-array
+| 3 | 4 | 5 |
+
+#+srcname: ruby-array-test
+#+begin_src ruby :var ar = simple-ruby-array :results silent
+ar.first.first
+#+end_src
+
+** DONE space trailing language name
+fix regexp so it works when there's a space trailing the language name
+
+#+srcname: test-trailing-space
+#+begin_src ruby 
+:schulte
+#+end_src
+
+** DONE Args out of range error
+   
+The following block resulted in the error below [DED]. It ran without
+error directly in the shell.
+#+begin_src sh
+cd ~/work/genopca
+for platf in ill aff ; do
+    for pop in CEU YRI ASI ; do
+	rm -f $platf/hapmap-genos-$pop-all $platf/hapmap-rs-all
+	cat $platf/hapmap-genos-$pop-* > $platf/hapmap-genos-$pop-all
+	cat $platf/hapmap-rs-* > $platf/hapmap-rs-all
+    done
+done
+#+end_src
+  
+ executing source block with sh...
+finished executing source block
+string-equal: Args out of range: "", -1, 0
+
+the error =string-equal: Args out of range: "", -1, 0= looks like what
+used to be output when the block returned an empty results string.
+This should be fixed in the current version, you should now see the
+following message =no result returned by source block=.
+
+** DONE ruby arrays not recognized as such
+
+Something is wrong in [[file:lisp/org-babel-script.el]] related to the
+recognition of ruby arrays as such.
+
+#+begin_src ruby :results replace
+[1, 2, 3, 4]
+#+end_src
+
+| 1 | 2 | 3 | 4 |
+
+#+begin_src python :results replace
+[1, 2, 3, 4]
+#+end_src
+
+| 1 | 2 | 3 | 4 |
+** REJECTED elisp reference fails for literal number
+   That's a bug in Dan's elisp, not in org-babel.
+#+srcname: elisp-test(a=4)
+#+begin_src emacs-lisp 
+(message a)
+#+end_src
+
+
+
+
+
+: 30
+
+
+* Tests
+Evaluate all the cells in this table for a comprehensive test of the
+org-babel functionality.
+
+*Note*: if you have customized =org-babel-default-header-args= then some
+of these tests may fail.
+
+#+TBLNAME: org-babel-tests
+| functionality           | block                      | arg |    expected |     results | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| basic evaluation        |                            |     |             |             | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| emacs lisp              | basic-elisp                |     |           5 |           5 | pass |
+| shell                   | basic-shell                |     |           6 |           6 | pass |
+| ruby                    | basic-ruby                 |     |   org-babel |   org-babel | pass |
+| python                  | basic-python               |     | hello world | hello world | pass |
+| R                       | basic-R                    |     |          13 |          13 | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| tables                  |                            |     |             |             | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| emacs lisp              | table-elisp                |     |           3 |           3 | pass |
+| ruby                    | table-ruby                 |     |       1-2-3 |       1-2-3 | pass |
+| python                  | table-python               |     |           5 |           5 | pass |
+| R                       | table-R                    |     |         3.5 |         3.5 | pass |
+| R: col names in R       | table-R-colnames           |     |          -3 |          -3 | pass |
+| R: col names in org     | table-R-colnames-org       |     |         169 |         169 | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| source block references |                            |     |             |             | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| all languages           | chained-ref-last           |     |       Array |       Array | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| source block functions  |                            |     |             |             | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| emacs lisp              | defun-fibb                 |     |       fibbd |       fibbd | pass |
+| run over                | Fibonacci                  |   0 |           1 |           1 | pass |
+| a                       | Fibonacci                  |   1 |           1 |           1 | pass |
+| variety                 | Fibonacci                  |   2 |           2 |           2 | pass |
+| of                      | Fibonacci                  |   3 |           3 |           3 | pass |
+| different               | Fibonacci                  |   4 |           5 |           5 | pass |
+| arguments               | Fibonacci                  |   5 |           8 |           8 | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| bugs and tasks          |                            |     |             |             | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| simple ruby arrays      | ruby-array-test            |     |           3 |           3 | pass |
+| R number evaluation     | bug-R-number-evaluation    |     |           2 |           2 | pass |
+| multi-line ruby blocks  | multi-line-ruby-test       |     |           2 |           2 | pass |
+| forcing vector results  | test-forced-vector-results |     |       Array |       Array | pass |
+| deeply nested arguments | deeply-nested-args-bug     |     |           4 |           4 | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| sessions                |                            |     |             |             | pass |
+|-------------------------+----------------------------+-----+-------------+-------------+------|
+| set ruby session        | set-ruby-session-var       |     |        :set |        :set | pass |
+| get from ruby session   | get-ruby-session-var       |     |           3 |           3 | pass |
+| set python session      | set-python-session-var     |     |         set |         set | pass |
+| get from python session | get-python-session-var     |     |           4 |           4 | pass |
+| set R session           | set-R-session-var          |     |         set |         set | pass |
+| get from R session      | get-R-session-var          |     |           5 |           5 | pass |
+#+TBLFM: $5='(if (= (length $3) 1) (progn (message (format "running %S" '(sbe $2 (n $3)))) (sbe $2 (n $3))) (sbe $2))::$6='(if (string= $4 $5) "pass" (format "expected %S but was %S" $4 $5))
+#+TBLFM: $5=""::$6=""
+
+
+The second TBLFM line (followed by replacing '[]' with '') can be used
+to blank out the table results, in the absence of a better method.
+
+** basic tests
+
+#+srcname: basic-elisp
+#+begin_src emacs-lisp :results silent
+(+ 1 4)
+#+end_src
+
+
+#+srcname: basic-shell
+#+begin_src sh :results silent
+expr 1 + 5
+#+end_src
+
+
+#+srcname: date-simple
+#+begin_src sh :results silent
+date
+#+end_src
+
+#+srcname: basic-ruby
+#+begin_src ruby :results silent
+"org-babel"
+#+end_src
+
+
+#+srcname: basic-python
+#+begin_src python :results silent
+'hello world'
+#+end_src
+
+
+#+srcname: basic-R
+#+begin_src R :results silent
+b <- 9
+b + 4
+#+end_src
+
+
+** read tables
+
+#+tblname: test-table
+| 1 | 2 | 3 |
+| 4 | 5 | 6 |
+
+#+tblname: test-table-colnames
+| var1 | var2 | var3 |
+|------+------+------|
+|    1 |   22 |   13 |
+|   41 |   55 |   67 |
+
+#+srcname: table-elisp
+#+begin_src emacs-lisp :results silent :var table=test-table
+(length (car table))
+#+end_src
+
+
+#+srcname: table-ruby
+#+begin_src ruby :results silent :var table=test-table
+table.first.join("-")
+#+end_src
+
+
+#+srcname: table-python
+#+begin_src python :var table=test-table
+table[1][1]
+#+end_src
+
+#+srcname: table-R(table=test-table)
+#+begin_src R
+mean(mean(table))
+#+end_src
+
+#+srcname: table-R-colnames(table=test-table-colnames)
+#+begin_src R :results silent
+sum(table$var2 - table$var3)
+#+end_src
+
+#+srcname: R-square(x=default-name-doesnt-exist)
+#+begin_src R :colnames t
+x^2
+#+end_src
+
+This should return 169. The fact that R is able to use the column name
+to index the data frame (x$var3) proves that a table with column names
+(a header row) has been recognised as input for the R-square function
+block, and that the R-square block has output an elisp table with
+column names, and that the colnames have again been recognised when
+creating the R variables in this block.
+#+srcname: table-R-colnames-org(x = R-square(x=test-table-colnames))
+#+begin_src R
+x$var3[1]
+#+end_src
+
+
+
+
+** references
+
+Lets pass a references through all of our languages...
+
+Lets start by reversing the table from the previous examples
+
+#+srcname: chained-ref-first
+#+begin_src python :var table = test-table
+table.reverse()
+table
+#+end_src
+
+#+resname: chained-ref-first
+| 4 | 5 | 6 |
+| 1 | 2 | 3 |
+
+Take the first part of the list
+
+#+srcname: chained-ref-second
+#+begin_src R :var table = chained-ref-first
+table[1]
+#+end_src
+
+#+resname: chained-ref-second
+| 4 |
+| 1 |
+
+Turn the numbers into string
+
+#+srcname: chained-ref-third
+#+begin_src emacs-lisp :var table = chained-ref-second
+(mapcar (lambda (el) (format "%S" el)) table)
+#+end_src
+
+#+resname: chained-ref-third
+| "(4)" | "(1)" |
+
+and Check that it is still a list
+
+#+srcname: chained-ref-last
+#+begin_src ruby :var table=chained-ref-third
+table.class.name
+#+end_src
+
+
+** source blocks as functions
+
+#+srcname: defun-fibb
+#+begin_src emacs-lisp :results silent
+(defun fibbd (n) (if (< n 2) 1 (+ (fibbd (- n 1)) (fibbd (- n 2)))))
+#+end_src
+
+
+#+srcname: fibonacci
+#+begin_src emacs-lisp :results silent :var n=7
+(fibbd n)
+#+end_src
+
+
+
+
+
+
+
+** sbe tests (these don't seem to be working...)
+Testing the insertion of results into org-mode tables.
+
+#+srcname: multi-line-output
+#+begin_src ruby :results replace
+"the first line ends here
+
+
+     and this is the second one
+
+even a third"
+#+end_src
+
+#+resname:
+: the first line ends here\n\n\n     and this is the second one\n\neven a third
+
+#+srcname: multi-line-error
+#+begin_src ruby :results replace
+raise "oh nooooooooooo"
+#+end_src
+
+#+resname:
+: oh nooooooooooo
+
+| the first line ends here... | -:5: warning: parenthesize argument(s) for future version... |
+#+TBLFM: $1='(sbe "multi-line-output")::$2='(sbe "multi-line-error")
+
+** forcing results types tests
+
+#+srcname: test-trivial-vector
+#+begin_src emacs-lisp :results vector silent
+8
+#+end_src
+
+#+srcname: test-forced-vector-results
+#+begin_src ruby :var triv=test-trivial-vector :results silent
+triv.class.name
+#+end_src
+
+** sessions
+
+#+srcname: set-ruby-session-var
+#+begin_src ruby :session :results silent
+var = [1, 2, 3]
+:set
+#+end_src
+
+#+srcname: get-ruby-session-var
+#+begin_src ruby :session :results silent
+var.size
+#+end_src
+
+#+srcname: set-python-session-var
+#+begin_src python :session
+var=4
+'set'
+#+end_src
+
+#+srcname: get-python-session-var
+#+begin_src python :session
+var
+#+end_src
+
+#+srcname: set-R-session-var
+#+begin_src R :session
+a <- 5
+'set'
+#+end_src
+
+#+srcname: get-R-session-var
+#+begin_src R :session
+a
+#+end_src
+
+
+* Sandbox
+  :PROPERTIES:
+  :CUSTOM_ID: sandbox
+  :END:
+To run these examples evaluate [[file:lisp/org-babel-init.el][org-babel-init.el]]
+
+** org-babel.el beginning functionality
+
+#+begin_src sh  :results replace
+date
+#+end_src
+
+#+resname:
+: Sun Jul  5 18:54:39 EDT 2009
+
+#+begin_src ruby
+Time.now
+#+end_src
+
+#+resname:
+: Sun Jul 05 18:54:35 -0400 2009
+
+#+begin_src python
+"Hello World"
+#+end_src
+
+#+resname:
+: Hello World
+
+
+** org-babel-R
+
+#+begin_src R :results replace
+a <- 9
+b <- 16
+a + b
+#+end_src
+
+#+resname:
+: 25
+
+#+begin_src R
+hist(rgamma(20,3,3))
+#+end_src
+
+
+
+** org-babel plays with tables
+Alright, this should demonstrate both the ability of org-babel to read
+tables into a lisp source code block, and to then convert the results
+of the source code block into an org table.  It's using the classic
+"lisp is elegant" demonstration transpose function.  To try this
+out...
+
+1. evaluate [[file:lisp/org-babel-init.el]] to load org-babel and friends
+2. evaluate the transpose definition =\C-c\\C-c= on the beginning of
+   the source block
+3. evaluate the next source code block, this should read in the table
+   because of the =:var table=previous=, then transpose the table, and
+   finally it should insert the transposed table into the buffer
+   immediately following the block
+
+*** Emacs lisp
+
+#+begin_src emacs-lisp :results silent
+(defun transpose (table)
+  (apply #'mapcar* #'list table))
+#+end_src
+
+
+#+TBLNAME: sandbox
+| 1 |       2 | 3 |
+| 4 | schulte | 6 |
+
+#+begin_src emacs-lisp :var table=sandbox :results replace
+(transpose table)
+#+end_src
+
+
+#+begin_src emacs-lisp
+'(1 2 3 4 5)
+#+end_src
+
+#+resname:
+| 1 | 2 | 3 | 4 | 5 |
+
+*** Ruby and Python
+
+#+begin_src ruby :var table=sandbox :results replace
+table.first.join(" - ")
+#+end_src
+
+#+resname:
+: 1 - 2 - 3
+
+#+begin_src python :var table=sandbox
+table[0]
+#+end_src
+
+
+#+begin_src ruby :var table=sandbox :results replace
+table
+#+end_src
+
+#+resname:
+: [[1, 2, 3], [4, "schulte", 6]]
+
+
+| 1 |         2 | 3 |
+| 4 | "schulte" | 6 |
+
+#+begin_src python :var table=sandbox :results replace
+len(table)
+#+end_src
+
+: 2
+
+| "__add__" | "__class__" | "__contains__" | "__delattr__" | "__delitem__" | "__delslice__" | "__doc__" | "__eq__" | "__format__" | "__ge__" | "__getattribute__" | "__getitem__" | "__getslice__" | "__gt__" | "__hash__" | "__iadd__" | "__imul__" | "__init__" | "__iter__" | "__le__" | "__len__" | "__lt__" | "__mul__" | "__ne__" | "__new__" | "__reduce__" | "__reduce_ex__" | "__repr__" | "__reversed__" | "__rmul__" | "__setattr__" | "__setitem__" | "__setslice__" | "__sizeof__" | "__str__" | "__subclasshook__" | "append" | "count" | "extend" | "index" | "insert" | "pop" | "remove" | "reverse" | "sort" |
+
+*** (sandbox table) R
+
+#+TBLNAME: sandbox_r
+| 1 |       2 | 3 |
+| 4 | schulte | 6 |
+
+#+begin_src R :results replace
+x <- c(rnorm(10, mean=-3, sd=1), rnorm(10, mean=3, sd=1))
+x
+#+end_src
+
+| -3.35473133869346 |
+|    -2.45714878661 |
+| -3.32819924928633 |
+| -2.97310212756194 |
+| -2.09640758369576 |
+| -5.06054014378736 |
+| -2.20713700711221 |
+| -1.37618039712037 |
+| -1.95839385821742 |
+| -3.90407396475502 |
+|  2.51168071590226 |
+|  3.96753011570494 |
+|  3.31793212627865 |
+|  1.99829753972341 |
+|  4.00403686419829 |
+|  4.63723764452927 |
+|  3.94636744261313 |
+|  3.58355906547775 |
+|  3.01563442274226 |
+|   1.7634976849927 |
+
+#+begin_src R var tabel=sandbox_r :results replace
+tabel
+#+end_src
+
+| 1 |         2 | 3 |
+| 4 | "schulte" | 6 |
+
+*** shell
+Now shell commands are converted to tables using =org-table-import=
+and if these tables are non-trivial (i.e. have multiple elements) then
+they are imported as org-mode tables...
+
+#+begin_src sh :results replace
+ls -l
+#+end_src
+
+| "total"      | 208 | ""    | ""    |    "" |   "" | "" | ""                |
+| "-rw-r--r--" |   1 | "dan" | "dan" |    57 | 2009 | 15 | "block"           |
+| "-rw-r--r--" |   1 | "dan" | "dan" | 35147 | 2009 | 15 | "COPYING"         |
+| "-rw-r--r--" |   1 | "dan" | "dan" |   722 | 2009 | 18 | "examples.org"    |
+| "drwxr-xr-x" |   4 | "dan" | "dan" |  4096 | 2009 | 19 | "existing_tools"  |
+| "-rw-r--r--" |   1 | "dan" | "dan" |  2207 | 2009 | 14 | "intro.org"       |
+| "drwxr-xr-x" |   2 | "dan" | "dan" |  4096 | 2009 | 18 | "org-babel"         |
+| "-rw-r--r--" |   1 | "dan" | "dan" |   277 | 2009 | 20 | "README.markdown" |
+| "-rw-r--r--" |   1 | "dan" | "dan" | 11837 | 2009 | 18 | "rorg.html"       |
+| "-rw-r--r--" |   1 | "dan" | "dan" | 61829 | 2009 | 19 | "#rorg.org#"      |
+| "-rw-r--r--" |   1 | "dan" | "dan" | 60190 | 2009 | 19 | "rorg.org"        |
+| "-rw-r--r--" |   1 | "dan" | "dan" |   972 | 2009 | 11 | "test-export.org" |
+
+
+** silent evaluation
+
+#+begin_src ruby
+:im_the_results
+#+end_src
+
+: :im_the_results
+
+#+begin_src ruby :results silent
+:im_the_results
+#+end_src
+
+#+begin_src ruby :results replace
+:im_the_results_
+#+end_src
+
+: :im_the_results_
+
+
+** (sandbox) referencing other source blocks
+Doing this in emacs-lisp first because it's trivial to convert
+emacs-lisp results to and from emacs-lisp.
+
+*** emacs lisp source reference
+This first example performs a calculation in the first source block
+named =top=, the results of this calculation are then saved into the
+variable =first= by the header argument =:var first=top=, and it is
+used in the calculations of the second source block.
+
+#+SRCNAME: top
+#+begin_src emacs-lisp
+(+ 4 2)
+#+end_src
+
+#+begin_src emacs-lisp :var first=top :results replace
+(* first 3)
+#+end_src
+
+: 18
+
+This example is the same as the previous only the variable being
+passed through is a table rather than a number.
+
+#+begin_src emacs-lisp :results silent
+(defun transpose (table)
+  (apply #'mapcar* #'list table))
+#+end_src
+
+#+TBLNAME: top_table
+| 1 |       2 | 3 |
+| 4 | schulte | 6 |
+
+#+SRCNAME: second_src_example
+#+begin_src emacs-lisp :var table=top_table
+(transpose table)
+#+end_src
+
+#+begin_src emacs-lisp :var table=second_src_example :results replace
+(transpose table)
+#+end_src
+
+| 1 |         2 | 3 |
+| 4 | "schulte" | 6 |
+*** ruby python
+Now working for ruby
+
+#+srcname: start
+#+begin_src ruby
+89
+#+end_src
+
+#+begin_src ruby :var other=start :results replace
+2 * other
+#+end_src
+
+and for python
+
+#+SRCNAME: start_two
+#+begin_src python
+98
+#+end_src
+
+#+begin_src python :var another=start_two :results replace
+another*3
+#+end_src
+
+*** mixed languages
+Since all variables are converted into Emacs Lisp it is no problem to
+reference variables specified in another language.
+
+#+SRCNAME: ruby-block
+#+begin_src ruby
+2
+#+end_src
+
+#+SRCNAME: lisp_block
+#+begin_src emacs-lisp :var ruby-variable=ruby-block
+(* ruby-variable 8)
+#+end_src
+
+#+begin_src python :var lisp_var=lisp_block
+lisp_var + 4
+#+end_src
+
+: 20
+
+*** R
+
+#+srcname: first_r
+#+begin_src R :results replace
+a <- 9
+a
+#+end_src
+
+: 9
+
+#+begin_src R :var other=first_r :results replace
+other + 2
+#+end_src
+
+: 11
+
+
+** (sandbox) selective export
+
+For exportation tests and examples see (including exportation of
+inline source code blocks) [[file:test-export.org]]
+
+
+** (sandbox) source blocks as functions
+
+#+srcname: default
+#+begin_src emacs-lisp :results silent
+5
+#+end_src
+
+#+srcname: triple
+#+begin_src emacs-lisp :var n=default :results replace
+(* 3 n)
+#+end_src
+
+: 15
+
+#+begin_src emacs-lisp :var result=triple(n=3, m=98) :results replace
+result
+#+end_src
+
+: 294
+
+The following just demonstrates the ability to assign variables to
+literal values, which was not implemented until recently.
+
+#+begin_src ruby :var num="eric" :results replace
+num+" schulte "
+#+end_src
+
+: "eric schulte "
+
+
+** (sandbox) inline source blocks
+
+This is an inline source code block src_ruby{1 + 6}.  And another
+source block with text output src_emacs-lisp{"eric"}.
+
+This is an inline source code block with header
+arguments.  src_ruby[:var n=fibbd( n = 0 )]{n}
+
+
+** (sandbox) integration w/org tables
+
+#+begin_src emacs-lisp :results silent
+(defun fibbd (n) (if (< n 2) 1 (+ (fibbd (- n 1)) (fibbd (- n 2)))))
+#+end_src
+
+#+srcname: fibbd
+#+begin_src emacs-lisp :var n=4 :results silent
+(fibbd n)
+#+end_src
+
+#+begin_src emacs-lisp :results silent
+(mapcar #'fibbd '(0 1 2 3 4 5 6 7 8))
+#+end_src
+
+Something is not working here.  The function `sbe ' works fine when
+called from outside of the table (see the source block below), but
+produces an error when called from inside the table.  I think there
+must be some narrowing going on during intra-table emacs-lisp
+evaluation.
+
+| original | fibbd |
+|----------+-------|
+|        0 |     1 |
+|        1 |     1 |
+|        2 |     2 |
+|        3 |     3 |
+|        4 |     5 |
+|        5 |     8 |
+|        6 |    13 |
+|        7 |    21 |
+|        8 |    34 |
+|        9 |    55 |
+#+TBLFM: $2='(sbe "fibbd" (n $1))
+
+silent-result
+
+#+begin_src emacs-lisp :results silent
+(sbe 'fibbd (n "8"))
+#+end_src
+
+
+* Buffer Dictionary
+ LocalWords:  DBlocks dblocks org-babel el eric fontification
+
+

contrib/babel/publish-babel.org

@@ -0,0 +1,77 @@
+#+TITLE: Tools for publishing Org-babel documentation
+#+OPTIONS: toc:t h:3 num:nil ^:nil
+
+This file contains the code required to export the documentation of Org-babel.
+
+* org-babel-documentation Project
+
+This defines the =org-babel-documentation= project, for ease of
+publishing.  Publish a project with =C-c C-e X=.
+
+#+begin_src emacs-lisp :results silent
+  (setq org-babel-dir (file-name-directory (or load-file-name buffer-file-name)))
+  (unless (boundp 'org-publish-project-alist)
+    (setq org-publish-project-alist nil))
+  (setq org-publish-project-alist
+        (cons
+         `("org-babel-documentation"
+           :base-directory ,org-babel-dir
+           :base-extension "org"
+           :exclude ,(regexp-opt-group '("org-babel.org" "test-export.org" "test-tangle.org" "test-tangle-load.org"))
+           :publishing-directory ,(expand-file-name "doc" org-babel-dir)
+           :index-filename "org-babel-worg.org"
+           :auto-postamble nil
+           :style "<link rel=\"stylesheet\"href=\"stylesheet.css\"type=\"text/css\">"
+           :publishing-function (org-publish-org-to-html org-publish-org-to-org)
+           :plain-source t
+           :htmlized-source t)
+         org-publish-project-alist))
+#+end_src
+
+* org-babel-documentation stylesheet
+
+Calling =org-babel-tangle= in this file will export the css file for
+the Org-babel documentation.
+
+#+begin_src sass :file doc/stylesheet.css :results silent
+  #logo
+    float: right
+    text-align: center
+    max-width: 240px
+    font-size: 8pt
+    margin-left: 1em
+    #attr
+      margin: -0.5em
+  
+  #subtitle
+    float: center
+    text-align: center
+  
+  #content
+    color: #2e2e2e
+  
+  .outline-text-2
+    margin-left: 2em
+  
+  .outline-text-3
+    margin-left: 2em
+  
+  .outline-text-4
+    margin-left: 2em
+  
+  .outline-text-5
+    margin-left: 2em
+  
+  .outline-text-6
+    margin-left: 2em
+  
+  h3
+    margin-left: 1em
+    color: #000
+  
+  a
+    text-decoration: none
+    color: #4a708b
+  a:hover
+    text-decoration: underline
+#+end_src

contrib/babel/snippets/org-mode/block

@@ -0,0 +1,5 @@
+#name : #+begin_...#+end_
+# --
+#+begin_$1 $2
+$0
+#+end_$1

contrib/babel/snippets/org-mode/sb

@@ -0,0 +1,6 @@
+#name : #+begin_src...#+end_src
+# --
+#+srcname: ${1:name}
+#+begin_src ${2:language} $3
+$0
+#+end_src

contrib/babel/test-export.org

@@ -0,0 +1,60 @@
+#+TITLE: Testing Org-Babel Export
+#+OPTIONS: toc:2 ^:nil
+
+* all
+
+** full source blocks
+
+*** ruby
+
+source block is here, but is shouldn't be exported...
+
+#+begin_src ruby :results silent :exports none
+class Schulte
+  def initialize
+    puts :eric
+  end
+end
+#+end_src
+
+The source block is here, and lets see the code
+
+#+begin_src ruby :results silent :exports code
+class Schulte
+  def initialize
+    puts :eric
+  end
+end
+#+end_src
+
+This is a source block, and lets see the results
+#+begin_src ruby :exports results :results replace
+:the_results
+#+end_src
+
+lets see the source, and results for a ruby array
+#+begin_src ruby :results replace
+[1, 2, 3, 4].map{ |n| n * 2 }
+#+end_src
+
+
+*** emacs-lisp
+
+a table
+
+#+begin_src emacs-lisp
+'(1 2 3 4 5)
+#+end_src
+
+hidden
+
+#+begin_src emacs-lisp :exports none :results silent
+9
+#+end_src
+
+
+** in-line source blocks
+
+This is an inline source code block src_ruby{1 + 6}.  And another
+source block with text output src_emacs-lisp{"eric"}.
+

contrib/babel/test-tangle-load.org

@@ -0,0 +1,18 @@
+#+TITLE: testing org-babel-load
+#+OPTIONS: toc:nil num:nil ^:nil
+
+* elisp blocks
+
+** lets look at the order
+
+#+begin_src emacs-lisp 
+(message "I'm the first")
+#+end_src
+
+#+begin_src emacs-lisp
+(message "I'm the second")
+#+end_src
+
+#+begin_src emacs-lisp
+(message "I'm the third")
+#+end_src

contrib/babel/test-tangle.org

@@ -0,0 +1,108 @@
+#+OPTIONS: toc:2 ^:nil
+#+TITLE: Testing Org-Babel Tangling
+
+* Some file
+
+Some text here
+
+#+BEGIN_SRC sh
+echo "line 1"
+echo "line 2"
+#+END_SRC
+
+more text
+
+#+srcname: ruby-no-session
+#+begin_src ruby
+  def hello
+    puts "hello world"
+  end
+#+end_src
+
+#+srcname: first-ruby-block
+#+begin_src ruby :session special :tangle trivial-symbol
+:block_the_first
+#+end_src
+
+#+srcname: ruby-with-noweb-references
+#+begin_src ruby :tangle yes
+  # <<ruby-no-session>>
+  hello()
+#+end_src
+
+
+
+** Some subsection
+
+#+BEGIN_SRC sh
+echo "line 3"
+echo "line 4"
+#+END_SRC
+
+blah blah blah
+
+#+BEGIN_EXAMPLE
+text line 1
+text line 2
+text line 3
+#+END_EXAMPLE
+
+more stuff
+
+#+srcname: i-have-a-name
+#+begin_src sh 
+echo "I have a name"
+#+end_src
+
+
+foo foo bar baz
+
+#+BEGIN_SRC sh
+echo "line 5"
+echo "line 6"
+#+END_SRC
+
+
+** Ruby blocks
+
+#+srcname: another-ruby-block
+#+begin_src ruby :session special
+holder = 98
+#+end_src
+
+
+#+srcname: ruby-plus-2
+#+begin_src ruby :session special
+def plus_two(n)
+  n + 2
+end
+#+end_src
+
+#+srcname: final-ruby
+#+begin_src ruby :session special
+plus_two(holder)
+#+end_src
+
+
+** Emacs Lisp initialization stuff
+
+#+srcname: lets-set-some-variables()
+#+begin_src emacs-lisp 
+  (setq test-tangle-loading "org-babel tangles")
+  (setq test-tangle-advert "use org-babel-tangle for all your emacs initialization files!!")
+#+end_src
+
+#+srcname: i-shouldnt-be-tangled
+#+begin_src emacs-lisp :tangle no
+  (setq test-tangle-i-should-not-exist "hopefully I'm not included")
+#+end_src
+
+*** Emacs Lisp (not to be tangled)
+    :PROPERTIES:
+    :tangle:   no
+    :END:
+
+#+srcname: i-also-shouldnt-be-tangled
+#+begin_src emacs-lisp 
+  (setq test-tangle-me-either "i also shouldn't be tangled")
+#+end_src