Fix content/contents mixup. (#81)

The correct term is actually "contents".

Author: floitsch

src/file.toit

@@ -161,8 +161,10 @@ class Stream extends Object with io.CloseableInMixin io.CloseableOutMixin implem
     return false
 
 
-/// Deprecated. Use $read-content instead.
-read-contents name:
+/**
+Use $read-contents instead.
+*/
+read-content name:
   return read-content name
 
 /**
@@ -174,7 +176,7 @@ The content is stored in an off-heap ByteArray.
 On small devices with a flash filesystem, simply gets a view
   of the underlying bytes. (Not implemented yet)
 */
-read-content file-name/string -> ByteArray:
+read-contents file-name/string -> ByteArray:
   length := size file-name
   if length == 0: return #[]
   file := Stream.for-read file-name
@@ -194,6 +196,10 @@ read-content file-name/string -> ByteArray:
   finally:
     file.close
 
+/** Use $write-contents instead. */
+write-content content/io.Data --path/string --permissions/int?=null -> none:
+  write-contents content --path=path --permissions=permissions
+
 /**
 Writes the given $content to a file of the given $path.
 The file must not change while it is read into memory.
@@ -202,7 +208,7 @@ If $permissions is provided uses it to set the permissions of the file.
 The $permissions are only used if the file is created, and not if it is
   overwritten.
 */
-write-content content/io.Data --path/string --permissions/int?=null -> none:
+write-contents content/io.Data --path/string --permissions/int?=null -> none:
   stream := Stream.for-write path --permissions=permissions
   try:
     stream.out.write content

tests/chmod_test.toit

@@ -14,7 +14,7 @@ main:
   expect (file.is-directory tmp-dir)
 
   directory.chdir tmp-dir
-  file.write-content "asdsd" --path="test"
+  file.write-contents "asdsd" --path="test"
   try:
     if system.platform == system.PLATFORM-WINDOWS:
       file.chmod "test" file.WINDOWS-FILE-ATTRIBUTE-READONLY

tests/copy_test.toit

@@ -27,31 +27,31 @@ test-recursive:
 
     content := "foobar".to-byte-array
     other-content := "gee".to-byte-array
-    file.write-content --path=tmp-file content
+    file.write-contents --path=tmp-file content
 
     // Copy absolute path to absolute target path.
     file2 := "$tmp-dir/file2.txt"
     file.copy --source=tmp-file --target=file2
-    expect-equals content (file.read-content file2)
+    expect-equals content (file.read-contents file2)
 
     // Copy of relative file to relative directory path.
     directory.mkdir "subdir2"
     file.copy --source="file.txt" --target="subdir2/file.txt"
-    expect-equals content (file.read-content "subdir2/file.txt")
-    expect-equals content (file.read-content "$tmp-dir/subdir2/file.txt")
+    expect-equals content (file.read-contents "subdir2/file.txt")
+    expect-equals content (file.read-contents "$tmp-dir/subdir2/file.txt")
 
     // Copy recursive.
     directory.mkdir "subdir2/nested-subdir"
-    file.write-content --path="subdir2/nested-subdir/other.txt" other-content
+    file.write-contents --path="subdir2/nested-subdir/other.txt" other-content
     file.copy --source="subdir2" --target="subdir3" --recursive
-    expect-equals content (file.read-content "subdir3/file.txt")
-    expect-equals other-content (file.read-content "subdir3/nested-subdir/other.txt")
+    expect-equals content (file.read-contents "subdir3/file.txt")
+    expect-equals other-content (file.read-contents "subdir3/nested-subdir/other.txt")
 
     // Copy recursive to existing directory.
     directory.mkdir "subdir4"
     file.copy --source="subdir3" --target="subdir4" --recursive
-    expect-equals content (file.read-content "subdir4/file.txt")
-    expect-equals other-content (file.read-content "subdir4/nested-subdir/other.txt")
+    expect-equals content (file.read-contents "subdir4/file.txt")
+    expect-equals other-content (file.read-contents "subdir4/nested-subdir/other.txt")
 
 test-permissions:
   file-permission0/int := ?
@@ -73,7 +73,7 @@ test-permissions:
 
   with-tmp-dir: | tmp-dir |
     file1 := "$tmp-dir/file1.txt"
-    file.write-content --path=file1 "foobar"
+    file.write-contents --path=file1 "foobar"
 
     file.chmod file1 file-permission0
     file.copy --source=file1 --target="$tmp-dir/file2.txt"
@@ -87,31 +87,31 @@ test-permissions:
     directory.mkdir dir
 
     file-in-dir := "$tmp-dir/dir/file.txt"
-    file.write-content --path=file-in-dir "gee"
+    file.write-contents --path=file-in-dir "gee"
 
     file.chmod dir dir-permission
     file.copy --source=dir --target="$tmp-dir/dir2" --recursive
     expect-equals dir-permission (file.stat "$tmp-dir/dir2")[file.ST-MODE]
-    expect-equals "gee".to-byte-array (file.read-content "$tmp-dir/dir2/file.txt")
+    expect-equals "gee".to-byte-array (file.read-contents "$tmp-dir/dir2/file.txt")
 
     // Note that the directory doesn't allow writing.
     // This means that the copy operation must temporarily lift that restriction to copy the
     // nested file.
     file.chmod dir read-only-dir-permission
     file.copy --source=dir --target="$tmp-dir/dir3" --recursive
     expect-equals read-only-dir-permission (file.stat "$tmp-dir/dir3")[file.ST-MODE]
-    expect-equals "gee".to-byte-array (file.read-content "$tmp-dir/dir2/file.txt")
+    expect-equals "gee".to-byte-array (file.read-contents "$tmp-dir/dir2/file.txt")
 
 test-symlinks:
   with-tmp-dir: | tmp-dir |
     file-target := "$tmp-dir/file.txt"
     file-content := "foobar".to-byte-array
-    file.write-content --path=file-target file-content
+    file.write-contents --path=file-target file-content
     dir-target := "$tmp-dir/dir"
     directory.mkdir dir-target
     dir-file := "$dir-target/file.txt"
     dir-file-content := "gee".to-byte-array
-    file.write-content --path=dir-file dir-file-content
+    file.write-contents --path=dir-file dir-file-content
 
     source-dir := "$tmp-dir/source"
     directory.mkdir source-dir
@@ -125,39 +125,39 @@ test-symlinks:
 
     copy-target := "$tmp-dir/copy-target-symlink"
     file.copy --source=source-dir --target=copy-target --recursive
-    expect-equals file-content (file.read-content "$copy-target/relative-link")
-    expect-equals file-content (file.read-content "$copy-target/absolute-link")
+    expect-equals file-content (file.read-contents "$copy-target/relative-link")
+    expect-equals file-content (file.read-contents "$copy-target/absolute-link")
     // Change the original file.
     // Since the copy is still a link we expect the content to change.
     file-content2 := "foobar2".to-byte-array
-    file.write-content --path=file-target file-content2
-    expect-equals file-content2 (file.read-content "$copy-target/relative-link")
-    expect-equals file-content2 (file.read-content "$copy-target/absolute-link")
+    file.write-contents --path=file-target file-content2
+    expect-equals file-content2 (file.read-contents "$copy-target/relative-link")
+    expect-equals file-content2 (file.read-contents "$copy-target/absolute-link")
     expect (is-link "$copy-target/relative-link")
     expect (is-link "$copy-target/absolute-link")
 
-    expect-equals dir-file-content (file.read-content "$copy-target/relative-dir/file.txt")
-    expect-equals dir-file-content (file.read-content "$copy-target/absolute-dir/file.txt")
+    expect-equals dir-file-content (file.read-contents "$copy-target/relative-dir/file.txt")
+    expect-equals dir-file-content (file.read-contents "$copy-target/absolute-dir/file.txt")
     // Change the original file.
     // Since the copy is still a link we expect the content to change.
     dir-file-content2 := "gee2".to-byte-array
-    file.write-content --path=dir-file dir-file-content2
-    expect-equals dir-file-content2 (file.read-content "$copy-target/relative-dir/file.txt")
-    expect-equals dir-file-content2 (file.read-content "$copy-target/absolute-dir/file.txt")
+    file.write-contents --path=dir-file dir-file-content2
+    expect-equals dir-file-content2 (file.read-contents "$copy-target/relative-dir/file.txt")
+    expect-equals dir-file-content2 (file.read-contents "$copy-target/absolute-dir/file.txt")
     expect (is-link "$copy-target/relative-dir")
     expect (is-link "$copy-target/absolute-dir")
 
     // Dereference links.
     copy-target = "$tmp-dir/copy-target-dereference"
 
     file.copy --source=source-dir --target=copy-target --recursive --dereference
-    expect-equals file-content2 (file.read-content "$copy-target/relative-link")
-    expect-equals file-content2 (file.read-content "$copy-target/absolute-link")
+    expect-equals file-content2 (file.read-contents "$copy-target/relative-link")
+    expect-equals file-content2 (file.read-contents "$copy-target/absolute-link")
     expect-not (is-link "$copy-target/relative-link")
     expect-not (is-link "$copy-target/absolute-link")
 
-    expect-equals dir-file-content2 (file.read-content "$copy-target/relative-dir/file.txt")
-    expect-equals dir-file-content2 (file.read-content "$copy-target/absolute-dir/file.txt")
+    expect-equals dir-file-content2 (file.read-contents "$copy-target/relative-dir/file.txt")
+    expect-equals dir-file-content2 (file.read-contents "$copy-target/absolute-dir/file.txt")
     expect-not (is-link "$copy-target/relative-dir")
     expect-not (is-link "$copy-target/absolute-dir")
 
@@ -168,23 +168,23 @@ test-symlinks:
     file.copy --source=source-dir --target=copy-target --recursive
 
     // Absolute links still work.
-    expect-equals file-content2 (file.read-content "$copy-target/absolute-link")
+    expect-equals file-content2 (file.read-contents "$copy-target/absolute-link")
     expect (is-link "$copy-target/absolute-link")
-    expect-equals dir-file-content2 (file.read-content "$copy-target/absolute-dir/file.txt")
+    expect-equals dir-file-content2 (file.read-contents "$copy-target/absolute-dir/file.txt")
     expect (is-link "$copy-target/absolute-dir")
 
-    expect-throws: file.read-content "$copy-target/relative-link"
+    expect-throws: file.read-contents "$copy-target/relative-link"
     expect (is-link "$copy-target/relative-link")
-    expect-throws: file.read-content "$copy-target/relative-dir/file.txt"
+    expect-throws: file.read-contents "$copy-target/relative-dir/file.txt"
     expect (is-link "$copy-target/relative-dir")
 
     // Create the target.
-    file.write-content --path="$tmp-dir/other/file.txt" file-content
+    file.write-contents --path="$tmp-dir/other/file.txt" file-content
     directory.mkdir "$tmp-dir/other/dir"
-    file.write-content --path="$tmp-dir/other/dir/file.txt" dir-file-content
+    file.write-contents --path="$tmp-dir/other/dir/file.txt" dir-file-content
     // Now the symlinks work again.
-    expect-equals file-content (file.read-content "$copy-target/relative-link")
-    expect-equals dir-file-content (file.read-content "$copy-target/relative-dir/file.txt")
+    expect-equals file-content (file.read-contents "$copy-target/relative-link")
+    expect-equals dir-file-content (file.read-contents "$copy-target/relative-dir/file.txt")
 
 is-link path/string -> bool:
   stat := file.stat path --no-follow-links

tests/file_test.toit

@@ -70,9 +70,9 @@ main:
         test-out.out.close
 
         10000.repeat:
-          file.read-content filename
+          file.read-contents filename
 
-        read-back := (file.read-content filename).to-string
+        read-back := (file.read-contents filename).to-string
 
         expect-equals test-contents read-back
 
@@ -86,7 +86,7 @@ main:
         test-out.out.close
         expect-equals
           ByteArray 0
-          file.read-content filename
+          file.read-contents filename
       finally:
         file.delete filename
 
@@ -100,7 +100,7 @@ main:
         test-out.out.write test-contents from to
         test-out.out.close
 
-        read-back := (file.read-content filename).to-string
+        read-back := (file.read-contents filename).to-string
 
         expect-equals (test-contents.copy from to) read-back
 
@@ -112,8 +112,8 @@ main:
       expect (not file.size filename)
 
       try:
-        file.write-content test-contents --path=filename
-        read-back := (file.read-content filename).to-string
+        file.write-contents test-contents --path=filename
+        read-back := (file.read-contents filename).to-string
         expect-equals test-contents read-back
       finally:
         file.delete filename
@@ -123,8 +123,8 @@ main:
       // Permissions does not quite work on windows
       if platform != PLATFORM-WINDOWS:
         try:
-          file.write-content test-contents --path=filename --permissions=(6 << 6)
-          read-back := (file.read-content filename).to-string
+          file.write-contents test-contents --path=filename --permissions=(6 << 6)
+          read-back := (file.read-contents filename).to-string
           expect-equals test-contents read-back
           stats := file.stat filename
           // We can't require that the permissions are exactly the same (as the umask

tests/link_test.toit

@@ -16,8 +16,8 @@ main:
   expect (file.is-directory tmp-dir)
 
   directory.chdir tmp-dir
-  file.write-content CONTENT --path="test-file"
-  expect-equals CONTENT.to-byte-array (file.read-content "test-file")
+  file.write-contents CONTENT --path="test-file"
+  expect-equals CONTENT.to-byte-array (file.read-contents "test-file")
   directory.mkdir "test-dir"
 
   try:
@@ -39,8 +39,8 @@ main:
     expect-equals dir-stat (file.stat "test-dir-soft-link")
     expect-not-equals dir-stat (file.stat --follow-links=false "test-dir-soft-link")
 
-    expect-equals CONTENT.to-byte-array (file.read-content "test-file-hard-link")
-    expect-equals CONTENT.to-byte-array (file.read-content "test-file-soft-link")
+    expect-equals CONTENT.to-byte-array (file.read-contents "test-file-hard-link")
+    expect-equals CONTENT.to-byte-array (file.read-contents "test-file-soft-link")
 
     // Test that we can't auto detect link type if the target does not exist.
     expect-throw "TARGET_NOT_FOUND": file.link --source="test-file" --target="test-file-that-does-not-exist"
@@ -53,33 +53,33 @@ main:
     expect-equals "relative-soft-name" (file.readlink "test-dir/relative")
     file.link --file --source="test-dir/relative-soft-name" --target="..$(directory.SEPARATOR)test-file"
     expect-equals "..$(directory.SEPARATOR)test-file" (file.readlink "test-dir/relative-soft-name")
-    expect-equals CONTENT.to-byte-array (file.read-content "test-dir/relative")
+    expect-equals CONTENT.to-byte-array (file.read-contents "test-dir/relative")
 
     // Test that hardlinks are always relative to cwd.
     file.link --hard --source="test-dir/relative-hard" --target="test-file"
-    expect-equals CONTENT.to-byte-array (file.read-content "test-dir/relative-hard")
+    expect-equals CONTENT.to-byte-array (file.read-contents "test-dir/relative-hard")
 
     // Test that hard-links behaves as hard-link and soft-link behaves as soft-links.
     file.delete "test-file"
-    expect-equals CONTENT.to-byte-array (file.read-content "test-file-hard-link")
-    expect-throw "FILE_NOT_FOUND: \"test-file-soft-link\"" : file.read-content "test-file-soft-link"
+    expect-equals CONTENT.to-byte-array (file.read-contents "test-file-hard-link")
+    expect-throw "FILE_NOT_FOUND: \"test-file-soft-link\"" : file.read-contents "test-file-soft-link"
 
     new-content := "new-content".to-byte-array
-    file.write-content new-content --path="test-file"
+    file.write-contents new-content --path="test-file"
 
     // Test relative links that isn't relative to the current directory.
     subdir := "$tmp-dir/subdir"
     directory.mkdir subdir
     file.link --file --source="$subdir/relative-link" --target="../test-file"
-    expect-equals new-content (file.read-content "$subdir/relative-link")
+    expect-equals new-content (file.read-contents "$subdir/relative-link")
     file.link --source="$subdir/relative-link2" --target="../test-file"
-    expect-equals new-content (file.read-content "$subdir/relative-link2")
+    expect-equals new-content (file.read-contents "$subdir/relative-link2")
 
     // Same for directories.
     file.link --directory --source="$subdir/relative-dir-link" --target=".."
-    expect-equals new-content (file.read-content "$subdir/relative-dir-link/test-file")
+    expect-equals new-content (file.read-contents "$subdir/relative-dir-link/test-file")
     file.link --source="$subdir/relative-dir-link2" --target=".."
-    expect-equals new-content (file.read-content "$subdir/relative-dir-link2/test-file")
+    expect-equals new-content (file.read-contents "$subdir/relative-dir-link2/test-file")
 
   finally:
     directory.rmdir tmp-dir --recursive

tests/mkdir_rmdir_test.toit

@@ -59,10 +59,10 @@ main:
     // Test permissions.
     dir0 := "$tmp-dir/perm0"
     mkdir dir0
-    file.write-content --path="$dir0/file1" "content"
+    file.write-contents --path="$dir0/file1" "content"
     dir1 := "$dir0/perm1"
     mkdir dir1
-    file.write-content --path="$dir1/file" "content"
+    file.write-contents --path="$dir1/file" "content"
 
     old-stat0 := file.stat dir0
     old-stat1 := file.stat dir1
@@ -82,7 +82,7 @@ main:
     // Test symbolic link.
     sym-file-target := "$tmp-dir/sym-file-target"
     sym-dir-target := "$tmp-dir/sym-dir-target"
-    file.write-content --path=sym-file-target "content"
+    file.write-contents --path=sym-file-target "content"
     mkdir sym-dir-target
 
     sub-dir := "$tmp-dir/sub-dir"