lib: move `Template::write_to_*` to `Streamable`

[nit.git] / lib / standard / file.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2004-2008 Jean Privat <jean@pryen.org>
# Copyright 2008 Floréal Morandat <morandat@lirmm.fr>
# Copyright 2008 Jean-Sébastien Gélinas <calestar@gmail.com>
#
# This file is free software, which comes along with NIT.  This software 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.  You can modify it is you want,  provided this header
# is kept unaltered, and a notification of the changes is added.
# You  are  allowed  to  redistribute it and sell it, alone or is a part of
# another product.

# File manipulations (create, read, write, etc.)
module file

intrude import stream
intrude import string
import string_search
import time

in "C Header" `{
        #include <dirent.h>
        #include <string.h>
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <unistd.h>
`}

redef class Object
# Simple I/O

        # Print `objects` on the standard output (`stdout`).
        protected fun printn(objects: Object...)
        do
                stdout.write(objects.to_s)
        end

        # Print an `object` on the standard output (`stdout`) and add a newline.
        protected fun print(object: Object)
        do
                stdout.write(object.to_s)
                stdout.write("\n")
        end

        # Read a character from the standard input (`stdin`).
        protected fun getc: Char
        do
                return stdin.read_char.ascii
        end

        # Read a line from the standard input (`stdin`).
        protected fun gets: String
        do
                return stdin.read_line
        end

        # Return the working (current) directory
        protected fun getcwd: String do return file_getcwd.to_s
        private fun file_getcwd: NativeString is extern "string_NativeString_NativeString_file_getcwd_0"
end

# File Abstract Stream
abstract class FStream
        super IOS
        # The path of the file.
        readable var _path: nullable String = null

        # The FILE *.
        var _file: nullable NativeFile = null

        fun file_stat: FileStat
        do return _file.file_stat end
end

# File input stream
class IFStream
        super FStream
        super BufferedIStream
        # Misc

        # Open the same file again.
        # The original path is reused, therefore the reopened file can be a different file.
        fun reopen
        do
                if not eof then close
                _file = new NativeFile.io_open_read(_path.to_cstring)
                _end_reached = false
                _buffer_pos = 0
                _buffer.clear
        end

        redef fun close
        do
                var i = _file.io_close
                _end_reached = true
        end

        redef fun fill_buffer
        do
                var nb = _file.io_read(_buffer._items, _buffer._capacity)
                if nb <= 0 then
                        _end_reached = true
                        nb = 0
                end
                _buffer._length = nb
                _buffer_pos = 0
        end
        
        # End of file?
        redef readable var _end_reached: Bool = false

        # Open the file at `path` for reading.
        init open(path: String)
        do
                _path = path
                prepare_buffer(10)
                _file = new NativeFile.io_open_read(_path.to_cstring)
                assert cant_open_file: _file != null
        end

        private init do end
        private init without_file do end
end

# File output stream
class OFStream
        super FStream
        super OStream
        
        redef fun write(s)
        do
                assert _writable
                write_native(s.to_cstring, s.length)
        end

        redef fun is_writable do return _writable
        
        redef fun close
        do
                var i = _file.io_close
                _writable = false
        end

        # Is the file open in write mode
        var _writable: Bool
        
        # Write `len` bytes from `native`.
        private fun write_native(native: NativeString, len: Int)
        do
                assert _writable
                var err = _file.io_write(native, len)
                if err != len then
                        # Big problem
                        printn("Problem in writing : ", err, " ", len, "\n")
                end
        end
        
        # Open the file at `path` for writing.
        init open(path: String)
        do
                _file = new NativeFile.io_open_write(path.to_cstring)
                assert cant_open_file: _file != null
                _path = path
                _writable = true
        end
        
        private init do end
        private init without_file do end
end

###############################################################################

class Stdin
        super IFStream
        private init do
                _file = new NativeFile.native_stdin
                _path = "/dev/stdin"
                prepare_buffer(1)
        end

        # Is these something to read? (non blocking)
        # FIXME: should be generalized
        fun poll_in: Bool is extern "file_stdin_poll_in"
end

class Stdout
        super OFStream
        private init do
                _file = new NativeFile.native_stdout
                _path = "/dev/stdout"
                _writable = true
        end
end

class Stderr
        super OFStream
        private init do
                _file = new NativeFile.native_stderr
                _path = "/dev/stderr"
                _writable = true
        end
end

###############################################################################

redef class Streamable
        # Like `write_to` but take care of creating the file
        fun write_to_file(filepath: String)
        do
                var stream = new OFStream.open(filepath)
                write_to(stream)
                stream.close
        end
end

redef class String
        # return true if a file with this names exists
        fun file_exists: Bool do return to_cstring.file_exists

        fun file_stat: FileStat do return to_cstring.file_stat
        fun file_lstat: FileStat do return to_cstring.file_lstat

        # Remove a file, return true if success
        fun file_delete: Bool do return to_cstring.file_delete

        # Copy content of file at `self` to `dest`
        fun file_copy_to(dest: String)
        do
                var input = new IFStream.open(self)
                var output = new OFStream.open(dest)

                while not input.eof do
                        var buffer = input.read(1024)
                        output.write buffer
                end

                input.close
                output.close
        end

        # remove the trailing extension "ext"
        fun strip_extension(ext: String): String
        do
                if has_suffix(ext) then
                        return substring(0, length - ext.length)
                end
                return self
        end

        # Extract the basename of a path and remove the extension
        fun basename(ext: String): String
        do
                var pos = last_index_of_from('/', _length - 1)
                var n = self
                if pos >= 0 then
                        n = substring_from(pos+1)
                end
                return n.strip_extension(ext)
        end

        # Extract the dirname of a path
        #
        #     assert "/path/to/a_file.ext".dirname         == "/path/to"
        #     assert "path/to/a_file.ext".dirname          == "path/to"
        #     assert "path/to".dirname                     == "path"
        #     assert "path/to/".dirname                    == "path"
        #     assert "path".dirname                        == "."
        #     assert "/path".dirname                       == "/"
        #     assert "/".dirname                           == "/"
        #     assert "".dirname                            == "."
        fun dirname: String
        do
                var l = _length - 1 # Index of the last char
                if l > 0 and self.chars[l] == '/' then l -= 1 # remove trailing `/`
                var pos = last_index_of_from('/', l)
                if pos > 0 then
                        return substring(0, pos)
                else if pos == 0 then
                        return "/"
                else
                        return "."
                end
        end

        # Return the canonicalized absolute pathname (see POSIX function `realpath`)
        fun realpath: String do
                var cs = to_cstring.file_realpath
                var res = cs.to_s_with_copy
                # cs.free_malloc # FIXME memory leak
                return res
        end

        # Simplify a file path by remove useless ".", removing "//", and resolving ".."
        # ".." are not resolved if they start the path
        # starting "/" is not removed
        # trainling "/" is removed
        #
        # Note that the method only wonrk on the string:
        #  * no I/O access is performed
        #  * the validity of the path is not checked
        #
        #     assert "some/./complex/../../path/from/../to/a////file//".simplify_path        ==  "path/to/a/file"
        #     assert "../dir/file".simplify_path       ==  "../dir/file"
        #     assert "dir/../../".simplify_path        ==  ".."
        #     assert "dir/..".simplify_path            ==  "."
        #     assert "//absolute//path/".simplify_path ==  "/absolute/path"
        fun simplify_path: String
        do
                var a = self.split_with("/")
                var a2 = new Array[String]
                for x in a do
                        if x == "." then continue
                        if x == "" and not a2.is_empty then continue
                        if x == ".." and not a2.is_empty and a2.last != ".." then
                                a2.pop
                                continue
                        end
                        a2.push(x)
                end
                if a2.is_empty then return "."
                return a2.join("/")
        end

        # Correctly join two path using the directory separator.
        #
        # Using a standard "{self}/{path}" does not work when `self` is the empty string.
        # This method ensure that the join is valid.
        #
        #     assert "hello".join_path("world")      ==  "hello/world"
        #     assert "hel/lo".join_path("wor/ld")      ==  "hel/lo/wor/ld"
        #     assert "".join_path("world")      ==  "world"
        #     assert "/hello".join_path("/world")      ==  "/world"
        #
        # Note: you may want to use `simplify_path` on the result
        #
        # Note: I you want to join a great number of path, you can write
        #
        #     [p1, p2, p3, p4].join("/")
        fun join_path(path: String): String
        do
                if path.is_empty then return self
                if self.is_empty then return path
                if path.chars[0] == '/' then return path
                return "{self}/{path}"
        end

        # Create a directory (and all intermediate directories if needed)
        fun mkdir
        do
                var dirs = self.split_with("/")
                var path = new Buffer
                if dirs.is_empty then return
                if dirs[0].is_empty then
                        # it was a starting /
                        path.add('/')
                end
                for d in dirs do
                        if d.is_empty then continue
                        path.append(d)
                        path.add('/')
                        path.to_s.to_cstring.file_mkdir
                end
        end

        # Change the current working directory
        #
        #     "/etc".chdir
        #     assert getcwd == "/etc"
        #     "..".chdir
        #     assert getcwd == "/"
        #
        # TODO: errno
        fun chdir do to_cstring.file_chdir

        # Return right-most extension (without the dot)
        fun file_extension : nullable String
        do
                var last_slash = last_index_of('.')
                if last_slash >= 0 then
                        return substring( last_slash+1, length )
                else
                        return null
                end
        end

        # returns files contained within the directory represented by self
        fun files : Set[ String ] is extern import HashSet[String], HashSet[String].add, NativeString.to_s, String.to_cstring, HashSet[String].as(Set[String]) `{
                char *dir_path;
                DIR *dir;

                dir_path = String_to_cstring( recv );
                if ((dir = opendir(dir_path)) == NULL)
                {
                        perror( dir_path );
                        exit( 1 );
                }
                else
                {
                        HashSet_of_String results;
                        String file_name;
                        struct dirent *de;

                        results = new_HashSet_of_String();

                        while ( ( de = readdir( dir ) ) != NULL )
                                if ( strcmp( de->d_name, ".." ) != 0 &&
                                        strcmp( de->d_name, "." ) != 0 )
                                {
                                        file_name = NativeString_to_s( strdup( de->d_name ) );
                                        HashSet_of_String_add( results, file_name );
                                }

                        closedir( dir );
                        return HashSet_of_String_as_Set_of_String( results );
                }
        `}
end

redef class NativeString
        private fun file_exists: Bool is extern "string_NativeString_NativeString_file_exists_0"
        private fun file_stat: FileStat is extern "string_NativeString_NativeString_file_stat_0"
        private fun file_lstat: FileStat `{
                struct stat* stat_element;
                int res;
                stat_element = malloc(sizeof(struct stat));
                res = lstat(recv, stat_element);
                if (res == -1) return NULL;
                return stat_element;
        `}
        private fun file_mkdir: Bool is extern "string_NativeString_NativeString_file_mkdir_0"
        private fun file_delete: Bool is extern "string_NativeString_NativeString_file_delete_0"
        private fun file_chdir is extern "string_NativeString_NativeString_file_chdir_0"
        private fun file_realpath: NativeString is extern "file_NativeString_realpath"
end

extern FileStat `{ struct stat * `}
# This class is system dependent ... must reify the vfs
        fun mode: Int is extern "file_FileStat_FileStat_mode_0"
        fun atime: Int is extern "file_FileStat_FileStat_atime_0"
        fun ctime: Int is extern "file_FileStat_FileStat_ctime_0"
        fun mtime: Int is extern "file_FileStat_FileStat_mtime_0"
        fun size: Int is extern "file_FileStat_FileStat_size_0"

        fun is_reg: Bool `{ return S_ISREG(recv->st_mode); `}
        fun is_dir: Bool `{ return S_ISDIR(recv->st_mode); `}
        fun is_chr: Bool `{ return S_ISCHR(recv->st_mode); `}
        fun is_blk: Bool `{ return S_ISBLK(recv->st_mode); `}
        fun is_fifo: Bool `{ return S_ISFIFO(recv->st_mode); `}
        fun is_lnk: Bool `{ return S_ISLNK(recv->st_mode); `}
        fun is_sock: Bool `{ return S_ISSOCK(recv->st_mode); `}
end

# Instance of this class are standard FILE * pointers
private extern NativeFile `{ FILE* `}
        fun io_read(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_read_2"
        fun io_write(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_write_2"
        fun io_close: Int is extern "file_NativeFile_NativeFile_io_close_0"
        fun file_stat: FileStat is extern "file_NativeFile_NativeFile_file_stat_0"

        new io_open_read(path: NativeString) is extern "file_NativeFileCapable_NativeFileCapable_io_open_read_1"
        new io_open_write(path: NativeString) is extern "file_NativeFileCapable_NativeFileCapable_io_open_write_1"
        new native_stdin is extern "file_NativeFileCapable_NativeFileCapable_native_stdin_0"
        new native_stdout is extern "file_NativeFileCapable_NativeFileCapable_native_stdout_0"
        new native_stderr is extern "file_NativeFileCapable_NativeFileCapable_native_stderr_0"
end

# Standard input.
fun stdin: Stdin do return once new Stdin

# Standard output.
fun stdout: OFStream do return once new Stdout

# Standard output for error.
fun stderr: OFStream do return once new Stderr