aoc_cli 0.2.3 → 1.0.1

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

data/lib/aoc_cli/tools.rb

@@ -1,120 +0,0 @@
-module AocCli 
-	module Tools
-		class Request
-			require 'curb'
-			attr_reader :user, :year, :day, :base, :page, :ua
-			def initialize(u:Metafile.get(:user),
-						   y:Metafile.get(:year),
-						   d:Metafile.get(:day), p:)
-				@user = Validate.user(u)
-				@year = Validate.year(y)
-				@day  = d
-				@page = p
-				@base = "https://adventofcode.com/#{year}"
-				@ua   = "github.com/apexatoll/aoc-cli"
-			end
-			protected
-			def get
-				Curl.get(url) do |h| 
-					h.headers['Cookie']     = cookie
-					h.headers['User-Agent'] = ua
-				end.body
-			end
-			def post(data:)
-				Curl.post(url, data) do |h| 
-					h.headers['Cookie']     = cookie
-					h.headers['User-Agent'] = ua
-				end.body
-			end
-			private
-			def cookie
-				Files::Config::Cookie.key(user:user)
-			end
-			def url
-				case page.to_sym
-				when :Calendar then base 
-				when :Stats    then base + "/leaderboard/self"
-				when :Puzzle   then base + "/day/#{day}"
-				when :Input    then base + "/day/#{day}/input"
-				when :Answer   then base + "/day/#{day}/answer"
-				end
-			end
-		end
-		class Convert < Request
-			require 'pandoc-ruby'
-			attr_accessor :input
-			def array
-				input.split("\n")
-			end
-			def chunk(f:, t:, t_off:0, f_off:0)
-				pt1 = array.index {|l| l =~ /#{f}/} + t_off
-				pt2 = array.rindex{|l| l =~ /#{t}/} + f_off
-				@input = array.slice(pt1, pt2 - pt1).join("\n")
-				self
-			end
-			def raw
-				input.split("\n").join("\n")
-			end
-			def plain
-				PandocRuby.new(input, f: html, t: :plain).convert
-			end
-			def md
-				PandocRuby.new(input, {f: html, t: :gfm}, 
-				   md_head, md_ref).convert
-			end
-			private 
-			def html
-				"html-native_divs-native_spans"
-			end
-			def md_head
-				"--markdown-headings=setext"
-			end
-			def md_ref
-				"--reference-links"
-			end
-		end
-		class Get < Convert
-			def initialize(u:Metafile.get(:user),
-						   y:Metafile.get(:year), d:nil, p:)
-				@input = Request.new(u:u, y:y, d:d, p:p).get
-			end
-		end
-		class Post < Convert
-			def initialize(u:Metafile.get(:user), 
-						   y:Metafile.get(:year),
-						   d:Metafile.get(:day), 
-						   p:"Answer", data:)
-				@input = Request
-					.new(u:u, y:y, d:d, p:p)
-					.post(data:data)
-			end
-		end
-		class Reddit
-			attr_reader :year, :day, :uniq, :browser
-			def initialize(y:Metafile.get(:year), 
-						   d:Metafile.get(:day), 
-						   b:Prefs.bool(key:"reddit_in_browser"))
-				@year = Validate.year(y)
-				@day  = Validate.day(d)
-				@uniq = Database::Query
-					.new(path:Paths::Database.root("reddit"))
-					.select(t:"'#{year}'", where:{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
-		end
-	end 
-end

data/lib/aoc_cli/year.rb

@@ -1,116 +0,0 @@
-module AocCli
-	module Year
-		def self.refresh
-			puts "- Updating calendar...".blue
-			Year::Meta.new.write
-			Year::Progress.new.write
-				.init_calendar_db
-		end
-		class Meta
-			attr_reader :user, :year, :paths
-			def initialize(u:Prefs.default_alias,
-						   y:Metafile.get(:year))
-				@user  = Validate.user(u)
-				@year  = Validate.year(y)
-				@paths = Paths::Year.new(u:user, y:year)
-			end
-			def write
-				File.write(paths.local(f:"meta"), 
-					Metafile.year(u:user, y:year))
-			end
-		end
-		class Progress < Meta
-			def stats
-				@stats ||= Requests::Stats.new(u:user, y:year)
-			end
-			def cal
-				@cal ||= Requests::Calendar.new(u:user, y:year)
-					.fill(stars:stats.stars)
-			end
-			def file
-				Files::Calendar.new(stats:stats, cal:cal).make
-			end
-			def write?
-				Prefs.bool(key:"calendar_file")
-			end
-			def write
-				File.write(paths.local(f:"Stars"), file) if write?
-				self
-			end
-			def init_calendar_db
-				Database::Calendar::Init
-					.new(u:user, y:year, stars:stats.stars)
-					.insert
-			end
-		end
-		module Requests
-			class Request < Meta
-				attr_reader :data
-				def initialize(u:Metafile.get(:user),
-							   y:Metafile.get(:year))
-					super(u:u, y:y)
-					@data = parse(raw: fetch)
-				end
-				private
-				def fetch
-					Tools::Get.new(u:user, y:year, p:page)
-						.plain.split("\n")
-				end
-			end
-			class Calendar < Request
-				def page
-					:Calendar
-				end
-				def parse(raw:)
-					raw.drop(raw.index{|l| l =~ /\*\*/})
-						.map{|l| l.gsub(/\*\*/, "")}
-				end
-				def fill(stars:)
-					stars.each{|s, n| data.each{|l| l
-						.gsub!(/(^.*)\b#{s}\b.$/, "\\1#{s}\s#{"*" * n}")}}
-					self
-				end
-			end
-			class Stats < Request
-				def page
-					:Stats
-				end
-				def parse(raw:)
-					/You haven't collected/.match?(raw.to_s) ?
-						raw : raw.drop(raw.index{|l| l =~ /^.*Part 1/}) 
-				end
-				def stars
-					data.map{|l| l.scan(/^\s+\d+/)&.first}
-						.reject{|s| s == nil}
-						.map{|s| [s.to_i, data
-						.grep(/^.*#{s}.*(\-.*){3}$/)
-						.count == 0 ? 2 : 1]}.to_h
-				end
-				def total_stars
-					stars.values.reduce(:+).to_i || 0
-				end
-			end
-		end
-		class GitWrap
-			require 'git'
-			attr_reader :git
-			def initialize
-				@git = Git.init 
-				File.write(".gitignore", ignore)
-				git.add(".gitignore")
-			end
-			def ignore_md?
-				Prefs.bool(key:"ignore_md_files")
-			end
-			def ignore_meta?
-				Prefs.bool(key:"ignore_meta_files")
-			end
-			def ignore
-				<<~ignore
-				#{".meta\n**/.meta" if ignore_meta?}#{
-				  "\n*.md\n**/*.md" if ignore_md?}
-				ignore
-			end
-		end
-	end 
-end

data/sample/aoc.rc

@@ -1,21 +0,0 @@
-//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