aoc_cli 0.2.3 → 1.0.1

data/lib/aoc_cli/commands.rb

@@ -1,232 +0,0 @@
-module AocCli
-	module Commands
-		class KeyStore
-			attr_reader :user, :key
-			def initialize(args)
-				args = defaults.merge(args).compact
-				@user, @key = args[:user], args[:key]
-			end
-			def exec
-				Files::Config::Cookie.store(user:user, key:key)
-				self
-			end
-			def respond
-				puts "Key added successfully"
-			end
-			def defaults
-				{ user:"main" }
-			end
-		end
-		class YearInit
-			attr_reader :user, :year, :git
-			def initialize(args)
-				args = defaults.merge(args).compact
-				@user, @year, @git = args[:user], args[:year], args[:git]
-			end
-			def exec
-				Year::Meta.new(u:user, y:year).write
-				Year::Progress.new(u:user, y:year).write.init_calendar_db
-				Year::GitWrap.new if git
-				self
-			end
-			def respond
-				puts "Year #{year} initialised"
-			end
-			def defaults
-				{ user:Prefs.default_alias,
-				   git:Prefs.bool(key:"init_git") }
-			end
-		end
-		class DayInit
-			attr_reader :user, :year, :day
-			def initialize(args)
-				args  = defaults.merge(args).compact
-				@user = args[:user]
-				@year = args[:year]
-				@day  = args[:day]
-			end
-			def exec
-				Day::Init.new(u:user, y:year, d:day).mkdir.meta
-				Day::Pages.new(u:user, y:year, d:day).load
-				self
-			end
-			def defaults
-				{ user:Metafile.get(:user), 
-				  year:Metafile.get(:year) }
-			end
-			def respond
-				puts "Day #{day} initialised"
-			end
-		end
-		class DaySolve
-			attr_reader :user, :year, :day, :part, :ans
-			def initialize(args)
-				args  = defaults.merge(args).compact
-				@user = args[:user]
-				@year = args[:year]
-				@day  = args[:day]
-				@part = args[:part]
-				@ans  = args[:ans]
-			end
-			def exec 
-				Solve::Attempt
-					.new(u:user, y:year, d:day, p:part, a:ans)
-					.respond
-				self
-			end
-			def defaults
-				{user:Metafile.get(:user),
-				 year:Metafile.get(:year),
-				  day:Metafile.get(:day),
-				 part:Metafile.get(:part)}
-			end
-		end
-		class OpenReddit
-			attr_reader :year, :day, :browser
-			def initialize(args)
-				args  = defaults.merge(args).compact
-				@year = Validate.year(args[:year])
-				@day  = Validate.day(args[:day])
-				@browser = args[:browser]
-			end
-			def exec
-				Tools::Reddit.new(y:year, d:day, b:browser).open
-				self
-			end
-			def defaults
-				{ year:Metafile.get(:year),
-				  day:Metafile.get(:day),
-				  browser:Prefs.bool(key:"reddit_in_browser") }
-			end
-		end
-		class DefaultAlias
-			attr_reader :user, :mode
-			def initialize(args)
-				@user = args[:user]
-				@mode = user.nil? ? :get : :set
-			end
-			def exec
-				set if mode == :set && alias_valid
-				self
-			end
-			def respond
-				case mode
-				when :get then current
-				when :set then update end
-			end
-			private
-			def set
-				Files::Config::Tools
-					.mod_line(key:"default", val:Validate.user(user)) 
-			end
-			def current
-				puts <<~aliases
-				Default alias: #{Prefs.default_alias.yellow}
-				All aliases: #{Prefs.list_aliases.map{|a| a.blue}
-					.join(", ")}
-				aliases
-			end
-			def alias_valid
-				Validate.key(Files::Config::Cookie.key(user:user))
-			end
-			def update
-				puts "Default alias changed to: #{user.yellow}"
-			end
-		end
-		class Refresh
-			def initialize(args)
-			end
-			def exec
-				case Metafile.type
-				when :DAY  then Day.refresh
-				when :ROOT then Year.refresh end
-				self
-			end
-		end
-		class AttemptsTable
-			attr_reader :user, :year, :day, :part
-			def initialize(args)
-				args = defaults.merge(args).compact
-				@user = args[:user]
-				@year = args[:year]
-				@day  = args[:day]
-				@part = args[:part]
-			end
-			def exec
-				Tables::Attempts.new(u:user, y:year, d:day, p:part).print
-				self
-			end
-			def defaults
-				{user:Metafile.get(:user),
-				 year:Metafile.get(:year),
-				  day:Metafile.get(:day),
-				 part:Metafile.get(:part)}
-			end
-		end
-		class StatsTable
-			attr_reader :user, :year, :day
-			def initialize(args)
-				args = defaults.merge(args).compact
-				@user = args[:user]
-				@year = args[:year]
-				@day  = args[:day]
-			end
-			def exec
-				day.nil? ?
-					Tables::Stats::Year.new(u:user, y:year).print :
-					Tables::Stats::Day.new(u:user, y:year, d:day).print
-			end
-			def defaults
-				{ user:Metafile.get(:user),
-				  year:Metafile.get(:year),
-				   day:Metafile.get(:day) }
-			end
-		end
-		class CalendarTable
-			attr_reader :user, :year
-			def initialize(args)
-				args = defaults.merge(args).compact
-				@user = Validate.user(args[:user])
-				@year = Validate.year(args[:year])
-			end
-			def exec
-				Tables::Calendar.new(u:user, y:year).print
-			end
-			def defaults
-				{ user:Metafile.get(:user),
-				  year:Metafile.get(:year) }
-			end
-		end
-		class PrintCal
-			attr_reader :path, :year
-			def initialize(args)
-				args  = defaults.merge(args).compact
-				@year = Validate.year(args[:year])
-			end
-			def path
-				case Metafile.type
-				when :DAY  then "../#{year}.md"
-				when :ROOT then "#{year}.md"
-				end
-			end
-			def exec
-				Prefs.bool(key:"calendar_file") ?
-					system("cat #{path} | less") :
-					puts("You have disabled calendar files")
-			end
-			def defaults
-				{year:Metafile.get(:year)}
-			end
-		end
-		class GenerateConfig
-			def initialize(args) end
-			def exec
-				Files::Config::Example.write
-				self
-			end
-			def respond
-				puts "Default config written to #{Paths::Config.path.blue}"
-			end
-		end
-	end
-end

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