aoc_cli 0.1.1

data/lib/aoc_cli/files.rb

@@ -0,0 +1,93 @@
+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)) :
+					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
+		end
+		class Metafile
+			def self.get(field)
+				read.scan(/(?<=#{field}=>).*$/)&.first&.chomp
+			end
+			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
+			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
+				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
+	end 
+end

data/lib/aoc_cli/help.rb

@@ -0,0 +1,53 @@
+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
+puts <<~help
+Advent of Code - cli, version 0.1.0
+#{"C. Welham Feb 2021".italic}
+
+#{title("Usage")}
+#{"    aoc".bold + " -flag".italic.yellow + " value".bold.blue}
+
+#{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")
+
+#{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("-r","--refresh")}Refresh puzzle
+#{flag("-a","--attempts")}Prints previous attempt table
+#{flag("-p","--part")}Specify part (attempts)
+#{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("-B","--browser")}Always open Reddit in browser (default: false)
+#{flag("-U","--default")}Default key alias to use (default: "main")
+help

data/lib/aoc_cli/interface.rb

@@ -0,0 +1,137 @@
+module AocCli
+	module Interface
+		class Query
+			def initialize
+				ARGV.size > 0 ? 
+					run(opts:Opts.new.parse_args) : 
+					puts(Help.print)
+				rescue StandardError => e
+					abort e.message
+			end
+			def run(opts:)
+				cmd = Object
+					.const_get("AocCli::Commands::#{opts.cmd}")
+					.new(opts.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 Opts
+			attr_reader :cmd, :args
+			def initialize
+				@args = {}
+			end
+			def parse_args
+				while ARGV.size > 0
+					case ARGV.shift
+					when "-a", "--attempts"
+						@cmd = :AttemptsTable
+					when "-b", "--browser"
+						args[:browser] = true
+					when "-d", "--init-day"
+						@cmd = :DayInit
+						args[:day]  = Validate.day(ARGV.shift.to_i)
+					when "-h", "--help"
+						exit Help.print
+					when "-k", "--key"
+						@cmd = :KeyStore
+						args[:key]  = Validate.set_key(ARGV.shift)
+					when "-p", "--part"
+						args[:part] = Validate.part(ARGV.shift.to_i)
+					when "-r", "--refresh"
+						@cmd = :Refresh
+					when "-s", "--solve"
+						@cmd = :DaySolve
+						args[:ans]  = Validate.ans(ARGV.shift)
+					when "-u", "--user"
+						args[:user] = ARGV.shift
+					when "-y", "--init-year"
+						@cmd = :YearInit
+						args[:year] = Validate.year(ARGV.shift.to_i)
+					when "-B", "--browser"
+						@cmd = :DefaultReddit
+						args[:value] = ARGV.shift
+					when "-D", "--day"
+						args[:day]  = Validate.day(ARGV.shift.to_i)
+					when "-R", "--reddit"
+						@cmd = :OpenReddit
+					when "-S", "--stats"
+						@cmd = :StatsTable
+					when "-U", "--default-user"
+						@cmd = :DefaultUser
+						args[:user] = ARGV.shift
+					when "-Y", "--year"
+						args[:year] = Validate.year(ARGV.shift.to_i)
+					else raise E::FlagInv
+					end 
+				end
+				raise E::NoCmd if cmd.nil?
+				self
+			end
+		end
+		class Validate
+			def self.user(user)
+				raise E::UserNil if user.nil?
+				raise E::UserInv.new(user) unless Files::Config
+					.new.is_set?(key:"cookie=>#{user}")
+				user
+			end
+			def self.set_user(user)
+				raise E::UserNil if user.nil?
+				raise E::UserDup if Files::Config.new
+					.is_set?(key:"cookie=>#{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 if Files::Config
+					.new.is_set?(val:key)
+				key
+			end
+			def self.get_key(key)
+				raise E::KeyNil if key.nil?
+				key
+			end
+			def self.ans(ans)
+				raise E::AnsNil if ans.nil?
+				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
+		end
+	end 
+end

data/lib/aoc_cli/paths.rb

@@ -0,0 +1,93 @@
+module AocCli
+	module Paths
+		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 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 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 ? "0#{day}" : day.to_s
+			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 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 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

@@ -0,0 +1,109 @@
+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(a)
+			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
+				Object
+					.const_get("AocCli::Solve::Respond::#{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
+					log = Database::Log
+						.new(attempt:attempt)
+						.correct
+					Database::Stats::Complete
+						.new(n:log.count_attempts)
+						.update
+					Year.refresh
+					Day.refresh
+					Database::Stats::Init.new.init 
+				end
+				def respond
+					response = "#{"Correct!".bold.green} "
+					response += case attempt.part
+						when "1" then next_part
+						when "2" then complete end
+					puts response
+					self
+				end
+				private 
+				def next_part
+					"Downloading part two.."
+				end
+				def complete
+					"This day is now complete!".green
+				end
+			end
+			class Incorrect < Response
+				def react
+					Database::Log
+						.new(attempt:attempt)
+						.incorrect(high:high, low:low)
+				end
+				def respond
+					response =  "#{"Incorrect".red.bold}: "\
+						"You guessed - #{attempt.answer.to_s.red}\n"
+					response += "This answer is too high\n" if high
+					response += "This answer is too low\n"  if low
+					puts response
+					self
+				end
+				def high
+					/too high/.match?(attempt.raw)
+				end
+				def low
+					/too low/.match?(attempt.raw)
+				end
+			end
+			class Wait < Response
+				def respond
+					response = "#{"Please wait".yellow.bold}: "\
+								"You have #{time.to_s} to wait"
+					puts response
+					self
+				end
+				def time
+					attempt.raw.scan(/(?:\d+m\s)?\d+s/).first.to_s
+				end
+				def react; end
+			end
+		end
+	end
+end