aoc_cli 0.2.2 → 1.0.0

data/lib/aoc_cli/core/repository.rb

@@ -0,0 +1,74 @@
+module AocCli
+  module Core
+    class Repository
+      HOST = "https://adventofcode.com".freeze
+
+      RESOURCES = {
+        stats: {
+          url: "%{host}/%{year}",
+          scope: "html/body/main/pre",
+          method: :get
+        },
+
+        puzzle: {
+          url: "%{host}/%{year}/day/%{day}",
+          scope: "html/body/main/article",
+          method: :get
+        },
+
+        input: {
+          url: "%{host}/%{year}/day/%{day}/input",
+          method: :get
+        },
+
+        solution: {
+          url: "%{host}/%{year}/day/%{day}/answer",
+          scope: "html/body/main/article",
+          method: :post,
+          params: %i[level answer]
+        }
+      }.freeze
+
+      class << self
+        def get_stats(year:)
+          html = build_resource(:stats, year:).fetch
+
+          StatsParser.new(html).to_h
+        end
+
+        def get_puzzle(year:, day:)
+          build_resource(:puzzle, year:, day:).fetch_markdown
+        end
+
+        def get_input(year:, day:)
+          build_resource(:input, year:, day:).fetch
+        end
+
+        def post_solution(year:, day:, level:, answer:)
+          response = build_resource(
+            :solution, year:, day:, level:, answer:
+          ).fetch_markdown
+
+          AttemptParser.new(response).to_h
+        end
+
+        private
+
+        def build_resource(type, **params)
+          attributes = RESOURCES[type]
+
+          Resource.new(
+            url: format_url(attributes[:url], **params),
+            scope: attributes[:scope],
+            method: attributes[:method],
+            params: params.slice(*attributes[:params])
+          )
+        end
+
+        def format_url(template, **params)
+          format(template, host: HOST, **params)
+        end
+      end
+    end
+  end
+end

data/lib/aoc_cli/core/request.rb

@@ -0,0 +1,37 @@
+module AocCli
+  module Core
+    class Request
+      extend Forwardable
+
+      attr_reader :client
+
+      def_delegators :client, :get, :post
+
+      def initialize(token:)
+        @client = setup_client!(token)
+      end
+
+      def self.build
+        token = AocCli.config.session.token
+
+        raise "session token not set" if token.nil?
+
+        new(token:)
+      end
+
+      class << self
+        extend Forwardable
+
+        def_delegators :build, :get, :post
+      end
+
+      private
+
+      def setup_client!(token)
+        cookie = "session=#{token}"
+
+        HTTP.headers(Cookie: cookie)
+      end
+    end
+  end
+end

data/lib/aoc_cli/core/resource.rb

@@ -0,0 +1,39 @@
+module AocCli
+  module Core
+    # Scope filters the response with the given xpath which ensures that only
+    # desired content is extracted from the (usually) HTML response. The whole
+    # response is considered the resource payload if no scope is specified.
+    class Resource
+      attr_reader :url, :scope, :method, :params
+
+      def initialize(url:, scope: nil, method: :get, params: {})
+        @url = url
+        @scope = scope
+        @method = method
+        @params = params
+      end
+
+      def fetch
+        return response if scope.nil?
+
+        Nokogiri.HTML5(response).xpath(scope).to_html
+      end
+
+      # Bypess ignores unknown tags and tries to convert their nested content.
+      # The parser adds an extra newline to the end which is removed with chomp.
+      def fetch_markdown
+        ReverseMarkdown.convert(fetch, unknown_tags: :bypass).chomp
+      end
+
+      private
+
+      def response
+        case method
+        when :get  then Request.get(url)
+        when :post then Request.post(url, form: params)
+        else raise "invalid HTTP method"
+        end.to_s
+      end
+    end
+  end
+end

data/lib/aoc_cli/core/stats_parser.rb

@@ -0,0 +1,43 @@
+module AocCli
+  module Core
+    # Calculates a User's year progress by parsing the CSS classes that are
+    # applied to each calendar link in the calendar view.
+    class StatsParser
+      DAY_CLASS_PREFIX = "calendar-day".freeze
+      ONE_STAR_CLASS   = "calendar-complete".freeze
+      TWO_STARS_CLASS  = "calendar-verycomplete".freeze
+
+      attr_reader :calendar_html
+
+      def initialize(calendar_html)
+        @calendar_html = calendar_html
+      end
+
+      def to_h
+        calendar_link_classes.to_h do |classes|
+          day = classes[0].delete_prefix(DAY_CLASS_PREFIX)
+          n_stars = count_stars(classes)
+
+          [:"day_#{day}", n_stars]
+        end
+      end
+
+      private
+
+      def calendar_link_classes
+        calendar_links.map(&:classes)
+      end
+
+      def calendar_links
+        Nokogiri.HTML5(calendar_html).xpath("//a")
+      end
+
+      def count_stars(classes)
+        return 2 if classes.include?(TWO_STARS_CLASS)
+        return 1 if classes.include?(ONE_STAR_CLASS)
+
+        0
+      end
+    end
+  end
+end

data/lib/aoc_cli/helpers/table_generator.rb

@@ -0,0 +1,64 @@
+module AocCli
+  module Helpers
+    class TableGenerator
+      include Kangaru::Validatable
+
+      attr_reader :rows, :gap, :indent
+
+      validates :rows, collection_type: { all: Array }
+
+      def initialize(rows:, gap: 2, indent: 0)
+        @rows = rows
+        @gap = gap
+        @indent = indent
+      end
+
+      # TODO: Use validates via method for checking row length once supported.
+      def validate
+        super
+        validate_rows_are_same_length! if errors.empty?
+      end
+
+      # TODO: Remove once validate! merged upstream.
+      def validate!
+        validate
+
+        raise errors.map(&:full_message).join("\n") unless errors.empty?
+      end
+
+      def generate!
+        validate!
+
+        rows.map do |row|
+          [space(indent), format_row!(row).strip, "\n"].join
+        end.join
+      end
+
+      private
+
+      def column_widths
+        @column_widths ||= rows.transpose.map do |column|
+          column.map(&:length).max + gap
+        end
+      end
+
+      def space(count)
+        " " * count
+      end
+
+      def format_row!(row)
+        row.zip(column_widths).map do |string, column_width|
+          string + space((column_width || raise) - string.length)
+        end.join
+      end
+
+      def validate_rows_are_same_length!
+        return if rows.all? { |row| row.length == rows[0].length }
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :rows, message: "must all be the same length"
+        )
+      end
+    end
+  end
+end

data/lib/aoc_cli/helpers/view_helper.rb

@@ -0,0 +1,35 @@
+module AocCli
+  module Helpers
+    module ViewHelper
+      def main_header
+        heading("aoc-cli::<#{VERSION}>")
+      end
+
+      def heading(text)
+        text.to_s.bold.cyan
+      end
+
+      def success_tag
+        "Success".green.bold
+      end
+
+      def table_for(*rows, gap: 2, indent: 0)
+        rows.map! { |row| row.map(&:to_s) }
+
+        TableGenerator.new(rows:, gap:, indent:).generate!
+      end
+
+      def wrap_text(text, width: 80, indent: 0)
+        raise "indent must be less than width" unless indent < width
+
+        text.gsub(
+          # Match the longest string (up to the indented width) thats followed
+          # by a non-word char or any combination of newlines.
+          /(.{1,#{width - indent}})(?:[^\S\n]+\n?|\n*\Z|\n)|\n/,
+          # Surround string fragment with indent and newline.
+          "#{' ' * indent}\\1\n"
+        ).chomp
+      end
+    end
+  end
+end

data/lib/aoc_cli/models/attempt.rb

@@ -0,0 +1,67 @@
+module AocCli
+  class Attempt < Kangaru::Model
+    many_to_one :puzzle
+
+    enum :status, incorrect: 0, correct: 1, rate_limited: 2, wrong_level: 3
+
+    enum :hint, too_low: 0, too_high: 1
+
+    validates :puzzle, required: true
+
+    validates :level, integer: { between: 1..2 }
+
+    validates :answer, required: true
+
+    validates :status, included: {
+      in: %i[incorrect correct rate_limited wrong_level]
+    }
+
+    def presenter
+      @presenter ||= Presenters::AttemptPresenter.new(self)
+    end
+
+    # TODO: move to a conditional validation when supported by Kangaru
+    def validate
+      super
+      validate_hint_not_set! unless incorrect?
+      validate_hint! if incorrect?
+      validate_wait_time_not_set! if correct? || wrong_level?
+      validate_wait_time_integer! if incorrect? || rate_limited?
+    end
+
+    private
+
+    def validate_hint_not_set!
+      return if hint.nil?
+
+      errors << Kangaru::Validation::Error.new(
+        attribute: :hint, message: "is not expected"
+      )
+    end
+
+    def validate_hint!
+      return if hint.nil?
+      return if %i[too_low too_high].include?(hint)
+
+      errors << Kangaru::Validation::Error.new(
+        attribute: :hint, message: "is not a valid option"
+      )
+    end
+
+    def validate_wait_time_not_set!
+      return if wait_time.nil?
+
+      errors << Kangaru::Validation::Error.new(
+        attribute: :wait_time, message: "is not expected"
+      )
+    end
+
+    def validate_wait_time_integer!
+      return if wait_time.is_a?(Integer)
+
+      errors << Kangaru::Validation::Error.new(
+        attribute: :wait_time, message: "is not an integer"
+      )
+    end
+  end
+end

data/lib/aoc_cli/models/event.rb

@@ -0,0 +1,9 @@
+module AocCli
+  class Event < Kangaru::Model
+    one_to_many :puzzles
+    one_to_one  :stats
+    one_to_one  :location, as: :resource
+
+    validates :year, event_year: true
+  end
+end

data/lib/aoc_cli/models/location.rb

@@ -0,0 +1,24 @@
+module AocCli
+  class Location < Kangaru::Model
+    many_to_one :resource, polymorphic: true
+
+    validates :resource, required: true
+    validates :path, required: true
+
+    def exists?
+      File.exist?(path)
+    end
+
+    def event_dir?
+      resource.is_a?(Event)
+    end
+
+    def puzzle_dir?
+      resource.is_a?(Puzzle)
+    end
+
+    def to_pathname
+      Pathname.new(path)
+    end
+  end
+end

data/lib/aoc_cli/models/puzzle.rb

@@ -0,0 +1,28 @@
+module AocCli
+  class Puzzle < Kangaru::Model
+    extend Forwardable
+
+    many_to_one :event
+    one_to_one :location, as: :resource
+    one_to_many :attempts
+
+    validates :event, required: true
+    validates :day, integer: { between: 1..25 }
+    validates :content, required: true
+    validates :input, required: true
+
+    def_delegators :event, :year
+
+    def presenter
+      @presenter ||= Presenters::PuzzlePresenter.new(self)
+    end
+
+    def mark_complete!(level)
+      case level
+      when 1 then update(part_one_completed_at: Time.now)
+      when 2 then update(part_two_completed_at: Time.now)
+      else raise "invalid level"
+      end
+    end
+  end
+end

data/lib/aoc_cli/models/puzzle_dir_sync_log.rb

@@ -0,0 +1,14 @@
+module AocCli
+  class PuzzleDirSyncLog < Kangaru::Model
+    many_to_one :location
+    many_to_one :puzzle
+
+    validates :location, required: true
+    validates :puzzle, required: true
+
+    STATUS_ENUM = { new: 0, unmodified: 1, modified: 2 }.freeze
+
+    enum :puzzle_status, STATUS_ENUM, prefix: true
+    enum :input_status, STATUS_ENUM, prefix: true
+  end
+end

data/lib/aoc_cli/models/stats.rb

@@ -0,0 +1,43 @@
+module AocCli
+  class Stats < Kangaru::Model
+    extend Forwardable
+
+    many_to_one :event
+
+    validates :event, required: true
+
+    def_delegators :event, :year
+
+    1.upto(25) do |i|
+      validates :"day_#{i}", integer: { between: 0..2 }
+    end
+
+    def presenter
+      @presenter ||= Presenters::StatsPresenter.new(self)
+    end
+
+    def total
+      1.upto(25).map { |day| progress(day) }.sum
+    end
+
+    def progress(day)
+      self[:"day_#{day}"] || raise("invalid day")
+    end
+
+    def current_level(day)
+      return if complete?(day)
+
+      progress(day) + 1
+    end
+
+    def complete?(day)
+      progress(day) == 2
+    end
+
+    def advance_progress!(day)
+      raise "already complete" if complete?(day)
+
+      update("day_#{day}": current_level(day))
+    end
+  end
+end

data/lib/aoc_cli/presenters/attempt_presenter.rb

@@ -0,0 +1,29 @@
+module AocCli
+  module Presenters
+    class AttemptPresenter
+      attr_reader :attempt
+
+      def initialize(attempt)
+        @attempt = attempt
+      end
+
+      def status
+        case attempt.status
+        when :wrong_level  then "Wrong level"
+        when :rate_limited then "Rate limited"
+        when :incorrect    then "Incorrect"
+        when :correct      then "Correct"
+        else raise
+        end
+      end
+
+      def hint
+        case attempt.hint
+        when :too_low  then "Too low"
+        when :too_high then "Too high"
+        else "-"
+        end
+      end
+    end
+  end
+end

data/lib/aoc_cli/presenters/puzzle_presenter.rb

@@ -0,0 +1,29 @@
+module AocCli
+  module Presenters
+    class PuzzlePresenter
+      attr_reader :puzzle
+
+      def initialize(puzzle)
+        @puzzle = puzzle
+      end
+
+      def date
+        "#{puzzle.event.year}-12-#{formatted_day}"
+      end
+
+      def puzzle_filename
+        "day_#{formatted_day}.md"
+      end
+
+      def input_filename
+        "input"
+      end
+
+      private
+
+      def formatted_day
+        puzzle.day.to_s.rjust(2, "0")
+      end
+    end
+  end
+end

data/lib/aoc_cli/presenters/stats_presenter.rb

@@ -0,0 +1,32 @@
+module AocCli
+  module Presenters
+    class StatsPresenter
+      attr_reader :stats
+
+      def initialize(stats)
+        @stats = stats
+      end
+
+      def total_progress
+        total = 1.upto(25).map { |day| stats.progress(day) }.sum
+
+        "#{total}/50"
+      end
+
+      def progress_icons(day)
+        case stats.progress(day)
+        when 0 then Icons::INCOMPLETE
+        when 1 then Icons::HALF_COMPLETE
+        when 2 then Icons::COMPLETE
+        else raise
+        end
+      end
+
+      module Icons
+        INCOMPLETE    = "○ ○".freeze
+        HALF_COMPLETE = "● ○".freeze
+        COMPLETE      = "● ●".freeze
+      end
+    end
+  end
+end

data/lib/aoc_cli/processors/event_initialiser.rb

@@ -0,0 +1,64 @@
+module AocCli
+  module Processors
+    class EventInitialiser < Core::Processor
+      validates :year, event_year: true
+
+      validates :dir, path: { exists: true }
+
+      attr_accessor :year, :dir
+
+      # TODO: use conditional validation once supported by Kangaru
+      def validate
+        super
+        validate_event_not_already_initialised! if errors.empty?
+        validate_event_dir_does_not_exist! if errors.empty?
+      end
+
+      def run
+        create_event!.tap do |event|
+          initialise_stats!(event)
+          make_event_directory!
+          attach_event!(event)
+        end
+      end
+
+      private
+
+      def event_dir
+        @event_dir ||= Pathname(dir).join(year.to_s)
+      end
+
+      def create_event!
+        Event.create(year:)
+      end
+
+      def initialise_stats!(event)
+        StatsInitialiser.run!(event:)
+      end
+
+      def make_event_directory!
+        event_dir.mkdir
+      end
+
+      def attach_event!(event)
+        ResourceAttacher.run!(resource: event, path: event_dir.to_s)
+      end
+
+      def validate_event_dir_does_not_exist!
+        return unless event_dir.exist?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :event_dir, message: "already exists"
+        )
+      end
+
+      def validate_event_not_already_initialised!
+        return if Event.where(year:).empty?
+
+        errors << Kangaru::Validation::Error.new(
+          attribute: :event, message: "already initialised"
+        )
+      end
+    end
+  end
+end