Metadata-Version: 1.1
Name: Fortpy
Version: 1.1.2
Summary: Fortran Parsing, Unit Testing and Intellisense
Home-page: https://github.com/rosenbrockc/fortpy
Author: Conrad W Rosenbrock
Author-email: rosenbrockc@gmail.com
License: MIT
Description: FORTPY
        ======
        
        Python Emacs Intellisense and Unit Testing Support for Fortran
        --------------------------------------------------------------
        
        Fortpy is a python based parsing, unit testing and auto-complete
        framework for supporting Fortran 2003 including object oriented
        constructs. Auto-completion integration currently only available for
        emacs. Here are some of the features:
        
        Python Package Installation
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        Fortpy requires the following python packages: -
        `python-epc <https://github.com/tkf/python-epc>`__ - argparse -
        `paramiko <https://github.com/paramiko/paramiko>`__ if you will be
        editing over SSH using tramp in emacs and still want auto-complete
        support. - pyparsing - dateutil
        
        If you install Fortpy using ``pip install`` the dependencies will
        automatically get installed.
        
        ::
        
            pip install fortpy
        
        Fortpy Configuration
        ~~~~~~~~~~~~~~~~~~~~
        
        In most real-usage scenarios, the out-of-the-box support for multiple
        libraries is incomplete. A `configuration
        file <https://github.com/rosenbrockc/fortpy/wiki/Fortpy-Global-Configuration>`__
        can be created that gives additional information about source code
        folders to parse, server information for SSH editing over tramp and
        auto-completion configuration settings. After you have created a
        ``config.xml`` file on your system, you need to configure an environment
        variable to tell Fortpy where to find it:
        
        ``export FORTPY_CONFIG="~/path/to/config.xml"``
        
        NOTE: Environment variables for emacs are set when it first starts;
        adding a config.xml file will not affect the emacs isense support until
        you restart emacs.
        
        Screenshots
        -----------
        
        Here are some of the things you can do once Fortpy is integrated with
        Emacs using fortpy.el:
        
        .. figure:: ../master/docs/screenshots/signature.png
           :alt: Help with call signatures of functions and subroutines.
        
           Automatic Signature Suggestions
        Help with call signatures of functions and subroutines.
        
        .. figure:: ../master/docs/screenshots/completion.png
           :alt: Completion suggestions for both methods and variables embedded in user-defined types.
        
           Embedded Member Suggestions
        Completion suggestions for both methods and variables embedded in
        user-defined types.
        
        .. figure:: ../master/docs/screenshots/bracket_complete.png
           :alt: Documentation strings for methods embedded in user-defined types
        
           Bracket Complete Embedded Methods
        Documentation strings for methods embedded in user-defined types.
        
        Features
        --------
        
        Auto-complete Support
        ~~~~~~~~~~~~~~~~~~~~~
        
        -  Integration with emacs using virtualenv, epc and auto-complete.
        -  Context-specific suggestions for variable names and available
           executables.
        
        See the `isense package
        documentation <https://github.com/rosenbrockc/fortpy/wiki/Intellisense-Package>`__
        
        XML Documentation Standard
        ~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        Fortpy uses an `XML documentation
        standard <https://github.com/rosenbrockc/fortpy/wiki/XML-Documentation-Standard>`__
        that is derived from the Microsoft XML code documentation standard. As
        such, many of the same tags and attributes are available for decorating
        the methods, types and variables in a Fortran module. Because the
        parsers were designed to work with Fortran 2003, they understand
        embedded methods in user types that point to other methods in the
        module. See the wiki page on documenting your code to work with Fortpy.
        
        .. figure:: ../master/docs/screenshots/xml_docs.png
           :alt: XML documentation standard allows for complex documentation strings and structures.
        
           XML Documentation Example
        Automated Unit Testing
        ~~~~~~~~~~~~~~~~~~~~~~
        
        Because Fortpy is aware of the structure and dependencies between
        modules, it can generate automated unit tests for individual functions.
        You can specify the tests to run in some XML documentation decorating
        the method to test. When the unit testing scripts are run, a fortran
        program gets generated and all the necessary dependencies are
        automatically included. After running the program, the framework tests
        the output and generates a similarity score. `See the full
        documentation <https://github.com/rosenbrockc/fortpy/wiki/Unit-Testing-Package>`__.
        
        Code Version Support
        ~~~~~~~~~~~~~~~~~~~~
        
        Fortpy's unit testing framework makes use of XML templates that specify
        the structure of input/output files to run and test. Using these same
        templates, the interoperability package allows input and ouput files to
        be converted between versions of the Fortran program. Since most Fortran
        programs run on simple text files for input, the interop package also
        gives support for XML input files to be used; scripts convert the XML
        input files to the correct plain-text format at run-time.
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: MacOS
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Topic :: Software Development :: Libraries :: Python Modules
