advent_of_ruby 0.1.0 → 0.3.0

data/lib/arb/api/other_solutions.rb

@@ -1,100 +1,92 @@
 module Arb
   module Api
     class OtherSolutions
-      UI_URI = "https://github.com"
-
-      private attr_reader :connection
-
-      PATHS = {
-        "eregon" => ->(year, day, part) {
-          if part == "1"
-            [
-              "adventofcode/tree/master/#{year}/#{day}.rb",
-              "adventofcode/tree/master/#{year}/#{day}a.rb",
-            ]
-          elsif part == "2"
-            ["adventofcode/tree/master/#{year}/#{day}b.rb"]
-          end
-        },
-        "gchan" => ->(year, day, part) {
-          ["advent-of-code-ruby/tree/main/#{year}/day-#{day.rjust(2, "0")}/day-#{day.rjust(2, "0")}-part-#{part}.rb"]
-        },
-        "ahorner" => ->(year, day, part) {
-          return [] if part == "1"
-          ["advent-of-code/tree/main/lib/#{year}/#{day.rjust(2, "0")}.rb"]
-        },
-        "ZogStriP" => ->(year, day, part) {
-          return [] if part == "1"
-
-          puzzle_name = File.read(Files::Instructions.path(year, day))
-            .match(/## --- Day \d\d?: (.+)(?= ---)/)
-            .captures
-            .first
-            .downcase
-            .gsub(" ", "_")
-
-          ["adventofcode/tree/master/#{year}/#{day.rjust(2, "0")}_#{puzzle_name}.rb"]
-        },
-        "erikw" => ->(year, day, part) {
-          ["advent-of-code-solutions/tree/main/#{year}/#{day.rjust(2, "0")}/part#{part}.rb"]
-        },
-      }
-
-      EDITS = {
-        "gchan" => ->(file_str) {
-          # Remove the first 5 lines (boilerplate).
-          file_str.lines[5..].join
-        },
-        "ZogStriP" => ->(file_str) {
-          # Remove input at the end of the file.
-          file_str.split("\n__END__").first
-        },
-        "erikw" => ->(file_str) {
-          # Remove the first 3 lines (boilerplate).
-          file_str.lines[3..].join
-        },
-      }
-
-      def initialize
-        @connection = Faraday.new(
-          url: "https://raw.githubusercontent.com",
-          headers: {
-            "User-Agent" => "github.com/fpsvogel/advent_of_ruby by fps.vogel@gmail.com",
-          }
-        )
+      private attr_reader :year, :day, :part, :gem_directory
+
+      def initialize(year:, day:, part:)
+        @year = year
+        @day = day
+        @part = part
+        @gem_directory = Gem.loaded_specs["advent_of_ruby"].gem_dir
+      end
+
+      def other_solutions
+        unless File.exist?(reddit_file_path)
+          return no_solutions_for_year_message
+        end
+
+        "#{year} Day #{day.to_i} Part #{part}\n\n" \
+          "#{github_solutions}" \
+          "#{reddit_solutions if part.to_i == 2}".rstrip + "\n"
+      end
+
+      private
+
+      def no_solutions_for_year_message
+        "Solutions for #{year} Day #{day.to_i} were not found. Run `gem update " \
+          "advent_of_ruby` and try again. If that doesn't work, and it's been " \
+          "more than a few days since the end of this year's Advent of Code, " \
+          "open an issue at https://github.com/fpsvogel/advent_of_ruby/issues/new" \
+          "?labels=bug&title=Add+#{year}+solutions" \
+          "&body=Solutions+for+#{year}+need+to+be+added+to+the+gem."
       end
 
-      def other_solutions(year, day, part)
-        "# #{year} Day #{day} Part #{part}\n\n" +
-          PATHS
-          .map { |username, path_builder|
-            actual_path = nil
-            solution = nil
-            paths = path_builder.call(year, day, part)
-
-            paths.each do |path|
-              next if solution
-              response = connection.get("/#{username}/#{path.sub("/tree/", "/")}")
-              next if response.status == 404
-
-              actual_path = path
-              solution = (EDITS[username] || :itself.to_proc).call(response.body)
-            end
-
-            if solution
-              <<~TPL
-                # ------------------------------------------------------------------------------
-                # #{username}: #{UI_URI}/#{username}/#{actual_path}
-                # ------------------------------------------------------------------------------
-
-                #{solution}
-
-              TPL
-            end
+      def github_solutions
+        github_directory = File.join(gem_directory, "data", "solutions", "github")
+
+        Dir.children(github_directory)
+          .select { |child| File.directory?(File.join(github_directory, child)) }
+          .map { |author|
+            file_path = File.join(github_directory, author, year.to_s, "#{day.to_s.rjust(2, "0")}_#{part}.yml")
+            # The year subdirectory doesn't exist, if the author has no solutions for the year.
+            next "" unless File.exist?(file_path)
+
+            solutions = YAML.load_file(file_path)
+            next "" if solutions.empty? # if the author has no solutions for the day
+
+            "# #{(solutions.count > 1) ? "Solutions" : "Solution"} by #{author}\n" +
+              solutions
+                .map { |solution|
+                  <<~SOLUTION
+                    #{"## #{solution[:name]}\n" if solutions.count > 1}#{solution[:url]}
+
+                    ```ruby
+                    #{solution[:solution]}
+                    ```
+
+                  SOLUTION
+                }
+                .join
           }
           .compact
           .join
-          .strip + "\n"
+      end
+
+      def reddit_file_path
+        File.join(gem_directory, "data", "solutions", "reddit", "ruby", year.to_s, "#{day.to_s.rjust(2, "0")}.yml")
+      end
+
+      def reddit_solutions
+        comments = YAML.load_file(reddit_file_path)
+
+        comments.map { |comment|
+          reddit_comment_to_markdown(comment)
+        }.join
+      end
+
+      def reddit_comment_to_markdown(comment, level: 0)
+        replies = comment[:replies].map { |reply|
+          reddit_comment_to_markdown(reply, level: level + 1)
+        }.join("\n\n")
+
+        <<~COMMENT.gsub(/(?:\n\s*){3,}/, "\n\n")
+          #{"#" * (level + 1)} #{"↳" * level}#{level.zero? ? "Solution by" : "Reply by"} #{comment[:author]}
+          #{comment[:url]}
+
+          #{comment[:body]}
+
+          #{replies unless replies.empty?}
+        COMMENT
       end
     end
   end

data/lib/arb/arb.rb

@@ -3,21 +3,17 @@ require "date"
 require "debug"
 require "dotenv"
 require "faraday"
+require "open3"
 require "pastel"
 require "reverse_markdown"
 require "rspec/core"
+require "yaml"
 
-class AppError < StandardError; end
-class InputError < AppError; end
-class ConfigError < AppError; end
-
-PASTEL = Pastel.new
-
-Dir[File.join(__dir__, "**", "*.rb")].each do |file|
-  require file
+module Arb
+  InputError = Class.new(StandardError)
+  PASTEL = Pastel.new
 end
 
-solution_files = File.join(Dir.pwd, "src", "**", "*.rb")
-Dir[solution_files].each do |file|
+Dir[File.join(__dir__, "**", "*.rb")].each do |file|
   require file
 end

data/lib/arb/cli/bootstrap.rb

@@ -7,19 +7,20 @@ module Arb
 
       year, day = YearDayValidator.validate_year_and_day(year:, day:)
 
-      instructions_path = Files::Instructions.download(year, day)
-      others_1_path, others_2_path = Files::OtherSolutions.download(year, day)
-      input_path = Files::Input.download(year, day)
-      source_path = Files::Source.create(year, day)
-      spec_path = Files::Spec.create(year, day)
+      instructions_path = Files::Instructions.download(year:, day:)
+      others_1_path, others_2_path = Files::OtherSolutions.download(year:, day:)
+      input_path = Files::Input.download(year:, day:)
+      solution_path = Files::Solution.create(year:, day:)
+      spec_path = Files::Spec.create(year:, day:)
 
-      puts "🤘 Bootstrapped #{year}##{day}\n\n"
+      puts "🤘 Bootstrapped #{year}##{day}"
+      puts
 
       # Open the new files.
       `#{ENV["EDITOR_COMMAND"]} #{others_1_path}`
       `#{ENV["EDITOR_COMMAND"]} #{others_2_path}`
       `#{ENV["EDITOR_COMMAND"]} #{input_path}`
-      `#{ENV["EDITOR_COMMAND"]} #{source_path}`
+      `#{ENV["EDITOR_COMMAND"]} #{solution_path}`
       `#{ENV["EDITOR_COMMAND"]} #{spec_path}`
       `#{ENV["EDITOR_COMMAND"]} #{instructions_path}`
 
@@ -27,10 +28,10 @@ module Arb
         puts "Now fill in the spec for Part One with an example from the instructions, " \
           "then run it with `#{PASTEL.blue.bold("arb run")}` (or just `arb`) as " \
           "you implement the solution. When the spec passes, your solution will " \
-          "be run with the real input and you'll be prompted to submit your solution.\n"
+          "be run with the real input and you'll be prompted to submit your solution."
       end
-    rescue AppError => e
-      puts Pastel.new.red(e.message)
+    rescue InputError => e
+      puts PASTEL.red(e.message)
     end
   end
 end

data/lib/arb/cli/commit.rb

@@ -3,32 +3,41 @@ module Arb
     def self.commit
       WorkingDirectory.prepare!
 
-      change_year, change_day = Git.new_solutions.first
-      unless change_year
+      puzzles = Git.modified_puzzles
+      if puzzles.any?
         files_modified = true
-        change_year, change_day = Git.modified_solutions.first
+      else
+        puzzles = Git.uncommitted_puzzles
       end
 
-      unless change_year
+      if puzzles.empty?
         puts "Nothing to commit."
 
         if Git.commit_count <= 2
-          puts "\nRun `#{PASTEL.blue.bold("arb bootstrap")}` (or `arb b`) to start the next puzzle."
+          puts
+          puts "Run `#{PASTEL.blue.bold("arb bootstrap")}` (or `arb b`) to start the next puzzle."
         end
 
         return
       end
 
-      message = "#{files_modified ? "Improve" : "Solve"} #{change_year}##{change_day}"
-      Git.commit_all!(message:)
+      puzzles.each do |(year, day), filenames|
+        message = "#{files_modified ? "Improve" : "Solve"} #{year}##{day}"
+        Git.commit!(filenames:, message:)
 
-      # TODO less naive check: ensure prev. days are finished too
-      if !files_modified && change_day == "25"
-        puts "\n🎉 You've finished #{change_year}!\n\n"
+        # TODO less naive check: ensure prev. days are finished too
+        if !files_modified && day == "25"
+          puts
+          puts "🎉 You've finished #{year}!"
+          puts
+        end
+
+        puts "Puzzle #{year}##{day}#{" (modified)" if files_modified} committed 🎉"
       end
 
       if Git.commit_count <= 1
-        puts "Solution committed! When you're ready to start the next puzzle, run " \
+        puts
+        puts "When you're ready to start the next puzzle, run " \
           "`#{PASTEL.blue.bold("arb bootstrap")}` (or `arb b`)."
       end
     end

data/lib/arb/cli/progress.rb

@@ -7,22 +7,25 @@ module Arb
 
       total_count = committed.values.sum(&:count)
       my_counts_by_year = committed
-        .transform_values { _1.values.count(&:itself) }
+        .transform_values { it.values.count(&:itself) }
         .reject { |k, v| v.zero? }
       my_total_count = my_counts_by_year.values.sum
 
       total_percent = (my_total_count.to_f / total_count * 100).round(1)
-      total_percent = total_percent == total_percent.to_i ? total_percent.to_i : total_percent
+      total_percent = (total_percent == total_percent.to_i) ? total_percent.to_i : total_percent
 
-      puts "You have completed:\n\n"
-      puts PASTEL.bold "#{PASTEL.blue("All:")}\t#{total_percent}% \t#{my_total_count}/#{total_count} puzzles\n"
+      puts "You have completed:"
+      puts
+      puts PASTEL.bold "#{PASTEL.blue("All:")}\t#{total_percent}% \t#{my_total_count}/#{total_count} puzzles"
+      puts
 
       my_counts_by_year.each do |year, my_count|
-        if year.to_i == Date.today.year
-          year_count = this_year_count
-        else
-          year_count = 25
-        end
+        year_count =
+          if year.to_i == Date.today.year
+            this_year_count
+          else
+            25
+          end
 
         year_percent = (my_count.to_f / year_count * 100).round
 

data/lib/arb/cli/run.rb

@@ -0,0 +1,178 @@
+module Arb
+  module Cli
+    # @param year [String, Integer]
+    # @param day [String, Integer]
+    # @param options [Hash] see `method_option`s above ArbApp#run_day.
+    def self.run(year:, day:, options:)
+      WorkingDirectory.prepare!
+
+      if options[:spec] && (options[:one] || options[:two])
+        raise InputError, "Don't use --spec (-s) with --one (-o) or --two (-t)"
+      end
+
+      year, day = YearDayValidator.validate_year_and_day(year:, day:, default_to_untracked_or_last_committed: true)
+
+      if Git.uncommitted_puzzles.empty? && !Git.last_committed_puzzle(year:)
+        bootstrap(year:, day:)
+        return
+      end
+
+      instructions_path = Files::Instructions.download(year:, day:, notify_exists: false, overwrite: false)
+      instructions = File.read(instructions_path)
+      correct_answer_1, correct_answer_2 = instructions.scan(/Your puzzle answer was `([^`]+)`./).flatten
+      skip_count = 0
+
+      if options[:spec]
+        run_specs_only(year:, day:)
+        return
+      elsif !(options[:one] || options[:two])
+        specs_passed, skip_count = run_specs_before_real(year:, day:)
+        return unless specs_passed
+        puts "👍 Specs passed!"
+        if skip_count > 1 || (skip_count == 1 && correct_answer_1)
+          puts PASTEL.yellow.bold("🤐 #{skip_count} skipped, however")
+        end
+        puts
+      end
+
+      Files::Input.download(year:, day:, notify_exists: false)
+      answers_1, answers_2 = [], []
+
+      begin
+        if options[:one] || (!options[:two] && ((correct_answer_1.nil? && skip_count <= 1) || correct_answer_2))
+          answers_1 = Runner.run_part(year:, day:, part: "1", correct_answer: correct_answer_1)
+        end
+        if options[:two] || (!options[:one] && ((correct_answer_1 && !correct_answer_2 && skip_count.zero?) || correct_answer_2))
+          if answers_1.count > 1
+            puts "------------"
+            puts
+          end
+
+          answers_2 = Runner.run_part(year:, day:, part: "2", correct_answer: correct_answer_2)
+        end
+      rescue Runner::SolutionFileNotFoundError
+        puts PASTEL.red("Solution file not found. Make sure this file exists: #{PASTEL.bold("./src/#{year}/#{day}")}")
+      rescue Runner::SolutionClassNotFoundError
+        puts PASTEL.red("Solution class not found. Make sure the class #{PASTEL.bold("Year#{year}::Day#{day}")} exists in this file (which *does* exist): ./src/#{year}/#{day}")
+      rescue Runner::SolutionMethodNotFoundError
+        puts PASTEL.red("🤔 Couldn't find the method #{PASTEL.bold("##{base_method_name}")}, though the class Year#{year}::Day#{day} exists.")
+      rescue Runner::SolutionArgumentError => e
+        puts PASTEL.red("#{e.message.capitalize}. Make sure that method has one parameter, the input file.")
+      end
+
+      answer_1, answer_2 = answers_1.compact.first, answers_2.compact.first
+
+      return unless answer_1 || answer_2
+
+      if correct_answer_2
+        puts "🙌 You've already submitted the answers to both parts.\n"
+
+        if Git.commit_count <= 1
+          puts "When you're done with this puzzle, run " \
+            "`#{PASTEL.blue.bold("arb commit")}` (or `arb c`) commit your solution to Git.\n"
+        end
+
+        return
+      elsif options[:one] && correct_answer_1
+        puts "🙌 You've already submitted the answer to this part.\n\n"
+        return
+      end
+
+      puts "Submit solution? (Y/n)"
+      print PASTEL.green("> ")
+      submit = $stdin.gets.strip.downcase
+      puts
+
+      if submit == "y" || submit == ""
+        options_part = if options[:one]
+          "1"
+        else
+          (options[:two] ? "2" : nil)
+        end
+        inferred_part = correct_answer_1.nil? ? "1" : "2"
+        aoc_api = Api::Aoc.new(cookie: ENV["AOC_COOKIE"])
+
+        response = aoc_api.submit(year:, day:, part: options_part || inferred_part, answer: answer_2 || answer_1)
+        message = response.match(/(?<=<article>).+(?=<\/article>)/m).to_s.strip
+        markdown_message = ReverseMarkdown.convert(message)
+        short_message = markdown_message
+          .sub(/\n\n.+/m, "")
+          .sub(/ \[\[.+/, "")
+
+        if short_message.start_with?("That's the right answer!")
+          puts
+          puts "⭐ #{short_message}"
+
+          # TODO don't re-download if the instructions file already contains the next part
+          instructions_path = Files::Instructions.download(year:, day:, overwrite: true)
+
+          if (options_part || inferred_part) == "1"
+            puts "Downloaded instructions for Part Two."
+            `#{ENV["EDITOR_COMMAND"]} #{instructions_path}`
+
+            spec_path = Files::Spec.create(year:, day:, notify_exists: false)
+            spec = File.read(spec_path)
+            spec_without_skips = spec.gsub("  xit ", "  it ")
+            File.write(spec_path, spec_without_skips)
+          end
+
+          if Git.commit_count <= 1
+            puts
+            puts "Now it's time to improve your solution! Be sure to look " \
+              "at other people's solutions (in the \"others\" directory). When " \
+              "you're done, run `#{PASTEL.blue.bold("arb commit")}` (or `arb c`) " \
+              "to commit your solution to Git.\n"
+          end
+        else
+          puts "❌ #{short_message}"
+        end
+      end
+    rescue InputError => e
+      puts PASTEL.red(e.message)
+    end
+
+    private_class_method def self.run_specs_only(year:, day:)
+      spec_filename =	File.join("spec", year, "#{day}_spec.rb")
+
+      # Running RSpec from within RSpec causes problems, so in the test environment
+      # run RSpec in a subprocess.
+      if ENV["TEST_ENV"]
+        system "rspec #{spec_filename}"
+      else
+        RSpec::Core::Runner.run([spec_filename])
+      end
+    end
+
+    private_class_method def self.run_specs_before_real(year:, day:)
+      spec_filename =	File.join("spec", year, "#{day}_spec.rb")
+
+      # Running RSpec from within RSpec causes problems, so in the test environment
+      # run RSpec in a subprocess.
+      if ENV["TEST_ENV"]
+        stdout, _status = Open3.capture2("rspec #{spec_filename} --color --tty")
+      else
+        stdout = StringIO.new
+
+        RSpec.configure do |config|
+          config.color = true
+          config.tty = true
+          config.output_stream = stdout
+        end
+
+        RSpec::Core::Runner.run([spec_filename])
+        stdout = stdout.string
+      end
+
+      if stdout.include? "Failures:"
+        puts stdout
+
+        [false, nil]
+      elsif stdout.include?("Finished in ") && stdout.include?("0 failures")
+        [true, stdout.scan("skipped with xit").count]
+      else
+        uncolorized_stdout = stdout.gsub(/\e\[\d+m/, "")
+        raise uncolorized_stdout
+      end
+    end
+  end
+end

data/lib/arb/cli/shared/git.rb

@@ -1,31 +1,42 @@
 module Arb
   module Cli
     class Git
-      # Years and days of uncommitted new solutions, or an empty array.
+      # A hash whose keys are ["<year>", "<day>"] of new solutions or specs, and
+      # and whose values are the names of the modified files (solution, spec, or both).
       # @return [Array<Array(String, String)>]
-      def self.new_solutions
+      def self.uncommitted_puzzles
         output = `git status -su | grep -e "^?? src" -e "^?? spec" -e "^A  src" -e "^A  spec"`
-        output.scan(/(?<year>\d{4})\/(?<day>\d\d)(?:_spec)?.rb$/).uniq
+        filenames = output.scan(/(?:src|spec)\/\d{4}\/\d\d(?:_spec)?.rb/).uniq
+        filenames.group_by { |filename|
+          filename
+            .match(/(?<year>\d{4})\/(?<day>\d\d)(?:_spec)?.rb$/)
+            .captures
+        }
       end
 
-      # Years and days of modified existing solutions, or an empty array.
-      # @return [Array<Array(String, String)>]
-      def self.modified_solutions
+      # A hash whose keys are ["<year>", "<day>"] of modified existing solutions
+      # or specs, and whose values are the names of the modified files
+      # (solution, spec, or both).
+      # @return [Hash{Array(String, String), Array<String>}]
+      def self.modified_puzzles
         output = `git status -su | grep -e "^ M src" -e "^ M spec" -e "^M  src" -e "^M  spec"`
-        output.scan(/(?<year>\d{4})\/(?<day>\d\d)(?:_spec)?.rb$/).uniq
+        filenames = output.scan(/(?:src|spec)\/\d{4}\/\d\d(?:_spec)?.rb/).uniq
+        filenames.group_by { |filename|
+          filename
+            .match(/(?<year>\d{4})\/(?<day>\d\d)(?:_spec)?.rb$/)
+            .captures
+        }
       end
 
       # Year and day of the latest-date solution in the most recent commit, or nil.
       # @return [Array(String, String), nil]
-      def self.last_committed_solution(year: nil, exclude_year: nil)
+      def self.last_committed_puzzle(year: nil, exclude_year: nil)
         if exclude_year
           output = `git log -n 1 --diff-filter=A --name-only --pretty=format: -- src spec ':!src/#{exclude_year}' ':!spec/#{exclude_year}'`
+        elsif year && !Dir.exist?(File.join("src", year))
+          return nil
         else
-          if year && !Dir.exist?(File.join("src", year))
-            return nil
-          else
-            output = `git log -n 1 --diff-filter=A --name-only --pretty=format: #{File.join("src", year || "")} #{File.join("spec", year || "")}`
-          end
+          output = `git log -n 1 --diff-filter=A --name-only --pretty=format: #{File.join("src", year || "")} #{File.join("spec", year || "")}`
         end
 
         return nil if output.empty?
@@ -41,26 +52,31 @@ module Arb
       def self.committed_by_year
         committed_solution_files = `git log --diff-filter=A --name-only --pretty=format: src`
 
-        previous_days = (2015..Date.today.year - 1).map { [_1, (1..25).to_a] }.to_h
-        previous_days.merge!(Date.today.year => (1..Date.today.day)) if Date.today.month == 12
+        previous_days = (2015..Date.today.year - 1).map { [it, (1..25).to_a] }.to_h
+        if Date.today.month == 12
+          previous_days[Date.today.year] = (1..Date.today.day)
+        end
 
         committed_days = committed_solution_files
           .split("\n")
           .reject(&:empty?)
           .map {
-            match = _1.match(/(?<year>\d{4})\/(?<day>\d\d).rb$/)
+            match = it.match(/(?<year>\d{4})\/(?<day>\d\d).rb$/)
             year, day = match[:year], match[:day]
             [year.to_i, day.to_i]
           }
           .group_by(&:first)
-          .transform_values { _1.map(&:last) }
+          .transform_values { it.map(&:last) }
 
         previous_days.map { |year, days|
           days_hash = days.map { |day|
-            [day, committed_days.has_key?(year) && committed_days[year].include?(day)]
+            [
+              day.to_s.rjust(2, "0"),
+              committed_days.has_key?(year) && committed_days[year].include?(day)
+            ]
           }.to_h
 
-          [year, days_hash]
+          [year.to_s, days_hash]
         }.to_h
       end
 
@@ -73,6 +89,11 @@ module Arb
         `git init`
       end
 
+      def self.commit!(filenames:, message:)
+        `git add #{filenames.join(" ")}`
+        `git commit -m "#{message}"`
+      end
+
       def self.commit_all!(message:)
         `git add -A`
         `git commit -m "#{message}"`