calculates highest count words across lines error in ruby coursera

#Implement all parts of this assignment within (this) module2_assignment2.rb file

#Implement a class called LineAnalyzer.
class LineAnalyzer
  #Implement the following read-only attributes in the LineAnalyzer class. 
  #* highest_wf_count - a number with maximum number of occurrences for a single word (calculated)
  #* highest_wf_words - an array of words with the maximum number of occurrences (calculated)
  #* content          - the string analyzed (provided)
  #* line_number      - the line number analyzed (provided)

  #Add the following methods in the LineAnalyzer class.
  #* initialize() - taking a line of text (content) and a line number
  #* calculate_word_frequency() - calculates result

  #Implement the initialize() method to:
  #* take in a line of text and line number
  #* initialize the content and line_number attributes
  #* call the calculate_word_frequency() method.

  #Implement the calculate_word_frequency() method to:
  #* calculate the maximum number of times a single word appears within
  #  provided content and store that in the highest_wf_count attribute.
  #* identify the words that were used the maximum number of times and
  #  store that in the highest_wf_words attribute.

    attr_accessor :highest_wf_count, :highest_wf_words, :content, :line_number


    def initialize(content, line)
    @content = content
    @line_number = line
    @highest_wf_count=0
    @highest_wf_words = []
    calculate_word_frequency()
  end

  def calculate_word_frequency()
    @highest_wf_words = Hash.new
    words = @content.split
    words.each { |w|
      if @highest_wf_words.has_key?(w)
        @highest_wf_words[w] += 1
      else
        @highest_wf_words[w] = 1
      end
    }
    @highest_wf_words.sort_by { |word, count| count }
    @highest_wf_words.each do |key, value|
      if value > @highest_wf_count
        @highest_wf_count = value
      end
    end
  end

  def highest_wf_count= (number)
    @highest_wf_count = number
  end

end


#  Implement a class called Solution. 
class Solution

  # Implement the following read-only attributes in the Solution class.
  #* analyzers - an array of LineAnalyzer objects for each line in the file
  #* highest_count_across_lines - a number with the maximum value for highest_wf_words attribute in the analyzers array.
  #* highest_count_words_across_lines - a filtered array of LineAnalyzer objects with the highest_wf_words attribute 
  #  equal to the highest_count_across_lines determined previously.
  
  # Implement the following methods in the Solution class.
  #* analyze_file() - processes 'test.txt' into an array of LineAnalyzers and stores them in analyzers.
  #* calculate_line_with_highest_frequency() - determines the highest_count_across_lines and 
  #  highest_count_words_across_lines attribute values  
  #* print_highest_word_frequency_across_lines() - prints the values of LineAnalyzer objects in 
  #  highest_count_words_across_lines in the specified format

  
  # Implement the analyze_file() method() to:
  #* Read the 'test.txt' file in lines 
  #* Create an array of LineAnalyzers for each line in the file

  # Implement the calculate_line_with_highest_frequency() method to:
  #* calculate the maximum value for highest_wf_count contained by the LineAnalyzer objects in analyzers array
  #  and stores this result in the highest_count_across_lines attribute.
  #* identifies the LineAnalyzer objects in the analyzers array that have highest_wf_count equal to highest_count_across_lines 
  #  attribute value determined previously and stores them in highest_count_words_across_lines.

  #Implement the print_highest_word_frequency_across_lines() method to
  #* print the values of objects in highest_count_words_across_lines in the specified format

  attr_reader  :analyzers, :highest_count_across_lines, :highest_count_words_across_lines

  def initialize
    @highest_count_across_lines = nil
    @highest_count_words_across_lines = nil
    @analyzers = []
  end

  def analyze_file()
    File.foreach('test.txt') do |content, line|
      LineAnalyzer = LineAnalyzer.new(content, line)
      @analyzers << LineAnalyzer
    end
  end

  def calculate_line_with_highest_frequency()
    @highest_count_across_lines = 0
    @highest_count_words_across_lines = []
    @analyzers.each do |analyzers|
      if analyzers.highest_wf_words > @highest_count_across_lines
        @highest_count_across_lines = analyzers.highest_wf_count
      end
      analyzers.highest_wf_words.each do |key, value|
       if analyzers.highest_count_words_across_lines < value
          @highest_count_words_across_lines << key
       end
      end
    end
  end

  def print_highest_word_frequency_across_lines()
    @highest_count_words_across_lines = Array.new
    puts "The following words have the highest word frequency per line:"
  end
end

LineAnalyzer
  has accessor for highest_wf_count
  has accessor for highest_wf_words
  has accessor for content
  has accessor for line_number
  has method calculate_word_frequency
  calls calculate_word_frequency when created
  attributes and values
    has attributes content and line_number
    content attribute should have value "test"
    line_number attribute should have value 1
  #calculate_word_frequency
    highest_wf_count value is 3
    highest_wf_words will include "really" and "you"
    content attribute will have value "This is a really really really cool cool you you you"
    line_number attribute will have value 2

Solution
  should respond to #analyze_file
  should respond to #calculate_line_with_highest_frequency
  should respond to #print_highest_word_frequency_across_lines
  #analyze_file
    creates 3 line analyzers
  #calculate_line_with_highest_frequency
    calculates highest count across lines to be 4
    calculates highest count words across lines to be will, it, really (FAILED - 1)

Failures:

  1) Solution#calculate_line_with_highest_frequency calculates highest count words across lines to be will, it, really
     Failure/Error: words_found = solution.highest_count_words_across_lines.map(&:highest_wf_words).flatten

     NoMethodError:
       undefined method `highest_wf_words' for "This":String
     # ./spec/solution_spec.rb:38:in `map'
     # ./spec/solution_spec.rb:38:in `block (3 levels) in <top (required)>'

Finished in 0.10817 seconds (files took 0.37345 seconds to load)
19 examples, 1 failure

Failed examples:

rspec ./spec/solution_spec.rb:31 # Solution#calculate_line_with_highest_frequency calculates highest count words across lines to be will, it, really

require_relative "../module2_assignment"
require 'rspec'

describe Solution do
  subject(:solution) { Solution.new }

  it { is_expected.to respond_to(:analyze_file) } 
  it { is_expected.to respond_to(:calculate_line_with_highest_frequency) } 
  it { is_expected.to respond_to(:print_highest_word_frequency_across_lines) } 

  context "#analyze_file" do
    it "creates 3 line analyzers" do
      expect(solution.analyzers.length).to eq 0 
      solution.analyze_file
      expect(solution.analyzers.length).to eq 3
    end  
  end
  
  context "#calculate_line_with_highest_frequency" do


    it "calculates highest count across lines to be 4" do
      solution.analyze_file

      expect(solution.highest_count_across_lines).to be nil
      
      solution.calculate_line_with_highest_frequency

      expect(solution.highest_count_across_lines).to be 4
    end  
    it "calculates highest count words across lines to be will, it, really" do
      solution.analyze_file

      expect(solution.highest_count_words_across_lines).to be nil
      
      solution.calculate_line_with_highest_frequency

      words_found = solution.highest_count_words_across_lines.map(&:highest_wf_words).flatten
      expect(words_found).to match_array ["will", "it", "really"] 
    end  
  end

end