advent_of_ruby 0.2.0 → 0.3.0

data/lib/download_solutions/api/github.rb

@@ -0,0 +1,164 @@
+module DownloadSolutions
+  module Api
+    class Github
+      UnexpectedResponseError = Class.new(StandardError)
+      NotFoundResponseError = Class.new(StandardError)
+
+      private attr_reader :user_agent, :auth_token
+
+      # @param auth_token [String]
+      def initialize(auth_token:)
+        @user_agent = "AdventOfRubyScript/#{Arb::VERSION} by fpsvogel"
+        @auth_token = auth_token
+      end
+
+      # @param author [String]
+      # @param year [Integer]
+      # @param day [Integer]
+      # @param max_day [Integer]
+      # @param force [Boolean]
+      # @param existing_solutions [Array<Array(Integer, Integer)>]
+      # @return [Array<Hash>, nil] nil if the year directory doesn't exist for the author.
+      def get_solutions(author:, year:, input_day: nil, max_day: 25, force: false, existing_solutions: [])
+        solutions = {new: {}, skipped: [], not_found: []}
+
+        year_directory = (REPOS[author][:year_directory] || "%<year>d") % {year:}
+        year_files = get_year_files!(solutions:, year_directory:, author:, year:) || (return solutions)
+
+        (input_day || 1).upto(input_day || max_day) do |day|
+          if REPOS[author][:day_directory]
+            day_files = get_day_files!(solutions:, year_directory:, author:, year:, day:, force:, existing_solutions:) || next
+          end
+
+          1.upto(2) do |part|
+            next if day == 25 && part == 2
+
+            if !force && existing_solutions.include?([day, part])
+              solutions[:skipped] << [day, part]
+            else
+              solution = get_part(author:, year:, day:, part:, year_files:, day_files:)
+
+              if solution.empty?
+                solutions[:not_found] << [day, part]
+              else
+                solutions[:new][[day, part]] = solution
+              end
+            end
+          end
+        end
+
+        solutions
+      end
+
+      private
+
+      def get_year_files!(solutions:, year_directory:, author:, year:)
+        year_response = api_connection.get("/repos/#{author}/#{REPOS[author][:repo]}/contents/#{year_directory}")
+
+        if year_response.status == 404
+          solutions[:not_found] = (1..max_day).flat_map { |day|
+            [[day, 1], ([day, 2] unless day == 25)]
+          }.compact
+
+          return nil
+        end
+
+        JSON.parse(year_response.body)
+      end
+
+      def get_day_files!(solutions:, year_directory:, author:, year:, day:, force:, existing_solutions:)
+        if !force && existing_solutions.any? { |existing_day, _existing_part| existing_day == day }
+          solutions[:skipped] << [day, 1]
+          solutions[:skipped] << [day, 1] unless day == 25
+          return nil
+        end
+
+        day_directory = REPOS[author][:day_directory] % {day:}
+        day_response = api_connection.get("/repos/#{author}/#{REPOS[author][:repo]}/contents/#{year_directory}/#{day_directory}")
+
+        if day_response.status == 404
+          solutions[:not_found] << [day, 1]
+          solutions[:not_found] << [day, 2] unless day == 25
+          return nil
+        end
+
+        JSON.parse(day_response.body)
+      end
+
+      def get_part(author:, year:, day:, part:, year_files:, day_files: nil)
+        exact_path = (REPOS[author][:"part_#{part}"] || REPOS[author][:both_parts]).is_a?(String)
+
+        if exact_path
+          (day_files || year_files)
+            .select {
+              if REPOS[author][:both_parts] && it["name"] == REPOS[author][:both_parts] % {year:, day:}
+                next if part == 1 && day != 25 # both_parts will be saved in part 2
+                true
+              elsif REPOS[author][:"part_#{part}"]
+                it["name"] == REPOS[author][:"part_#{part}"] % {year:, day:}
+              end
+            }
+            .map { simplify_response(it, author) }
+        else # regex-matched paths
+          (day_files || year_files)
+            .select {
+              if REPOS[author][:both_parts] && it["name"].match?(REPOS[author][:both_parts].call(day:))
+                next if part == 1 && day != 25 # both_parts will be saved in part 2
+                true
+              elsif REPOS[author][:part_1] && REPOS[author][:part_2]
+                if part == 2
+                  it["name"].match?(REPOS[author][:part_2].call(day:)) &&
+                    !it["name"].match?(REPOS[author][:part_1].call(day:))
+                else
+                  it["name"].match?(REPOS[author][:part_1].call(day:))
+                end
+              end
+            }
+            .map { simplify_response(it, author) }
+        end
+      end
+
+      def simplify_response(response, author)
+        solution = raw_connection.get(response["download_url"]).body
+        solution = REPOS[author][:edits].call(solution) if REPOS[author][:edits]
+        {
+          name: response["name"],
+          url: response["html_url"].rpartition("/").first,
+          solution: solution.strip
+        }
+      end
+
+      def api_connection
+        @api_connection ||= Faraday.new(
+          url: "https://api.github.com",
+          headers: {
+            "User-Agent" => user_agent,
+            "Accept" => "application/vnd.github+json"
+          }
+        ) do |f|
+          f.request :authorization, "token", -> { auth_token }
+          f.request :retry, {
+            max: 5,
+            interval: 0.5,
+            interval_randomness: 0.5,
+            backoff_factor: 2
+          }
+        end
+      end
+
+      def raw_connection
+        @raw_connection ||= Faraday.new(
+          url: "https://raw.githubusercontent.com",
+          headers: {"User-Agent" => user_agent}
+        ) do |f|
+          f.request :retry, {
+            max: 5,
+            interval: 0.5,
+            interval_randomness: 0.5,
+            backoff_factor: 2
+          }
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/add_missing_replies.rb

@@ -0,0 +1,43 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class AddMissingReplies
+        # Fetches replies to comments that are not yet loaded, only listed in
+        # "more children" nodes.
+        #
+        # @param params [Reddit::Params]
+        # @return [void] params.comments is modified in place.
+        def self.call(params:)
+          params.comments.each do |comment|
+            add_missing_replies!(comment, params)
+          end
+
+          params.comments.reject! do |comment|
+            comment[:parent_id] != params.thread_id
+          end
+        end
+
+        private_class_method def self.add_missing_replies!(comment, params)
+          comments_from_more_children, more_children_from_more_children =
+            GetSerialComments.call(
+              params:,
+              parent_id: comment[:id]
+            )
+          params.original_comments += comments_from_more_children
+          debugger unless more_children_from_more_children.empty?
+          params.original_comments += more_children_from_more_children
+
+          children = params.original_comments.filter { it[:parent_id] == comment[:id] }
+
+          comment[:replies] += children
+
+          children.each do |child|
+            add_missing_replies!(child, params)
+          end
+
+          comment[:replies].uniq!
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/clean_bodies.rb

@@ -0,0 +1,64 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class CleanBodies
+        MARKDOWN_PARSER = Redcarpet::Markdown.new(Redcarpet::Render::HTML, fenced_code_blocks: true)
+
+        # Clean up comment bodies by removing unwanted characters, translating
+        # encoded characters, and standardizing to fenced (triple backtick) code
+        # blocks.
+        #
+        # @param params [Reddit::Params]
+        # @return [void] params.comments is modified in place.
+        def self.call(params:)
+          params.comments.each do |comment|
+            clean_body!(comment, params.languages)
+          end
+        end
+
+        private_class_method def self.clean_body!(comment, languages)
+          comment[:body] = preclean_markdown(comment[:body], languages)
+            .then { |body_markdown| MARKDOWN_PARSER.render(body_markdown) }
+            .then { |body_html| to_cleaned_markdown(body_html, languages) }
+
+          comment[:replies].each do |reply|
+            clean_body!(reply, languages)
+          end
+        end
+
+        private_class_method def self.preclean_markdown(initial_body_markdown, languages)
+          initial_body_markdown
+            .tr("\u00a0", " ") # Non-breaking space
+            # Zero-width space (unintentional); do not remove "\u200b" (intentional, e.g. Unihedron's poems in 2019)
+            .gsub("#x200B;", "")
+            .gsub("&", "&")
+            # Mysterious ampersand, on Reddit an empty paragraph
+            .gsub("\n\n&\n\n", "\n\n")
+            .delete_suffix("\n\n&")
+            .gsub("&lt;", "<")
+            .gsub("&gt;", ">")
+            .gsub("&#39;", "'")
+            # Convert one or two backticks on their own line, to three for a code block.
+            .gsub(
+              /\\?`(?:\\?`)?(?:#{languages.first})?\n(.+?)\n\\?`(?:\\?`)?(?=\n|\z)/m,
+              "\n\n```\n\\1\n```\n"
+            )
+            .gsub(/    ```.*/, "") # Superfluous backticks (already indented)
+            # Add an empty line above code blocks, if missing.
+            .gsub(/\n{0,2}```(?:#{languages.first})?/, "\n\n```")
+        end
+
+        private_class_method def self.to_cleaned_markdown(body_html, languages)
+          body_html
+            # https://github.com/xijo/reverse_markdown/blob/14d53d5f914fd926b49e6492fd7bd95e62ef541a/lib/reverse_markdown/converters/pre.rb#L37
+            .gsub("<pre>", "<pre class=\"brush:#{languages.first};\">")
+            .gsub(/<pre><code class=([^>]+)>/, "<pre class=\\1><code>")
+            .then { |cleaned_raw_body|
+              ReverseMarkdown.convert(cleaned_raw_body, github_flavored: true)
+            }
+            .gsub(/ +\n/, "\n") # Strip trailing spaces
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/filter_by_language.rb

@@ -0,0 +1,32 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class FilterByLanguage
+        # Filters comments by the desired programming language(s).
+        #
+        # @param params [Reddit::Params]
+        # @return [Array<Hash>]
+        def self.call(params:)
+          params.original_comments.filter { |comment|
+            comment_body = comment[:body]&.downcase
+            next unless comment_body
+
+            language_specified = comment_body.match?(/\[[[:punct:]]*language:/i)
+
+            if language_specified
+              params.languages.any? { |language|
+                comment_body.match?(/\[[[:punct:]]*language:\s*#{language}/i)
+              }
+            else
+              params.languages.any? { |language|
+                # "sh:" because of "<pre class=\"brush:ruby", see:
+                # https://github.com/xijo/reverse_markdown/blob/14d53d5f914fd926b49e6492fd7bd95e62ef541a/lib/reverse_markdown/converters/pre.rb#L37
+                comment_body.match?(/(?<!```|sh:)#{language}/i)
+              }
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/get_initial_response.rb

@@ -0,0 +1,30 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class GetInitialResponse
+        # Equivalent to the initial page load of a Reddit thread, which loads
+        # some comments, but (if the thread has many comments) not all of them.
+        #
+        # @param params [Reddit::Params]
+        # @return [Faraday::Response]
+        def self.call(params:)
+          initial_response = nil
+
+          loop do
+            initial_response = params.connection.get(params.megathread_path)
+
+            if initial_response.body.empty?
+              puts PASTEL.bright_black("Throttled by Reddit. Sleeping for 60 seconds...")
+              sleep 60
+            else
+              puts "Fetching comments for #{params.year}##{params.day.to_s.rjust(2, "0")}..."
+              break
+            end
+          end
+
+          initial_response
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/get_serial_comments.rb

@@ -0,0 +1,145 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class GetSerialComments
+        MAX_SLEEP_COUNT = 10
+
+        # Equivalent to repeatedly pressing "View more comments" in a thread's top
+        # level (or the "+" below a comment) until reaching the end. "Serial"
+        # because this doesn't fetch all replies; many (not all) replies are in
+        # "more children" nodes and not yet fetched.
+        #
+        # @param params [Reddit::Params]
+        # @param parent_id [String] the ID of the parent, by default the thread.
+        # @return [Array(Array<Hash>, Array<Hash>)] comments and "more children" nodes.
+        #
+        # @raise [MaxSleepCountReachedError] if Reddit seemingly throttled for an
+        #   unusually long time, "seemingly" because the only sign is an empty
+        #   JSON response body after loading additional comments.
+        # @raise [MultipleMoreChildrensError] if there are multiple "more children"
+        #   nodes for the thread or a comment; only one at a time is expected.
+        #   If there are ever more, this algorithm will need to change from a
+        #   serial loop to recursion.
+        def self.call(params:, parent_id: params.thread_id)
+          comments = initial_comments_or_replies(params, parent_id) || (return [[], []])
+
+          loop do
+            more_top_level_childrens, comments = comments.partition {
+              it[:children] && it[:parent_id] == parent_id
+            }
+            break unless more_top_level_childrens.any?
+            raise Reddit::MultipleMoreChildrensError if more_top_level_childrens.count > 1
+
+            # Loop again to fetch more if there are more top-level comments.
+            comments += fetch_more_children(params, more_top_level_childrens.first, parent_id)
+          end
+
+          more_childrens, comments = comments.partition { it[:children] }
+
+          [comments, more_childrens]
+        end
+
+        private_class_method def self.initial_comments_or_replies(params, parent_id)
+          if parent_id == params.thread_id
+            parse_initial_response(params)
+          else
+            more_childrens = params.more_childrens.select {
+              it[:parent_id] == parent_id
+            }
+            raise Reddit::MultipleMoreChildrensError if more_childrens.count > 1
+
+            if more_childrens.empty?
+              # signal to return empty arrays for comments and more_childrens
+              return nil
+            end
+
+            fetch_more_children(params, more_childrens.first, parent_id)
+          end
+        end
+
+        private_class_method def self.parse_initial_response(params)
+          simplify_comments(
+            JSON.parse(params.initial_response.body).dig(-1, "data", "children")
+          )
+        end
+
+        private_class_method def self.fetch_more_children(params, more_children, parent_id)
+          response = nil
+          sleep_count = 0
+          loop do
+            # POST because a GET request would sometimes be too long.
+            response = params.connection.post(
+              "/api/morechildren.json",
+              "link_id=#{params.thread_id}" \
+                "&children=#{more_children[:children].join(",")}"
+            )
+
+            if response.body.empty?
+              if sleep_count < MAX_SLEEP_COUNT
+                puts PASTEL.bright_black("Throttled by Reddit. Sleeping for 60 seconds...")
+                sleep_count += 1
+                sleep 60
+              else
+                raise Reddit::MaxSleepCountReachedError
+              end
+            else
+              puts "Continuing to fetch comments..." if sleep_count > 1
+              break
+            end
+          end
+
+          simplify_comments(
+            JSON.parse(response.body).dig("jquery", 10, 3, 0)
+          )
+        end
+
+        private_class_method def self.simplify_comments(raw_comments)
+          raw_more_childrens, raw_comments = raw_comments.partition { it["kind"] == "more" }
+
+          comments = raw_comments.map { |raw_comment|
+            simplify_comment(raw_comment, raw_more_childrens)
+          }
+
+          more_childrens = raw_more_childrens.filter_map {
+            if it["data"]["children"].any?
+              {
+                children: it["data"]["children"],
+                parent_id: it["data"]["parent_id"]
+              }
+            end
+          }
+
+          comments + more_childrens
+        end
+
+        private_class_method def self.simplify_comment(raw_comment, raw_more_childrens)
+          {
+            author: raw_comment["data"]["author"],
+            url: "https://www.reddit.com#{raw_comment["data"]["permalink"]}",
+            body: raw_comment["data"]["body"],
+            id: raw_comment["data"]["name"],
+            parent_id: raw_comment["data"]["parent_id"],
+            replies: simplify_replies(raw_comment, raw_more_childrens)
+          }
+        end
+
+        private_class_method def self.simplify_replies(raw_comment, raw_more_childrens)
+          return [] if raw_comment["data"]["replies"].nil? || raw_comment["data"]["replies"].empty?
+
+          raw_comment.dig("data", "replies", "data", "children").filter_map { |child|
+            if child["kind"] == "more"
+              # Move "more children" nodes (listing additional replies that are
+              # not yet fetched) out to an array that is appended onto the
+              # upper-level comments (see #simplify_comments), so that they can
+              # all be dealt with together by #add_missing_replies!
+              raw_more_childrens << child
+              next nil
+            end
+
+            simplify_comment(child, raw_more_childrens)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/megathread_ids.rb

@@ -0,0 +1,19 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      # From https://www.reddit.com/r/adventofcode/wiki/archives/solution_megathreads
+      MEGATHREAD_IDS = {
+        2024 => %w[1h3vp6n 1h4ncyr 1h5frsp 1h689qf 1h71eyz 1h7tovg 1h8l3z5 1h9bdmp 1ha27bo 1hau6hl 1hbm0al 1hcdnk0 1hd4wda 1hdvhvu 1hele8m 1hfboft 1hg38ah 1hguacy 1hhlb8g 1hicdtb 1hj2odw 1hjroap 1hkgj5b 1hl698z 1hlu4ht],
+        2023 => %w[1883ibu 188w447 189m3qw 18actmy 18b4b0r 18bwe6t 18cnzbm 18df7px 18e5ytd 18evyu9 18fmrjk 18ge41g 18h940b 18i0xtn 18isayp 18jjpfk 18k9ne5 18l0qtr 18ltr8m 18mmfxb 18nevo3 18o7014 18oy4pc 18pnycy 18qbsxs],
+        2022 => %w[z9ezjb zac2v2 zb865p zc0zta zcxid5 zdw0u6 zesk40 zfpnka zgnice zhjfo4 zifqmh zjnruc zkmyh4 zli1rd zmcn64 zn6k1l znykq2 zoqhvy zpihwi zqezkn zrav4h zsct8w zt6xz5 zu28ij zur1an],
+        2021 => %w[r66vow r6zd93 r7r0ff r8i1lq r9824c r9z49j rar7ty rbj87a rca6vp rd0s54 rds32p rehj2r rf7onx rfzq6f rgqzt5 rhj2hm ri9kdq rizw2c rjpf7f rkf5ek rl6p8y rlxhmg rmnozs rnejv5 ro2uav],
+        2020 => %w[k4e4lm k52psu k5qsrk k6e8sw k71h6r k7ndux k8a31f k8xw8h k9lfwj ka8z8x kaw6oz kbj5me kc4njx kcr1ct kdf85p ke2qp6 keqsfa kfeldk kg1mro kgo01p khaiyk khyjgv kimluc kj96iw kjtg7y],
+        2019 => %w[e4axxe e4u0rw e5bz2w e5u5fv e6carb e6tyva e7a4nj e7pkmt e85b6d e8m1z3 e92jm2 e9j0ve e9zgse eafj32 eaurfo ebai4g ebr7dg ec8090 ecogl3 ed5ei2 edll5a ee0rqi eefva8 eewjtt efca4m],
+        2018 => %w[a20646 a2aimr a2lesz a2xef8 a3912m a3kr4r a3wmnl a47ubw a4i97s a4skra a53r6i a5eztl a5qd71 a61ojp a6chwa a6mf8a a6wpup a77xq6 a7j9zc a7uk3f a86jgt a8i1cy a8s17l a91ysq a9c61w],
+        2017 => %w[7gsrc2 7h0rnm 7h7ufl 7hf5xb 7hngbn 7hvtoq 7i44pg 7icnff 7iksqc 7irzg5 7izym2 7j89tr 7jgyrt 7jpelc 7jxkiw 7k572l 7kc0xw 7kj35s 7kr2ac 7kz6ik 7l78eb 7lf943 7lms6p 7lte5z 7lzo3l],
+        2016 => %w[5fur6q 5g1hfm 5g80ck 5gdvve 5gk2yv 5gr0xf 5gy1f2 5h52ro 5hbygy 5hijk5 5hoia9 5hus40 5i1q0h 5i8pzz 5ifn4v 5imh3d 5isvxv 5iyp50 5j4lp1 5jbeqo 5ji29h 5jor9q 5jvbzt 5k1he1 5k6yfu],
+        2015 => %w[3uyl7s 3v3w2f 3v8roh 3vdn8a 3viazx 3vmltn 3vr4m4 3vw32y 3w192e 3w6h3m 3wbzyv 3wh73d 3wm0oy 3wqtx2 3wwj84 3x1i26 3x6cyr 3xb3cj 3xflz8 3xjpp2 3xnyoi 3xspyl 3xxdxt 3y1s7f 3y5jco]
+      }
+    end
+  end
+end

data/lib/download_solutions/api/reddit/params.rb

@@ -0,0 +1,40 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      # A parameter object that is passed into each step within Reddit#get_comments.
+      class Params
+        attr_reader :year, :day, :languages, :connection, :megathread_path, :thread_id
+        attr_accessor :initial_response, :original_comments, :more_childrens, :comments
+
+        # @param year [Integer]
+        # @param day [Integer]
+        # @param languages [Array<String>] e.g. ["ruby"]
+        def initialize(year:, day:, languages:, connection:)
+          @year = year
+          @day = day
+          @languages = languages
+          @connection = connection
+          @megathread_path = build_megathread_path(year:, day:)
+          @thread_id = "t3_#{megathread_id(year:, day:)}"
+        end
+
+        private
+
+        def build_megathread_path(year:, day:)
+          if year == 2015 && day == 1
+            return "/r/programming/comments/#{Reddit::MEGATHREAD_IDS[2015][0]}/daily_programming_puzzles_at_advent_of_code.json"
+          end
+
+          slug = "day_#{day.to_i}_solutions"
+          slug = "#{year.to_i}_#{slug}" if year > 2015
+
+          "/r/adventofcode/comments/#{megathread_id(year:, day:)}/#{slug}.json"
+        end
+
+        def megathread_id(year:, day:)
+          Reddit::MEGATHREAD_IDS[year.to_i][day - 1]
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/reject_unwanted_replies.rb

@@ -0,0 +1,31 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class RejectUnwantedReplies
+        # Filters out replies that are not gennerally relevant for posterity:
+        #   - removed with no replies
+        #   - by moderators
+        #   - by bots
+        #
+        # @param params [Reddit::Params]
+        # @return [void] params.comments is modified in place.
+        def self.call(params:)
+          params.comments.each do |comment|
+            reject_unwanted_replies!(comment)
+          end
+        end
+
+        private_class_method def self.reject_unwanted_replies!(comment)
+          comment[:replies].each do |reply|
+            reject_unwanted_replies!(reply)
+          end
+
+          comment[:replies].reject! do
+            (it[:body].strip == "[removed]" && it[:replies].empty?) ||
+              %w[AutoModerator daggerdragon backtickbot].include?(it[:author])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/remove_ids.rb

@@ -0,0 +1,26 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class RemoveIds
+        # Removes IDs from comments.
+        #
+        # @param params [Reddit::Params]
+        # @return [void] params.comments is modified in place.
+        def self.call(params:)
+          params.comments.each do |comment|
+            remove_ids!(comment)
+          end
+        end
+
+        private_class_method def self.remove_ids!(comment)
+          comment.delete(:id)
+          comment.delete(:parent_id)
+
+          comment[:replies].each do |reply|
+            remove_ids!(reply)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/download_solutions/api/reddit/remove_language_tags.rb

@@ -0,0 +1,29 @@
+module DownloadSolutions
+  module Api
+    class Reddit
+      class RemoveLanguageTags
+        # Removes language tags from comment bodies.
+        #
+        # @param params [Reddit::Params]
+        # @return [void] params.comments is modified in place.
+        def self.call(params:)
+          params.comments.each do |comment|
+            remove_language_tag!(comment, params.languages)
+          end
+        end
+
+        private_class_method def self.remove_language_tag!(comment, languages)
+          languages.each do |language|
+            comment[:body].sub!(/\[[[:punct:]]*language:\s*#{language}[[:punct:]]*\]/i, "")
+          end
+
+          comment[:body].strip!
+
+          comment[:replies].each do |reply|
+            remove_language_tag!(reply, languages)
+          end
+        end
+      end
+    end
+  end
+end