aoc_cli 0.2.2 → 1.0.0

data/lib/aoc_cli/processors/puzzle_dir_synchroniser.rb

@@ -0,0 +1,80 @@
+module AocCli
+  module Processors
+    class PuzzleDirSynchroniser < Core::Processor
+      extend Forwardable
+
+      attr_accessor :puzzle, :location, :skip_cache
+
+      set_default skip_cache: false
+
+      validates :puzzle, required: true
+
+      validates :location, required: true
+
+      # TODO: replace with conditional validation
+      def validate
+        super
+        validate_puzzle_dir_exists! if errors.empty?
+      end
+
+      def run
+        refresh_puzzle! if skip_cache
+
+        create_puzzle_dir_sync_log!.tap do
+          puzzle_file.write(puzzle.content)
+          input_file.write(puzzle.input)
+        end
+      end
+
+      private
+
+      def_delegators :puzzle, :year, :day, :presenter
+
+      def_delegators :presenter, :puzzle_filename, :input_filename
+
+      def puzzle_dir
+        @puzzle_dir ||= location.to_pathname
+      end
+
+      def puzzle_file
+        @puzzle_file ||= puzzle_dir.join(puzzle_filename)
+      end
+
+      def input_file
+        @input_file ||= puzzle_dir.join(input_filename)
+      end
+
+      def refresh_puzzle!
+        PuzzleRefresher.run!(puzzle:)
+
+        puzzle.reload
+      end
+
+      def create_puzzle_dir_sync_log!
+        PuzzleDirSyncLog.create(
+          puzzle:, location:, puzzle_status:, input_status:
+        )
+      end
+
+      def puzzle_status
+        return :new unless puzzle_file.exist?
+
+        puzzle_file.read == puzzle.content ? :unmodified : :modified
+      end
+
+      def input_status
+        return :new unless input_file.exist?
+
+        input_file.read == puzzle.input ? :unmodified : :modified
+      end
+
+      def validate_puzzle_dir_exists!
+        return if puzzle_dir.exist?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :puzzle_dir, message: "does not exist"
+        )
+      end
+    end
+  end
+end

data/lib/aoc_cli/processors/puzzle_initialiser.rb

@@ -0,0 +1,91 @@
+module AocCli
+  module Processors
+    class PuzzleInitialiser < Core::Processor
+      attr_accessor :event, :day
+
+      validates :event, required: true
+      validates :day, integer: { between: 1..25 }
+
+      def validate
+        super
+        validate_event_location_set! if errors.empty?
+        validate_event_dir_exists! if errors.empty?
+        validate_puzzle_dir_does_not_exist! if errors.empty?
+      end
+
+      def run
+        create_or_update_puzzle!(fetch_content!, fetch_input!).tap do |puzzle|
+          attach_puzzle_dir!(puzzle).tap do |location|
+            write_puzzle_files!(puzzle, location)
+          end
+        end
+      end
+
+      private
+
+      def_delegators :event, :year
+
+      def event_dir
+        @event_dir ||= event.location.to_pathname
+      end
+
+      def puzzle_dir
+        @puzzle_dir ||= event_dir.join(day.to_s)
+      end
+
+      def existing_puzzle
+        @existing_puzzle ||= Puzzle.first(event:, day:)
+      end
+
+      def fetch_content!
+        Core::Repository.get_puzzle(year:, day:)
+      end
+
+      def fetch_input!
+        Core::Repository.get_input(year:, day:)
+      end
+
+      def create_or_update_puzzle!(content, input)
+        if existing_puzzle.nil?
+          Puzzle.create(event:, day:, content:, input:)
+        else
+          existing_puzzle.update(content:, input:) || existing_puzzle
+        end
+      end
+
+      def attach_puzzle_dir!(puzzle)
+        puzzle_dir.mkdir
+
+        ResourceAttacher.run!(resource: puzzle, path: puzzle_dir.to_s)
+      end
+
+      def write_puzzle_files!(puzzle, location)
+        PuzzleDirSynchroniser.run!(puzzle:, location:)
+      end
+
+      def validate_event_location_set!
+        return unless event.location.nil?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :event_location, message: "can't be blank"
+        )
+      end
+
+      def validate_event_dir_exists!
+        return if event_dir.exist?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :event_dir, message: "does not exist"
+        )
+      end
+
+      def validate_puzzle_dir_does_not_exist!
+        return unless puzzle_dir.exist?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :puzzle_dir, message: "already exists"
+        )
+      end
+    end
+  end
+end

data/lib/aoc_cli/processors/puzzle_refresher.rb

@@ -0,0 +1,27 @@
+module AocCli
+  module Processors
+    class PuzzleRefresher < Core::Processor
+      attr_accessor :puzzle
+
+      validates :puzzle, type: { equals: Puzzle }
+
+      def run
+        puzzle.update(content:, input:) || puzzle
+      end
+
+      private
+
+      extend Forwardable
+
+      def_delegators :puzzle, :year, :day
+
+      def content
+        Core::Repository.get_puzzle(year:, day:)
+      end
+
+      def input
+        Core::Repository.get_input(year:, day:)
+      end
+    end
+  end
+end

data/lib/aoc_cli/processors/resource_attacher.rb

@@ -0,0 +1,22 @@
+module AocCli
+  module Processors
+    class ResourceAttacher < Core::Processor
+      extend Forwardable
+
+      attr_accessor :resource, :path
+
+      validates :resource, type: { one_of: [Event, Puzzle] }
+      validates :path, path: { exists: true }
+
+      def run
+        if location.nil?
+          Location.create(resource:, path:)
+        else
+          location&.update(path:) || location
+        end.tap { resource.reload }
+      end
+
+      def_delegators :resource, :location
+    end
+  end
+end

data/lib/aoc_cli/processors/solution_poster.rb

@@ -0,0 +1,72 @@
+module AocCli
+  module Processors
+    class SolutionPoster < Core::Processor
+      attr_accessor :puzzle, :answer
+
+      validates :puzzle, type: { equals: Puzzle }
+
+      validates :answer, required: true
+
+      # TODO: replace with conditional validation
+      def validate
+        super
+        validate_puzzle_location_set! if errors.empty?
+        validate_stats_associated! if errors.empty?
+        validate_puzzle_not_complete! if errors.empty?
+      end
+
+      def run
+        create_attempt!(post_solution!).tap do |attempt|
+          advance_puzzle! if attempt.correct?
+        end
+      end
+
+      private
+
+      def_delegators :puzzle, :event, :location, :year, :day
+
+      def level
+        @level ||= event.stats.current_level(day) || raise
+      end
+
+      def post_solution!
+        Core::Repository.post_solution(year:, day:, level:, answer:)
+      end
+
+      def create_attempt!(response)
+        Attempt.create(puzzle:, level:, answer:, **response)
+      end
+
+      def advance_puzzle!
+        event.stats.advance_progress!(day)
+        puzzle.mark_complete!(level)
+
+        PuzzleDirSynchroniser.run!(puzzle:, location:, skip_cache: true)
+      end
+
+      def validate_puzzle_location_set!
+        return unless location.nil?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :location, message: "can't be blank"
+        )
+      end
+
+      def validate_stats_associated!
+        return unless puzzle.event.stats.nil?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :stats, message: "can't be blank"
+        )
+      end
+
+      def validate_puzzle_not_complete!
+        return unless event.stats.complete?(day)
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :puzzle, message: "is already complete"
+        )
+      end
+    end
+  end
+end

data/lib/aoc_cli/processors/stats_initialiser.rb

@@ -0,0 +1,36 @@
+module AocCli
+  module Processors
+    class StatsInitialiser < Core::Processor
+      attr_accessor :event
+
+      validates :event, type: { equals: Event }
+
+      def validate
+        super
+        validate_stats_do_not_exist! if errors.empty?
+      end
+
+      def run
+        stats = BLANK_STATS.merge(fetch_stats!)
+
+        Stats.create(event:, **stats)
+      end
+
+      private
+
+      BLANK_STATS = 1.upto(25).to_h { |day| [:"day_#{day}", 0] }
+
+      def fetch_stats!
+        Core::Repository.get_stats(year: event.year)
+      end
+
+      def validate_stats_do_not_exist!
+        return if event.stats.nil?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :stats, message: "already exist"
+        )
+      end
+    end
+  end
+end

data/lib/aoc_cli/processors/stats_refresher.rb

@@ -0,0 +1,23 @@
+module AocCli
+  module Processors
+    class StatsRefresher < Core::Processor
+      attr_accessor :stats
+
+      validates :stats, type: { equals: Stats }
+
+      def run
+        stats.update(**updated_stats) || stats
+      end
+
+      private
+
+      extend Forwardable
+
+      def_delegators :stats, :year
+
+      def updated_stats
+        Core::Repository.get_stats(year:)
+      end
+    end
+  end
+end

data/lib/aoc_cli/validators/collection_type_validator.rb

@@ -0,0 +1,57 @@
+module AocCli
+  module Validators
+    class CollectionTypeValidator < Kangaru::Validator
+      def validate
+        validate_preconditions!
+
+        return add_error!("can't be blank") if value.nil?
+        return add_error!("is not an array") unless value.is_a?(Array)
+
+        case validation_rule
+        when :all  then validate_all_elements!
+        when :any  then validate_any_elements!
+        when :none then validate_none_elements!
+        else raise
+        end
+      end
+
+      private
+
+      VALIDATION_RULES = %i[all any none].freeze
+
+      ERROR = "elements have incompatible types".freeze
+
+      def validation_rule
+        @validation_rule ||= params.slice(*VALIDATION_RULES).keys.first || raise
+      end
+
+      def target_type
+        @target_type ||= params[validation_rule]
+      end
+
+      def validate_preconditions!
+        return if params.slice(*VALIDATION_RULES).count == 1
+
+        raise "Collection type rule must be one of #{VALIDATION_RULES.inspect}"
+      end
+
+      def validate_all_elements!
+        return if value.all? { |element| element.is_a?(target_type) }
+
+        add_error!(ERROR)
+      end
+
+      def validate_any_elements!
+        return if value.any? { |element| element.is_a?(target_type) }
+
+        add_error!(ERROR)
+      end
+
+      def validate_none_elements!
+        return if value.none? { |element| element.is_a?(target_type) }
+
+        add_error!(ERROR)
+      end
+    end
+  end
+end

data/lib/aoc_cli/validators/event_year_validator.rb

@@ -0,0 +1,42 @@
+module AocCli
+  module Validators
+    class EventYearValidator < Kangaru::Validator
+      def validate
+        case value
+        when Integer  then validate_year!
+        when NilClass then add_error!(ERRORS[:blank])
+        else add_error!(ERRORS[:invalid])
+        end
+      end
+
+      private
+
+      ERRORS = {
+        blank: "can't be blank",
+        invalid: "is not an integer",
+        too_low: "is before first Advent of Code event (2015)",
+        too_high: "is in the future"
+      }.freeze
+
+      MIN_YEAR = 2015
+
+      def max_year
+        return Date.today.year if in_december?
+
+        Date.today.year - 1
+      end
+
+      def in_december?
+        Date.today.month == 12
+      end
+
+      def validate_year!
+        if value < MIN_YEAR
+          add_error!(ERRORS[:too_low])
+        elsif value > max_year
+          add_error!(ERRORS[:too_high])
+        end
+      end
+    end
+  end
+end

data/lib/aoc_cli/validators/included_validator.rb

@@ -0,0 +1,21 @@
+module AocCli
+  module Validators
+    class IncludedValidator < Kangaru::Validator
+      def validate
+        return if allowed_values.include?(value)
+
+        add_error!(ERRORS[:not_included])
+      end
+
+      private
+
+      ERRORS = {
+        not_included: "is not a valid option"
+      }.freeze
+
+      def allowed_values
+        params[:in]
+      end
+    end
+  end
+end

data/lib/aoc_cli/validators/integer_validator.rb

@@ -0,0 +1,32 @@
+module AocCli
+  module Validators
+    class IntegerValidator < Kangaru::Validator
+      def validate
+        return add_error!(ERRORS[:blank]) if value.nil?
+        return add_error!(ERRORS[:type]) unless value.is_a?(Integer)
+
+        validate_range! if params.keys.include?(:between)
+      end
+
+      private
+
+      ERRORS = {
+        blank: "can't be blank",
+        type: "is not an integer",
+        too_small: "is too small",
+        too_large: "is too large"
+      }.freeze
+
+      def range
+        params[:between]
+      end
+
+      def validate_range!
+        return if range.include?(value)
+
+        add_error!(ERRORS[:too_small]) if value < range.first
+        add_error!(ERRORS[:too_large]) if value > params[:between].last
+      end
+    end
+  end
+end

data/lib/aoc_cli/validators/path_validator.rb

@@ -0,0 +1,39 @@
+module AocCli
+  module Validators
+    class PathValidator < Kangaru::Validator
+      def validate
+        return add_error!(ERRORS[:blank]) if value.nil?
+
+        if params[:exists] == false
+          validate_path_does_not_exist!
+        else
+          validate_path_exists!
+        end
+      end
+
+      private
+
+      ERRORS = {
+        blank: "can't be blank",
+        exists: "already exists",
+        does_not_exist: "does not exist"
+      }.freeze
+
+      def path_exists?
+        File.exist?(value)
+      end
+
+      def validate_path_does_not_exist!
+        return unless path_exists?
+
+        add_error!(ERRORS[:exists])
+      end
+
+      def validate_path_exists!
+        return if path_exists?
+
+        add_error!(ERRORS[:does_not_exist])
+      end
+    end
+  end
+end

data/lib/aoc_cli/validators/type_validator.rb

@@ -0,0 +1,54 @@
+module AocCli
+  module Validators
+    class TypeValidator < Kangaru::Validator
+      def validate
+        validate_target_type_set!
+
+        if params[:equals]
+          validate_type!
+        elsif params[:one_of]
+          validate_type_from_list!
+        end
+      end
+
+      private
+
+      ERRORS = {
+        blank: "can't be blank",
+        type: "has incompatible type"
+      }.freeze
+
+      def valid_type
+        params[:equals]
+      end
+
+      def valid_types
+        params[:one_of]
+      end
+
+      def error
+        return ERRORS[:blank] if value.nil?
+
+        ERRORS[:type]
+      end
+
+      def validate_target_type_set!
+        return if valid_type || valid_types
+
+        raise "type must be specified via :equals or :one_of options"
+      end
+
+      def validate_type!
+        return if value.is_a?(valid_type)
+
+        add_error!(error)
+      end
+
+      def validate_type_from_list!
+        return if valid_types&.include?(value.class)
+
+        add_error!(error)
+      end
+    end
+  end
+end

data/lib/aoc_cli/version.rb

@@ -1,3 +1,3 @@
 module AocCli
-  VERSION = "0.2.2"
+  VERSION = "1.0.0".freeze
 end

data/lib/aoc_cli/views/event/attach.erb

@@ -0,0 +1,3 @@
+<%= success_tag %>: <%= queried_event.year %> location updated
+  from  <%= @source %>
+  to    <%= @target %>

data/lib/aoc_cli/views/event/init.erb

@@ -0,0 +1,3 @@
+<%= success_tag %>: event initialised
+  year  <%= @event.year %>
+  path  <%= @event.location.path %>

data/lib/aoc_cli/views/help/event/attach.erb

@@ -0,0 +1,32 @@
+aoc event attach
+
+Description:
+
+  Attaches an existing event to the specified directory (defaults to current
+  directory). This may be useful if the original directories have been moved
+  or deleted.
+
+  This command cannot be executed from, or target, a directory that is already
+  managed by aoc (i.e., existing event and puzzle directories).
+
+  The command will fail if the event has not already been initialized. To
+  create a new event, see the event init command.
+
+Usage:
+
+  aoc event attach <year> [--dir=<dir>]
+
+  * <year>: Year of the event to relocate.
+  * <dir>: The new event directory (default ".").
+
+Examples:
+
+  aoc event attach 2023 (in a non-AoC directory)
+
+  Relocates the 2023 event directory to the current directory
+
+
+  aoc event attach 2023 --dir /foo/bar/aoc
+
+  Relocates the 2023 event directory to the specified directory.
+

data/lib/aoc_cli/views/help/event/init.erb

@@ -0,0 +1,38 @@
+aoc event init
+
+Description:
+
+  Initializes the event for the specified year by fetching event stats and
+  creating an event directory in the target directory. The target directory
+  defaults to the current directory but can be explicitly specified with the
+  optional --dir String argument.
+
+  The event directory serves as the location of event puzzle directories. For
+  more information, refer to puzzle init. The name of the created event
+  directory defaults to the event year.
+
+  This command cannot be executed from, or target, a directory that is already
+  managed by aoc (i.e., existing event and puzzle directories).
+
+  The command will fail if the event has already been initialized elsewhere. To
+  move an existing event's location, see the event attach command.
+
+Usage:
+
+  aoc event init <year> [--dir=<dir>]
+
+  * <year>: Year of the event to initialize.
+  * <dir>: Base directory to initialize the event within (default ".").
+
+Examples:
+
+  aoc event init 2023 (in a non-AoC directory)
+
+  Initializes the 2023 event and creates the 2023 event directory inside the
+  current directory.
+
+  aoc event init 2023 --dir /foo/bar/aoc
+
+  Initializes the 2023 event and creates the 2023 event directory in the
+  specified directory.
+