advent_of_ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a387ce043139b5090d50ac18e76a0687f248fa75dc7e4ba098780f9e739b8687
-  data.tar.gz: e805613b4a188fafa0a0d17499893abb2edd26e5e33c2367fa717a9aa8a827c9
+  metadata.gz: ed16b9db7d2113dc310e48d6fc3792c673dfdfeab2259ad4c8af67797b4c7c6b
+  data.tar.gz: 6cde22c6e469c4c774d0ba336a6f37dfacedf2f98e421480153ddc9d875369b1
 SHA512:
-  metadata.gz: a731b8c4449af8c8d89a542bc4979ed96edb8972802177709425e62ac8270c1c89fddf71f2c3239ebc430693fdc917b633f53f2006d59c5ce16e027530621203
-  data.tar.gz: 1c87883119e89399b0c7dc6c41a7472142c863d605bca45eafeb2d8b32a51fae11f77474655bef263d1e0696d9ad49d1e8bb84cb406dfb8cf1554390e7b99641
+  metadata.gz: 77e2f6d78f40aec3b30f625fce9367af74612c015111cab5f11ee207ff150b4feadbe21cff287e8f372b68fa711c3d81f17ac5b923be8bef9b991bf0781514d8
+  data.tar.gz: 1274475154d99500503228440120a0322d83832f0c30f39ffdbbc56bcc29d54d258ef0c6e4f8914617818183682b4a2f1c5525581c1803d3f611b90a35f00f11

data/bin/arb

@@ -11,19 +11,13 @@ class ArbApp < Thor
     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:)
+  method_option :one, type: :boolean, aliases: "-o"
+  method_option :two, type: :boolean, aliases: "-t"
+  def run_day(year = nil, day = nil) # can't be named `run` due to Thor conflict
+    Arb::Cli.run(year:, day:, options:)
   end
 
   desc "progress", "Shows progress based on the number of your solutions " \

data/lib/arb/api/aoc.rb

@@ -3,7 +3,7 @@ module Arb
     class Aoc
       private attr_reader :connection
 
-      def initialize(cookie)
+      def initialize(cookie:)
         @connection = Faraday.new(
           url: "https://adventofcode.com",
           headers: {
@@ -13,22 +13,22 @@ module Arb
         )
       end
 
-      def input(year, day)
+      def input(year:, day:)
         logged_in {
-          connection.get("/#{year}/day/#{day}/input")
+          connection.get("/#{year}/day/#{day.delete_prefix("0")}/input")
         }
       end
 
-      def instructions(year, day)
+      def instructions(year:, day:)
         logged_in {
-          connection.get("/#{year}/day/#{day}")
+          connection.get("/#{year}/day/#{day.delete_prefix("0")}")
         }
       end
 
-      def submit(year, day, part, answer)
+      def submit(year:, day:, part:, answer:)
         logged_in {
           connection.post(
-            "/#{year}/day/#{day}/answer",
+            "/#{year}/day/#{day.delete_prefix("0")}/answer",
             "level=#{part}&answer=#{answer}",
           )
         }

data/lib/arb/api/other_solutions.rb

@@ -6,37 +6,37 @@ module Arb
       private attr_reader :connection
 
       PATHS = {
-        "eregon" => ->(year, day, part) {
+        "eregon" => ->(year:, day:, part:) {
           if part == "1"
             [
-              "adventofcode/tree/master/#{year}/#{day}.rb",
-              "adventofcode/tree/master/#{year}/#{day}a.rb",
+              "adventofcode/tree/master/#{year}/#{day.delete_prefix("0")}.rb",
+              "adventofcode/tree/master/#{year}/#{day.delete_prefix("0")}a.rb",
             ]
           elsif part == "2"
-            ["adventofcode/tree/master/#{year}/#{day}b.rb"]
+            ["adventofcode/tree/master/#{year}/#{day.delete_prefix("0")}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"]
+        "gchan" => ->(year:, day:, part:) {
+          ["advent-of-code-ruby/tree/main/#{year}/day-#{day}/day-#{day}-part-#{part}.rb"]
         },
-        "ahorner" => ->(year, day, part) {
+        "ahorner" => ->(year:, day:, part:) {
           return [] if part == "1"
-          ["advent-of-code/tree/main/lib/#{year}/#{day.rjust(2, "0")}.rb"]
+          ["advent-of-code/tree/main/lib/#{year}/#{day}.rb"]
         },
-        "ZogStriP" => ->(year, day, part) {
+        "ZogStriP" => ->(year:, day:, part:) {
           return [] if part == "1"
 
-          puzzle_name = File.read(Files::Instructions.path(year, day))
+          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"]
+          ["adventofcode/tree/master/#{year}/#{day}_#{puzzle_name}.rb"]
         },
-        "erikw" => ->(year, day, part) {
-          ["advent-of-code-solutions/tree/main/#{year}/#{day.rjust(2, "0")}/part#{part}.rb"]
+        "erikw" => ->(year:, day:, part:) {
+          ["advent-of-code-solutions/tree/main/#{year}/#{day}/part#{part}.rb"]
         },
       }
 
@@ -64,13 +64,13 @@ module Arb
         )
       end
 
-      def other_solutions(year, day, part)
+      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 = path_builder.call(year:, day:, part:)
 
             paths.each do |path|
               next if solution
@@ -82,14 +82,14 @@ module Arb
             end
 
             if solution
-              <<~TPL
+              <<~SOLUTION
                 # ------------------------------------------------------------------------------
                 # #{username}: #{UI_URI}/#{username}/#{actual_path}
                 # ------------------------------------------------------------------------------
 
                 #{solution}
 
-              TPL
+              SOLUTION
             end
           }
           .compact

data/lib/arb/arb.rb

@@ -3,6 +3,7 @@ require "date"
 require "debug"
 require "dotenv"
 require "faraday"
+require "open3"
 require "pastel"
 require "reverse_markdown"
 require "rspec/core"
@@ -16,8 +17,3 @@ 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

@@ -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,7 +28,7 @@ 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)

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

@@ -14,8 +14,10 @@ module Arb
       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"
+      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

data/lib/arb/cli/run.rb

@@ -0,0 +1,171 @@
+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::SolutionNotFoundError
+        puts PASTEL.red("Solution class not found. Make sure this class exists: #{PASTEL.bold("Year#{year}::Day#{day}")}")
+      rescue Runner::SolutionArgumentError
+        puts PASTEL.red("ArgumentError when running your solution. Make sure every method has a one parameter (the input file).")
+      rescue Runner::SolutionArgumentError
+      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 = options[:one] ? "1" : (options[:two] ? "2" : nil)
+        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 AppError => 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,23 +1,36 @@
 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}'`
         else
@@ -57,10 +70,13 @@ module Arb
 
         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}"`

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

@@ -1,17 +1,41 @@
 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
+      SolutionNotFoundError = 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 { _1.to_s.start_with?(base_method_name)}
+            .sort
+
+        if variant_method_names.empty?
+          puts PASTEL.red("🤔 Couldn't find the method #{PASTEL.bold("Year#{year}::Day#{day}##{base_method_name}")}.")
+          return
+        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
+            raise SolutionArgumentError
+          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 +51,31 @@ 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 NameError
+        raise SolutionNotFoundError
       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|
@@ -43,7 +41,8 @@ module Arb
         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,19 +53,19 @@ module Arb
         File.write(".env", generate_dotenv)
       end
 
-      private
-
-      def self.generate_dotenv(new_dotenv)
+      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})"
@@ -76,6 +75,7 @@ module Arb
           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
@@ -97,6 +97,7 @@ module Arb
 
           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,18 +10,17 @@ 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 && !default_to_untracked_or_last_committed
                 if day == "25"
                   day = :end
                 else
@@ -31,7 +30,7 @@ module Arb
 
               if !day || day == :end
                 default_year = "2015"
-                default_day = "1"
+                default_day = "01"
                 bootstrap_year_prompt = nil
 
                 committed = Git.committed_by_year
@@ -46,7 +45,7 @@ module Arb
                   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
@@ -54,12 +53,14 @@ module Arb
                   print PASTEL.green("> ")
                   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 +79,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,26 +1,24 @@
 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

data/lib/arb/files/other_solutions.rb

@@ -1,20 +1,18 @@
 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")
+          file_path = File.join(year_directory, "#{day}_#{part}.rb")
 
           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.other_solutions(year:, day:, part:)
             File.write(file_path, other_solutions)
           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.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: advent_of_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Felipe Vogel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-21 00:00:00.000000000 Z
+date: 2024-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debug
@@ -137,7 +137,7 @@ files:
 - lib/arb/cli/bootstrap.rb
 - lib/arb/cli/commit.rb
 - lib/arb/cli/progress.rb
-- lib/arb/cli/run_day.rb
+- lib/arb/cli/run.rb
 - lib/arb/cli/shared/git.rb
 - lib/arb/cli/shared/runner.rb
 - lib/arb/cli/shared/working_directory.rb
@@ -145,7 +145,7 @@ files:
 - lib/arb/files/input.rb
 - lib/arb/files/instructions.rb
 - lib/arb/files/other_solutions.rb
-- lib/arb/files/source.rb
+- lib/arb/files/solution.rb
 - lib/arb/files/spec.rb
 - lib/arb/version.rb
 homepage: https://github.com/fpsvogel/advent_of_ruby

data/lib/arb/cli/run_day.rb

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