aoc_cli 0.1.1

data/lib/aoc_cli/database.rb

@@ -0,0 +1,159 @@
+module AocCli
+	module Database
+		class Query
+			require 'sqlite3'
+			attr_reader :db
+			def initialize(path:)
+				@db = SQLite3::Database.open(path)
+			end
+			def select(t:, cols:"*", data:)
+				db.execute(
+				"SELECT #{cols} FROM #{t} "\
+				"WHERE #{data.map{|k, v| "#{k} = #{v}"}.join(" AND ")}")
+			end
+			def table(t:, cols:)
+				db.execute(
+				"CREATE TABLE IF NOT EXISTS "\
+				"#{t}(#{cols.map{|c, t| "#{c} #{t}"}.join(", ")})")
+				self
+			end
+			def insert(t:, val:)
+				db.execute(
+				"INSERT INTO #{t} "\
+				"VALUES(#{val.join(", ")})")
+				self
+			end
+			def update(t:, val:, where:)
+				db.execute(
+				"UPDATE #{t} "\
+				"SET #{val.map{|c, v| "#{c} = #{v}"}.join(", ")} "\
+				"WHERE #{where.map{|c, v| "#{c} = #{v}"}.join(" AND ")}")
+				self
+			end
+		end
+		class Log
+			attr_reader :attempt, :db
+			def initialize(attempt:)
+				@attempt = attempt
+				@db = Query.new(path:Paths::Database
+					.cfg("#{attempt.user}"))
+					.table(t:"attempts", cols:cols)
+			end
+			def correct
+				db.insert(t:"attempts", val:data << 1 << 0 << 0)
+				self
+			end
+			def incorrect(high:, low:)
+				db.insert(t:"attempts", val:data.push(0)
+					.push(parse_hint(high:high, low:low)))
+				self
+			end
+			def parse_hint(high:, low:)
+				[ high ? 1 : 0, low ? 1 : 0 ]
+			end
+			def data
+				[ "'#{Time.now}'",
+				  "'#{attempt.year}'",
+				  "'#{attempt.day}'",
+				  "'#{attempt.part}'",
+				  "'#{attempt.answer}'" ]
+			end
+			def cols
+				{ time: :TEXT, 
+				  year: :INT, 
+				  day: :INT, 
+				  part: :INT, 
+				  answer: :TEXT, 
+				  correct: :INT,
+				  low: :INT,
+				  high: :INT }
+			end
+			def count_attempts
+				db.select(t:"attempts", data:where).count
+			end
+			def where
+				{ year:attempt.year,
+				  day:attempt.day,
+				  part:attempt.part }
+			end
+		end
+		module Stats
+			class Init
+				attr_reader :user, :year, :day, :part, :now, :db
+				def initialize(u:Metafile.get(:user),
+							   y:Metafile.get(:year),
+							   d:Metafile.get(:day),
+							   p:Metafile.get(:part))
+					@user = Validate.user(u)
+					@year = Validate.year(y)
+					@day  = Validate.day(d)
+					@part = p
+					@now  = Time.now
+					@db   = Query.new(path:Paths::Database.cfg(user))
+							 .table(t:"stats", cols:cols)
+				end
+				def cols
+					{ year: :INT, 
+					  day: :INT, 
+					  part: :INT, 
+					  dl_time: :TEXT,
+					  end_time: :TEXT,
+					  elapsed: :TEXT,
+					  attempts: :INT,
+					  correct: :INT }
+				end
+				def init
+					db.insert(t:"stats", val:data)
+				end
+				def data
+					[ "'#{year}'",
+					  "'#{day}'",
+					  "'#{part}'",
+					  "'#{now}'",
+					  "NULL",
+					  "NULL",
+					  "'0'",
+					  "'0'" ]
+				end
+			end
+			class Complete < Init
+				attr_reader :n_attempts
+				def initialize(u:Metafile.get(:user),
+							   y:Metafile.get(:year),
+							   d:Metafile.get(:day),
+							   p:Metafile.get(:part),
+							   n:)
+					super(u:u, y:y, d:d, p:p)
+					@n_attempts = n
+				end
+				def update
+					db.update(t:"stats", val:val, where:where)
+				end
+				def val
+					{ elapsed:  "'#{elapsed}'", 
+					  end_time: "'#{now}'", 
+					  attempts: "'#{n_attempts}'",
+					  correct:  "'1'" }
+				end
+				def where
+					{ year: year,
+					  day:  day, 
+					  part: part }
+				end
+				def elapsed
+					@elapsed ||= hms(now - dl_time)
+				end
+				def hms(seconds)
+					[seconds/3600, seconds/60 % 60, seconds % 60]
+						.map{|t| t.to_i.to_s.rjust(2, "0")}.join(":")
+				end
+				def dl_time
+					@dl_time ||= Time
+						.parse(db
+						.select(t:"stats", cols:"dl_time", data:where)
+						.flatten.first)
+				end
+			end
+		end
+	end 
+end

data/lib/aoc_cli/day.rb

@@ -0,0 +1,153 @@
+module AocCli
+	module Day
+		def self.refresh
+			puts "- Updating puzzle...".yellow
+			Init.new.write
+			Data::Puzzle.new.write
+		end
+		class Init
+			attr_reader :year, :day, :user, :paths, :part
+			def initialize(u:Metafile.get(:user), 
+						   y:Metafile.get(:year), 
+						   d:Metafile.get(:day))
+				@user  = Validate.user(u)
+				@year  = Validate.year(y)
+				@day   = Validate.day(d)
+				@paths = Paths::Day.new(u:user, y:year, d:day)
+			end
+			def mkdir
+				Dir.mkdir(Validate.day_dir(paths.day_dir))
+				self
+			end
+			def write
+				File.write(paths.local(f:"meta"), 
+						Metafile.day(u:user, y:year, d:day))
+				self
+			end
+		end
+		class Pages < Init
+			attr_reader :cache, :files
+			def initialize(u:Metafile.get(:user), 
+						   y:Metafile.get(:year),
+						   d:Metafile.get(:day), 
+						   f:[:Input, :Puzzle])
+				super(u:u, y:y, d:d)
+				@files = f
+			end
+			def write
+				cache.each{|page, data| data ? 
+					File.write(paths.local(f:page), data) : 
+					download(page:page)}
+			end
+			private
+			def cache
+				@cache ||= Cache
+					.new(u:user, y:year, d:day, f:files).load
+			end
+			def download(page:, to:paths.cache_and_local(f:page))
+				dl = Object.const_get("AocCli::Day::Data::#{page}")
+					.new(u:user, y:year, d:day)
+					.write(to:to)
+				dl.init_db if dl.class
+					.instance_methods
+					.include?(:init_db)
+			end
+		end
+		module Data
+			class DayObject < Init
+				attr_reader :user, :year, :day, :data, :paths, :part
+				def initialize(u:Metafile.get(:user), 
+							   y:Metafile.get(:year),
+							   d:Metafile.get(:day))
+					super(u:u, y:y, d:d)
+					@part = Metafile.part(d:day)
+					@data  = parse(raw: fetch)
+				end
+				def write(to:paths.cache_and_local(f:page))
+					to.each{|path| File.write(path, data)}
+					self
+				end
+				private
+				def fetch
+					Tools::Get.new(u:user, y:year, d:day, p:page)
+				end
+			end
+			class Puzzle < DayObject
+				def page
+					:Puzzle
+				end
+				def parse(raw:)
+					raw.chunk(f:"<article", t:"<\/article", f_off:2)
+						.md
+						.gsub(/(?<=\])\[\]/, "")
+						.gsub(/\n.*<!--.*-->.*\n/, "")
+				end
+				def init_db
+					Database::Stats::Init
+						.new(d:day, p:part)
+						.init if part < 3
+					self
+				end
+			end
+			class Input < DayObject
+				def page
+					:Input
+				end
+				def parse(raw:)
+					raw.raw
+				end
+			end
+		end
+		class Cache < Pages
+			require 'fileutils'
+			def initialize(u:Metafile.get(:user), 
+						   y:Metafile.get(:year),
+						   d:Metafile.get(:day),
+						   f:[:Input, :Puzzle])
+				super(u:u, y:y, d:d, f:f)
+				FileUtils.mkdir_p(paths.cache_dir) unless Dir
+					.exist?(paths.cache_dir)
+			end
+			def load
+				files.map{|f| [f, read_file(f:f)]}.to_h
+			end
+			private
+			def read_file(f:)
+				cached?(f:f) ? read(f:f) : nil
+			end
+			def cached?(f:)
+				File.exist?(paths.cache_path(f:f))
+			end
+			def read(f:)
+				File.read(paths.cache_path(f:f))
+			end
+		end
+		class Reddit
+			attr_reader :year, :day, :uniq, :browser
+			def initialize(y:Metafile.get(:year), 
+						   d:Metafile.get(:day),
+						   b:false)
+				@year = Validate.year(y)
+				@day  = Validate.day(d)
+				@uniq = Database::Query
+					.new(path:Paths::Database.root("reddit"))
+					.select(t:"'#{year}'", data:{day:"'#{day}'"})
+					.flatten[1]
+				@browser = b
+			end
+			def open
+				system("#{browser ? "open" : cmd} #{link}")
+			end
+			def cmd
+				["ttrv", "rtv"]
+					.map{|cli| cli unless `which #{cli}`.empty?}
+					.reject{|cmd| cmd.nil?}&.first || "open"
+			end
+			def link
+				"https://www.reddit.com/r/"\
+				"adventofcode/comments/#{uniq}/"\
+				"#{year}_day_#{day}_solutions"
+			end
+		end
+	end
+end

data/lib/aoc_cli/errors.rb

@@ -0,0 +1,171 @@
+module AocCli
+	module Errors
+		ERROR = "Error".bold.red
+		class UserNil < StandardError
+			def message
+				<<~error
+				#{ERROR}: No user alias value.
+				Specify an alias to use when passing the #{"-u".yellow} or #{"--user".yellow} flag
+				error
+			end
+		end
+		class UserInv < StandardError
+			def initialize(user)
+				@user = user
+			end
+			def message
+				<<~error
+				#{ERROR}: Invalid user: #{@user.to_s.red}
+				No key was found under this alias
+				error
+			end
+		end
+		class UserDup < StandardError
+			attr_reader :user
+			def initialize(user)
+				@user = user
+			end
+			def message
+				<<~error
+				#{ERROR}: There is already a key set for the user #{user.yellow}
+				Either check your config file or set a new username for this key using the #{"-u".yellow} or #{"--user".yellow} flags
+				error
+			end
+		end
+		class YearNil < StandardError
+			def message
+				<<~error
+				#{ERROR}: No year value.
+				Set the year using the #{"-y".yellow} or #{"--year".yellow} flags.
+				error
+			end
+		end
+		class YearInv < StandardError
+			attr_reader :year
+			def initialize(year)
+				@year = year
+			end
+			def message
+				<<~error
+				#{ERROR}: Invalid year: #{year.to_s.red}
+				Advent of Code currently spans 2015 - 2020.
+				error
+			end
+		end
+		class DayNil < StandardError
+			def message
+				<<~error
+				#{ERROR}: No day value.
+				Specify the day using the #{"-d".yellow} or #{"--day".yellow} flags.
+				error
+			end
+		end
+		class DayInv < StandardError
+			def initialize(day)
+				@day = day
+			end
+			def message
+				<<~error
+				#{ERROR}: Invalid day: #{@day.to_s.red}
+				Valid days are between 1 and 25
+				error
+			end
+		end
+		class DayExist < StandardError
+			def initialize(day)
+				@day = day.to_s
+			end
+			def message
+				<<~error
+				#{ERROR}: Day #{@day.red} is already initialised!
+				error
+			end
+		end
+		class PartNil < StandardError
+			def message
+				<<~error
+				#{ERROR}: No part value.
+				Check the .meta file or pass it manually with the #{"-p".yellow} or #{"--part".yellow} flags
+				error
+			end
+		end
+		class PartInv < StandardError
+			attr_reader :part
+			def initialize(part)
+				@part = part
+			end
+			def message
+				<<~error
+				#{ERROR}: Invalid part: #{part.red}
+				Part refers to the part of the puzzle and can either be 1 or 2.
+				error
+			end
+		end
+		class AnsNil < StandardError
+			def message
+				<<~error
+				#{ERROR}: No answer value.
+				error
+			end
+		end
+		class KeyNil < StandardError
+			def message
+				<<~error
+				#{ERROR}: No session key value.
+				Use the #{"-k".yellow} or #{"--key".yellow} flags
+				error
+			end
+		end
+		class KeyDup < StandardError
+			attr_reader :key
+			def initialize(key)
+				@key = key
+			end
+			def message
+				<<~error
+				#{ERROR}: The key #{user.yellow} already exists in your config file
+				error
+			end
+		end
+		class AlrInit < StandardError
+			def message
+				<<~error
+				#{ERROR}: This directory is already initialised.
+				error
+			end
+		end
+		class NotInit < StandardError
+			def message
+				<<~error
+				#{ERROR}: You must initialise the directory first
+				error
+			end
+		end
+		class PuzzComp < StandardError
+			def message
+				<<~error
+				#{ERROR}: This puzzle is already complete!
+				error
+			end
+		end
+		class FlagInv < StandardError
+			attr_reader :flag
+			def initialize(flag)
+				@flag = flag
+			end
+			def message
+				<<~error
+				#{ERROR}: Invalid flag: #{flag.red}
+				Use the #{"-h".yellow} or #{"--help".yellow} flags for a list of commands
+				error
+			end
+		end
+		class NoCmd < StandardError
+			def message
+				<<~error
+				#{ERROR}: Flags passed but no command specified
+				error
+			end
+		end
+	end 
+end