concept string methods minor arrangement

valentin-p · BethanyG · commit f12fa7ff9a8d · 2021-02-10T05:33:15.000-08:00
diff --git a/concepts/str-methods/about.md b/concepts/str-methods/about.md
diff --git a/concepts/str-methods/introduction.md b/concepts/str-methods/introduction.md
diff --git a/concepts/str-methods/links.json b/concepts/str-methods/links.json
diff --git a/concepts/string-methods/introduction.md b/concepts/string-methods/introduction.md
@@ -1,11 +1,7 @@
-Python provides a number of useful methods that you can use to manipulate
-strings. These methods can be used for cleaning, splitting, translating,
-or otherwise working with the str type. New strings can be created based
-on method arguments, and/or additional information can be returned. Strings
-can be concatenated using the `+` operator or with `str.join()`. Strings
-also implement all of the common sequence operations along with iteration using
-the `for item in <string>` syntax.
+Python provides several useful methods that can be used to manipulate strings.
+These methods can be used for cleaning, splitting, translating any variable of type `str`.
+Strings can be concatenated using the `+` operator or with `str.join()`.
+Strings also implement all of the common operations for a sequence and can be iterated using the syntax: `for item in <string>`.
 
-`Strings` are immutable (meaning the value does not change), so each of these
-methods will actually return a new instance of `str` instead of modifying
-the existing one.
+`Strings` are immutable, meaning their value in memory cannot change.
+It means the standard library methods will return a new instance of `str` instead of modifying the existing `str`.
diff --git a/exercises/concept/little-sisters-essay/.docs/instructions.md b/exercises/concept/little-sisters-essay/.docs/instructions.md
@@ -1,10 +1,10 @@
-In this exercise you are helping your younger sister edit her paper for school. The teacher is looking for correct punctuation, grammar, and excellent word choice.
+In this exercise, you are helping your younger sister edit her paper for school. The teacher is looking for correct punctuation, grammar, and excellent choice of words.
 
 You have four tasks to clean up and modify strings.
 
 ## 1. Capitalize the title of the paper
 
-Any good paper needs a properly formatted title. Implement the function `capitalize_title()` which takes in the parameter `title` and capitalizes the first letter of each word of the title. This function will return a `str`.
+Any good paper needs a properly formatted title. Implement the function `capitalize_title()` which takes `title` as parameter and capitalizes the first letter of each word of the title. This function will return a `str`.
 
 ```python
 >>> capitalize_title("my hobbies")
@@ -13,7 +13,7 @@ Any good paper needs a properly formatted title. Implement the function `capital
 
 ## 2. Check if each sentence ends with a period
 
-You want to make sure that the punctuation in the paper is perfect. Implement the function `check_sentence_ending()` that takes in the parameter `sentence`. This function should return a `bool`.
+You want to make sure that the punctuation in the paper is perfect. Implement the function `check_sentence_ending()` that takes `sentence` as a parameter. This function should return a `bool`.
 
 ```python
 >>> check_sentence_ending("I like to hike, bake, and read.")
@@ -22,7 +22,7 @@ True
 
 ## 3. Clean up spacing
 
-To make the paper look professional, unnecessary spacing needs to be removed. Implement the function `remove_extra_spaces()` which takes in the parameter `sentence` and removes extra whitespace at the beginning and at the end of the sentence. This function should return a `str`.
+For the paper to look professional, you need to remove unnecessary spacing. Implement the function `remove_extra_spaces()` which takes `sentence` as a parameter and removes any extra whitespace at the beginning and the end of the sentence. This function should return a `str`.
 
 ```python
 >>> remove_extra_spaces(" I like to go on hikes with my dog.  ")
@@ -31,9 +31,9 @@ To make the paper look professional, unnecessary spacing needs to be removed. Im
 
 ## 4. Replace words with a synonym
 
-To make the paper even better, you can replace some of the adjectives with synonyms. Write a function `replace_word_choice()` that takes in the parameters `sentence`, `old_word`, and `new_word`. This function should replace all instances of the `old_word` with the `new_word` and return the updated sentence. The function should return a `str`.
+To make the paper even better, you can replace some of the adjectives with synonyms. Write a function `replace_word_choice()` that takes `sentence`, `old_word`, and `new_word` as parameters. This function should replace all instances of the `old_word` with the `new_word` and return the updated sentence. The function should return a `str`.
 
 ```python
->>> replace_word_choice("I bake good cakes", "good", "amazing")
-"I bake amazing cakes"
+>>> replace_word_choice("I bake good cakes.", "good", "amazing")
+"I bake amazing cakes."
 ```
diff --git a/exercises/concept/little-sisters-essay/.docs/introduction.md b/exercises/concept/little-sisters-essay/.docs/introduction.md
@@ -1,11 +1,7 @@
-Python provides a number of useful methods that you can use to manipulate
-strings. These methods can be used for cleaning, splitting, translating,
-or otherwise working with the str type. New strings can be created based
-on method arguments, and/or additional information can be returned. Strings
-can be concatenated using the `+` operator or with `str.join()`. Strings
-also implement all of the common sequence operations along with iteration using
-the `for item in <string>` syntax.
+Python provides several useful methods that can be used to manipulate strings.
+These methods can be used for cleaning, splitting, translating any variable of type `str`.
+Strings can be concatenated using the `+` operator or with `str.join()`.
+Strings also implement all of the common operations for a sequence and can be iterated using the syntax: `for item in <string>`.
 
-`Strings` are immutable (meaning the value does not change), so each of these
-methods will actually return a new instance of `str` instead of modifying
-the existing one.
+`Strings` are immutable, meaning their value in memory cannot change.
+It means the standard library methods will return a new instance of `str` instead of modifying the existing `str`.
diff --git a/exercises/concept/little-sisters-essay/.meta/config.json b/exercises/concept/little-sisters-essay/.meta/config.json
@@ -1,4 +1,10 @@
 {
+  "contributors": [
+    {
+      "github_username": "valentin-p",
+      "exercism_username": "valentin-p"
+    }
+  ],
   "authors": [
     {
       "github_username": "kimolivia",
diff --git a/exercises/concept/little-sisters-essay/.meta/exemplar.py b/exercises/concept/little-sisters-essay/.meta/exemplar.py
@@ -5,8 +5,8 @@ def check_sentence_ending(sentence):
     return sentence.endswith(".")
 
 def clean_up_spacing(sentence):
-    new_sentence = sentence.strip()
-    return new_sentence
+    clean_sentence = sentence.strip()
+    return clean_sentence
 
 def replace_word_choice(sentence, new_word, old_word):
     better_sentence = sentence.replace(new_word, old_word)
diff --git a/exercises/concept/little-sisters-essay/string_methods_test.py b/exercises/concept/little-sisters-essay/string_methods_test.py
@@ -2,22 +2,32 @@
 from string_methods import *
 
 
-class test_string_methods(unittest.TestCase):
+class TestStringMethods(unittest.TestCase):
+    def test_capitalize_word(self):
+        self.assertEqual(capitalize_title("canopy"), "Canopy")
+
     def test_capitalize_title(self):
         self.assertEqual(capitalize_title("fish are cold blooded"),
                          "Fish Are Cold Blooded")
 
     def test_sentence_ending(self):
         self.assertEqual(check_sentence_ending("Snails can sleep for 3 years."), True)
 
+    def test_sentence_ending_without_period(self):
+        self.assertEqual(check_sentence_ending("Fittonia are nice"), False)
+
+    def remove_extra_spaces_only_start(self):
+        self.assertEqual(remove_extra_spaces("  A rolling stone gathers no moss"),
+                        "A rolling stone gathers no moss")
+
     def remove_extra_spaces(self):
         self.assertEqual(remove_extra_spaces("  Elephants can't jump.  "),
                         "Elephants can't jump.")
 
     def test_replace_word_choice(self):
-        self.assertEqual(replace_word_choice("Animals are cool", "cool", "awesome"),
-                        "Animals are awesome")
+        self.assertEqual(replace_word_choice("Animals are cool.", "cool", "awesome"),
+                        "Animals are awesome.")
 
     def test_replace_word_not_exist(self):
-        self.assertEqual(replace_word_choice("Animals are cool", "small", "tiny"),
-                        "Animals are cool")
+        self.assertEqual(replace_word_choice("Animals are cool.", "small", "tiny"),
+                        "Animals are cool.")

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,10 @@`
`1`	`1`	`{`
	`2`	`+ "contributors": [`
	`3`	`+ {`
	`4`	`+ "github_username": "valentin-p",`
	`5`	`+ "exercism_username": "valentin-p"`
	`6`	`+ }`
	`7`	`+ ],`
`2`	`8`	`"authors": [`
`3`	`9`	`{`
`4`	`10`	`"github_username": "kimolivia",`