aoc_cli 0.2.3 → 1.0.1

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

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