TOP DIRECTORY NAME PROCESSING see if requested new directory already exists and process appropriately temporarily change to new directory as a test. NB: System dependent
| Type | Intent | Optional | Attributes | Name | ||
|---|---|---|---|---|---|---|
| type(fpm_new_settings), | intent(in) | :: | settings |
subroutine cmd_new(settings) type(fpm_new_settings), intent(in) :: settings integer,parameter :: tfc = selected_char_kind('DEFAULT') character(len=:,kind=tfc),allocatable :: bname ! baeename of NAME character(len=:,kind=tfc),allocatable :: tomlfile(:) character(len=:,kind=tfc),allocatable :: littlefile(:) !> TOP DIRECTORY NAME PROCESSING !> see if requested new directory already exists and process appropriately if(exists(settings%name) .and. .not.settings%backfill )then write(stderr,'(*(g0,1x))')& & '<ERROR>',settings%name,'already exists.' write(stderr,'(*(g0,1x))')& & ' perhaps you wanted to add --backfill ?' return elseif(is_dir(settings%name) .and. settings%backfill )then write(*,'(*(g0))')'backfilling ',settings%name elseif(exists(settings%name) )then write(stderr,'(*(g0,1x))')& & '<ERROR>',settings%name,'already exists and is not a directory.' return else ! make new directory call mkdir(settings%name) endif !> temporarily change to new directory as a test. NB: System dependent call run('cd '//settings%name) ! NOTE: need some system routines to handle filenames like "." ! like realpath() or getcwd(). bname=basename(settings%name) littlefile=[character(len=80) :: '# '//bname, 'My cool new project!'] ! create NAME/README.md call warnwrite(join_path(settings%name, 'README.md'), littlefile) ! start building NAME/fpm.toml if(settings%with_full)then tomlfile=[character(len=80) :: & &' # This is your fpm(Fortran Package Manager) manifest file ',& &' # ("fpm.toml"). It is heavily annotated to help guide you though ',& &' # customizing a package build, although the defaults are sufficient ',& &' # for many basic packages. ',& &' # ',& &' # The manifest file is not only used to provide metadata identifying ',& &' # your project (so it can be used by others as a dependency). It can ',& &' # specify where your library and program sources live, what the name ',& &' # of the executable(s) will be, what files to build, dependencies on ',& &' # other fpm packages, and what external libraries are required. ',& &' # ',& &' # The manifest format must conform to the TOML configuration file ',& &' # standard. ',& &' # ',& &' # TOML files support flexible use of white-space and commenting of the ',& &' # configuration data, but for clarity in this sample active directives ',& &' # begin in column one. Inactive example directives are commented ',& &' # out with a pound character ("#") but begin in column one as well. ',& &' # Commentary begins with a pound character in column three. ',& &' # ',& &' # This file draws heavily upon the following references: ',& &' # ',& &' # The fpm home page at ',& &' # https://github.com/fortran-lang/fpm ',& &' # A complete list of keys and their attributes at ',& &' # https://github.com/fortran-lang/fpm/blob/main/manifest-reference.md ',& &' # examples of fpm project packaging at ',& &' # https://github.com/fortran-lang/fpm/blob/main/PACKAGING.md ',& &' # The Fortran TOML file interface and it''s references at ',& &' # https://github.com/toml-f/toml-f ',& &' # ',& &' #----------------------- ',& &' # project Identification ',& &' #----------------------- ',& &' # We begin with project metadata at the manifest root. This data is designed ',& &' # to aid others when searching for the project in a repository and to ',& &' # identify how and when to contact the package supporters. ',& &' ',& &'name = "'//bname//'"',& &' # The project name (required) is how the project will be referred to. ',& &' # The name is used by other packages using it as a dependency. It also ',& &' # is used as the default name of any library built and the optional ',& &' # default executable built from app/main.f90. It must conform to the rules ',& &' # for a Fortran variable name. ',& &' ',& &'version = "0.1.0" ',& &' # The project version number is a string. A recommended scheme for ',& &' # specifying versions is the Semantic Versioning scheme. ',& &' ',& &'license = "license" ',& &' # Licensing information specified using SPDX identifiers is preferred ',& &' # (eg. "Apache-2.0 OR MIT" or "LGPL-3.0-or-later"). ',& &' ',& &'maintainer = "jane.doe@example.com" ',& &' # Information on the project maintainer and means to reach out to them. ',& &' ',& &'author = "Jane Doe" ',& &' # Information on the project author. ',& &' ',& &'copyright = "Copyright 2020 Jane Doe" ',& &' # A statement clarifying the Copyright status of the project. ',& &' ',& &'#description = "A short project summary in plain text" ',& &' # The description provides a short summary on the project. It should be ',& &' # plain text and not use any markup formatting. ',& &' ',& &'#categories = ["fortran", "graphics"] ',& &' # Categories associated with the project. Listing only one is preferred. ',& &' ',& &'#keywords = ["hdf5", "mpi"] ',& &' # The keywords field is an array of strings describing the project. ',& &' ',& &'#homepage = "https://stdlib.fortran-lang.org" ',& &' # URL to the webpage of the project. ',& &' ',& &' # ----------------------------------------- ',& &' # We are done with identifying the project. ',& &' # ----------------------------------------- ',& &' # ',& &' # Now lets start describing how the project should be built. ',& &' # ',& &' # Note tables would go here but we will not be talking about them (much)!!' ,& &' # ',& &' # Tables are a way to explicitly specify large numbers of programs in ',& &' # a compact format instead of individual per-program entries in the ',& &' # [[executable]], [[test]], and [[example]] sections to follow but ',& &' # will not be discussed further except for the following notes: ',& &' # ',& &' # + Tables must appear (here) before any sections are declared. Once a ',& &' # section is specified in a TOML file everything afterwards must be ',& &' # values for that section or the beginning of a new section. A simple ',& &' # example looks like: ',& &' ',& &'#executable = [ ',& &'# { name = "a-prog" }, ',& &'# { name = "app-tool", source-dir = "tool" }, ',& &'# { name = "fpm-man", source-dir = "tool", main="fman.f90" } ',& &'#] ',& &' ',& &' # This would be in lieue of the [[executable]] section found later in this ',& &' # configuration file. ',& &' # + See the reference documents (at the beginning of this document) ',& &' # for more information on tables if you have long lists of programs ',& &' # to build and are not simply depending on auto-detection. ',& &' # ',& &' # Now lets begin the TOML sections (lines beginning with "[") ... ',& &' # ',& &' ',& &'[install] # Options for the "install" subcommand ',& &' ',& &' # When you run the "install" subcommand only executables are installed by ',& &' # default on the local system. Library projects that will be used outside of ',& &' # "fpm" can set the "library" boolean to also allow installing the module ',& &' # files and library archive. Without this being set to "true" an "install" ',& &' # subcommand ignores parameters that specify library installation. ',& &' ',& &' # If your project sets `[library] type = "shared"`, enabling this option ',& &' # will install the compiled `.so`, `.dylib`, or `.dll` files into the ',& &' # appropriate `lib/` folder. This applies equally to static archives. ',& &' # ',& &' # For shared libraries, installing is typically required for runtime usage. ',& &' ',& &'library = false ',& &' ',& &'[build] # General Build Options ',& &' ',& &' ### Automatic target discovery ',& &' # ',& &' # Normally fpm recursively searches the app/, example/, and test/ directories ',& &' # for program sources and builds them. To disable this automatic discovery of ',& &' # program targets set the following to "false": ',& &' ',& &'#auto-executables = true ',& &'#auto-examples = true ',& &'#auto-tests = true ',& &' ',& &' ### Package-level External Library Links ',& &' # ',& &' # To declare link-time dependencies on external libraries a list of ',& &' # native libraries can be specified with the "link" entry. You may ',& &' # have one library name or a list of strings in case several ',& &' # libraries should be linked. This list of library dependencies is ',& &' # exported to dependent packages. You may have to alter your library ',& &' # search-path to ensure the libraries can be accessed. Typically, ',& &' # this is done with the LD_LIBRARY_PATH environment variable on ULS ',& &' # (Unix-Like Systems). You only specify the core name of the library ',& &' # (as is typical with most programming environments, where you ',& &' # would specify "-lz" on your load command to link against the zlib ',& &' # compression library even though the library file would typically be ',& &' # a file called "libz.a" "or libz.so"). So to link against that library ',& &' # you would specify: ',& &' ',& &'#link = "z" ',& &' ',& &' # Note that in some cases the order of the libraries matters: ',& &' ',& &'#link = ["blas", "lapack"] ',& &''] endif if(settings%with_bare)then elseif(settings%with_lib)then call mkdir(join_path(settings%name,'src') ) ! create next section of fpm.toml if(settings%with_full)then tomlfile=[character(len=80) :: tomlfile, & &'[library] ',& &' ',& &' # You can change the name of the directory to search for your library ',& &' # source from the default of "src/". Library targets are exported ',& &' # and usable by other projects. ',& &' ',& &'source-dir="src" ',& &' ',& &' # this can be a list: ',& &' ',& &'#source-dir=["src", "src2"] ',& &' ',& &' # More complex libraries may organize their modules in subdirectories. ',& &' # For modules in a top-level directory fpm requires (but does not ',& &' # enforce) that: ',& &' # ',& &' # + The module has the same name as the source file. This is important. ',& &' # + There should be only one module per file. ',& &' # ',& &' # These two requirements simplify the build process for fpm. As Fortran ',& &' # compilers emit module files (.mod) with the same name as the module ',& &' # itself (but not the source file, .f90), naming the module the same ',& &' # as the source file allows fpm to: ',& &' # ',& &' # + Uniquely and exactly map a source file (.f90) to its object (.o) ',& &' # and module (.mod) files. ',& &' # + Avoid conflicts with modules of the same name that could appear ',& &' # in dependency packages. ',& &' # ',& &' ### Multi-level library source ',& &' # You can place your module source files in any number of levels of ',& &' # subdirectories inside your source directory, but there are certain naming ',& &' # conventions to be followed -- module names must contain the path components ',& &' # of the directory that its source file is in. ',& &' # ',& &' # This rule applies generally to any number of nested directories and ',& &' # modules. For example, src/a/b/c/d.f90 must define a module called a_b_c_d. ',& &' # Again, this is not enforced but may be required in future releases. ',& &' ',& &' ### Library type ',& &' # Set `type = "shared"` to build dynamic libraries (.so/.dylib/.dll) ',& &' # instead of a static archive. You can also set `type = "static"` to ',& &' # generate per-package archives, or use `type = "monolithic"` (default) ',& &' # to bundle all sources and dependencies into a single archive. ',& &' # ',& &' # Supported types: ',& &' # ',& &' # + "monolithic": Single archive with used sources and dependencies. ',& &' # + "static": One full archive per package (for external integration). ',& &' # + "shared": One shared library per package, for dynamic linking. ',& &' # ',& &' # Shared libraries are useful for plugin systems, dynamic linking, or ',& &' # language bindings. Static per-package archives may aid external reuse. ',& &' # ',& &' # When running with `fpm run`, shared library paths are automatically ',& &' # added to the environment (e.g. `LD_LIBRARY_PATH`, `PATH`) at runtime. ',& &' # ',& &' # Note: library files are not installed unless `[install] library=true` ',& &' # is also enabled. ',& &' # ',& &' # Example: ',& &' ',& &'type = "shared" ',& &' ',& &''] endif ! create placeholder module src/bname.f90 littlefile=[character(len=80) :: & &'module '//to_fortran_name(bname), & &' implicit none', & &' private', & &'', & &' public :: say_hello', & &'contains', & &' subroutine say_hello', & &' print *, "Hello, '//bname//'!"', & &' end subroutine say_hello', & &'end module '//to_fortran_name(bname)] ! create NAME/src/NAME.f90 call warnwrite(join_path(settings%name, 'src', bname//'.f90'),& & littlefile) endif if(settings%with_full)then tomlfile=[character(len=80) :: tomlfile ,& &'[dependencies] ',& &' ',& &' # Inevitably, you will want to be able to include other packages in ',& &' # a project. Fpm makes this incredibly simple, by taking care of ',& &' # fetching and compiling your dependencies for you. You just tell it ',& &' # what your dependencies names are, and where to find them. ',& &' # ',& &' # If you are going to distribute your package only place dependencies ',& &' # here someone using your package as a remote dependency needs built. ',& &' # You can define dependencies just for developer executables in the ',& &' # next section, or even for specific executables as we will see below ',& &' # (Then fpm will still fetch and compile it when building your ',& &' # developer executables, but users of your library will not have to). ',& &' # ',& &' ## GLOBAL DEPENDENCIES (exported with your project) ',& &' # ',& &' # Typically, dependencies are defined by specifying the project''s ',& &' # git repository. ',& &' # ',& &' # You can be specific about which version of a dependency you would ',& &' # like. By default the latest default branch is used. You can ',& &' # optionally specify a branch, a tag or a commit value. ',& &' # ',& &' # So here are several alternates for specifying a remote dependency (you ',& &' # can have at most one of "branch", "rev" or "tag" present): ',& &' ',& &'#stdlib = { git = "https://github.com/LKedward/stdlib-fpm.git" } ',& &'#stdlib = {git="https://github.com/LKedward/stdlib-fpm.git",branch = "master" },',& &'#stdlib = {git="https://github.com/LKedward/stdlib-fpm.git", tag = "v0.1.0" }, ',& &'#stdlib = {git="https://github.com/LKedward/stdlib-fpm.git", rev = "5a9b7a8" }. ',& &' ',& &' # There may be multiple packages listed: ',& &' ',& &'#M_strings = { git = "https://github.com/urbanjost/M_strings.git" } ',& &'#M_time = { git = "https://github.com/urbanjost/M_time.git" } ',& &' ',& &' # ',& &' # You can even specify the local path to another project if it is in ',& &' # a sub-folder (If for example you have got another fpm package **in ',& &' # the same repository**) like this: ',& &' ',& &'#M_strings = { path = "M_strings" } ',& &' ',& &' # This tells fpm that we depend on a crate called M_strings which is found ',& &' # in the M_strings folder (relative to the fpm.toml it’s written in). ',& &' # ',& &' # For a more verbose layout use normal tables rather than inline tables ',& &' # to specify dependencies: ',& &' ',& &'#[dependencies.toml-f] ',& &'#git = "https://github.com/toml-f/toml-f" ',& &'#rev = "2f5eaba864ff630ba0c3791126a3f811b6e437f3" ',& &' ',& &' # Now you can use any modules from these libraries anywhere in your ',& &' # code -- whether is in your library source or a program source. ',& &' ',& &'[dev-dependencies] ',& &' ',& &' ## Dependencies Only for Development ',& &' # ',& &' # You can specify dependencies your library or application does not ',& &' # depend on in a similar way. The difference is that these will not ',& &' # be exported as part of your project to those using it as a remote ',& &' # dependency. ',& &' # ',& &' # Currently, like a global dependency it will still be available for ',& &' # all codes. It is up to the developer to ensure that nothing except ',& &' # developer test programs rely upon it. ',& &' ',& &'#M_msg = { git = "https://github.com/urbanjost/M_msg.git" } ',& &'#M_verify = { git = "https://github.com/urbanjost/M_verify.git" } ',& &''] endif if(settings%with_bare)then elseif(settings%with_executable)then ! create next section of fpm.toml call mkdir(join_path(settings%name, 'app')) ! create NAME/app or stop if(settings%with_full)then tomlfile=[character(len=80) :: tomlfile, & &' #----------------------------------- ',& &' ## Application-specific declarations ',& &' #----------------------------------- ',& &' # Now lets begin entries for the TOML tables (lines beginning with "[[") ',& &' # that describe the program sources -- applications, tests, and examples. ',& &' # ',& &' # First we will configuration individual applications run with "fpm run". ',& &' # ',& &' # + the "name" entry for the executable to be built must always ',& &' # be specified. The name must satisfy the rules for a Fortran ',& &' # variable name. This will be the name of the binary installed by ',& &' # the "install" subcommand and used on the "run" subcommand. ',& &' # + The source directory for each executable can be adjusted by the ',& &' # "source-dir" entry. ',& &' # + The basename of the source file containing the program body can ',& &' # be specified with the "main" entry. ',& &' # + Executables can also specify their own external package and ',& &' # library link dependencies. ',& &' # ',& &' # Currently, like a global dependency any external package dependency ',& &' # will be available for all codes. It is up to the developer to ensure ',& &' # that nothing except the application programs specified rely upon it. ',& &' # ',& &' # Note if your application needs to use a module internally, but you do not ',& &' # intend to build it as a library to be used in other projects, you can ',& &' # include the module in your program source file or directory as well. ',& &' ',& &'[[executable]] ',& &'name="'//bname//'"',& &'source-dir="app" ',& &'main="main.f90" ',& &' ',& &' # You may repeat this pattern to define additional applications. For instance,',& &' # the following sample illustrates all accepted options, where "link" and ',& &' # "executable.dependencies" keys are the same as the global external library ',& &' # links and package dependencies described previously except they apply ',& &' # only to this executable: ',& &' ',& &'#[[ executable ]] ',& &'#name = "app-name" ',& &'#source-dir = "prog" ',& &'#main = "program.f90" ',& &'#link = "z" ',& &'#[executable.dependencies] ',& &'#M_CLI = { git = "https://github.com/urbanjost/M_CLI.git" } ',& &'#helloff = { git = "https://gitlab.com/everythingfunctional/helloff.git" } ',& &'#M_path = { git = "https://github.com/urbanjost/M_path.git" } ',& &''] endif if(exists(bname//'/src/'))then littlefile=[character(len=80) :: & &'program main', & &' use '//to_fortran_name(bname)//', only: say_hello', & &' implicit none', & &'', & &' call say_hello()', & &'end program main'] else littlefile=[character(len=80) :: & &'program main', & &' implicit none', & &'', & &' print *, "hello from project '//bname//'"', & &'end program main'] endif call warnwrite(join_path(settings%name, 'app/main.f90'), littlefile) endif if(settings%with_bare)then elseif(settings%with_test)then ! create NAME/test or stop call mkdir(join_path(settings%name, 'test')) ! create next section of fpm.toml if(settings%with_full)then tomlfile=[character(len=80) :: tomlfile ,& &'[[test]] ',& &' ',& &' # The same declarations can be made for test programs, which are ',& &' # executed with the "fpm test" command and are not build when your ',& &' # package is used as a dependency by other packages. These are ',& &' # typically unit tests of the package only used during package ',& &' # development. ',& &' ',& &'name="runTests" ',& &'source-dir="test" ',& &'main="check.f90" ',& &' ',& &' # you may repeat this pattern to add additional explicit test program ',& &' # parameters. The following example contains a sample of all accepted ',& &' # options. ',& &' ',& &'#[[ test ]] ',& &'#name = "tester" ',& &'#source-dir="test" ',& &'#main="tester.f90" ',& &'#link = ["blas", "lapack"] ',& &'#[test.dependencies] ',& &'#M_CLI2 = { git = "https://github.com/urbanjost/M_CLI2.git" } ',& &'#M_io = { git = "https://github.com/urbanjost/M_io.git" } ',& &'#M_system= { git = "https://github.com/urbanjost/M_system.git" } ',& &''] endif littlefile=[character(len=80) :: & &'program check', & &'implicit none', & &'', & &'print *, "Put some tests in here!"', & &'end program check'] ! create NAME/test/check.f90 call warnwrite(join_path(settings%name, 'test/check.f90'), littlefile) endif if(settings%with_bare)then elseif(settings%with_example)then ! create NAME/example or stop call mkdir(join_path(settings%name, 'example')) ! create next section of fpm.toml if(settings%with_full)then tomlfile=[character(len=80) :: tomlfile, & &'[[example]] ',& &' ',& &' # Example applications for a project are defined here. ',& &' # These are run via "fpm run --example NAME" and like the ',& &' # test applications, are not built when this package is used as a ',& &' # dependency by other packages. ',& &' ',& &'name="demo" ',& &'source-dir="example" ',& &'main="demo.f90" ',& &' ',& &' # ',& &' # you may add additional programs to the example table. The following ',& &' # example contains a sample of all accepted options ',& &' ',& &'#[[ example ]] ',& &'#name = "example-tool" ',& &'#source-dir="example" ',& &'#main="tool.f90" ',& &'#link = "z" ',& &'#[example.dependencies] ',& &'#M_kracken95 = { git = "https://github.com/urbanjost/M_kracken95.git" } ',& &'#datetime = {git = "https://github.com/wavebitscientific/datetime-fortran.git" }',& &''] endif littlefile=[character(len=80) :: & &'program demo', & &'implicit none', & &'', & &'print *, "Put some examples in here!"', & &'end program demo'] ! create NAME/example/demo.f90 call warnwrite(join_path(settings%name, 'example/demo.f90'), littlefile) endif ! now that built it write NAME/fpm.toml if( allocated(tomlfile) )then call validate_toml_data(tomlfile) call warnwrite(join_path(settings%name, 'fpm.toml'), tomlfile) else call create_verified_basic_manifest(join_path(settings%name, 'fpm.toml')) endif ! assumes git(1) is installed and in path if(which('git')/='')then call run('git init ' // settings%name) endif contains function git_metadata(what) result(returned) !> get metadata values such as email address and git name from git(1) or return appropriate default use fpm_filesystem, only : get_temp_filename, getline character(len=*), intent(in) :: what ! keyword designating what git metatdata to query character(len=:), allocatable :: returned ! value to return for requested keyword character(len=:), allocatable :: command character(len=:), allocatable :: temp_filename character(len=:), allocatable :: iomsg character(len=:), allocatable :: temp_value integer :: stat, unit temp_filename = get_temp_filename() ! for known keywords set default value for RETURNED and associated git(1) command for query select case(what) case('uname') returned = "Jane Doe" command = "git config --get user.name > " // temp_filename case('email') returned = "jane.doe@example.com" command = "git config --get user.email > " // temp_filename case default write(stderr,'(*(g0,1x))')& & '<ERROR> *git_metadata* unknown metadata name ',trim(what) returned='' return end select ! Execute command if git(1) is in command path if(which('git')/='')then call run(command, exitstat=stat) if (stat /= 0) then ! If command failed just return default return else ! Command did not return an error so try to read expected output file open(file=temp_filename, newunit=unit,iostat=stat) if(stat == 0)then ! Read file into a scratch variable until status of doing so is checked call getline(unit, temp_value, stat, iomsg) if (stat == 0 .and. temp_value /= '') then ! Return output from successful command returned=temp_value endif endif ! Always do the CLOSE because a failed open has unpredictable results. ! Add IOSTAT so a failed close does not cause program to stop close(unit, status="delete",iostat=stat) endif endif end function git_metadata subroutine create_verified_basic_manifest(filename) !> create a basic but verified default manifest file use tomlf, only : toml_table, toml_serialize use fpm_toml, only : set_value use fpm_manifest_package, only : package_config_t, new_package use fpm_error, only : error_t implicit none character(len=*),intent(in) :: filename type(toml_table) :: table type(package_config_t) :: package type(error_t), allocatable :: error integer :: lun character(len=8) :: date character(:), allocatable :: output if(exists(filename))then write(stderr,'(*(g0,1x))')'<INFO> ',filename,& & 'already exists. Not overwriting' return endif !> get date to put into metadata in manifest file "fpm.toml" call date_and_time(DATE=date) table = toml_table() call fileopen(filename,lun) ! fileopen stops on error call set_value(table, "name", BNAME) call set_value(table, "version", "0.1.0") call set_value(table, "license", "license") call set_value(table, "author", git_metadata('uname')) call set_value(table, "maintainer", git_metadata('email')) call set_value(table, "copyright", 'Copyright '//date(1:4)//', '//git_metadata('uname')) ! continue building of manifest ! ... call new_package(package, table, error=error) if (allocated(error)) call fpm_stop( 3,'') output = toml_serialize(table) if(settings%verbose)then print '(a)', output endif write(lun, '(a)') output call fileclose(lun) ! fileopen stops on error end subroutine create_verified_basic_manifest subroutine validate_toml_data(input) !> verify a string array is a valid fpm.toml file ! use tomlf, only : toml_table, toml_load, toml_serialize implicit none character(kind=tfc,len=:),intent(in),allocatable :: input(:) character(len=1), parameter :: nl = new_line('a') type(toml_table), allocatable :: table character(kind=tfc, len=:), allocatable :: joined_string ! you have to add a newline character by using the intrinsic ! function `new_line("a")` to get the lines processed correctly. joined_string = join(input,right=nl) if (allocated(table)) deallocate(table) call toml_load(table, joined_string) if (allocated(table)) then if(settings%verbose)then ! If the TOML file is successfully parsed the table will be allocated and ! can be written by `toml_serialize` to the standard output print '(a)', toml_serialize(table) endif call table%destroy endif end subroutine validate_toml_data end subroutine cmd_new