advent_of_ruby 0.1.0 → 0.3.0

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

@@ -1,17 +1,42 @@
 module Arb
   module Cli
     class Runner
-      def self.load_solution(year, day)
-        padded_day = day.rjust(2, "0")
-        Module.const_get("Year#{year}").const_get("Day#{padded_day}").new
-      rescue NameError
-        puts "There is no solution for this puzzle"
-      end
+      SolutionFileNotFoundError = Class.new(StandardError)
+      SolutionClassNotFoundError = Class.new(StandardError)
+      SolutionMethodNotFoundError = Class.new(StandardError)
+      SolutionArgumentError = Class.new(StandardError)
+
+      def self.run_part(year:, day:, part:, correct_answer:)
+        solution_class = solution_class(year:, day:)
+        base_method_name = "part_#{part}"
+        variant_method_names = solution_class
+          .instance_methods(false)
+          .filter { it.to_s.start_with?(base_method_name) }
+          .sort
+
+        if variant_method_names.empty?
+          raise SolutionMethodNotFoundError
+        end
+
+        answers = []
+
+        variant_method_names.each do |variant_method_name|
+          solution = solution_class.new
+          input_file = File.new(Files::Input.path(year:, day:))
+          answer = nil
+
+          begin
+            run_time = Benchmark.realtime do
+              answer = solution.send(variant_method_name, input_file)
+            end
+            variant = variant_method_name.to_s.delete_prefix(base_method_name).delete_prefix("_")
+            variant_note = " `#{PASTEL.blue.bold(variant)}`" unless variant.empty?
+          rescue ArgumentError => e
+            raise SolutionArgumentError, "#{e.message} at .#{e.backtrace.first.delete_prefix(Dir.pwd)}"
+          end
+
+          part_name = "#{year}##{day}.#{part}#{variant_note}"
 
-      def self.run_part(part_name, correct_answer)
-        answer = nil
-        t = Benchmark.realtime do
-          answer = yield
           if answer
             puts "Result for #{part_name}:"
 
@@ -27,15 +52,33 @@ module Arb
           else
             puts "❌ No result for #{part_name}"
           end
-        end
 
-        if answer
-          puts "(obtained in #{t.round(10)} seconds)"
+          if answer && run_time
+            if variant_method_names.count > 1
+              puts "(obtained in #{PASTEL.cyan("%.6f" % run_time)} seconds)"
+            else
+              puts "(obtained in #{"%.6f" % run_time} seconds)"
+            end
+          end
+
+          answers << answer
+
+          puts
         end
 
-        puts
+        answers
+      end
 
-        answer
+      private_class_method def self.solution_class(year:, day:)
+        require "#{Dir.pwd}/src/#{year}/#{day}"
+
+        Module
+          .const_get("Year#{year}")
+          .const_get("Day#{day}")
+      rescue LoadError
+        raise SolutionFileNotFoundError
+      rescue NameError
+        raise SolutionClassNotFoundError
       end
     end
   end

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

@@ -2,20 +2,18 @@ module Arb
   module Cli
     class WorkingDirectory
       FILES = {
-        gitignore: <<~FILE,
+        ".gitignore" => <<~FILE,
           input/**/*
           instructions/**/*
           others/**/*
           .env
-
         FILE
-        ruby_version: "3.3.0\n",
-        gemfile: <<~FILE,
+        ".ruby-version" => "3.3.0\n",
+        "Gemfile" => <<~FILE,
           source "https://rubygems.org"
           ruby file: ".ruby-version"
-
         FILE
-        spec_helper_addition: <<~FILE
+        File.join("spec", "spec_helper.rb") => <<~FILE
           require "debug"
 
           Dir[File.join(__dir__, "..", "src", "**", "*.rb")].each do |file|
@@ -26,24 +24,25 @@ module Arb
         FILE
       }
 
-      def self.env_keys = ["EDITOR_COMMAND", "AOC_COOKIE"]
-      def self.default_editor_command = "code"
+      ENV_KEYS = ["EDITOR_COMMAND", "AOC_COOKIE"]
+      DEFAULT_EDITOR_COMMAND = "code"
 
       def self.prepare!
         files_created = []
 
         existing_dotenv = Dotenv.parse(".env")
-        unless env_keys.all? { existing_dotenv.has_key?(_1) }
+        unless ENV_KEYS.all? { existing_dotenv.has_key?(it) }
           create_dotenv!(existing_dotenv)
           files_created << :dotenv
         end
         Dotenv.load
-        Dotenv.require_keys(*env_keys)
+        Dotenv.require_keys(*ENV_KEYS)
 
         files_created += create_other_files!
 
         if files_created.any?
-          puts "✅ Initial files created and committed to a new Git repository.\n\n"
+          puts "✅ Initial files created and committed to a new Git repository."
+          puts
         end
       end
 
@@ -54,28 +53,29 @@ module Arb
         File.write(".env", generate_dotenv)
       end
 
-      private
-
-      def self.generate_dotenv(new_dotenv)
-        new_dotenv.slice(*env_keys).map { |k, v|
+      private_class_method def self.generate_dotenv(new_dotenv)
+        new_dotenv.slice(*ENV_KEYS).map { |k, v|
           "#{k}=#{v}"
         }.join("\n")
       end
 
-      def self.create_dotenv!(existing_dotenv)
+      private_class_method def self.create_dotenv!(existing_dotenv)
         new_dotenv = existing_dotenv.dup
 
-        puts "🎄 Welcome to Advent of Code in Ruby! 🎄\n\n"
-        puts "Let's start with some configuration.\n\n"
+        puts "🎄 Welcome to Advent of Code in Ruby! 🎄"
+        puts
+        puts "Let's start with some configuration."
+        puts
 
         unless existing_dotenv.has_key?("EDITOR_COMMAND")
-          puts "What's the shell command to start your editor? (default: #{default_editor_command})"
+          puts "What's the shell command to start your editor? (default: #{DEFAULT_EDITOR_COMMAND})"
           print PASTEL.green("> ")
-          editor_command = STDIN.gets.strip
-          editor_command = default_editor_command if editor_command.empty?
+          editor_command = $stdin.gets.strip
+          editor_command = DEFAULT_EDITOR_COMMAND if editor_command.empty?
           new_dotenv["EDITOR_COMMAND"] = editor_command
         end
 
+        puts
         puts
 
         unless existing_dotenv.has_key?("AOC_COOKIE")
@@ -85,7 +85,7 @@ module Arb
         File.write(".env", generate_dotenv(new_dotenv))
       end
 
-      def self.input_aoc_cookie
+      private_class_method def self.input_aoc_cookie
         aoc_cookie = nil
 
         loop do
@@ -95,8 +95,9 @@ module Arb
           puts PASTEL.dark.white("  Chrome: Developer Tools ⇨ Application tab ⇨ Cookies")
           print PASTEL.green("> ")
 
-          aoc_cookie = STDIN.gets.strip
+          aoc_cookie = $stdin.gets.strip
 
+          puts
           puts
 
           break unless aoc_cookie.strip.empty?
@@ -105,32 +106,24 @@ module Arb
         aoc_cookie
       end
 
-      def self.create_other_files!
+      private_class_method def self.create_other_files!
         other_files_created = []
 
         unless Dir.exist?("src")
           Dir.mkdir("src")
-          other_files_created << :src_dir
+          other_files_created << "src"
         end
 
         unless Dir.exist?("spec")
           Dir.mkdir("spec")
-          other_files_created << :spec_dir
-        end
-
-        unless File.exist?(".gitignore")
-          File.write(".gitignore", FILES.fetch(:gitignore))
-          other_files_created << :gitignore
+          other_files_created << "spec"
         end
 
-        unless File.exist?(".ruby-version")
-          File.write(".ruby-version", FILES.fetch(:ruby_version))
-          other_files_created << :ruby_version
-        end
-
-        unless File.exist?("Gemfile")
-          File.write("Gemfile", FILES.fetch(:gemfile))
-          other_files_created << :gemfile
+        FILES.slice(".gitignore", ".ruby-version", "Gemfile").each do |filename, contents|
+          unless File.exist?(filename)
+            File.write(filename, contents)
+            other_files_created << filename
+          end
         end
 
         spec_helper_path = File.join("spec", "spec_helper.rb")
@@ -138,16 +131,16 @@ module Arb
           rspec_init_output = `rspec --init`
           unless rspec_init_output.match?(/exist\s+spec.spec_helper.rb/)
             original_spec_helper = File.read(spec_helper_path)
-            File.write(spec_helper_path, FILES.fetch(:spec_helper_addition) + original_spec_helper)
-            other_files_created << :spec_helper
+            File.write(spec_helper_path, FILES.fetch(spec_helper_path) + original_spec_helper)
+            other_files_created << spec_helper_path
           end
-          other_files_created << :rspec
+          other_files_created << ".rspec"
         end
 
         unless Git.repo_exists?
           Git.init!
           Git.commit_all!(message: "Initial commit")
-          other_files_created << :git
+          other_files_created << ".git"
         end
 
         other_files_created

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

@@ -1,8 +1,8 @@
 module Arb
   module Cli
     class YearDayValidator
-      def self.validate_year_and_day(year:, day:, default_untracked_or_done: false)
-        year, day = year&.to_s, day&.to_s
+      def self.validate_year_and_day(year:, day:, default_to_untracked_or_last_committed: false)
+        year, day = year&.to_s, day&.to_s&.rjust(2, "0")
 
         # The first two digits of the year may be omitted.
         year = "20#{year}" if year && year.length == 2
@@ -10,56 +10,58 @@ module Arb
         if day && !year
           raise InputError, "If you specify the day, specify the year also."
         elsif !day
-          if default_untracked_or_done
-            year, day = Git.new_solutions.last
+          if !year && default_to_untracked_or_last_committed
+            year, day = Git.uncommitted_puzzles.keys.last
           end
 
           unless day
-            if year && !Dir.exist?(File.join("src", year))
-              Dir.mkdir(File.join("src", year))
-              day = "1"
+            if year && Git.committed_by_year[year].values.none?
+              day = "01"
             else
-              year, day = Git.last_committed_solution(year:)
+              year, day = Git.last_committed_puzzle(year:)
 
-              if day && !default_untracked_or_done
-                if day == "25"
-                  day = :end
-                else
-                  day = day.next
-                end
+              if day && !default_to_untracked_or_last_committed
+                day =
+                  if day == "25"
+                    :end
+                  else
+                    day.next
+                  end
               end
 
               if !day || day == :end
                 default_year = "2015"
-                default_day = "1"
+                default_day = "01"
                 bootstrap_year_prompt = nil
 
                 committed = Git.committed_by_year
-                total_committed = committed.values.sum { _1.values.count(&:itself) }
+                total_committed = committed.values.sum { it.values.count(&:itself) }
                 if total_committed.zero?
                   bootstrap_year_prompt = "What year's puzzles do you want to start with? (default: #{default_year})"
                 else
                   earliest_year_with_fewest_committed = committed
-                    .transform_values { _1.values.count(&:itself) }
-                    .sort_by(&:last).first.first
+                    .transform_values { it.values.count(&:itself) }
+                    .min_by(&:last).first
                   default_year = earliest_year_with_fewest_committed
                   default_day = committed[default_year].values.index(false)
 
                   puts "You've recently finished #{year}. Yay!"
-                  bootstrap_year_prompt = "What year do you want to bootstrap next? (default: #{default_year} [at Day #{default_day}])"
+                  bootstrap_year_prompt = "What year do you want to bootstrap next? (default: #{default_year} [at Day #{default_day.to_s.delete_prefix("0")}])"
                 end
 
                 loop do
                   puts bootstrap_year_prompt
                   print PASTEL.green("> ")
-                  year_input = STDIN.gets.strip
+                  year_input = $stdin.gets.strip
+                  puts
                   puts
+
                   if year_input.strip.empty?
                     year = default_year
                     day = default_day
                   else
                     year = year_input.strip.match(/\A\d{4}\z/)&.to_s
-                    day = "1"
+                    day = "01"
                   end
                   break if year
                 end
@@ -78,7 +80,7 @@ module Arb
           raise InputError, "Day must be between 1 and 25, and <= today."
         end
 
-        [year.to_s, day.to_s]
+        [year.to_s, day.to_s.rjust(2, "0")]
       end
     end
   end

data/lib/arb/files/input.rb

@@ -1,19 +1,22 @@
 module Arb
   module Files
     class Input
-      def self.download(year, day, notify_exists: true)
+      def self.path(year:, day:)
         year_directory = File.join("input", year)
+        File.join(year_directory, "#{day}.txt")
+      end
+
+      def self.download(year:, day:, notify_exists: true)
         Dir.mkdir("input") unless Dir.exist?("input")
+        year_directory = File.join("input", year)
         Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
-
-        padded_day = day.rjust(2, "0")
-        file_path = File.join(year_directory, "#{padded_day}.txt")
+        file_path = File.join(year_directory, "#{day}.txt")
 
         if File.exist?(file_path)
           puts "Already exists: #{file_path}" if notify_exists
         else
-          aoc_api = Api::Aoc.new(ENV["AOC_COOKIE"])
-          response = aoc_api.input(year, day)
+          aoc_api = Api::Aoc.new(cookie: ENV["AOC_COOKIE"])
+          response = aoc_api.input(year:, day:)
 
           File.write(file_path, response)
         end

data/lib/arb/files/instructions.rb

@@ -1,32 +1,30 @@
 module Arb
   module Files
     class Instructions
-      def self.path(year, day)
+      def self.path(year:, day:)
         year_directory = File.join("instructions", year)
-        Dir.mkdir("instructions") unless Dir.exist?("instructions")
-        Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
-
-        padded_day = day.rjust(2, "0")
-
-        File.join(year_directory, "#{padded_day}.md")
+        File.join(year_directory, "#{day}.md")
       end
 
-      def self.download(year, day, notify_exists: true, overwrite: false)
-        file_path = path(year, day)
+      def self.download(year:, day:, notify_exists: true, overwrite: false)
+        Dir.mkdir("instructions") unless Dir.exist?("instructions")
+        year_directory = File.join("instructions", year)
+        Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
+        file_path = File.join(year_directory, "#{day}.md")
 
         if File.exist?(file_path) && !overwrite
           puts "Already exists: #{file_path}" if notify_exists
         else
-          url = "https://adventofcode.com/#{year}/day/#{day}"
+          url = "https://adventofcode.com/#{year}/day/#{day.delete_prefix("0")}"
 
-          aoc_api = Api::Aoc.new(ENV["AOC_COOKIE"])
-          response = aoc_api.instructions(year, day)
+          aoc_api = Api::Aoc.new(cookie: ENV["AOC_COOKIE"])
+          response = aoc_api.instructions(year:, day:)
           instructions = response.match(/(?<=<main>).+(?=<\/main>)/m).to_s
           markdown_instructions = ReverseMarkdown.convert(instructions).strip
           markdown_instructions = markdown_instructions
             .sub(/\nTo play, please identify yourself via one of these services:.+/m, "")
             .sub(/\nTo begin, \[get your puzzle input\].+/m, "")
-            .sub(/\n\<form method="post".+/m, "")
+            .sub(/\n<form method="post".+/m, "")
             .sub(/\nAt this point, you should \[return to your Advent calendar\].+/m, "")
             .concat("\n#{url}\n")
 

data/lib/arb/files/other_solutions.rb

@@ -1,27 +1,23 @@
 module Arb
   module Files
     class OtherSolutions
-      def self.download(year, day)
+      def self.download(year:, day:)
         year_directory = File.join("others", year)
         Dir.mkdir("others") unless Dir.exist?("others")
         Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
 
-        padded_day = day.rjust(2, "0")
-
-        file_paths = %w[1 2].map do |part|
-          file_path = File.join(year_directory, "#{padded_day}_#{part}.rb")
+        %w[1 2].map do |part|
+          file_path = File.join(year_directory, "#{day}_#{part}.md")
 
           if File.exist?(file_path)
             puts "Already exists: #{file_path}"
           else
-            other_solutions = Api::OtherSolutions.new.other_solutions(year, day, part)
+            other_solutions = Api::OtherSolutions.new(year:, day:, part:).other_solutions
             File.write(file_path, other_solutions)
           end
 
           file_path
         end
-
-        file_paths
       end
     end
   end

data/lib/arb/files/{source.rb → solution.rb}

@@ -1,29 +1,26 @@
 module Arb
   module Files
-    class Source
-      def self.create(year, day)
+    class Solution
+      def self.create(year:, day:)
         year_directory = File.join("src", year)
         Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
 
-        padded_day = day.rjust(2, "0")
-        file_path = File.join(year_directory, "#{padded_day}.rb")
+        file_path = File.join(year_directory, "#{day}.rb")
 
         if File.exist?(file_path)
           puts "Already exists: #{file_path}"
         else
-          File.write(file_path, source(year, day))
+          File.write(file_path, template(year:, day:))
         end
 
         file_path
       end
 
-      def self.source(year, day)
-        padded_day = day.rjust(2, "0")
-
-        <<~TPL
-          # https://adventofcode.com/#{year}/day/#{day}
+      def self.template(year:, day:)
+        <<~SRC
+          # https://adventofcode.com/#{year}/day/#{day.delete_prefix("0")}
           module Year#{year}
-            class Day#{padded_day}
+            class Day#{day}
               def part_1(input_file)
                 lines = input_file.readlines(chomp: true)
 
@@ -37,7 +34,7 @@ module Arb
               end
             end
           end
-        TPL
+        SRC
       end
     end
   end

data/lib/arb/files/spec.rb

@@ -1,27 +1,24 @@
 module Arb
   module Files
     class Spec
-      def self.create(year, day, notify_exists: true)
+      def self.create(year:, day:, notify_exists: true)
         year_directory = File.join("spec", year)
         Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
 
-        padded_day = day.rjust(2, "0")
-        file_path = File.join(year_directory, "#{padded_day}_spec.rb")
+        file_path = File.join(year_directory, "#{day}_spec.rb")
 
         if File.exist?(file_path)
           puts "Already exists: #{file_path}" if notify_exists
         else
-          File.write(file_path, source(year, day))
+          File.write(file_path, template(year:, day:))
         end
 
         file_path
       end
 
-      def self.source(year, day)
-        padded_day = day.rjust(2, "0")
-
-        <<~TPL
-          RSpec.describe Year#{year}::Day#{padded_day} do
+      def self.template(year:, day:)
+        <<~SPECS
+          RSpec.describe Year#{year}::Day#{day} do
             let(:input) {
               StringIO.new(
                 <<~IN
@@ -38,7 +35,7 @@ module Arb
               expect(subject.part_2(input)).to eq(:todo)
             end
           end
-        TPL
+        SPECS
       end
     end
   end

data/lib/arb/version.rb

@@ -1,3 +1,3 @@
 module Arb
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/download_solutions/api/github/repos.rb

@@ -0,0 +1,87 @@
+module DownloadSolutions
+  module Api
+    class Github
+      REPOS = {
+        "ahorner" => {
+          repo: "advent-of-code",
+          year_directory: "lib/%<year>d",
+          both_parts: "%<day>.2d.rb"
+        },
+        "eregon" => {
+          repo: "adventofcode",
+          part_1: ->(day:) {
+            /\A#{day}(?:a.*)?\.rb\z/
+          },
+          part_2: ->(day:) {
+            /\A#{day}(?:b.*|\D*)\.rb\z/
+          }
+        },
+        "erikw" => {
+          repo: "advent-of-code-solutions",
+          day_directory: "%<day>.2d",
+          part_1: "part1.rb",
+          part_2: "part2.rb",
+          edits: ->(file_contents) {
+            # Remove the first 3 lines (boilerplate).
+            file_contents.lines[3..].join
+          }
+        },
+        "gchan" => {
+          repo: "advent-of-code-ruby",
+          day_directory: "day-%<day>.2d",
+          part_1: "day-%<day>.2d-part-1.rb",
+          part_2: "day-%<day>.2d-part-2.rb",
+          # rarely, e.g. https://github.com/gchan/advent-of-code-ruby/tree/main/2023/day-17
+          both_parts: "day-%<day>.2d-part-1-and-2.rb",
+          edits: ->(file_contents) {
+            # Remove the first 5 lines (boilerplate).
+            file_contents.lines[5..].join
+          }
+        },
+        "ZogStriP" => {
+          repo: "adventofcode-old",
+          both_parts: ->(day:) {
+            /\A#{day.to_s.rjust(2, "0")}_.+\.rb\z/
+          },
+          edits: ->(file_contents) {
+            # Remove input at the end of the file.
+            file_contents.split("\n__END__").first
+          }
+        }
+      }
+
+      # 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
+      #         <<~SOLUTION
+      #           # ------------------------------------------------------------------------------
+      #           # #{username}: #{UI_URI}/#{username}/#{actual_path}
+      #           # ------------------------------------------------------------------------------
+
+      #           #{solution}
+
+      #         SOLUTION
+      #       end
+      #     }
+      #       .compact
+      #       .join
+      #       .strip + "\n"
+      # end
+    end
+  end
+end