friends 0.16 → 0.17

data/lib/friends/location.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# Location represents a location in the world.
+
+require "friends/regex_builder"
+require "friends/serializable"
+
+module Friends
+  class Location
+    extend Serializable
+
+    SERIALIZATION_PREFIX = "- ".freeze
+
+    # @return [Regexp] the regex for capturing groups in deserialization
+    def self.deserialization_regex
+      # Note: this regex must be on one line because whitespace is important
+      /(#{SERIALIZATION_PREFIX})?(?<name>.+)/
+    end
+
+    # @return [Regexp] the string of what we expected during deserialization
+    def self.deserialization_expectation
+      "[Location Name]"
+    end
+
+    # @param name [String] the name of the location
+    def initialize(name:)
+      @name = name
+    end
+
+    attr_accessor :name
+
+    # @return [String] the file serialization text for the location
+    def serialize
+      "#{SERIALIZATION_PREFIX}#{@name}"
+    end
+
+    # @return [Regexp] the regex used to match this location's name in an
+    #   activity description
+    def regex_for_name
+      Friends::RegexBuilder.regex(@name)
+    end
+
+    private
+
+    # Default sorting for an array of locations is alphabetical.
+    def <=>(other)
+      name <=> other.name
+    end
+  end
+end

data/lib/friends/regex_builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# RegexpBuilder is an internal class that helps us build regexes to find things.
+
+module Friends
+  class RegexBuilder
+    # We don't want to match strings that are "escaped" with a leading
+    # backslash.
+    NO_LEADING_BACKSLASH = "(?<!\\\\)".freeze
+
+    # We don't want to match strings that are directly touching double asterisks
+    # as these are treated as sacred by our program.
+    NO_LEADING_ASTERISKS = "(?<!\\*\\*)".freeze
+    NO_TRAILING_ASTERISKS = "(?!\\*\\*)".freeze
+
+    # We don't want to match strings that are directly touching underscores
+    # as these are treated as sacred by our program.
+    NO_LEADING_UNDERSCORES = "(?<!_)".freeze
+    NO_TRAILING_UNDERSCORES = "(?!_)".freeze
+
+    # We don't want to match strings that are part of other words.
+    NO_LEADING_ALPHABETICALS = "(?<![A-z])".freeze
+    NO_TRAILING_ALPHABETICALS = "(?![A-z])".freeze
+
+    def self.regex(str)
+      Regexp.new(
+        NO_LEADING_BACKSLASH +
+        NO_LEADING_ASTERISKS +
+        NO_LEADING_UNDERSCORES +
+        NO_LEADING_ALPHABETICALS +
+        str +
+        NO_TRAILING_ALPHABETICALS +
+        NO_TRAILING_UNDERSCORES +
+        NO_TRAILING_ASTERISKS,
+        Regexp::IGNORECASE
+      )
+    end
+  end
+end

data/lib/friends/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Friends
-  VERSION = "0.16".freeze
+  VERSION = "0.17".freeze
 end

data/test/activity_spec.rb

@@ -5,7 +5,10 @@ describe Friends::Activity do
   let(:date_s) { date.to_s }
   let(:friend1) { Friends::Friend.new(name: "Elizabeth Cady Stanton") }
   let(:friend2) { Friends::Friend.new(name: "John Cage") }
-  let(:description) { "Lunch with **#{friend1.name}** and **#{friend2.name}**" }
+  let(:description) do
+    "Lunch with **#{friend1.name}** and **#{friend2.name}** on _The Moon_ "\
+    "after hanging out in _Atlantis_."
+  end
   let(:partition) { Friends::Activity::DATE_PARTITION }
   let(:activity) do
     Friends::Activity.new(str: "#{date_s}#{partition}#{description}")
@@ -99,7 +102,9 @@ describe Friends::Activity do
       subject.
         must_equal "#{Paint[date_s, :bold]}: "\
           "Lunch with #{Paint[friend1.name, :bold, :magenta]} and "\
-          "#{Paint[friend2.name, :bold, :magenta]}"
+          "#{Paint[friend2.name, :bold, :magenta]} on "\
+          "#{Paint['The Moon', :bold, :yellow]} after hanging out in "\
+          "#{Paint['Atlantis', :bold, :yellow]}."
     end
   end
 
@@ -113,7 +118,7 @@ describe Friends::Activity do
     end
   end
 
-  describe "#highlight_friends" do
+  describe "#highlight_description" do
     # Add helpers to set internal states for friends and activities.
     def stub_friends(val)
       old_val = introvert.instance_variable_get(:@friends)
@@ -129,16 +134,34 @@ describe Friends::Activity do
       introvert.instance_variable_set(:@activities, old_val)
     end
 
+    def stub_locations(val)
+      old_val = introvert.instance_variable_get(:@locations)
+      introvert.instance_variable_set(:@locations, val)
+      yield
+      introvert.instance_variable_set(:@locations, old_val)
+    end
+
+    let(:locations) do
+      [
+        Friends::Location.new(name: "Atlantis"),
+        Friends::Location.new(name: "The Moon")
+      ]
+    end
     let(:friends) { [friend1, friend2] }
     let(:introvert) { Friends::Introvert.new }
     subject do
-      stub_friends(friends) { activity.highlight_friends(introvert: introvert) }
+      stub_friends(friends) do
+        stub_locations(locations) do
+          activity.highlight_description(introvert: introvert)
+        end
+      end
     end
 
-    it "finds all friends" do
+    it "finds all friends and locations" do
       subject
-      activity.description.
-        must_equal "Lunch with **#{friend1.name}** and **#{friend2.name}**"
+      activity.description.must_equal "Lunch with **#{friend1.name}** and "\
+                                      "**#{friend2.name}** on _The Moon_ "\
+                                      "after hanging out in _Atlantis_."
     end
 
     describe "when description has first names" do
@@ -332,23 +355,32 @@ describe Friends::Activity do
     end
   end
 
+  describe "#includes_location?" do
+    subject { activity.includes_location?(location: loc) }
+    let(:loc) { Friends::Location.new(name: "Atlantis") }
+
+    describe "when the given location is in the activity" do
+      let(:activity) { Friends::Activity.new(str: "Explored _#{loc.name}_") }
+      it { subject.must_equal true }
+    end
+
+    describe "when the given location is not in the activity" do
+      let(:activity) { Friends::Activity.new(str: "Explored _Elsewhere_") }
+      it { subject.must_equal false }
+    end
+  end
+
   describe "#includes_friend?" do
     subject { activity.includes_friend?(friend: friend) }
 
     describe "when the given friend is in the activity" do
       let(:friend) { friend1 }
-
-      it "returns true" do
-        subject.must_equal true
-      end
+      it { subject.must_equal true }
     end
 
     describe "when the given friend is not in the activity" do
       let(:friend) { Friends::Friend.new(name: "Claude Debussy") }
-
-      it "returns false" do
-        subject.must_equal false
-      end
+      it { subject.must_equal false }
     end
   end
 
@@ -382,10 +414,13 @@ describe Friends::Activity do
     end
   end
 
-  describe "#update_name" do
+  describe "#update_friend_name" do
     let(:description) { "Lunch with **John Candy**." }
     subject do
-      activity.update_name(old_name: "John Candy", new_name: "John Cleese")
+      activity.update_friend_name(
+        old_name: "John Candy",
+        new_name: "John Cleese"
+      )
     end
 
     it "renames the given friend in the description" do
@@ -403,7 +438,7 @@ describe Friends::Activity do
     describe "when the description contains the complete old name" do
       let(:description) { "Coffee with **John** at John's Studio." }
       subject do
-        activity.update_name(old_name: "John", new_name: "Joe")
+        activity.update_friend_name(old_name: "John", new_name: "Joe")
       end
 
       it "only replaces the actual name" do
@@ -411,4 +446,40 @@ describe Friends::Activity do
       end
     end
   end
+
+  describe "#update_location_name" do
+    let(:description) { "Lunch in _Paris_." }
+    subject do
+      activity.update_location_name(
+        old_name: "Paris",
+        new_name: "Paris, France"
+      )
+    end
+
+    it "renames the given friend in the description" do
+      subject.must_equal "Lunch in _Paris, France_."
+    end
+
+    describe "when the description contains a fragment of the old name" do
+      let(:description) { "Lunch in _Paris_ at the Parisian Café." }
+
+      it "only replaces the name" do
+        subject.must_equal "Lunch in _Paris, France_ at the Parisian Café."
+      end
+    end
+
+    describe "when the description contains the complete old name" do
+      let(:description) { "Lunch in _Paris_ at The Paris Café." }
+      subject do
+        activity.update_location_name(
+          old_name: "Paris",
+          new_name: "Paris, France"
+        )
+      end
+
+      it "only replaces the actual name" do
+        subject.must_equal "Lunch in _Paris, France_ at The Paris Café."
+      end
+    end
+  end
 end

data/test/friend_spec.rb

@@ -30,15 +30,6 @@ describe Friends::Friend do
     it { subject.name.must_equal friend_name }
   end
 
-  describe "#rename" do
-    subject { friend }
-
-    it "renames the friend" do
-      friend.rename("Ada Lovelace")
-      subject.name.must_equal "Ada Lovelace"
-    end
-  end
-
   describe "#serialize" do
     subject { friend.serialize }
 
@@ -118,10 +109,8 @@ describe Friends::Friend do
     subject { friend.regexes_for_name }
 
     it "generates appropriate regexes" do
-      subject.must_equal [
-        /(?<!\\)(?<!\*\*)(?<![A-z])Jacob\s+Evelyn(?![A-z])(?!\*\*)/i,
-        /(?<!\\)(?<!\*\*)(?<![A-z])Jacob(?![A-z])(?!\*\*)/i
-      ]
+      subject.any? { |r| r =~ friend_name }.must_equal true
+      subject.any? { |r| r =~ friend_name.partition(" ").first }.must_equal true
     end
   end
 

data/test/introvert_spec.rb

@@ -8,7 +8,7 @@ describe Friends::Introvert do
     end
   end
 
-  # Add helpers to set internal states for friends and activities.
+  # Add helpers to set internal states for friends/locations/activities.
   def stub_friends(val)
     old_val = introvert.instance_variable_get(:@friends)
     introvert.instance_variable_set(:@friends, val)
@@ -23,6 +23,13 @@ describe Friends::Introvert do
     introvert.instance_variable_set(:@activities, old_val)
   end
 
+  def stub_locations(val)
+    old_val = introvert.instance_variable_get(:@locations)
+    introvert.instance_variable_set(:@locations, val)
+    yield
+    introvert.instance_variable_set(:@locations, old_val)
+  end
+
   let(:filename) { "test/tmp/friends.md" }
   let(:args) { { filename: filename } }
   let(:introvert) { Friends::Introvert.new(args) }
@@ -38,6 +45,12 @@ describe Friends::Introvert do
       )
     ]
   end
+  let(:locations) do
+    [
+      Friends::Location.new(name: "The Eiffel Tower"),
+      Friends::Location.new(name: "Atlantis")
+    ]
+  end
 
   describe "#new" do
     it "accepts all arguments" do
@@ -67,22 +80,28 @@ describe Friends::Introvert do
       unsorted_friends = sorted_friends.reverse
       sorted_activities = activities.sort
       unsorted_activities = sorted_activities.reverse
+      sorted_locations = locations.sort
+      unsorted_locations = sorted_locations.reverse
 
-      serialized_names = sorted_friends.map(&:serialize)
-      name_output = serialized_names.join("\n")
-
-      serialized_descriptions = sorted_activities.map(&:serialize)
-      descriptions_output = serialized_descriptions.join("\n")
+      serialized_friends = sorted_friends.map(&:serialize).join("\n")
+      serialized_activities = sorted_activities.map(&:serialize).join("\n")
+      serialized_locations = sorted_locations.map(&:serialize).join("\n")
 
       expected_output =
-        "#{Friends::Introvert::ACTIVITIES_HEADER}\n#{descriptions_output}\n\n"\
-        "#{Friends::Introvert::FRIENDS_HEADER}\n#{name_output}\n"
+        "#{Friends::Introvert::ACTIVITIES_HEADER}\n"\
+        "#{serialized_activities}\n\n"\
+        "#{Friends::Introvert::FRIENDS_HEADER}\n"\
+        "#{serialized_friends}\n\n"\
+        "#{Friends::Introvert::LOCATIONS_HEADER}\n"\
+        "#{serialized_locations}\n"
 
       # Read the input as unsorted, and make sure we get sorted output.
       stub_friends(unsorted_friends) do
         stub_activities(unsorted_activities) do
-          subject
-          File.read(filename).must_equal expected_output
+          stub_locations(unsorted_locations) do
+            subject
+            File.read(filename).must_equal expected_output
+          end
         end
       end
     end
@@ -91,11 +110,35 @@ describe Friends::Introvert do
   end
 
   describe "#list_friends" do
-    subject { introvert.list_friends }
+    subject { introvert.list_friends(location_name: location_name) }
 
-    it "lists the names of friends" do
-      stub_friends(friends) do
-        subject.must_equal friend_names
+    describe "when no location name has been passed" do
+      let(:location_name) { nil }
+
+      it "lists the names of friends" do
+        stub_friends(friends) do
+          subject.must_equal friend_names
+        end
+      end
+    end
+
+    describe "when a location name has been passed" do
+      let(:location_name) { "Atlantis" }
+      let(:friends) do
+        [
+          Friends::Friend.new(name: "Mark Watney", location_name: "Mars"),
+          Friends::Friend.new(name: "Aquaman", location_name: "Atlantis"),
+          Friends::Friend.new(name: "Shark-Boy", location_name: "Atlantis"),
+          Friends::Friend.new(name: "Ms. Nowhere")
+        ]
+      end
+
+      it "lists the names of friends" do
+        stub_friends(friends) do
+          stub_locations(locations) do
+            subject.must_equal ["Aquaman", "Shark-Boy"]
+          end
+        end
       end
     end
   end
@@ -104,14 +147,12 @@ describe Friends::Introvert do
     let(:new_friend_name) { "Jacob Evelyn" }
     subject { introvert.add_friend(name: new_friend_name) }
 
-    # Delete the file that is created each time.
-    after { File.delete(filename) if File.exists?(filename) }
-
     describe "when there is no existing friend with that name" do
       it "adds the given friend" do
         stub_friends(friends) do
           subject
-          introvert.list_friends.must_include new_friend_name
+          introvert.list_friends(location_name: nil).
+            must_include new_friend_name
         end
       end
 
@@ -133,10 +174,57 @@ describe Friends::Introvert do
     end
   end
 
+  describe "#add_location" do
+    let(:new_location_name) { "Peru" }
+    subject { introvert.add_location(name: new_location_name) }
+
+    describe "when there is no existing location with that name" do
+      it "adds the given location" do
+        stub_locations(locations) do
+          subject
+          introvert.list_locations.must_include new_location_name
+        end
+      end
+
+      it "returns the location added" do
+        stub_locations(locations) do
+          subject.name.must_equal new_location_name
+        end
+      end
+    end
+
+    describe "when there is an existing location with that name" do
+      let(:new_location_name) { locations.first.name }
+
+      it "raises an error" do
+        stub_locations(locations) do
+          proc { subject }.must_raise Friends::FriendsError
+        end
+      end
+    end
+  end
+
+  describe "#list_locations" do
+    subject { introvert.list_locations }
+
+    it "lists all locations" do
+      stub_locations(locations) do
+        subject.must_equal locations.map(&:name)
+      end
+    end
+  end
+
   describe "#list_activities" do
-    subject { introvert.list_activities(limit: limit, with: with) }
+    subject do
+      introvert.list_activities(
+        limit: limit,
+        with: with,
+        location_name: location_name
+      )
+    end
     let(:limit) { nil }
     let(:with) { nil }
+    let(:location_name) { nil }
 
     describe "when the limit is lower than the number of activities" do
       let(:limit) { 1 }
@@ -226,6 +314,74 @@ describe Friends::Introvert do
         end
       end
     end
+
+    describe "when not filtering by a location" do
+      let(:location_name) { nil }
+
+      it "lists the activities" do
+        stub_activities(activities) do
+          subject.must_equal activities.map(&:display_text)
+        end
+      end
+    end
+
+    describe "when filtering by part of a location name" do
+      let(:location_name) { "City" }
+
+      describe "when there is more than one location match" do
+        let(:locations) do
+          [
+            Friends::Location.new(name: "New York City"),
+            Friends::Location.new(name: "Kansas City")
+          ]
+        end
+
+        it "raises an error" do
+          stub_friends(friends) do
+            stub_locations(locations) do
+              stub_activities(activities) do
+                proc { subject }.must_raise Friends::FriendsError
+              end
+            end
+          end
+        end
+      end
+
+      describe "when there are no location matches" do
+        let(:locations) { [Friends::Location.new(name: "Atantis")] }
+
+        it "raises an error" do
+          stub_friends(friends) do
+            stub_locations(locations) do
+              stub_activities(activities) do
+                proc { subject }.must_raise Friends::FriendsError
+              end
+            end
+          end
+        end
+      end
+
+      describe "when there is exactly one location match" do
+        let(:location_name) { "Atlantis" }
+        let(:activities) do
+          [
+            Friends::Activity.new(str: "Swimming near _Atlantis_."),
+            Friends::Activity.new(str: "Swimming somewhere else.")
+          ]
+        end
+
+        it "filters the activities by that location" do
+          stub_friends(friends) do
+            stub_locations(locations) do
+              stub_activities(activities) do
+                # Only one activity has that friend.
+                subject.must_equal activities[0..0].map(&:display_text)
+              end
+            end
+          end
+        end
+      end
+    end
   end
 
   describe "#add_activity" do
@@ -233,9 +389,6 @@ describe Friends::Introvert do
     let(:activity_description) { "Snorkeling with **Betsy Ross**." }
     subject { introvert.add_activity(serialization: activity_serialization) }
 
-    # Delete the file that is created each time.
-    after { File.delete(filename) if File.exists?(filename) }
-
     it "adds the given activity" do
       stub_friends(friends) do
         subject
@@ -293,14 +446,101 @@ describe Friends::Introvert do
     end
   end
 
+  describe "#rename_location" do
+    subject do
+      introvert.rename_location(old_name: old_name, new_name: new_name)
+    end
+    let(:old_name) { "Paris" }
+    let(:new_name) { "Paris, France" }
+
+    let(:activities) do
+      [
+        Friends::Activity.new(str: "Dining in _Paris_."),
+        Friends::Activity.new(str: "Falling in love in _Paris_."),
+        Friends::Activity.new(str: "Swimming near _Atlantis_.")
+      ]
+    end
+    let(:locations) do
+      [
+        Friends::Location.new(name: "Paris"),
+        Friends::Location.new(name: "Atlantis")
+      ]
+    end
+
+    it "replaces old name within activities to the new name" do
+      stub_locations(locations) do
+        stub_activities(activities) do
+          subject
+          introvert.activities.map do |activity|
+            activity.description.include? new_name
+          end.must_equal [true, true, false]
+        end
+      end
+    end
+
+    describe "when there are friends at the location" do
+      let(:friends) do
+        [
+          Friends::Friend.new(name: "Jacques Cousteau", location_name: "Paris"),
+          Friends::Friend.new(name: "Marie Antoinette", location_name: "Paris"),
+          Friends::Friend.new(name: "Julius Caesar", location_name: "Rome")
+        ]
+      end
+
+      it "updates their locations" do
+        stub_locations(locations) do
+          stub_friends(friends) do
+            subject
+            introvert.friends.map do |friend|
+              friend.location_name == new_name
+            end.must_equal [true, true, false]
+          end
+        end
+      end
+    end
+
+    describe "when given names with leading and trailing spaces" do
+      let(:new_name) { "    Paris, France " }
+      let(:old_name) { " Paris    " }
+      subject do
+        introvert.rename_location(old_name: old_name, new_name: new_name)
+      end
+
+      it "correctly strips the spaces" do
+        stub_locations(locations) do
+          stub_activities(activities) do
+            subject
+            introvert.activities.map do |activity|
+              activity.description.include? new_name
+            end.must_equal [true, true, false]
+          end
+        end
+      end
+    end
+  end
+
+  describe "#set_location" do
+    subject do
+      introvert.set_location(
+        name: friend_names.first,
+        location_name: locations.first.name
+      )
+    end
+
+    it "returns the modified friend" do
+      stub_friends(friends) do
+        stub_locations(locations) do
+          subject.must_equal friends.first
+        end
+      end
+    end
+  end
+
   describe "#add_nickname" do
     subject do
       introvert.add_nickname(name: friend_names.first, nickname: "The Dude")
     end
 
-    # Delete the file that is created each time.
-    after { File.delete(filename) if File.exists?(filename) }
-
     it "returns the modified friend" do
       stub_friends(friends) do
         subject.must_equal friends.first
@@ -313,9 +553,6 @@ describe Friends::Introvert do
       introvert.remove_nickname(name: "Jeff", nickname: "The Dude")
     end
 
-    # Delete the file that is created each time.
-    after { File.delete(filename) if File.exists?(filename) }
-
     it "returns the modified friend" do
       friend = Friends::Friend.new(name: "Jeff",
                                    nickname_str: "a.k.a. The Dude")
@@ -357,28 +594,61 @@ describe Friends::Introvert do
   end
 
   describe "#suggest" do
-    subject { introvert.suggest }
+    subject { introvert.suggest(location_name: location_name) }
 
-    it "returns distant, moderate, and close friends" do
-      stub_friends(friends) do
-        stub_activities(activities) do
-          subject.must_equal(
-            distant: ["George Washington Carver"],
-            moderate: [],
-            close: ["Betsy Ross"]
-          )
+    describe "when no location name is passed" do
+      let(:location_name) { nil }
+
+      it "returns distant, moderate, and close friends" do
+        stub_friends(friends) do
+          stub_activities(activities) do
+            subject.must_equal(
+              distant: ["George Washington Carver"],
+              moderate: [],
+              close: ["Betsy Ross"]
+            )
+          end
+        end
+      end
+
+      it "doesn't choke when there are no friends" do
+        stub_friends([]) do
+          stub_activities([]) do
+            subject.must_equal(
+              distant: [],
+              moderate: [],
+              close: []
+            )
+          end
         end
       end
     end
 
-    it "doesn't choke when there are no friends" do
-      stub_friends([]) do
-        stub_activities([]) do
-          subject.must_equal(
-            distant: [],
-            moderate: [],
-            close: []
-          )
+    describe "when a location name is passed" do
+      let(:location_name) { "USA" }
+
+      it "returns distant, moderate, and close friends" do
+        friends.first.location_name = location_name
+        stub_friends(friends) do
+          stub_activities(activities) do
+            subject.must_equal(
+              distant: ["George Washington Carver"],
+              moderate: [],
+              close: []
+            )
+          end
+        end
+      end
+
+      it "doesn't choke when there are no friends" do
+        stub_friends([]) do
+          stub_activities([]) do
+            subject.must_equal(
+              distant: [],
+              moderate: [],
+              close: []
+            )
+          end
         end
       end
     end
@@ -431,12 +701,14 @@ describe Friends::Introvert do
       it "returns a hash of months and frequencies" do
         stub_friends(friends) do
           stub_activities(activities) do
-            subject.must_equal({
-              "Jan 2016" => 1,
-              "Feb 2016" => 1,
-              "Mar 2016" => 0,
-              "Apr 2016" => 1
-            })
+            subject.must_equal(
+              {
+                "Jan 2016" => 1,
+                "Feb 2016" => 1,
+                "Mar 2016" => 0,
+                "Apr 2016" => 1
+              }
+            )
           end
         end
       end
@@ -448,11 +720,13 @@ describe Friends::Introvert do
       it "returns a hash of months and frequencies" do
         stub_friends(friends) do
           stub_activities(activities) do
-            subject.must_equal({
-              "Feb 2016" => 1,
-              "Mar 2016" => 0,
-              "Apr 2016" => 1
-            })
+            subject.must_equal(
+              {
+                "Feb 2016" => 1,
+                "Mar 2016" => 0,
+                "Apr 2016" => 1
+              }
+            )
           end
         end
       end