advent_of_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a387ce043139b5090d50ac18e76a0687f248fa75dc7e4ba098780f9e739b8687
+  data.tar.gz: e805613b4a188fafa0a0d17499893abb2edd26e5e33c2367fa717a9aa8a827c9
+SHA512:
+  metadata.gz: a731b8c4449af8c8d89a542bc4979ed96edb8972802177709425e62ac8270c1c89fddf71f2c3239ebc430693fdc917b633f53f2006d59c5ce16e027530621203
+  data.tar.gz: 1c87883119e89399b0c7dc6c41a7472142c863d605bca45eafeb2d8b32a51fae11f77474655bef263d1e0696d9ad49d1e8bb84cb406dfb8cf1554390e7b99641

data/bin/arb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require "thor"
+require_relative "../lib/arb/arb"
+
+# The CLI application
+class ArbApp < Thor
+  desc "bootstrap [YEAR] [DAY]", "Creates puzzle files for the next day, or " \
+    "for a given year and optionally day (defaults to Day 1)."
+  def bootstrap(year = nil, day = nil)
+    Arb::Cli.bootstrap(year:, day:)
+  end
+
+  # TODO add a [VARIANT] arg, so that additional versions of the same solution
+  # can co-exist as additional methods, e.g.:
+  #
+  #   #part_1_first     # for my initial attempt
+  #   #part_1_concise   # for a code-golf type solution
+  #   #part_1_alt       # for an alternative approach
+  desc "run [YEAR] [DAY]", "Runs the puzzle that's untracked in Git, or the " \
+    "puzzle of the given day and year. `-s` runs only specs, `-o` part 1, `-t` part 2."
+  method_option :spec, type: :boolean, aliases: "-s"
+  method_option :real_part_1, type: :boolean, aliases: "-o"
+  method_option :real_part_2, type: :boolean, aliases: "-t"
+  def run_day(year = nil, day = nil)
+    Arb::Cli.run_day(year:, day:, options:)
+  end
+
+  desc "progress", "Shows progress based on the number of your solutions " \
+    "committed in Git."
+  def progress
+    Arb::Cli.progress
+  end
+
+  # TODO extract/abstract run_day contents (without terminal output) to a class,
+  # then use it here to silently run each untracked puzzle before committing it,
+  # and if anything is incorrect then show confirmation prompt to user.
+  desc "commit", "Commits new and modified solutions to Git."
+  def commit
+    Arb::Cli.commit
+  end
+
+  default_task :run_day
+end
+
+ArbApp.start

data/lib/arb/api/aoc.rb

@@ -0,0 +1,51 @@
+module Arb
+  module Api
+    class Aoc
+      private attr_reader :connection
+
+      def initialize(cookie)
+        @connection = Faraday.new(
+          url: "https://adventofcode.com",
+          headers: {
+            "Cookie" => "session=#{cookie}",
+            "User-Agent" => "github.com/fpsvogel/advent_of_ruby by fps.vogel@gmail.com",
+          }
+        )
+      end
+
+      def input(year, day)
+        logged_in {
+          connection.get("/#{year}/day/#{day}/input")
+        }
+      end
+
+      def instructions(year, day)
+        logged_in {
+          connection.get("/#{year}/day/#{day}")
+        }
+      end
+
+      def submit(year, day, part, answer)
+        logged_in {
+          connection.post(
+            "/#{year}/day/#{day}/answer",
+            "level=#{part}&answer=#{answer}",
+          )
+        }
+      end
+
+      private
+
+      LOGGED_OUT_RESPONSE = "Puzzle inputs differ by user.  Please log in to get your puzzle input.\n"
+
+      def logged_in(&block)
+        while (response = block.call.body) == LOGGED_OUT_RESPONSE
+          Config.refresh_aoc_cookie!
+          initialize(ENV["AOC_COOKIE"])
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/arb/api/other_solutions.rb

@@ -0,0 +1,101 @@
+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",
+          }
+        )
+      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
+          }
+          .compact
+          .join
+          .strip + "\n"
+      end
+    end
+  end
+end

data/lib/arb/arb.rb

@@ -0,0 +1,23 @@
+require "benchmark"
+require "date"
+require "debug"
+require "dotenv"
+require "faraday"
+require "pastel"
+require "reverse_markdown"
+require "rspec/core"
+
+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
+end
+
+solution_files = File.join(Dir.pwd, "src", "**", "*.rb")
+Dir[solution_files].each do |file|
+  require file
+end

data/lib/arb/cli/bootstrap.rb

@@ -0,0 +1,36 @@
+module Arb
+  module Cli
+    # @param year [String, Integer]
+    # @param day [String, Integer]
+    def self.bootstrap(year: nil, day: nil)
+      WorkingDirectory.prepare!
+
+      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)
+
+      puts "🤘 Bootstrapped #{year}##{day}\n\n"
+
+      # 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"]} #{spec_path}`
+      `#{ENV["EDITOR_COMMAND"]} #{instructions_path}`
+
+      if Git.commit_count <= 1
+        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"
+      end
+    rescue AppError => e
+      puts Pastel.new.red(e.message)
+    end
+  end
+end

data/lib/arb/cli/commit.rb

@@ -0,0 +1,36 @@
+module Arb
+  module Cli
+    def self.commit
+      WorkingDirectory.prepare!
+
+      change_year, change_day = Git.new_solutions.first
+      unless change_year
+        files_modified = true
+        change_year, change_day = Git.modified_solutions.first
+      end
+
+      unless change_year
+        puts "Nothing to commit."
+
+        if Git.commit_count <= 2
+          puts "\nRun `#{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:)
+
+      # 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"
+      end
+
+      if Git.commit_count <= 1
+        puts "Solution committed! When you're ready to start the next puzzle, run " \
+          "`#{PASTEL.blue.bold("arb bootstrap")}` (or `arb b`)."
+      end
+    end
+  end
+end

data/lib/arb/cli/progress.rb

@@ -0,0 +1,33 @@
+module Arb
+  module Cli
+    def self.progress
+      WorkingDirectory.prepare!
+
+      committed = Git.committed_by_year
+
+      total_count = committed.values.sum(&:count)
+      my_counts_by_year = committed
+        .transform_values { _1.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
+
+      puts "You have completed:\n\n"
+      puts PASTEL.bold "#{PASTEL.blue("All:")}\t#{total_percent}% \t#{my_total_count}/#{total_count} puzzles\n"
+
+      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_percent = (my_count.to_f / year_count * 100).round
+
+        puts "#{PASTEL.blue("#{year}:")}\t#{year_percent}%\t#{my_count}/#{year_count}"
+      end
+    end
+  end
+end

data/lib/arb/cli/run_day.rb

@@ -0,0 +1,140 @@
+module Arb
+  module Cli
+    # @param year [String, Integer]
+    # @param day [String, Integer]
+    # @param options [Thor::CoreExt::HashWithIndifferentAccess] see `method_option`s
+    #   above ArbApp#run_day.
+    def self.run_day(year:, day:, options:)
+      WorkingDirectory.prepare!
+
+      if options.spec? && (options.real_part_1? || options.real_part_2?)
+        raise InputError, "Don't use --spec (-s) with --real_part_1 (-o) or --real_part_2 (-t)"
+      end
+
+      year, day = YearDayValidator.validate_year_and_day(year:, day:, default_untracked_or_done: true)
+
+      if Git.new_solutions.none? && !Git.last_committed_solution(year:)
+        bootstrap(year:, day:)
+        return
+      end
+
+      solution = Runner.load_solution(year, day)
+      input_path = Files::Input.download(year, day, notify_exists: false)
+      answer_1, answer_2 = nil, nil
+
+      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.real_part_1? || options.real_part_2?)
+        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 "\n"
+      end
+
+      if options.real_part_1? || (!options.real_part_2? && ((correct_answer_1.nil? && skip_count <= 1) || correct_answer_2))
+        answer_1 = Runner.run_part("#{year}##{day}.1", correct_answer_1) do
+          solution.part_1(File.new(input_path))
+        end
+      end
+      if options.real_part_2? || (!options.real_part_1? && ((correct_answer_1 && !correct_answer_2 && skip_count.zero?) || correct_answer_2))
+        answer_2 = Runner.run_part("#{year}##{day}.2", correct_answer_2) do
+          solution.part_2(File.new(input_path))
+        end
+      end
+
+      return unless answer_1 || answer_2
+
+      if correct_answer_2
+        puts "🙌 You've already submitted the answers to both parts.\n\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.real_part_1? && 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
+
+      if submit == "y" || submit == ""
+        options_part = options.real_part_1? ? "1" : (options.real_part_2? ? "2" : nil)
+        inferred_part = correct_answer_1.nil? ? "1" : "2"
+        aoc_api = Api::Aoc.new(ENV["AOC_COOKIE"])
+
+        response = aoc_api.submit(year, day, options_part || inferred_part, 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 "⭐ #{short_message}\n"
+
+          # 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 "\nDownloaded instructions for Part Two.\n\n"
+            `#{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 "\n\nNow 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 AppError => e
+      puts PASTEL.red(e.message)
+    end
+
+    private_class_method def self.run_specs_only(year, day)
+      padded_day = day.rjust(2, "0")
+      spec_filename =	[File.join("spec", year, "#{padded_day}_spec.rb")]
+
+      RSpec::Core::Runner.run(spec_filename)
+    end
+
+    private_class_method def self.run_specs_before_real(year, day)
+      padded_day = day.rjust(2, "0")
+      spec_filename =	[File.join("spec", year, "#{padded_day}_spec.rb")]
+
+      out = StringIO.new
+      RSpec::Core::Runner.run(spec_filename, $stderr, out)
+
+      if out.string.match?(/Failures:/)
+        RSpec.reset
+        RSpec::Core::Runner.run(spec_filename)
+
+        [false, nil]
+      else
+        [true, out.string.scan("skipped with xit").count]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Arb
+  module Cli
+    class Git
+      # Years and days of uncommitted new solutions, or an empty array.
+      # @return [Array<Array(String, String)>]
+      def self.new_solutions
+        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
+      end
+
+      # Years and days of modified existing solutions, or an empty array.
+      # @return [Array<Array(String, String)>]
+      def self.modified_solutions
+        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
+      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)
+        if exclude_year
+          output = `git log -n 1 --diff-filter=A --name-only --pretty=format: -- src spec ':!src/#{exclude_year}' ':!spec/#{exclude_year}'`
+        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
+        end
+
+        return nil if output.empty?
+
+        output.scan(/(?<year>\d{4})\/(?<day>\d\d)(?:_spec)?.rb$/).last
+      end
+
+      # @return [Integer]
+      def self.commit_count
+        `git rev-list HEAD --count`.to_i
+      end
+
+      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
+
+        committed_days = committed_solution_files
+          .split("\n")
+          .reject(&:empty?)
+          .map {
+            match = _1.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) }
+
+        previous_days.map { |year, days|
+          days_hash = days.map { |day|
+            [day, committed_days.has_key?(year) && committed_days[year].include?(day)]
+          }.to_h
+
+          [year, days_hash]
+        }.to_h
+      end
+
+      # @return [Boolean]
+      def self.repo_exists?
+        `git rev-parse --is-inside-work-tree 2> /dev/null`.chomp == "true"
+      end
+
+      def self.init!
+        `git init`
+      end
+
+      def self.commit_all!(message:)
+        `git add -A`
+        `git commit -m "#{message}"`
+      end
+    end
+  end
+end

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

@@ -0,0 +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
+
+      def self.run_part(part_name, correct_answer)
+        answer = nil
+        t = Benchmark.realtime do
+          answer = yield
+          if answer
+            puts "Result for #{part_name}:"
+
+            if correct_answer
+              if answer.to_s == correct_answer
+                puts PASTEL.green.bold("✅ #{answer}")
+              else
+                puts PASTEL.red.bold("❌ #{answer} -- should be #{correct_answer}")
+              end
+            else
+              puts PASTEL.bright_white.bold(answer)
+            end
+          else
+            puts "❌ No result for #{part_name}"
+          end
+        end
+
+        if answer
+          puts "(obtained in #{t.round(10)} seconds)"
+        end
+
+        puts
+
+        answer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+module Arb
+  module Cli
+    class WorkingDirectory
+      FILES = {
+        gitignore: <<~FILE,
+          input/**/*
+          instructions/**/*
+          others/**/*
+          .env
+
+        FILE
+        ruby_version: "3.3.0\n",
+        gemfile: <<~FILE,
+          source "https://rubygems.org"
+          ruby file: ".ruby-version"
+
+        FILE
+        spec_helper_addition: <<~FILE
+          require "debug"
+
+          Dir[File.join(__dir__, "..", "src", "**", "*.rb")].each do |file|
+            require file
+          end
+
+
+        FILE
+      }
+
+      def self.env_keys = ["EDITOR_COMMAND", "AOC_COOKIE"]
+      def self.default_editor_command = "code"
+
+      def self.prepare!
+        files_created = []
+
+        existing_dotenv = Dotenv.parse(".env")
+        unless env_keys.all? { existing_dotenv.has_key?(_1) }
+          create_dotenv!(existing_dotenv)
+          files_created << :dotenv
+        end
+        Dotenv.load
+        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"
+        end
+      end
+
+      def self.refresh_aoc_cookie!
+        print "Uh oh, your Advent of Code session cookie has expired or was " \
+          "incorrectly entered. "
+        ENV["AOC_COOKIE"] = input_aoc_cookie
+        File.write(".env", generate_dotenv)
+      end
+
+      private
+
+      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)
+        new_dotenv = existing_dotenv.dup
+
+        puts "🎄 Welcome to Advent of Code in Ruby! 🎄\n\n"
+        puts "Let's start with some configuration.\n\n"
+
+        unless existing_dotenv.has_key?("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?
+          new_dotenv["EDITOR_COMMAND"] = editor_command
+        end
+
+        puts
+
+        unless existing_dotenv.has_key?("AOC_COOKIE")
+          new_dotenv["AOC_COOKIE"] = input_aoc_cookie
+        end
+
+        File.write(".env", generate_dotenv(new_dotenv))
+      end
+
+      def self.input_aoc_cookie
+        aoc_cookie = nil
+
+        loop do
+          puts "What's your Advent of Code session cookie?"
+          puts PASTEL.dark.white("To find it, log in to [Advent of Code](https://adventofcode.com/) and then:")
+          puts PASTEL.dark.white("  Firefox: Developer Tools ⇨ Storage tab ⇨ Cookies")
+          puts PASTEL.dark.white("  Chrome: Developer Tools ⇨ Application tab ⇨ Cookies")
+          print PASTEL.green("> ")
+
+          aoc_cookie = STDIN.gets.strip
+
+          puts
+
+          break unless aoc_cookie.strip.empty?
+        end
+
+        aoc_cookie
+      end
+
+      def self.create_other_files!
+        other_files_created = []
+
+        unless Dir.exist?("src")
+          Dir.mkdir("src")
+          other_files_created << :src_dir
+        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
+        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
+        end
+
+        spec_helper_path = File.join("spec", "spec_helper.rb")
+        unless File.exist?(".rspec") && File.exist?(spec_helper_path)
+          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
+          end
+          other_files_created << :rspec
+        end
+
+        unless Git.repo_exists?
+          Git.init!
+          Git.commit_all!(message: "Initial commit")
+          other_files_created << :git
+        end
+
+        other_files_created
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+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
+
+        # The first two digits of the year may be omitted.
+        year = "20#{year}" if year && year.length == 2
+
+        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
+          end
+
+          unless day
+            if year && !Dir.exist?(File.join("src", year))
+              Dir.mkdir(File.join("src", year))
+              day = "1"
+            else
+              year, day = Git.last_committed_solution(year:)
+
+              if day && !default_untracked_or_done
+                if day == "25"
+                  day = :end
+                else
+                  day = day.next
+                end
+              end
+
+              if !day || day == :end
+                default_year = "2015"
+                default_day = "1"
+                bootstrap_year_prompt = nil
+
+                committed = Git.committed_by_year
+                total_committed = committed.values.sum { _1.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
+                  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}])"
+                end
+
+                loop do
+                  puts bootstrap_year_prompt
+                  print PASTEL.green("> ")
+                  year_input = STDIN.gets.strip
+                  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"
+                  end
+                  break if year
+                end
+              end
+            end
+          end
+        end
+
+        year = Integer(year, exception: false) || (raise InputError, "Year must be a number.")
+        day = Integer(day, exception: false) || (raise InputError, "Day must be a number.")
+
+        unless year.between?(2015, Date.today.year)
+          raise InputError, "Year must be between 2015 and this year."
+        end
+        unless day.between?(1, 25) && Date.new(year, 12, day) <= Date.today
+          raise InputError, "Day must be between 1 and 25, and <= today."
+        end
+
+        [year.to_s, day.to_s]
+      end
+    end
+  end
+end

data/lib/arb/files/input.rb

@@ -0,0 +1,25 @@
+module Arb
+  module Files
+    class Input
+      def self.download(year, day, notify_exists: true)
+        year_directory = File.join("input", year)
+        Dir.mkdir("input") unless Dir.exist?("input")
+        Dir.mkdir(year_directory) unless Dir.exist?(year_directory)
+
+        padded_day = day.rjust(2, "0")
+        file_path = File.join(year_directory, "#{padded_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)
+
+          File.write(file_path, response)
+        end
+
+        file_path
+      end
+    end
+  end
+end

data/lib/arb/files/instructions.rb

@@ -0,0 +1,40 @@
+module Arb
+  module Files
+    class Instructions
+      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")
+      end
+
+      def self.download(year, day, notify_exists: true, overwrite: false)
+        file_path = path(year, day)
+
+        if File.exist?(file_path) && !overwrite
+          puts "Already exists: #{file_path}" if notify_exists
+        else
+          url = "https://adventofcode.com/#{year}/day/#{day}"
+
+          aoc_api = Api::Aoc.new(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(/\nAt this point, you should \[return to your Advent calendar\].+/m, "")
+            .concat("\n#{url}\n")
+
+          File.write(file_path, markdown_instructions)
+        end
+
+        file_path
+      end
+    end
+  end
+end

data/lib/arb/files/other_solutions.rb

@@ -0,0 +1,28 @@
+module Arb
+  module Files
+    class OtherSolutions
+      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")
+
+          if File.exist?(file_path)
+            puts "Already exists: #{file_path}"
+          else
+            other_solutions = Api::OtherSolutions.new.other_solutions(year, day, part)
+            File.write(file_path, other_solutions)
+          end
+
+          file_path
+        end
+
+        file_paths
+      end
+    end
+  end
+end

data/lib/arb/files/source.rb

@@ -0,0 +1,44 @@
+module Arb
+  module Files
+    class Source
+      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")
+
+        if File.exist?(file_path)
+          puts "Already exists: #{file_path}"
+        else
+          File.write(file_path, source(year, day))
+        end
+
+        file_path
+      end
+
+      def self.source(year, day)
+        padded_day = day.rjust(2, "0")
+
+        <<~TPL
+          # https://adventofcode.com/#{year}/day/#{day}
+          module Year#{year}
+            class Day#{padded_day}
+              def part_1(input_file)
+                lines = input_file.readlines(chomp: true)
+
+                nil
+              end
+
+              def part_2(input_file)
+                lines = input_file.readlines(chomp: true)
+
+                nil
+              end
+            end
+          end
+        TPL
+      end
+    end
+  end
+end

data/lib/arb/files/spec.rb

@@ -0,0 +1,45 @@
+module Arb
+  module Files
+    class Spec
+      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")
+
+        if File.exist?(file_path)
+          puts "Already exists: #{file_path}" if notify_exists
+        else
+          File.write(file_path, source(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
+            let(:input) {
+              StringIO.new(
+                <<~IN
+                  something
+                IN
+              )
+            }
+
+            it "solves Part One" do
+              expect(subject.part_1(input)).to eq(:todo)
+            end
+
+            xit "solves Part Two" do
+              expect(subject.part_2(input)).to eq(:todo)
+            end
+          end
+        TPL
+      end
+    end
+  end
+end

data/lib/arb/version.rb

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

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: advent_of_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Felipe Vogel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: reverse_markdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description:
+email:
+- fps.vogel@gmail.com
+executables:
+- arb
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/arb
+- lib/arb/api/aoc.rb
+- lib/arb/api/other_solutions.rb
+- lib/arb/arb.rb
+- lib/arb/cli/bootstrap.rb
+- lib/arb/cli/commit.rb
+- lib/arb/cli/progress.rb
+- lib/arb/cli/run_day.rb
+- lib/arb/cli/shared/git.rb
+- lib/arb/cli/shared/runner.rb
+- lib/arb/cli/shared/working_directory.rb
+- lib/arb/cli/shared/year_day_validator.rb
+- lib/arb/files/input.rb
+- lib/arb/files/instructions.rb
+- lib/arb/files/other_solutions.rb
+- lib/arb/files/source.rb
+- lib/arb/files/spec.rb
+- lib/arb/version.rb
+homepage: https://github.com/fpsvogel/advent_of_ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/fpsvogel/advent_of_ruby
+  changelog_uri: https://github.com/fpsvogel/avent_of_ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.10
+signing_key:
+specification_version: 4
+summary: CLI for Advent of Code in Ruby, via the `arb` command.
+test_files: []