aoc_cli 0.2.2 → 1.0.0

data/lib/aoc_cli/files.rb

@@ -1,163 +0,0 @@
-module AocCli
-	module Files
-		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
-				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,
-					  day_dir_prefix:"",
-					  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
-			def self.get(field)
-				read.scan(/(?<=#{field}=>).*$/)&.first&.chomp
-			end
-			def self.type
-				get("dir").to_sym
-			end
-			def self.part(d:)
-				Database::Calendar::Part.new(d:d).get
-			end
-			private
-			def self.read(dir:".")
-				File.read("#{Validate.init(dir)}/.meta")
-			end
-			def self.year(u:, y:)
-				<<~meta
-				dir=>ROOT
-				user=>#{u}
-				year=>#{y}
-				meta
-			end
-			def self.day(u:, y:, d:)
-				<<~meta
-				dir=>DAY
-				user=>#{u}
-				year=>#{y}
-				day=>#{d}
-				part=>#{part(d:d)}
-				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

data/lib/aoc_cli/help.rb

@@ -1,77 +0,0 @@
-def title(title)
-	"#{title.bold}"
-end
-def flag(short, full)
-	str = "    #{short.yellow.bold} [#{full.blue.italic}]"
-	full.length > 6 ?
-		str += "\t"  :
-		str += "\t\t"
-	str
-end
-
-help = <<~help
-Advent of Code - cli, version #{AocCli::VERSION}
-#{"C. Welham Feb 2021".italic}
-
-#{title("Usage")}
-#{"    aoc".bold + " -flag".italic.yellow + " value".bold.blue}
-
-#{title("General")}
-#{flag("-v","--version")}Print version
-#{flag("-h","--help")}Print this screen
-
-#{title("Setup")}
-- Store session cookie keys to access AoC
-
-#{flag("-k","--key")}Store a session cookie to use the cli.
-#{flag("-u","--user")}Set alias for key (default: "main")
-#{flag("-U","--default")}Get/set default alias
-
-#{title("Year Directory")}
-- Initialise a year directory to use aoc-cli.
-- If no alias is passed, the default key is used
-
-#{flag("-y","--init-year")}Initialise directory and fetch calendar
-#{flag("-u","--user")}Specify alias for initialisation
-#{flag("-d","--init-day")}Create day subdirectory, fetch puzzle and input
-#{flag("-r", "--refresh")}Refresh calendar
- 
-#{title("Day Subdirectory")}
-- These commands can be run from the day subdirectory
-
-#{flag("-s","--solve")}Attempt puzzle
-#{flag("-p","--part")}Specify part (attempts)
-#{flag("-r","--refresh")}Refresh puzzle
-
-#{title("Reddit")}
-- Defaults to a Reddit CLI if one is installed
-
-#{flag("-R","--reddit")}Open Reddit solution megathread
-#{flag("-B","--browser")}Open Reddit thread in browser 
-
-#{title("Manual Usage")}
-- AocCli uses metadata so that these flags do not need to be entered.
-- Command flags can be entered manually, but this is not recommended
-
-#{flag("-u","--user")}Specify user
-#{flag("-Y","--year")}Specify year
-#{flag("-D","--day")}Specify day
-#{flag("-p","--part")}Specify part
- 
-#{title("Configuration")}
-- Pass with a value to update setting
-- Pass without an argument to display current setting. 
-
-#{flag("-U","--default")}Default key alias to use 
-#{flag("-G","--gen-config")}Creates an example config file
-
-#{title("Tables")}
-- Print stats in a terminal-friendly table
-
-#{flag("-a","--attempts")}Prints previous attempts for puzzle (part needed)
-#{flag("-c","--simple-cal")}Prints your progress
-#{flag("-C","--fancy-cal")}Prints your calendar file
-#{flag("-S","--stats")}Prints your stats (time taken, number of attempts)
-
-help
-system("echo '#{help}' | less -r")

data/lib/aoc_cli/interface.rb

@@ -1,81 +0,0 @@
-module AocCli
-	module Interface
-		class Query
-			def initialize
-				ARGV.size > 0 ? 
-					run(args:Args.new.parse) : Help.print
-				rescue StandardError => e
-					abort e.message
-			end
-			def run(args:)
-				cmd = Commands.const_get(Validate.cmd(args.cmd))
-					.new(args.args).exec
-				cmd.respond if cmd.class
-					.instance_methods.include?(:respond)
-			end
-		end
-		class Help
-			def self.print
-				require_relative "help.rb"
-			end
-		end
-		class Args
-			attr_reader :cmd, :args
-			def initialize
-				@args = {}
-			end
-			def parse
-				while ARGV.size > 0
-					case ARGV.shift
-					when "-a", "--attempts"
-						@cmd = :AttemptsTable
-					when "-B", "--browser"
-						@cmd = :OpenReddit
-						args[:browser] = true
-					when "-c", "--simple-cal"
-						@cmd = :CalendarTable
-					when "-C", "--fancy-cal"
-						@cmd = :PrintCal
-					when "-d", "--init-day"
-						@cmd = :DayInit
-						args[:day]  = Validate.day(ARGV.shift.to_i)
-					when "-D", "--day"
-						args[:day]  = ARGV.shift.to_i
-					when "-G", "--gen-config"
-						@cmd = :GenerateConfig
-					when "-h", "--help"
-						exit Help.print
-					when "-k", "--key"
-						@cmd = :KeyStore
-						args[:key]  = Validate.set_key(ARGV.shift)
-					when "-p", "--part"
-						args[:part] = ARGV.shift.to_i
-					when "-r", "--refresh"
-						@cmd = :Refresh
-					when "-R", "--reddit"
-						@cmd = :OpenReddit
-					when "-s", "--solve"
-						@cmd = :DaySolve
-						args[:ans]  = ARGV.shift
-					when "-S", "--stats"
-						@cmd = :StatsTable
-					when "-u", "--user"
-						args[:user] = ARGV.shift
-					when "-U", "--default"
-						@cmd = :DefaultAlias
-						args[:user] = ARGV.shift
-					when "-v", "--version"
-						abort "aoc-cli(#{VERSION})"
-					when "-y", "--init-year"
-						@cmd = :YearInit
-						args[:year] = Validate.year(ARGV.shift.to_i)
-					when "-Y", "--year"
-						args[:year] = ARGV.shift.to_i
-					else raise Errors::FlagInv
-					end 
-				end
-				self
-			end
-		end
-	end 
-end

data/lib/aoc_cli/paths.rb

@@ -1,101 +0,0 @@
-module AocCli
-	module Paths
-		require 'fileutils'
-		class Year
-			attr_reader :user, :year
-			def initialize(u:Metafile.get(:user),
-						   y:Metafile.get(:year))
-				@user = Validate.user(u)
-				@year = Validate.year(y)
-			end
-			def in_year?
-				File.exist?("./.meta") ? 
-					Metafile.type == :ROOT : true
-			end
-			def year_dir
-				in_year? ? "." : ".."
-			end
-			def local(f:)
-				"#{Validate.not_init(dir:year_dir, 
-					year:year)}/#{filename(f:f)}"
-			end
-			def filename(f:)
-				case f.to_sym
-				when :Stars then "#{year}.md"
-				when :meta  then ".meta"
-				end
-			end
-		end
-		class Day
-			attr_reader :user, :year, :day
-			def initialize(u:Metafile.get(:user), 
-						   y:Metafile.get(:year), d:)
-				@user = Validate.user(u)
-				@year = Validate.year(y)
-				@day  = Validate.day(d)
-			end
-			def create_cache
-				FileUtils.mkdir_p(cache_dir) unless Dir.exist?(cache_dir)
-			end
-			def prefix
-				Prefs.string(key:"day_dir_prefix")
-			end
-			def filename(f:)
-				case f.to_sym
-				when :Input  then "input"
-				when :Puzzle then "#{day}.md"
-				when :meta   then ".meta"
-				end 
-			end
-			def in_day?
-				Metafile.type == :DAY 
-			end
-			def day_dir
-				day.to_i < 10 ? 
-					"#{prefix}0#{day}" : 
-					"#{prefix}#{day}"
-			end
-			def local_dir
-				in_day? ? "." : "#{day_dir}"
-			end
-			def cache_dir
-				"#{Dir.home}/.cache/aoc-cli/"\
-				"#{user}/#{year}/#{day_dir}" 
-			end
-			def local(f:)
-				"#{local_dir}/#{filename(f:f)}"
-			end
-			def cache_path(f:)
-				"#{cache_dir}/#{filename(f:f)}"
-			end
-			def cache_and_local(f:)
-				[cache_path(f:f), local(f:f)]
-			end
-		end
-		class Config
-			def self.create
-				FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-				File.write(path, "", mode:"a") unless File.exist?(path)
-			end
-			def self.dir
-				"#{Dir.home}/.config/aoc-cli"
-			end
-			def self.path
-				"#{dir}/aoc.rc"
-			end
-		end
-		class Database < Config
-			def self.dir
-				"#{super}/db"
-			end
-			def self.cfg(name)
-				FileUtils.mkdir_p(dir) unless Dir
-					.exist?(dir)
-				"#{dir}/#{name}.db"
-			end
-			def self.root(name)
-				"#{__dir__}/db/#{name}.db"
-			end
-		end
-	end
-end

data/lib/aoc_cli/solve.rb

@@ -1,104 +0,0 @@
-module AocCli
-	module Solve
-		CORRECT   = "That's the right answer"
-		INCORRECT = "That's not the right answer"
-		WAIT      = "You gave an answer too recently"
-		class Attempt
-			attr_reader :user, :year, :day, :part, :answer
-			def initialize(u:Metafile.get(:user),
-						   y:Metafile.get(:year),
-						   d:Metafile.get(:day),
-						   p:Metafile.get(:part), a:)
-				@user   = Validate.user(u)
-				@year   = Validate.year(y)
-				@day    = Validate.day(d)
-				@part   = Validate.part(p)
-				@answer = Validate.ans(attempt:self, ans:a)
-			end
-			def exists?
-				Database::Attempt.new(attempt:self)
-			end
-			def raw
-				@raw ||= Tools::Post.new(u:user, y:year, d:day, 
-					 data:{level:part, answer:answer}).plain
-			end
-			def check
-				case raw
-				when /#{CORRECT}/   then :Correct
-				when /#{INCORRECT}/ then :Incorrect
-				when /#{WAIT}/      then :Wait
-				end
-			end
-			def respond
-				Respond.const_get(check)
-					.new(attempt:self)
-					.respond
-					.react
-			end
-		end
-		module Respond
-			class Response
-				attr_reader :attempt
-				def initialize(attempt:)
-					@attempt = attempt
-				end
-			end
-			class Correct < Response
-				def react
-					Database.correct(attempt:attempt)
-					Year.refresh
-					Day.refresh(files:[:Puzzle])
-				end
-				def respond
-					puts <<~response
-					#{"Correct!".bold.green} #{ 
-					case attempt.part
-					when "1" then "Downloading part two..."
-					when "2" then "This day is now complete!".green
-					end }
-					response
-					self
-				end
-			end
-			class Incorrect < Response
-				def react
-					Database::Attempt
-						.new(attempt:attempt)
-						.incorrect(high:high, low:low)
-				end
-				def respond
-					puts <<~response
-					#{"Incorrect".red.bold}: You guessed - #{attempt
-						.answer.to_s.red} #{
-					high ? "(too high)" : 
-					low  ? "(too low)"  : ""}
-					#{"Please wait".yellow} #{wait_time} before answering again
-					response
-					self
-				end
-				def high
-					/too high/.match?(attempt.raw)
-				end
-				def low
-					/too low/.match?(attempt.raw)
-				end
-				def wait_time
-					attempt.raw.scan(/(?:(one minute|\d+ minutes))/)
-						.first.first.to_s
-				end
-			end
-			class Wait < Response
-				def respond
-					puts <<~response
-					#{"Please wait".yellow.bold}: #{time.to_s} 
-					response
-					self
-				end
-				def time
-					attempt.raw.scan(/(?:\d+m\s)?\d+s/).first.to_s
-				end
-				def react; end
-			end
-		end
-	end
-end

data/lib/aoc_cli/tables.rb

@@ -1,138 +0,0 @@
-module AocCli
-	module Tables
-		class Table
-			require 'terminal-table'
-			attr_reader :user, :year, :table, :cols, :where
-			def initialize(u:Metafile.get(:user), y:Metafile.get(:year))
-				@user = Validate.user(u)
-				@year = Validate.year(y)
-			end
-			def border
-				Prefs.bool(key:"unicode_tables") ? :unicode : :ascii
-			end
-			def data
-				Database::Query
-					.new(path:Paths::Database.cfg(user))
-					.select(t:table, cols:cols, where:where)
-			end
-			def print
-				puts rows.count > 0 ? make : nil_message
-			end
-			def make
-				tab = Terminal::Table.new(
-					:headings  => headings,
-					:rows      => rows,
-					:title     => title)
-				tab.style = {
-					:border    => border, 
-					:alignment => :center}
-				tab
-			end
-		end
-		class Attempts < Table
-			attr_reader :day, :part 
-			def initialize(u:Metafile.get(:user),
-						   y:Metafile.get(:year),
-						   d:Metafile.get(:day),
-						   p:Metafile.get(:part))
-				super(u:u, y:y)
-				@day   = Validate.day(d)
-				@part  = Validate.part(p)
-				@table = :attempts
-				@cols  = "time, answer, high, low, correct"
-				@where = {year:year, day:day, part:part}
-			end
-			def title
-				"#{year} - Day #{day}:#{part}".bold
-			end
-			def headings
-				["Answer", "Time", "Hint"]
-			end
-			def rows
-				@rows ||= data.map do |d|
-					[parse_ans(d), parse_time(d), parse_hint(d)]
-				end
-			end
-			def parse_ans(row)
-				row[4] == 1 ?  row[1].to_s.green : row[1].to_s.red
-			end
-			def parse_time(row)
-				DateTime.strptime(row[0], "%Y-%m-%d %H:%M:%S %Z")
-					.strftime("%H:%M - %d/%m/%y")
-			end
-			def parse_hint(row)
-				row[3] == 1 ? "low" : 
-					row[2] == 1 ? "high" : "-"
-			end
-			def nil_message
-				"You have not attempted part #{part} yet!"
-			end
-		end
-		module Stats
-			class Year < Table
-				def initialize(u:Metafile.get(:user),
-							   y:Metafile.get(:year))
-					super(u:u, y:y)
-					@table = :stats
-					@cols  = "day, part, attempts, elapsed"
-					@where = {year:"'#{year}'", correct:"'1'"}
-				end
-				def title
-					"Year #{year}"
-				end
-				def headings
-					["Day", "Part", "Attempts", "Time (h:m:s)"]
-				end
-				def rows
-					@rows ||= data.map{|d| [d[0], d[1], d[2], d[3]]}
-				end
-				def nil_message
-					"You have not completed any puzzles yet"
-				end
-			end
-			class Day < Year
-				attr_reader :day
-				def initialize(u:Metafile.get(:user),
-							   y:Metafile.get(:year), 
-							   d:Metafile.get(:day))
-					super(u:u, y:y)
-					@day = Validate.day(d)
-					@cols = "part, attempts, elapsed"
-					@where = { year:"'#{year}'", 
-							   day:"'#{day}'", 
-							   correct:"'1'" }
-				end
-				def title
-					"Year #{year}: Day #{day}"
-				end
-				def headings
-					["Part", "Attempts", "Time (h:m:s)"]
-				end
-				def rows
-					@rows ||= data.map{|d| [d[0], d[1], d[2]]}
-				end
-			end
-		end
-		class Calendar < Table
-			def initialize(u:Metafile.get(:user),
-						   y:Metafile.get(:year))
-				super(u:u, y:y)
-				@table = :calendar
-				@cols  = "*"
-				@where = {year:year}
-			end
-			def title
-				"#{user}: #{year}"
-			end
-			def headings
-				["Day", "Stars"]
-			end
-			def rows
-				@rows ||= data.map{|d| [d[1], parse_stars(d[2])]}
-			end
-			def parse_stars(day)
-				day.to_i == 0 ? ".." : ("*" * day.to_i).ljust(2, ".")
-			end
-		end
-	end
-end