friends 0.28 → 0.29

data/test/friend_spec.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require "./test/helper"
-
-describe Friends::Friend do
-  let(:friend_name) { "Jacob Evelyn" }
-  let(:friend) { Friends::Friend.new(name: friend_name) }
-
-  describe ".deserialize" do
-    subject { Friends::Friend.deserialize(serialized_str) }
-
-    describe "when string is well-formed" do
-      let(:serialized_str) do
-        "#{Friends::Friend::SERIALIZATION_PREFIX}#{friend_name}"
-      end
-
-      it "creates a friend with the correct name" do
-        subject.name.must_equal friend_name
-      end
-    end
-
-    describe "when string is malformed" do
-      let(:serialized_str) { "" }
-
-      it { proc { subject }.must_raise Serializable::SerializationError }
-    end
-
-    describe "when string has one nickname" do
-      let(:serialized_str) { "Guybrush Threepwood (a.k.a. Brush)" }
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it { subject.instance_variable_get(:@nicknames).must_equal ["Brush"] }
-    end
-
-    describe "when string has multiple nicknames" do
-      let(:serialized_str) { "Guybrush Threepwood (a.k.a. Brush a.k.a. Guy)" }
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it do
-        subject.instance_variable_get(:@nicknames).must_equal ["Brush", "Guy"]
-      end
-    end
-
-    describe "when string has a location" do
-      let(:serialized_str) { "Guybrush Threepwood [Plunder Island]" }
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it { subject.location_name.must_equal "Plunder Island" }
-    end
-
-    describe "when string has one tag" do
-      let(:serialized_str) { "Guybrush Threepwood @pirate" }
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it { subject.tags.must_equal ["@pirate"] }
-    end
-
-    describe "when string has multiple tags" do
-      let(:serialized_str) { "Guybrush Threepwood @pirate @swashbuckler" }
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it { subject.tags.must_equal ["@pirate", "@swashbuckler"] }
-    end
-
-    describe "when string has nicknames and tags" do
-      let(:serialized_str) do
-        "Guybrush Threepwood (a.k.a. Brush a.k.a. Guy) @pirate @swashbuckler"
-      end
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it do
-        subject.instance_variable_get(:@nicknames).must_equal ["Brush", "Guy"]
-      end
-      it { subject.tags.must_equal ["@pirate", "@swashbuckler"] }
-    end
-
-    describe "when string has nicknames and a location" do
-      let(:serialized_str) do
-        "Guybrush Threepwood (a.k.a. Brush a.k.a. Guy) [Plunder Island]"
-      end
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it do
-        subject.instance_variable_get(:@nicknames).must_equal ["Brush", "Guy"]
-      end
-      it { subject.location_name.must_equal "Plunder Island" }
-    end
-
-    describe "when string has a location and tags" do
-      let(:serialized_str) do
-        "Guybrush Threepwood [Plunder Island] @pirate @swashbuckler"
-      end
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it { subject.location_name.must_equal "Plunder Island" }
-      it { subject.tags.must_equal ["@pirate", "@swashbuckler"] }
-    end
-
-    describe "when string has nicknames, a location, and tags" do
-      let(:serialized_str) do
-        "Guybrush Threepwood (a.k.a. Brush a.k.a. Guy) [Plunder Island] "\
-          "@pirate @swashbuckler"
-      end
-      it { subject.name.must_equal "Guybrush Threepwood" }
-      it do
-        subject.instance_variable_get(:@nicknames).must_equal ["Brush", "Guy"]
-      end
-      it { subject.location_name.must_equal "Plunder Island" }
-      it { subject.tags.must_equal ["@pirate", "@swashbuckler"] }
-    end
-  end
-
-  describe "#new" do
-    subject { friend }
-
-    it { subject.name.must_equal friend_name }
-  end
-
-  describe "#serialize" do
-    subject { friend.serialize }
-
-    it do
-      subject.must_equal(
-        "#{Friends::Friend::SERIALIZATION_PREFIX}#{friend_name}"
-      )
-    end
-  end
-
-  describe "#add_nickname" do
-    subject { friend.add_nickname("The Dude") }
-
-    it "adds the nickname" do
-      subject
-      friend.instance_variable_get(:@nicknames).must_include("The Dude")
-    end
-
-    it "does not keep duplicates" do
-      # Add the same nickname twice. Do not use `subject` because it's memoized.
-      friend.add_nickname("The Dude")
-      friend.add_nickname("The Dude")
-
-      friend.instance_variable_get(:@nicknames).must_equal ["The Dude"]
-    end
-  end
-
-  describe "#remove_nickname" do
-    subject { friend.remove_nickname("Jake") }
-
-    describe "when the nickname is present" do
-      let(:friend) do
-        Friends::Friend.new(name: friend_name, nickname_str: "Jake")
-      end
-
-      it "removes the nickname" do
-        friend.instance_variable_get(:@nicknames).must_equal ["Jake"]
-        subject
-        friend.instance_variable_get(:@nicknames).must_equal []
-      end
-    end
-
-    describe "when the nickname is not present" do
-      it "raises an error if the nickname is not found" do
-        proc { subject }.must_raise Friends::FriendsError
-      end
-    end
-  end
-
-  describe "#add_tag" do
-    subject { friend.add_tag("@college") }
-
-    it "adds the nickname" do
-      subject
-      friend.tags.must_include("@college")
-    end
-
-    it "does not keep duplicates" do
-      # Add the same nickname twice. Do not use `subject` because it's memoized.
-      friend.add_tag("@college")
-      friend.add_tag("@college")
-
-      friend.tags.must_equal ["@college"]
-    end
-  end
-
-  describe "@remove_tag" do
-    subject { friend.remove_tag("@school") }
-
-    describe "when the tag is present" do
-      let(:friend) do
-        Friends::Friend.new(name: friend_name, tags_str: "@school @work")
-      end
-
-      it "removes the nickname" do
-        friend.instance_variable_get(:@tags).must_equal ["@school", "@work"]
-        subject
-        friend.instance_variable_get(:@tags).must_equal ["@work"]
-      end
-    end
-
-    describe "when the nickname is not present" do
-      it "raises an error if the nickname is not found" do
-        proc { subject }.must_raise Friends::FriendsError
-      end
-    end
-  end
-
-  describe "#n_activities" do
-    subject { friend.n_activities }
-
-    it "defaults to zero" do
-      subject.must_equal 0
-    end
-
-    it "is writable" do
-      friend.n_activities += 1
-      subject.must_equal 1
-    end
-  end
-
-  describe "#likelihood_score" do
-    subject { friend.likelihood_score }
-
-    it "defaults to zero" do
-      subject.must_equal 0
-    end
-
-    it "is writable" do
-      friend.likelihood_score += 1
-      subject.must_equal 1
-    end
-  end
-
-  describe "#regexes_for_name" do
-    subject { friend.regexes_for_name }
-
-    it "generates appropriate regexes" do
-      subject.any? { |r| r =~ friend_name }.must_equal true
-      subject.any? { |r| r =~ friend_name.partition(" ").first }.must_equal true
-    end
-  end
-
-  describe "#<=>" do
-    it "sorts alphabetically" do
-      aaron = Friends::Friend.new(name: "Aaron")
-      zeke = Friends::Friend.new(name: "Zeke")
-      [zeke, aaron].sort.must_equal [aaron, zeke]
-    end
-  end
-end

data/test/graph_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-require "./test/helper"
-
-describe Friends::Graph do
-  subject do
-    Friends::Graph.new(
-      start_date: start_date,
-      end_date: end_date,
-      activities: activities
-    ).to_h
-  end
-
-  let(:start_date) { Date.new(2016, 1, 1) }
-  let(:end_date) { Date.new(2016, 2, 1) }
-  let(:activities) do
-    [
-      Friends::Activity.new(
-        str: "2016-02-01: Relaxing."
-      ),
-
-      Friends::Activity.new(
-        str: "2016-01-01: Running."
-      )
-    ]
-  end
-
-  it "graphs activities by month" do
-    subject.must_equal(
-      "Jan 2016" => 1,
-      "Feb 2016" => 1
-    )
-  end
-
-  describe "there is a gap between activities" do
-    let(:end_date) { Date.new(2016, 3, 1) }
-
-    let(:activities) do
-      [
-        Friends::Activity.new(
-          str: "2016-03-01: Relaxing."
-        ),
-
-        Friends::Activity.new(
-          str: "2016-01-01: Running."
-        )
-      ]
-    end
-
-    it "includes the month with no activities" do
-      subject.must_equal(
-        "Jan 2016" => 1,
-        "Feb 2016" => 0,
-        "Mar 2016" => 1
-      )
-    end
-  end
-
-  describe "graph starts before the first activity" do
-    let(:start_date) { Date.new(2015, 12, 1) }
-
-    it "graphs activities by month" do
-      subject.must_equal(
-        "Dec 2015" => 0,
-        "Jan 2016" => 1,
-        "Feb 2016" => 1
-      )
-    end
-  end
-
-  describe "graph ends after the last activity" do
-    let(:end_date) { Date.new(2016, 3, 1) }
-
-    it "graphs activities by month" do
-      subject.must_equal(
-        "Jan 2016" => 1,
-        "Feb 2016" => 1,
-        "Mar 2016" => 0
-      )
-    end
-  end
-
-  describe "there are no activities" do
-    let(:activities) { [] }
-
-    it "graphs activities by month" do
-      subject.must_equal(
-        "Jan 2016" => 0,
-        "Feb 2016" => 0
-      )
-    end
-  end
-end

data/test/introvert_spec.rb

@@ -1,969 +0,0 @@
-# frozen_string_literal: true
-
-require "./test/helper"
-
-describe Friends::Introvert do
-  # Add readers to make internal state easier to test.
-  module Friends
-    class Introvert
-      attr_reader :filename, :activities, :friends
-    end
-  end
-
-  # 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)
-    introvert.send(:set_n_activities!, :friend)
-    yield
-    introvert.instance_variable_set(:@friends, old_val)
-  end
-
-  def stub_activities(val)
-    old_val = introvert.instance_variable_get(:@activities)
-    introvert.instance_variable_set(:@activities, val)
-    introvert.send(:set_n_activities!, :friend)
-    introvert.send(:set_n_activities!, :location)
-    yield
-    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)
-    introvert.send(:set_n_activities!, :location)
-    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) }
-  let(:friend_names) { ["George Washington Carver", "Betsy Ross"] }
-  let(:friends) do
-    friend_names.map do |name|
-      Friends::Friend.new(name: name, tags_str: "@test")
-    end
-  end
-  let(:activities) do
-    [
-      Friends::Activity.new(
-        str: "Lunch w/ **#{friend_names.first}** and **#{friend_names.last}**."
-      ),
-      Friends::Activity.new(
-        str: "Yesterday: Called **#{friend_names.last}**."
-      )
-    ]
-  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
-      introvert # Build a new introvert.
-
-      # Check passed values.
-      introvert.filename.must_equal filename
-    end
-
-    it "has sane defaults" do
-      args.clear # Pass no arguments to the initializer.
-      introvert # Build a new introvert.
-
-      # Check default values.
-      introvert.filename.must_equal Friends::Introvert::DEFAULT_FILENAME
-    end
-  end
-
-  describe "#clean" do
-    subject { introvert.clean }
-
-    # Delete the file that is created each time.
-    after { File.delete(filename) if File.exist?(filename) }
-
-    it "writes cleaned file" do
-      sorted_friends = friends.sort
-      unsorted_friends = sorted_friends.reverse
-      sorted_activities = activities.sort
-      unsorted_activities = sorted_activities.reverse
-      sorted_locations = locations.sort
-      unsorted_locations = sorted_locations.reverse
-
-      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"\
-        "#{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
-          stub_locations(unsorted_locations) do
-            subject
-            File.read(filename).must_equal expected_output
-          end
-        end
-      end
-    end
-
-    it { subject.must_equal filename }
-  end
-
-  describe "#list_friends" do
-    subject do
-      introvert.list_friends(
-        location_name: location_name,
-        tagged: tagged,
-        verbose: verbose
-      )
-    end
-
-    describe "when a location name has been passed" do
-      let(:location_name) { "Atlantis" }
-      let(:tagged) { nil }
-      let(:verbose) { false }
-      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 in that location" do
-        stub_friends(friends) do
-          stub_locations(locations) do
-            subject.must_equal ["Aquaman", "Shark-Boy"]
-          end
-        end
-      end
-    end
-
-    describe "when a tag has been passed" do
-      let(:location_name) { nil }
-      let(:tagged) { "@superhero" }
-      let(:verbose) { false }
-      let(:friends) do
-        [
-          Friends::Friend.new(name: "Mark Watney"),
-          Friends::Friend.new(name: "Aquaman", tags_str: "@superhero"),
-          Friends::Friend.new(name: "Shark-Boy", tags_str: "@superhero"),
-          Friends::Friend.new(name: "Ms. Nowhere")
-        ]
-      end
-
-      it "lists the names of friends in that location" do
-        stub_friends(friends) do
-          stub_locations(locations) do
-            subject.must_equal ["Aquaman", "Shark-Boy"]
-          end
-        end
-      end
-    end
-
-    describe "when not verbose" do
-      let(:verbose) { false }
-      let(:location_name) { nil }
-      let(:tagged) { nil }
-      it "lists the names of friends" do
-        stub_friends(friends) do
-          subject.must_equal friend_names
-        end
-      end
-    end
-
-    describe "when verbose" do
-      let(:verbose) { true }
-      let(:location_name) { nil }
-      let(:tagged) { nil }
-      it "lists the names and details of friends" do
-        stub_friends(friends) do
-          # Just check that there's a difference between the verbose and
-          # non-verbose versions of friends (otherwise our test is useless).
-          subject.wont_equal friend_names
-
-          subject.must_equal friends.map(&:to_s)
-        end
-      end
-    end
-  end
-
-  describe "#add_friend" do
-    let(:new_friend_name) { "Jacob Evelyn" }
-    subject { introvert.add_friend(name: new_friend_name) }
-
-    describe "when there is no existing friend with that name" do
-      it "adds the given friend" do
-        stub_friends(friends) do
-          subject
-          introvert.
-            instance_variable_get(:@friends).
-            map(&:name).
-            must_include new_friend_name
-        end
-      end
-
-      it "returns the friend added" do
-        stub_friends(friends) do
-          subject.name.must_equal new_friend_name
-        end
-      end
-    end
-
-    describe "when there is an existing friend with that name" do
-      let(:new_friend_name) { friend_names.first }
-
-      it "raises an error" do
-        stub_friends(friends) do
-          proc { subject }.must_raise Friends::FriendsError
-        end
-      end
-    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_tags" do
-    subject { introvert.list_tags(from: from) }
-
-    let(:activities) do
-      [
-        Friends::Activity.new(str: "Lunch in the park. @picnic @food"),
-        Friends::Activity.new(str: "Fancy dinner. @food @swanky")
-      ]
-    end
-
-    let(:friends) do
-      [
-        Friends::Friend.new(name: "Grace Hopper", tags_str: "@coder @navy"),
-        Friends::Friend.new(name: "James Bond", tags_str: "@cool @swanky")
-      ]
-    end
-
-    describe "when from flag is nil" do
-      let(:from) { nil }
-      it "lists all tags in sorted order" do
-        stub_activities(activities) do
-          stub_friends(friends) do
-            subject.must_equal [
-              "@coder",
-              "@cool",
-              "@food",
-              "@navy",
-              "@picnic",
-              "@swanky"
-            ]
-          end
-        end
-      end
-    end
-
-    describe 'when from flag is "activities"' do
-      let(:from) { "activities" }
-      it "lists all activity tags in sorted order" do
-        stub_activities(activities) do
-          stub_friends(friends) do
-            subject.must_equal ["@food", "@picnic", "@swanky"]
-          end
-        end
-      end
-    end
-
-    describe 'when from flag is "friends"' do
-      let(:from) { "friends" }
-      it "lists all friend tags in sorted order" do
-        stub_activities(activities) do
-          stub_friends(friends) do
-            subject.must_equal ["@coder", "@cool", "@navy", "@swanky"]
-          end
-        end
-      end
-    end
-  end
-
-  describe "#list_activities" do
-    subject do
-      introvert.list_activities(
-        limit: limit,
-        with: with,
-        location_name: location_name,
-        tagged: tagged
-      )
-    end
-    let(:limit) { nil }
-    let(:with) { nil }
-    let(:location_name) { nil }
-    let(:tagged) { nil }
-
-    describe "when the limit is lower than the number of activities" do
-      let(:limit) { 1 }
-
-      it "lists that number of activities" do
-        stub_activities(activities) do
-          subject.size.must_equal limit
-        end
-      end
-    end
-
-    describe "when the limit is equal to the number of activities" do
-      let(:limit) { activities.size }
-
-      it "lists all activities" do
-        stub_activities(activities) do
-          subject.size.must_equal activities.size
-        end
-      end
-    end
-
-    describe "when the limit is greater than the number of activities" do
-      let(:limit) { activities.size + 5 }
-
-      it "lists all activities" do
-        stub_activities(activities) do
-          subject.size.must_equal activities.size
-        end
-      end
-    end
-
-    describe "when the limit is nil" do
-      let(:limit) { nil }
-
-      it "lists all activities" do
-        stub_activities(activities) do
-          subject.size.must_equal activities.size
-        end
-      end
-    end
-
-    describe "when not filtering by a friend" do
-      let(:with) { nil }
-
-      it "lists the activities" do
-        stub_activities(activities) do
-          subject.must_equal activities.map(&:to_s)
-        end
-      end
-    end
-
-    describe "when filtering by part of a friend's name" do
-      let(:with) { "george" }
-
-      describe "when there is more than one friend match" do
-        let(:friend_names) { ["George Washington Carver", "George Harrison"] }
-
-        it "raises an error" do
-          stub_friends(friends) do
-            stub_activities(activities) do
-              proc { subject }.must_raise Friends::FriendsError
-            end
-          end
-        end
-      end
-
-      describe "when there are no friend matches" do
-        let(:friend_names) { ["Joe"] }
-
-        it "raises an error" do
-          stub_friends(friends) do
-            stub_activities(activities) do
-              proc { subject }.must_raise Friends::FriendsError
-            end
-          end
-        end
-      end
-
-      describe "when there is exactly one friend match" do
-        it "filters the activities by that friend" do
-          stub_friends(friends) do
-            stub_activities(activities) do
-              # Only one activity has that friend.
-              subject.must_equal activities[0..0].map(&:to_s)
-            end
-          end
-        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(&:to_s)
-        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(&:to_s)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    describe "when not filtering by a tag" do
-      let(:tagged) { nil }
-
-      it "lists the activities" do
-        stub_activities(activities) do
-          subject.must_equal activities.map(&:to_s)
-        end
-      end
-    end
-
-    describe "when filtering by a tag" do
-      let(:activities) do
-        [
-          Friends::Activity.new(str: "Tennis after work. @exercise @tennis"),
-          Friends::Activity.new(str: "Wimbledon! @tennis"),
-          Friends::Activity.new(str: "Drinks after work. @beer")
-        ]
-      end
-
-      describe "when the tag ('@tag') is not used at all" do
-        let(:tagged) { "@garbage" }
-        it "returns no results" do
-          stub_activities(activities) do
-            subject.must_equal []
-          end
-        end
-      end
-
-      describe "when the tag ('@tag') is used once" do
-        let(:tagged) { "@beer" }
-        it "returns the activity with that tag" do
-          stub_activities(activities) do
-            subject.must_equal [activities.last.to_s]
-          end
-        end
-      end
-
-      describe "when the tag ('@tag') is used multiple times" do
-        let(:tagged) { "@tennis" }
-        it "returns the activities with that tag" do
-          stub_activities(activities) do
-            subject.must_equal activities[0..1].map(&:to_s)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#add_activity" do
-    let(:activity_serialization) { "2014-01-01: Snorkeling with Betsy." }
-    let(:activity_description) { "Snorkeling with **Betsy Ross**." }
-    subject { introvert.add_activity(serialization: activity_serialization) }
-
-    it "adds the given activity" do
-      stub_friends(friends) do
-        subject
-        introvert.activities.first.description.must_equal activity_description
-      end
-    end
-
-    it "adds the activity after others on the same day" do
-      stub_friends(friends) do
-        introvert.add_activity(serialization: "2014-01-01: Ate breakfast.")
-        subject
-        introvert.activities.first.description.must_equal activity_description
-      end
-    end
-
-    it "returns the activity added" do
-      stub_friends(friends) do
-        subject.description.must_equal activity_description
-      end
-    end
-  end
-
-  describe "#rename_friend" do
-    let(:new_name) { "David Bowie" }
-    subject do
-      introvert.rename_friend(old_name: friend_names.last, new_name: new_name)
-    end
-
-    it "replaces old name within activities to the new name" do
-      stub_friends(friends) do
-        stub_activities(activities) do
-          subject
-          introvert.activities.first.description.must_include new_name
-          introvert.activities.last.description.must_include new_name
-        end
-      end
-    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
-  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
-
-    it "returns the modified friend" do
-      stub_friends(friends) do
-        subject.must_equal friends.first
-      end
-    end
-  end
-
-  describe "#remove_nickname" do
-    subject do
-      introvert.remove_nickname(name: "Jeff", nickname: "The Dude")
-    end
-
-    it "returns the modified friend" do
-      friend = Friends::Friend.new(name: "Jeff", nickname_str: "The Dude")
-      stub_friends([friend]) do
-        subject.must_equal friend
-      end
-    end
-  end
-
-  describe "#add_tag" do
-    subject do
-      introvert.add_tag(name: friend_names.first, tag: "@school")
-    end
-
-    it "returns the modified friend" do
-      stub_friends(friends) do
-        subject.must_equal friends.first
-      end
-    end
-
-    describe "when more than one friend name matches" do
-      let(:friend_names) { ["George Washington Carver", "George Washington"] }
-
-      describe "when one friend name matches exactly" do
-        it "returns the modified friend" do
-          stub_friends(friends) do
-            subject.must_equal friends.first
-          end
-        end
-      end
-
-      describe "when no friend name matches exactly" do
-        it "raises an error" do
-          proc do
-            stub_friends(friends) do
-              introvert.add_tag(name: "George", tag: "@school")
-            end
-          end.must_raise Friends::FriendsError
-        end
-      end
-    end
-  end
-
-  describe "#remove_tag" do
-    subject do
-      introvert.remove_tag(name: "Jeff", tag: "@school")
-    end
-
-    it "returns the modified friend" do
-      friend = Friends::Friend.new(name: "Jeff", tags_str: "@school")
-      stub_friends([friend]) do
-        subject.must_equal friend
-      end
-    end
-  end
-
-  describe "#list_favorite_friends" do
-    subject { introvert.list_favorite_friends(limit: limit) }
-
-    describe "when there are more friends than favorites requested" do
-      let(:limit) { 1 }
-
-      it "returns the number of favorites requested" do
-        stub_friends(friends) do
-          stub_activities(activities) do
-            subject.must_equal ["Betsy Ross (2 activities)"]
-          end
-        end
-      end
-    end
-  end
-
-  describe "#list_favorite_locations" do
-    subject { introvert.list_favorite_locations(limit: limit) }
-
-    describe "when there are more locations than favorites requested" do
-      let(:limit) { 1 }
-
-      it "returns the number of favorites requested" do
-        stub_locations(locations) do
-          stub_activities(
-            [Friends::Activity.new(str: "Swimming in _Atlantis_.")]
-          ) do
-            subject.must_equal ["Atlantis (1 activity)"]
-          end
-        end
-      end
-    end
-  end
-
-  describe "#suggest" do
-    subject { introvert.suggest(location_name: location_name) }
-
-    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
-
-    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
-  end
-
-  describe "#graph" do
-    subject do
-      introvert.graph(
-        with: with,
-        location_name: location_name,
-        tagged: tagged
-      )
-    end
-
-    let(:with) { nil }
-    let(:location_name) { nil }
-    let(:tagged) { nil }
-
-    let(:activities) do
-      [
-        # In a location
-        Friends::Activity.new(
-          str: "2016-01-01: \
-            At _The Eiffel Tower_ with **George Washington Carver**."
-        ),
-
-        # Tagged
-        Friends::Activity.new(
-          str: "2016-01-01: Called **George Washington Carver**. @phone"
-        ),
-
-        # With a friend
-        Friends::Activity.new(
-          str: "2016-01-01: Hung out with **Betsy Ross**."
-        )
-      ]
-    end
-
-    it "graphs activities by month" do
-      stub_activities(activities) do
-        subject.must_equal("Jan 2016" => 3)
-      end
-    end
-
-    describe "No activities" do
-      it "returns an empty graph" do
-        subject.must_equal({})
-      end
-    end
-
-    describe "Filtering by friend" do
-      let(:with) { "Betsy Ross" }
-
-      it "graphs activities with a friend" do
-        stub_friends(friends) do
-          stub_activities(activities) do
-            subject.must_equal("Jan 2016" => 1)
-          end
-        end
-      end
-
-      describe "when the friend does not exist" do
-        let(:with) { "Oscar the Grouch" }
-
-        it "raises an error" do
-          stub_activities(activities) do
-            proc { subject }.must_raise Friends::FriendsError
-          end
-        end
-      end
-    end
-
-    describe "Filtering by location" do
-      let(:location_name) { "The Eiffel Tower" }
-
-      it "graphs activities in a location" do
-        stub_locations(locations) do
-          stub_activities(activities) do
-            subject.must_equal("Jan 2016" => 1)
-          end
-        end
-      end
-
-      describe "when the location does not exist" do
-        let(:location_name) { "Nowhere" }
-
-        it "raises an error" do
-          stub_activities(activities) do
-            proc { subject }.must_raise Friends::FriendsError
-          end
-        end
-      end
-    end
-
-    describe "Filtering by tag" do
-      let(:tagged) { "@phone" }
-
-      it "graphs tagged activities" do
-        stub_activities(activities) do
-          subject.must_equal("Jan 2016" => 1)
-        end
-      end
-    end
-  end
-
-  describe "#total_friends" do
-    it "returns 0 when there are no friends" do
-      introvert.total_friends.must_equal 0
-    end
-
-    it "returns the total number of friends" do
-      stub_friends(friends) do
-        introvert.total_friends.must_equal friends.size
-      end
-    end
-  end
-
-  describe "#total_activities" do
-    it "returns 0 when there are no activities" do
-      introvert.total_activities.must_equal 0
-    end
-
-    it "returns the total number of activities" do
-      stub_activities(activities) do
-        introvert.total_activities.must_equal activities.size
-      end
-    end
-  end
-
-  describe "#elapsed_days" do
-    it "return 0 elapsed days when there are no activities" do
-      introvert.elapsed_days.must_equal 0
-    end
-
-    it "returns the number of days between the first and last activity" do
-      stub_activities(activities) do
-        introvert.elapsed_days.must_equal 1
-      end
-    end
-  end
-end