aoc_cli 0.1.3 → 0.2.0

data/lib/aoc_cli/database.rb

@@ -1,15 +1,20 @@
 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:"*", data:)
+			def select(t:, cols:"*", where:)
 				db.execute(
 				"SELECT #{cols} FROM #{t} "\
-				"WHERE #{data.map{|k, v| "#{k} = #{v}"}.join(" AND ")}")
+				"WHERE #{where.map{|k, v| "#{k} = #{v}"}.join(" AND ")}")
 			end
 			def table(t:, cols:)
 				db.execute(
@@ -31,25 +36,24 @@ module AocCli
 				self
 			end
 		end
-		class Log
+		class Attempt
 			attr_reader :attempt, :db
 			def initialize(attempt:)
 				@attempt = attempt
-				@db = Query.new(path:Paths::Database
-					.cfg("#{attempt.user}"))
+				@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)))
+			def incorrect(low:, high:)
+				db.insert(t:"attempts", 
+					val:data << 0 << parse_hint(low:low, high:high))
 				self
 			end
-			def parse_hint(high:, low:)
-				[ high ? 1 : 0, low ? 1 : 0 ]
+			def parse_hint(low:, high:)
+				[ low ? 1 : 0, high ? 1 : 0 ]
 			end
 			def data
 				[ "'#{Time.now}'",
@@ -69,7 +73,7 @@ module AocCli
 				  high: :INT }
 			end
 			def count_attempts
-				db.select(t:"attempts", data:where).count
+				db.select(t:"attempts", where:where).count
 			end
 			def where
 				{ year:attempt.year,
@@ -148,12 +152,69 @@ module AocCli
 						.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)
+					@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,12 +1,7 @@
 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
+			attr_reader :user, :year, :day, :paths
 			def initialize(u:Metafile.get(:user), 
 						   y:Metafile.get(:year), 
 						   d:Metafile.get(:day))
@@ -19,135 +14,111 @@ module AocCli
 				Dir.mkdir(Validate.day_dir(paths.day_dir))
 				self
 			end
-			def write
+			def meta
 				File.write(paths.local(f:"meta"), 
-						Metafile.day(u:user, y:year, d:day))
+					Metafile.day(u:user, y:year, d:day))
 				self
 			end
 		end
 		class Pages < Init
-			attr_reader :cache, :files
+			attr_reader :files, :use_cache
 			def initialize(u:Metafile.get(:user), 
 						   y:Metafile.get(:year),
 						   d:Metafile.get(:day), 
-						   f:[:Input, :Puzzle])
+						   f:[:Input, :Puzzle],
+						   use_cache:true)
 				super(u:u, y:y, d:d)
 				@files = f
+				@use_cache = use_cache
 			end
-			def write
-				cache.each{|page, data| data ? 
-					File.write(paths.local(f:page), data) : 
-					download(page:page)}
+			def load
+				files.each do |file| use_cache && cache[file] ?
+					copy(file:file) : download(page:file) end
 			end
-			private
 			def cache
-				@cache ||= Cache
-					.new(u:user, y:year, d:day, f:files).load
+				@cache ||= Cache.new(d:day, f:files).query
+			end
+			def copy(file:)
+				File.write(paths.local(f:file), cache[file])
 			end
-			def download(page:, to:paths.cache_and_local(f:page))
-				dl = Object.const_get("AocCli::Day::Data::#{page}")
+			def download(page:)
+				req = Requests.const_get(page)
 					.new(u:user, y:year, d:day)
-					.write(to:to)
-				dl.init_db if dl.class
-					.instance_methods
-					.include?(:init_db)
+					.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 Data
-			class DayObject < Init
-				attr_reader :user, :year, :day, :data, :paths, :part
+		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)
-					@data  = parse(raw: fetch)
 				end
-				def write(to:paths.cache_and_local(f:page))
-					to.each{|path| File.write(path, data)}
-					self
+				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 < DayObject
+			class Puzzle < Request
 				def page
 					:Puzzle
 				end
-				def parse(raw:)
+				def parse(raw:fetch)
 					raw.chunk(f:"<article", t:"<\/article", f_off:2)
 						.md
 						.gsub(/(?<=\])\[\]/, "")
 						.gsub(/\n.*<!--.*-->.*\n/, "")
 				end
-				def init_db
+				def init_stats
 					Database::Stats::Init
 						.new(d:day, p:part)
-						.init if part < 3
-					self
+						.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 < DayObject
+			class Input < Request
 				def page
 					:Input
 				end
-				def parse(raw:)
+				def parse(raw:fetch)
 					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
+		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

@@ -112,7 +112,7 @@ module AocCli
 			def message
 				<<~error
 				#{ERROR}: No session key value.
-				Use the #{"-k".yellow} or #{"--key".yellow} flags
+				Use the #{"-k".yellow} or #{"--key".yellow} flags to store the key
 				error
 			end
 		end
@@ -123,7 +123,7 @@ module AocCli
 			end
 			def message
 				<<~error
-				#{ERROR}: The key #{user.yellow} already exists in your config file
+				#{ERROR}: The key #{key.yellow} already exists in your config file
 				error
 			end
 		end
@@ -160,12 +160,27 @@ module AocCli
 				error
 			end
 		end
-		class NoCmd < StandardError
+		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
 	end 
 end

data/lib/aoc_cli/files.rb

@@ -1,52 +1,106 @@
 module AocCli
 	module Files
-		class Config
-			require 'fileutils'
-			def initialize
-				Paths::Config.create
-			end
-			def def_acc
-				get_line(key:"default") || "main"
-			end
-			def is_set?(key:nil, val:nil)
-				read.split("\n").grep(/#{key}=>#{val}/).any?
-			end
-			def mod_line(key:, val:)
-				is_set?(key:key) ?
-					write(f:read.gsub(/(?<=^#{key}=>).*$/, 
-						  val.to_s)) :
+		module Config
+			class Tools
+				def self.is_set?(key:nil, val:nil)
+					read.split("\n").grep(/(?<!\/\/)#{key}=>#{val}/).any?
+				end
+				def self.get_all(key:)
+					read.scan(/(?:(?<=(?<!\/\/)#{key}=>)).*$/)
+				end
+				def self.get_line(key:)
+					get_all(key:key)&.first
+					#read.scan(/(?:(?<=(?<!\/\/)#{key}=>)).*$/)&.first
+				end
+				def self.get_bool(key:)
+					get_line(key:key) == "true" ? true : false
+				end
+				def self.mod_line(key:, val:)
+					is_set?(key:key) ?
+						write(f:read.gsub(/(?<=^#{key}=>).*$/, val.to_s)) :
+						write(f:"#{key}=>#{val}\n", m:"a")
+				end
+				def self.set_line(key:, val:)
 					write(f:"#{key}=>#{val}\n", m:"a")
-			end
-			def get_line(key:)
-				read.scan(/(?<=#{key}=>).*$/)&.first
-			end
-			def get_bool(key:)
-				get_line(key:key) == "true" ? true : false
-			end
-			protected
-			def set_line(key:, val:)
-				write(f:"#{key}=>#{val}\n", m:"a")
-			end
-			private
-			def read
-				File.read(Paths::Config.path)
-			end
-			def write(f:, m:"w")
-				File.write(Paths::Config.path, f, mode:m)
-			end
-		end
-		class Cookie < Config
-			attr_reader :user
-			def initialize(u:)
-				@user = u
-				super()
-			end
-			def store(key:)
-				set_line(key:"cookie=>#{Validate.set_user(user)}",
-						 val:Validate.set_key(key))
-			end
-			def key
-				get_line(key:"cookie=>#{user}")
+				end
+				private
+				def self.read
+					Paths::Config.create
+					File.read(Paths::Config.path)
+				end
+				def self.write(f:, m:"w")
+					Paths::Config.create
+					File.write(Paths::Config.path, f, mode:m)
+				end
+			end
+			class Prefs < Tools
+				def self.default_alias
+					is_set?(key:"default") ? get_line(key:"default") :
+						is_set?(key:"cookie=>main") ? "main" :
+							list_aliases.first || "main"
+				end
+				def self.list_aliases
+					get_all(key:"cookie")&.map{|a| a.gsub(/=>.*/, "")}
+				end
+				def self.bool(key:)
+					is_set?(key:key) ?  
+						get_bool(key:key) : defaults[key.to_sym]
+				end
+				def self.string(key:)
+					is_set?(key:key) ? 
+						get_line(key:key) : defaults[key.to_sym]
+				end
+				private
+				def self.defaults
+					{ calendar_file:true,
+					  ignore_md_files:true,
+					  ignore_meta_files:true,
+					  init_git:false,
+					  lb_in_calendar:true,
+					  reddit_in_browser:false,
+					  unicode_tables:true
+					}
+				end
+			end
+			class Cookie < Tools
+				def self.store(user:, key:)
+					set_line(key:"cookie=>#{Validate.set_user(user)}",
+							 val:Validate.set_key(key))
+				end
+				def self.key(user:)
+					Validate.key(get_line(key:"cookie=>#{Validate
+						.user(user)}"))
+				end
+			end
+			class Example
+				def self.write
+					File.write(Validate.no_config, file)
+				end
+				def self.file
+					<<~file
+					//aoc-cli example config
+					//See the github repo for more information on configuring aoc-cli
+					//https://github.com/apexatoll/aoc-cli
+					
+					[General]
+					//Print table in unicode rather than ascii
+					unicode_tables=>true
+					//Open Reddit in browser rather than use a Reddit CLI
+					reddit_in_browser=>false
+					
+					[Initialise Year]
+					//Create a calendar file 
+					calendar_file=>true
+					//Initialise git repo on year initialisation
+					init_git=>false
+					//Add calendar and puzzle files to gitignore
+					ignore_md_files=>true
+					//Add .meta files to gitignore
+					ignore_meta_files=>true
+					//Include leaderboard stats in calendar file
+					lb_in_calendar=>true
+					file
+				end
 			end
 		end
 		class Metafile
@@ -56,22 +110,13 @@ module AocCli
 			def self.type
 				get("dir").to_sym
 			end
-			def self.add(hash:, path:".meta")
-				hash.map {|k, v| "#{k}=>#{v}\n"}
-					.each{|l| File.write(path, l, mode:"a")}
-			end
 			def self.part(d:)
-				JSON.parse(read(dir:root_dir)
-					.scan(/(?<=stars=>).*$/)&.first)[d.to_s]
-					.to_i + 1
+				Database::Calendar::Part.new(d:d).get
 			end
 			private
 			def self.read(dir:".")
 				File.read("#{Validate.init(dir)}/.meta")
 			end
-			def self.root_dir
-				type == :ROOT ? "." : ".."
-			end
 			def self.year(u:, y:)
 				<<~meta
 				dir=>ROOT
@@ -89,5 +134,29 @@ module AocCli
 				meta
 			end
 		end
+		class Calendar
+			attr_reader :cal, :stats, :year
+			def initialize(y:Metafile.get(:year), cal:, stats:)
+				@year, @cal, @stats  = Validate.year(y), cal, stats
+			end
+			def include_leaderboard?
+				Prefs.bool(key:"lb_in_calendar")
+			end
+			def title
+				"Year #{year}: #{stats.total_stars}/50 *"
+			end
+			def underline
+				"-" * (cal.data[0].to_s.length + 2)
+			end
+			def make
+				<<~file
+					#{title}
+					#{underline}
+					#{cal.data.join("\n")}\n
+					#{stats.data.join("\n") if stats.total_stars > 0 &&
+						include_leaderboard?}
+				file
+			end
+		end
 	end 
 end