advent_of_ruby 0.3.5 → 0.4.0

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

@@ -1,145 +0,0 @@
-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"]}".delete_suffix("/"),
-            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

@@ -1,19 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,31 +0,0 @@
-module DownloadSolutions
-  module Api
-    class Reddit
-      class RejectUnwantedReplies
-        # Filters out replies that are not gennerally relevant for posterity:
-        #   - removed/deleted 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
-            (["[removed]", "[deleted]"].include?(it[:body].strip) && 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

@@ -1,26 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

data/lib/download_solutions/api/reddit.rb

@@ -1,101 +0,0 @@
-module DownloadSolutions
-  module Api
-    class Reddit
-      MaxSleepCountReachedError = Class.new(StandardError)
-      MultipleMoreChildrensError = Class.new(StandardError)
-
-      private attr_reader :user_agent, :client_id, :client_secret, :username, :password
-
-      # @param client_id [String]
-      # @param client_secret [String]
-      # @param username [String]
-      # @param password [String]
-      def initialize(client_id:, client_secret:, username:, password:)
-        @user_agent = "AdventOfRubyScript/#{Arb::VERSION} by fpsvogel"
-        @client_id = client_id
-        @client_secret = client_secret
-        @username = username
-        @password = password
-      end
-
-      # @param year [Integer]
-      # @param day [Integer]
-      # @param languages [Array<String>] e.g. ["ruby"]
-      # @return [Array<Hash>]
-      #
-      # @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.
-      def get_comments(year:, day:, languages:)
-        params = Params.new(
-          year:,
-          day:,
-          languages:,
-          connection:
-        )
-
-        initial_response = GetInitialResponse.call(params:)
-        params.initial_response = initial_response
-
-        # Keep unfetched replies ("more children" nodes) separate so that after
-        # filtering, the replies to filtered-in comments can then be fetched.
-        original_comments, more_childrens = GetSerialComments.call(params:)
-        params.original_comments = original_comments
-        params.more_childrens = more_childrens
-
-        filtered_comments = FilterByLanguage.call(params:)
-        params.comments = filtered_comments
-
-        # These operations modify params#comments in place.
-        AddMissingReplies.call(params:)
-        RejectUnwantedReplies.call(params:)
-        CleanBodies.call(params:)
-        RemoveLanguageTags.call(params:)
-        RemoveIds.call(params:)
-
-        params.comments
-      end
-
-      private
-
-      def connection
-        @connection ||= Faraday.new(
-          url: "https://oauth.reddit.com",
-          headers: {
-            "User-Agent" => user_agent,
-            "Accept" => "application/json"
-          }
-        ) do |f|
-          f.request :authorization, "Bearer", -> { auth_token }
-          f.request :retry, {
-            max: 5,
-            interval: 0.5,
-            interval_randomness: 0.5,
-            backoff_factor: 2
-          }
-        end
-      end
-
-      def auth_token
-        connection = Faraday.new(
-          url: "https://www.reddit.com",
-          headers: {
-            "User-Agent" => user_agent
-          }
-        ) do |f|
-          f.request :authorization, :basic, client_id, client_secret
-          f.response :json
-        end
-
-        response = connection.post(
-          "/api/v1/access_token",
-          "grant_type=password&username=#{username}&password=#{password}"
-        )
-
-        response.body["access_token"]
-      end
-    end
-  end
-end

data/lib/download_solutions/cli/cli/shared.rb

@@ -1,35 +0,0 @@
-module DownloadSolutions
-  module Cli
-    private_class_method def self.validate_year_and_day(year:, day:)
-      if day
-        if year.nil?
-          raise InputError, "Year must be specified when day is specified."
-        end
-        if !day.between?(1, 25) && Date.new(year, 12, day) > Date.today
-          raise InputError, "Day must be between 1 and 25, and <= today."
-        end
-      end
-      if year && !year.between?(2015, Date.today.year)
-        raise InputError, "Year must be between 2015 and this year."
-      end
-    end
-
-    private_class_method def self.max_year_and_day(year:, day:)
-      if Date.today.year == year && Date.today.month == 12
-        [Date.today.year, Date.today.day]
-      else
-        [Date.today.year - 1, 25]
-      end
-    end
-
-    private_class_method def self.output_initial_message(source:, year:, day:, force:, detail:)
-      force_description = PASTEL.red("FORCE ") if force
-      year_description = year.nil? ? "all years" : year.to_s
-      day_description = day.nil? ? "" : "##{day.to_s.rjust(2, "0")}"
-      time_description = PASTEL.blue("#{year_description}#{day_description}")
-
-      puts "#{force_description}Downloading #{source} solutions from #{time_description} #{detail}..."
-      puts
-    end
-  end
-end

data/lib/download_solutions/cli/github.rb

@@ -1,107 +0,0 @@
-module DownloadSolutions
-  module Cli
-    def self.github(year: nil, day: nil, author: nil, force: false)
-      validate_year_and_day(year:, day:)
-
-      author_name = author.nil? ? "all authors" : PASTEL.blue(author)
-      detail = "by #{author_name}"
-      output_initial_message(source: "GitHub", year:, day:, force:, detail:)
-
-      github_directory = File.join("data", "solutions", "github")
-
-      repos = Api::Github::REPOS
-      if author
-        if repos.key?(author)
-          repos = repos.select { it == author }
-        else
-          raise InputError, "Repo author #{PASTEL.blue(author)} not found."
-        end
-      end
-
-      max_year, max_day = max_year_and_day(year:, day:)
-
-      authors = repos.keys
-      authors.each do |author|
-        author_directory = File.join(github_directory, author)
-        Dir.mkdir(author_directory) unless Dir.exist?(author_directory)
-
-        (year || 2015).upto(year || max_year) do |current_year|
-          year_directory = File.join(author_directory, current_year.to_s)
-
-          existing_solutions =
-            if Dir.exist?(year_directory)
-              Dir.entries(year_directory)
-                .filter_map {
-                  it.delete_suffix(".yml").split("_").map(&:to_i) if it.end_with?(".yml")
-                }.sort
-            else
-              []
-            end
-
-          solutions = github_api.get_solutions(
-            author:,
-            year: current_year,
-            input_day: day,
-            max_day:,
-            force:,
-            existing_solutions:
-          )
-
-          skipped_list = solutions_str(solutions[:skipped])
-          if solutions[:skipped].any?
-            puts "#{PASTEL.yellow.bold("Skipping")} from #{author} #{current_year}, already existing: #{PASTEL.yellow(skipped_list)}"
-          end
-
-          not_found_list = solutions_str(solutions[:not_found])
-          if solutions[:not_found].any?
-            puts "#{PASTEL.red.bold("Not found")} from #{author} #{current_year}: #{PASTEL.red(not_found_list)}"
-            if solutions[:not_found].size < 49
-              # Save empty files for not found solutions, so that they won't be
-              # attempted to be downloaded again.
-              Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
-              solutions[:not_found].each do |(day, part)|
-                path = File.join(year_directory, "#{day.to_s.rjust(2, "0")}_#{part}.yml")
-                File.write(path, [].to_yaml)
-              end
-            end
-          end
-
-          if solutions[:new].any?
-            Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
-            solutions[:new].each do |(day, part), content|
-              path = File.join(year_directory, "#{day.to_s.rjust(2, "0")}_#{part}.yml")
-              File.write(path, content.to_yaml(line_width: -1))
-            end
-
-            new_list = solutions_str(solutions[:new].keys)
-            puts "#{PASTEL.blue.bold("Saved")} from #{author} #{current_year}: #{PASTEL.blue(new_list)}"
-            puts "Saved to #{year_directory}"
-          end
-        end
-
-        puts
-      end
-    rescue InputError => e
-      puts PASTEL.red(e.message)
-    end
-
-    private_class_method def self.solutions_str(solutions)
-      if solutions.count == 49
-        "all"
-      else
-        solutions.sort.map { it.join(".") }.join(", ")
-      end
-    end
-
-    private_class_method def self.github_api
-      return @github_api if @github_api
-
-      github_token = "GITHUB_TOKEN"
-
-      Dotenv.load
-      Dotenv.require_keys([github_token])
-
-      @github_api = Api::Github.new(auth_token: ENV[github_token])
-    end
-  end
-end

data/lib/download_solutions/cli/reddit.rb

@@ -1,64 +0,0 @@
-module DownloadSolutions
-  module Cli
-    def self.reddit(year: nil, day: nil, languages: ["ruby"], force: false)
-      validate_year_and_day(year:, day:)
-
-      language_names = PASTEL.blue(languages.join(", "))
-      detail = "for #{language_names}"
-      output_initial_message(source: "Reddit", year:, day:, force:, detail:)
-
-      language_directory = File.join("data", "solutions", "reddit", languages.join("-"))
-      Dir.mkdir(language_directory) unless Dir.exist?(language_directory)
-
-      max_year, max_day = max_year_and_day(year:, day:)
-
-      (year || 2015).upto(year || max_year) do |current_year|
-        year_directory = File.join("data", "solutions", "reddit", languages.join("-"), current_year.to_s)
-        Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
-
-        (day || 1).upto(day || max_day) do |current_day|
-          path = File.join("data", "solutions", "reddit", languages.join("-"), year.to_s, "#{current_day.to_s.rjust(2, "0")}.yml")
-
-          if File.exist?(path) && !force
-            puts PASTEL.yellow("Skipping #{PASTEL.yellow.bold("#{current_year}##{current_day.to_s.rjust(2, "0")}")} as it already exists.")
-            puts
-            next
-          end
-
-          comments = reddit_api.get_comments(
-            year: current_year,
-            day: current_day,
-            languages:
-          )
-
-          File.write(path, comments.to_yaml(line_width: -1))
-
-          puts "Saved #{PASTEL.blue("#{current_year}##{current_day.to_s.rjust(2, "0")}")} to #{path}"
-          puts
-        end
-      end
-    rescue InputError => e
-      puts PASTEL.red(e.message)
-    end
-
-    private_class_method def self.reddit_api
-      return @reddit_api if @reddit_api
-
-      reddit_api_keys = %w[
-        REDDIT_CLIENT_ID
-        REDDIT_CLIENT_SECRET
-        REDDIT_USERNAME
-        REDDIT_PASSWORD
-      ]
-
-      Dotenv.load
-      Dotenv.require_keys(reddit_api_keys)
-
-      reddit_api_kwargs = %i[client_id client_secret username password]
-        .zip(reddit_api_keys.map { ENV[it] })
-        .to_h
-
-      @reddit_api = Api::Reddit.new(**reddit_api_kwargs)
-    end
-  end
-end

data/lib/download_solutions/download_solutions.rb

@@ -1,18 +0,0 @@
-require "debug"
-require "dotenv"
-require "faraday"
-require "faraday/retry"
-require "pastel"
-require "redcarpet"
-require "reverse_markdown"
-require "yaml"
-require_relative "../arb/version"
-
-module DownloadSolutions
-  InputError = Class.new(StandardError)
-  PASTEL = Pastel.new
-end
-
-Dir[File.join(__dir__, "**", "*.rb")].each do |file|
-  require file
-end

data/lib/download_solutions/reverse_markdown/converters/br.rb

@@ -1,15 +0,0 @@
-# Monkeypatch. Reason: "  \n" is rendered as a line break by Markdown viewers,
-# but trailing spaces are annoying and I strip them out because that's what my
-# editor does on save anyway. Which leaves only the newline, which is rendered
-# as a space. So it's preferable for <br> to become a paragraph break.
-module ReverseMarkdown
-  module Converters
-    class Br < Base
-      def convert(node, state = {})
-        "\n\n" # CHANGED from "  \n"
-      end
-    end
-
-    register :br, Br.new
-  end
-end

data/lib/download_solutions/reverse_markdown/converters/pre.rb

@@ -1,46 +0,0 @@
-# Monkeypatch. Reason: leading spaces are significant for aligning lines of
-# code that are indented as well as wrapped in a fenced code block.
-module ReverseMarkdown
-  module Converters
-    class Pre < Base
-      def convert(node, state = {})
-        content = treat_children(node, state)
-        if ReverseMarkdown.config.github_flavored
-          # CHANGED from content.strip
-          "\n```#{language(node)}\n" << content.chomp << "\n```\n"
-        else
-          "\n\n    " << content.lines.to_a.join("    ") << "\n\n"
-        end
-      end
-
-      private
-
-      # Override #treat as proposed in https://github.com/xijo/reverse_markdown/pull/69
-      def treat(node, state)
-        case node.name
-        when "code", "text"
-          node.text.chomp # CHANGED from node.text.strip
-        when "br"
-          "\n"
-        else
-          super
-        end
-      end
-
-      def language(node)
-        lang = language_from_highlight_class(node)
-        lang || language_from_confluence_class(node)
-      end
-
-      def language_from_highlight_class(node)
-        node.parent["class"].to_s[/highlight-([a-zA-Z0-9]+)/, 1]
-      end
-
-      def language_from_confluence_class(node)
-        node["class"].to_s[/brush:\s?(:?.*);/, 1]
-      end
-    end
-
-    register :pre, Pre.new
-  end
-end