aoc_cli 0.2.2 → 1.0.0

data/lib/aoc_cli/database.rb

@@ -1,224 +0,0 @@
-module AocCli
-	module Database
-		def self.correct(attempt:)
-			attempt = Attempt.new(attempt:attempt).correct
-			Stats::Complete.new(n:attempt.count_attempts).update
-			Calendar::Part.new.increment
-		end
-		class Query
-			require 'sqlite3'
-			attr_reader :db
-			def initialize(path:)
-				@db = SQLite3::Database.open(path)
-			end
-			def select(t:, cols:"*", where:)
-				db.execute(
-				"SELECT #{cols} FROM #{t} "\
-				"WHERE #{where.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 Attempt
-			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(low:, high:)
-				db.insert(t:"attempts", 
-					val:data << 0 << parse_hint(low:low, high:high))
-				self
-			end
-			def duplicate?(ans:)
-				db.select(t:"attempts", 
-						  where:where.merge({answer:ans})).count > 0
-			end
-			def parse_hint(low:, high:)
-				[ low ? 1 : 0, high ? 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", where: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", where:where)
-						.flatten.first)
-				end
-			end
-		end
-		module Calendar
-			class Init
-				attr_reader :user, :year, :db, :stars
-				def initialize(u:Metafile.get(:user),
-							   y:Metafile.get(:year), 
-							   stars:)
-					@user = Validate.user(u)
-					@year = Validate.year(y)
-					@stars = stars
-					@db   = Query
-						.new(path:Paths::Database.cfg(user))
-						.table(t:"calendar", cols:cols)
-				end
-				def cols
-					{ year: :INT,
-					   day: :INT,
-					 stars: :TEXT }
-				end
-				def n_stars(day)
-					stars.keys.include?(day) ? stars[day] : 0
-				end
-				def day_data(day)
-					["'#{year}'", "'#{day}'", "'#{n_stars(day)}'"]
-				end
-				def table_exist?
-					db.select(t:"calendar", where:{year:"'#{year}'"}).count > 0
-				end
-				def insert
-					unless table_exist?
-						1.upto(25){|day| 
-							db.insert(t:"calendar", 
-									  val:day_data(day))}
-					end
-				end
-			end
-			class Part
-				attr_reader :user, :year, :day, :db
-				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)
-					@db   = Query.new(path:Paths::Database.cfg(user))
-				end
-				def get
-					db.select(t:"calendar", cols:"stars", where:where)
-						.flatten.first.to_i + 1
-				end
-				def increment
-					db.update(t:"calendar", val:{stars:get}, where:where)
-				end
-				def where
-					{ year:"'#{year}'",
-					   day:"'#{day}'" }
-				end
-			end
-		end
-	end 
-end

data/lib/aoc_cli/day.rb

@@ -1,124 +0,0 @@
-module AocCli
-	module Day
-		class Init
-			attr_reader :user, :year, :day, :paths
-			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 meta
-				File.write(paths.local(f:"meta"), 
-					Metafile.day(u:user, y:year, d:day))
-				self
-			end
-		end
-		class Pages < Init
-			attr_reader :files, :use_cache
-			def initialize(u:Metafile.get(:user), 
-						   y:Metafile.get(:year),
-						   d:Metafile.get(:day), 
-						   f:[:Input, :Puzzle],
-						   use_cache:true)
-				super(u:u, y:y, d:d)
-				@files = f
-				@use_cache = use_cache
-			end
-			def load
-				files.each do |file| use_cache && cache[file] ?
-					copy(file:file) : download(page:file) end
-			end
-			def cache
-				@cache ||= Cache.new(d:day, f:files).query
-			end
-			def copy(file:)
-				File.write(paths.local(f:file), cache[file])
-			end
-			def download(page:)
-				req = Requests.const_get(page)
-					.new(u:user, y:year, d:day)
-					.write(to:paths.cache_and_local(f:page))
-				req.init_stats if page == :Puzzle
-			end
-		end
-		class Cache < Pages
-			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)
-				paths.create_cache
-			end
-			def query
-				files.map{|file| [file, read(file:file)]}.to_h
-			end
-			private
-			def read(file:)
-				File.exist?(paths.cache_path(f:file)) ?
-					File.read(paths.cache_path(f:file)) : nil
-			end
-		end
-		module Requests
-			class Request < Init
-				attr_reader :data, :part
-				def initialize(u:Metafile.get(:user), 
-							   y:Metafile.get(:year),
-							   d:Metafile.get(:day))
-					super(u:u, y:y, d:d)
-					@data = parse(raw:fetch)
-					@part = Metafile.part(d:day)
-				end
-				def write(to:)
-					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 < Request
-				def page
-					:Puzzle
-				end
-				def parse(raw:fetch)
-					raw.chunk(f:"<article", t:"<\/article", f_off:2)
-						.md
-						.gsub(/(?<=\])\[\]/, "")
-						.gsub(/\n.*<!--.*-->.*\n/, "")
-				end
-				def init_stats
-					Database::Stats::Init
-						.new(d:day, p:part)
-						.init if part < 3 && !stats_exist?
-				end
-				def stats_exist?
-					Database::Query
-						.new(path:Paths::Database.cfg(user))
-						.select(t:"stats", 
-								where:{year:year, day:day, part:part})
-						.count > 0
-				end
-			end
-			class Input < Request
-				def page
-					:Input
-				end
-				def parse(raw:fetch)
-					raw.raw
-				end
-			end
-		end
-		def self.refresh(files:[:Input, :Puzzle])
-			puts "- Updating puzzle...".blue
-			Init.new.meta
-			Pages.new(f:files, use_cache:false).load
-		end
-	end
-end

data/lib/aoc_cli/errors.rb

@@ -1,275 +0,0 @@
-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 to store the key
-				error
-			end
-		end
-		class KeyDup < StandardError
-			attr_reader :key
-			def initialize(key)
-				@key = key
-			end
-			def message
-				<<~error
-				#{ERROR}: The key #{key.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 CmdNil < StandardError
-			def message
-				<<~error
-				#{ERROR}: Flags passed but no command specified
-				error
-			end
-		end
-		class KeyInv < StandardError
-			def message
-				<<~error
-				#{ERROR}: Invalid key
-				Double check your session key. It should start with "session=" 
-				error
-			end
-		end
-		class ConfigExist < StandardError
-			def message
-				<<~error
-				#{ERROR}: A config file already exists in #{Paths::Config.path.blue}
-				error
-			end
-		end
-		class AtmptDup < StandardError
-			attr_reader :answer
-			def initialize(answer)
-				@answer = answer
-			end
-			def message
-				<<~error
-				#{ERROR}: You have already tried #{answer.red}
-				To see previous attempts run #{"aoc -a".yellow}
-				error
-			end
-		end
-	end 
-	class Validate
-		E = Errors
-		def self.cmd(cmd)
-			raise E::CmdNil if cmd.nil?
-			cmd
-		end
-		def self.user(user)
-			raise E::UserNil if user.nil?
-			raise E::UserInv.new(user) unless user_in_config?(user)
-			user
-		end
-		def self.set_user(user)
-			raise E::UserNil if user.nil?
-			raise E::UserDup.new(user) if user_in_config?(user)
-			user
-		end
-		def self.year(year)
-			raise E::YearNil if year.nil?
-			raise E::YearInv.new(year) if year.to_i < 2015 ||
-				year.to_i > 2020
-			year
-		end
-		def self.day(day)
-			raise E::DayNil if day.nil? || day == 0
-			raise E::DayInv.new(day) if day.to_i < 1 ||
-				day.to_i > 25
-			day
-		end
-		def self.part(part)
-			raise E::PartNil  if part.nil?
-			raise E::PuzzComp if part.to_i == 3
-			raise E::PartInv  if part.to_i < 1 || part.to_i > 2
-			part
-		end
-		def self.set_key(key)
-			raise E::KeyNil if key.nil?
-			raise E::KeyDup.new(key) if Files::Config::Tools
-				.is_set?(val:"#{key}(\b|$)")
-			raise E::KeyInv unless valid_key?(key)
-			key
-		end
-		def self.key(key)
-			raise E::KeyNil if key.nil?
-			raise E::KeyInv unless valid_key?(key)
-			key
-		end
-		def self.ans(attempt:, ans:)
-			raise E::AnsNil if ans.nil?
-			raise E::AtmptDup.new(ans) if Database::Attempt
-				.new(attempt:attempt).duplicate?(ans:ans)
-			ans
-		end
-		def self.day_dir(day)
-			raise E::DayExist.new(day) if Dir.exist?(day)
-			day
-		end
-		def self.init(dir)
-			raise E::NotInit unless File.exist?("#{dir}/.meta")
-			dir
-		end
-		def self.not_init(dir:, year:)
-			raise E::AlrInit if File.exist?("#{dir}/.meta") && 
-				Metafile.get(:year) != year.to_s
-			dir
-		end
-		def self.no_config
-			raise E::ConfigExist if File.exist?(Paths::Config.path)
-			Paths::Config.path
-		end
-		private
-		def self.valid_key?(key)
-			/session=(?:[a-f0-9]){96}/.match?(key)
-		end
-		def self.user_in_config?(user)
-			Files::Config::Tools.is_set?(key:"cookie=>#{user}")
-		end
-	end
-end