921 lines
27 KiB
Ruby
921 lines
27 KiB
Ruby
require "text.rb"
|
|
require "latex.rb"
|
|
|
|
class NilClass
|
|
def lookup_or_nil(x)
|
|
nil;
|
|
end
|
|
end
|
|
|
|
class Array
|
|
def lookup_or_nil(x)
|
|
self[x]
|
|
end
|
|
|
|
def oxford_comma
|
|
if length <= 1 then self.join(", ")
|
|
elsif length == 2 then "#{self[0]} and #{self[1]}"
|
|
else
|
|
"#{self[0...-1].join(", ")}, and #{self[-1]}"
|
|
end
|
|
end
|
|
end
|
|
|
|
class Hash
|
|
def lookup_or_nil(x)
|
|
self[x]
|
|
end
|
|
end
|
|
|
|
class CV < Latex::Builder
|
|
include Text
|
|
|
|
def initialize(who, out, options = {})
|
|
super(out)
|
|
@data = $db["cv"][who]
|
|
@who = who
|
|
@include_rejected_grants = options.fetch(:include_rejected_grants, false)
|
|
@include_pending_papers = options.fetch(:include_pending_papers, false)
|
|
@include_pending_grants = options.fetch(:include_pending_grants, false)
|
|
@include_blurb = options.fetch(:include_blurb, false)
|
|
@title = options.fetch(:title, "Curriculum Vitae")
|
|
@since = Hash.new { |h,k| if h.has_key? :rest then h[:rest] else 0 end }
|
|
options[:since].each { |k, v| @since[k] = v } if options.has_key?(:since)
|
|
@skip = options.fetch(:skip, [:blurb])
|
|
@abbreviate = options.fetch(:abbreviate, [])
|
|
|
|
gen
|
|
end
|
|
|
|
def CV.make(who, out, options = {})
|
|
CV.new(who, out, options)
|
|
end
|
|
|
|
def make_section(title)
|
|
section!(title)
|
|
print_direct "~"
|
|
endl("-0.4in")
|
|
hrule
|
|
nopagebreak
|
|
print_direct "~"
|
|
endl("-.2in")
|
|
nopagebreak
|
|
puts_direct "\n\n"
|
|
end
|
|
|
|
def gen
|
|
|
|
documentclass("11pt", "article")
|
|
usepackage "fullpage"
|
|
usepackage "bibentry"
|
|
usepackage "enumitem"
|
|
|
|
document do
|
|
pagestyle "empty"
|
|
|
|
render_header
|
|
vspace "0.15in"
|
|
|
|
unless skip?(:contact)
|
|
render_contact_details
|
|
vspace! "-0.1in"
|
|
end
|
|
|
|
render_blurb if @include_blurb
|
|
render_education unless skip?(:education)
|
|
render_employment_history unless skip?(:employment)
|
|
render_honors unless skip?(:honors)
|
|
render_students unless skip?(:students)
|
|
render_professional_activities unless skip?(:service)
|
|
render_invited_talks unless skip?(:invited_talks)
|
|
render_courses_taught unless skip?(:courses)
|
|
render_grant_support unless skip?(:grants)
|
|
render_short_grant_support if @abbreviate.include? :grants
|
|
render_pubs_and_artifacts unless skip?(:publications)
|
|
end
|
|
end
|
|
|
|
def filter_records(category, records)
|
|
records.select { |record|
|
|
duration_is_since?(record, @since[category])
|
|
}
|
|
end
|
|
|
|
def build_filtered_itemize(category, records, *args)
|
|
args.unshift(filter_records(category, records))
|
|
build_itemize(*args) { |record| yield record }
|
|
end
|
|
|
|
def skip?(category)
|
|
@skip.include? category or @abbreviate.include? category
|
|
end
|
|
|
|
def since_title_subscript(category)
|
|
if @since.has_key? category
|
|
" (since #{@since[category]})"
|
|
else "" end
|
|
end
|
|
|
|
|
|
############### HEADER ################
|
|
|
|
def render_header
|
|
noindent
|
|
textbf { huge; puts @title }
|
|
hfill
|
|
textbf { huge; puts @data["name"] }
|
|
endl "0.05in"
|
|
hrule
|
|
end
|
|
|
|
############### CONTACT DETAILS ################
|
|
|
|
def render_contact_details
|
|
noindent
|
|
puts @data["work"]["dept"]
|
|
hfill
|
|
puts address_line_1(@data["home"])
|
|
endl
|
|
|
|
puts @data["work"]["employer"]
|
|
hfill
|
|
puts address_line_2(@data["home"])
|
|
endl
|
|
|
|
puts address_line_1(@data["work"]["address"])
|
|
endl
|
|
puts address_line_2(@data["work"]["address"])
|
|
|
|
puts ""
|
|
puts ""
|
|
smallskip
|
|
noindent
|
|
even_odd = false
|
|
@data["contact"].each do |k,v|
|
|
textit { puts "#{k}:" }
|
|
puts v
|
|
if even_odd then endl
|
|
else hfill end
|
|
even_odd = !even_odd
|
|
end
|
|
end
|
|
|
|
############### BLURB ################
|
|
|
|
def render_blurb
|
|
make_section("Overview")
|
|
puts @data["blurb"]
|
|
end
|
|
|
|
############### EDUCATION ################
|
|
|
|
def render_education
|
|
make_section("Education")
|
|
build_filtered_itemize(:education, @data["education"], "label=,leftmargin=0mm") do |r|
|
|
textit { puts "#{r["degree"]}," }
|
|
puts "#{r["university"]}, #{r["city"]}"
|
|
hfill
|
|
puts r["year"]
|
|
endl
|
|
|
|
puts r["dept"]
|
|
case r["degree"].split(/ +/)[0]
|
|
when "PhD"
|
|
endl
|
|
puts "Thesis: "
|
|
textit { puts "``#{r["Thesis"]}''" }
|
|
endl
|
|
puts "Advisor: #{r["Advisor"]}"
|
|
end
|
|
end
|
|
end
|
|
|
|
############### EMPLOYMENT HISTORY ################
|
|
|
|
def render_employment_history(elems = @data["employment"])
|
|
make_section("Employment History")
|
|
build_filtered_itemize(:employment, elems) do |r|
|
|
puts "#{r["title"]}, #{r["employer"]}"
|
|
hfill
|
|
puts duration(r)
|
|
end
|
|
end
|
|
|
|
############### HONORS ################
|
|
|
|
def render_honors
|
|
make_section("Honors")
|
|
build_filtered_itemize(:honors, @data["honors"], "label=,leftmargin=0mm") do |r|
|
|
puts r["description"]
|
|
end
|
|
end
|
|
|
|
############### PROFESSIONAL ACTIVITIES ################
|
|
|
|
def render_one_activity_class(activity_class, data, role_title)
|
|
role_title =
|
|
case role_title
|
|
when Proc then role_title
|
|
else
|
|
orig_role_title = role_title
|
|
lambda { |r| r[orig_role_title] }
|
|
end
|
|
build_filtered_itemize(activity_class, data, "noitemsep,leftmargin=5mm,label=--") do |r|
|
|
puts(role_title.call(r))
|
|
hfill
|
|
puts duration(r)
|
|
unless r["roles"].nil?
|
|
build_itemize(r["roles"], "noitemsep") do |role|
|
|
puts role["title"]
|
|
hfill
|
|
puts duration(role)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def render_professional_activities(args = {})
|
|
make_section("Professional Activities")
|
|
|
|
unless skip? :chair
|
|
subsection!("Chair Positions")
|
|
render_one_activity_class(:reviewer, @data["chairs"],
|
|
lambda { |r|
|
|
position = r["position"]
|
|
raise "Position missing from #{r}" unless position
|
|
venue = LabMetadata.complete_venue(r)["type"]
|
|
raise "Unknown Venue: #{r}" unless venue;
|
|
"#{position.capitalize}: #{LabMetadata.venue_name(r, size: :full)}"
|
|
})
|
|
end
|
|
|
|
unless skip? :reviewer
|
|
|
|
subsection!("Program Comittee Member")
|
|
render_one_activity_class(:reviewer, @data["reviewer"].select { |r| r.fetch("pc", false) },
|
|
lambda { |r|
|
|
venue = LabMetadata.complete_venue(r)["type"]
|
|
raise "Unknown Venue: #{r}" unless venue;
|
|
"#{venue.capitalize}: #{LabMetadata.venue_name(r)}"
|
|
})
|
|
|
|
subsection!("Reviewer")
|
|
render_one_activity_class(:reviewer, @data["reviewer"].select { |r| not r.fetch("pc", false) },
|
|
lambda { |r|
|
|
venue = LabMetadata.complete_venue(r)["type"]
|
|
raise "Unknown Venue: #{r}" unless venue;
|
|
"#{venue.capitalize}: #{LabMetadata.venue_name(r)}"
|
|
})
|
|
end
|
|
|
|
unless skip? :general_service
|
|
subsection!("Service")
|
|
render_one_activity_class(:general_service, @data["service"]["general"], "description")
|
|
end
|
|
|
|
unless skip? :memberships
|
|
subsection!("Professional Memberships")
|
|
render_one_activity_class(:memberships, @data["memberships"], "org")
|
|
end
|
|
|
|
unless skip? :volunteering
|
|
subsection!("Volunteer Work")
|
|
render_one_activity_class(:volunteering, @data["volunteering"], "org")
|
|
end
|
|
|
|
unless skip? :dept_service
|
|
subsection!("Departmental Service")
|
|
build_itemize(@data["service"]["dept"]) do |dept|
|
|
puts dept["org"]
|
|
render_one_activity_class(:dept_service, dept["service"], "org")
|
|
end
|
|
end
|
|
end
|
|
|
|
############### INVITED TALKS ################
|
|
|
|
def render_invited_talks
|
|
make_section("Invited Talks"+since_title_subscript(:talks))
|
|
build_filtered_itemize(:talks, @data["talks"], "noitemsep,leftmargin=5mm", enumerate: true) do |r|
|
|
textit { puts r["venue"] }
|
|
wrap {
|
|
small
|
|
em_dash
|
|
puts " #{r["talk"]}"
|
|
puts "(with #{r["with"].join(', ')})" unless r["with"].nil?
|
|
}
|
|
hfill
|
|
puts r["date"]
|
|
end
|
|
end
|
|
|
|
############### COURSES ################
|
|
|
|
def render_courses_taught
|
|
make_section("Courses Taught"+since_title_subscript(:courses))
|
|
|
|
courses = @data["courses"]
|
|
|
|
since = @since[:courses]
|
|
courses = courses.map do |dept|
|
|
dept = dept.clone
|
|
dept["courses"] = dept["courses"].select do |c|
|
|
unless /([0-9]{4})/ =~ c["semester"]
|
|
raise "Invalid Semester: '#{c["semester"]}'"
|
|
end
|
|
$1.to_i >= since
|
|
end
|
|
dept unless dept["courses"].empty?
|
|
end.compact
|
|
|
|
build_itemize(courses, "leftmargin=1mm,label=") do |dept|
|
|
puts dept["venue"]
|
|
build_itemize(dept["courses"], "noitemsep,leftmargin=7mm") do |r|
|
|
texttt { puts r["code"] }
|
|
puts ":"
|
|
wrap {
|
|
small
|
|
puts "#{r["title"]}"
|
|
puts " (as #{r["role"]})" unless r["role"].nil?
|
|
puts "--- #{r["enrollment"]} students" unless r["enrollment"].nil?
|
|
}
|
|
hfill
|
|
puts r["semester"]
|
|
end
|
|
end
|
|
end
|
|
|
|
############### GRANT SUPPORT ################
|
|
|
|
def render_grant_support(args = {})
|
|
make_section("Grant Support"+since_title_subscript(:grants))
|
|
|
|
test_for_since = proc { |r| duration_is_since?(r, @since[:grants]) }
|
|
|
|
grant_categories = [
|
|
["Planned Applications", "planned", ["grant", "gift"]],
|
|
["Pending Applications", "submitted", ["grant", "gift"]],
|
|
["Active Grants", "accepted", ["grant"]],
|
|
["Gifts", "accepted", ["gift"]],
|
|
]
|
|
grant_categories += [
|
|
["Completed", "completed", ["grant", "gift"]]
|
|
] unless skip?(:completed_grants)
|
|
grant_categories += [
|
|
["Declined", "rejected", ["grant", "gift"]]
|
|
] if args.fetch(:include_rejected, @include_rejected_grants)
|
|
|
|
fields_to_display = args.fetch(:fields, [
|
|
"title",
|
|
"agency",
|
|
"role",
|
|
"effective dates",
|
|
"start",
|
|
"end",
|
|
"amount",
|
|
"effort",
|
|
"copis",
|
|
"collaborative",
|
|
"feedback",
|
|
"supplements"
|
|
])
|
|
|
|
grant_categories.each do |sec, status, type|
|
|
|
|
## Find the set of grants that apply to the current categories
|
|
grants_in_category = @data["grants"].select { |r|
|
|
(r["status"] == status) and
|
|
(type.include?(r["type"])) and
|
|
test_for_since.call(r)
|
|
}.sort { |a,b| to_date(b["start"]) <=> to_date(a["start"])}
|
|
|
|
|
|
unless grants_in_category.empty?
|
|
|
|
awarded_grants =
|
|
grants_in_category
|
|
.select { |r| r["status"] == "accepted" or r["status"] == "completed" }
|
|
|
|
total_amount =
|
|
awarded_grants.map { |r| amt = r["amount"]; if amt.is_a? Numeric then amt else 0 end }.sum
|
|
by_effort =
|
|
awarded_grants.map { |r| amt = r["amount"]; if amt.is_a? Numeric then amt * (r["effort"].sub(/%/, "").to_f/100.0) else 0 end }.sum
|
|
|
|
dollar_summary =
|
|
if total_amount > 0
|
|
"--- #{format_money total_amount} Total; #{format_money by_effort} By Effort"
|
|
else
|
|
""
|
|
end
|
|
|
|
## Header for the category
|
|
subsection!("#{sec} (#{grants_in_category.length}) #{dollar_summary}")
|
|
|
|
## For each grant in the category
|
|
grants_in_category.each do |r|
|
|
collaborative_total = 0;
|
|
supplements_total = 0
|
|
our_total = 0;
|
|
total_awarded = 0;
|
|
award_value_is_string = true
|
|
|
|
# Derive grant totals for collaborative grants and
|
|
# grants with supplements, as well as fractional
|
|
# amounts for us.
|
|
if r["amount"].is_a? Numeric then
|
|
collaborative_total =
|
|
if r["collaborative"].nil? then 0 else
|
|
r["collaborative"].map { |x| x["amount"].to_f }.sum
|
|
end
|
|
supplements_total =
|
|
if r["supplements"].nil? then 0 else
|
|
r["supplements"].map { |x| x["amount"].to_f }.sum
|
|
end
|
|
our_total = r["amount"].to_f + supplements_total
|
|
total_awarded = our_total + collaborative_total;
|
|
award_value_is_string = false
|
|
end
|
|
|
|
noindent
|
|
|
|
tabular("p{0.15\\textwidth}p{0.8\\textwidth}") do
|
|
|
|
# For each field being displayed
|
|
fields_to_display.each do |k|
|
|
|
|
# Only display fields if they're available
|
|
unless r[k].nil?
|
|
# Field title
|
|
textit { puts(
|
|
case k
|
|
when "copis" then "Co-PI".pluralize(r["copis"].length)
|
|
when "collaborative" then
|
|
"Peer Org.".pluralize(r["collaborative"].length)
|
|
else k.capitalize
|
|
end
|
|
)}
|
|
# Break
|
|
print_direct ":&"
|
|
|
|
# Post-processing on field value
|
|
case k
|
|
when "title", "agency"
|
|
parbox("5in") do
|
|
if k == "title" then textsf { puts r[k] } else puts r[k] end
|
|
end
|
|
when "effective dates"
|
|
puts duration(r)
|
|
when "copis"
|
|
puts r["copis"].join(", ")
|
|
when "amount"
|
|
unless award_value_is_string
|
|
puts format_money our_total
|
|
unless r["collaborative"].nil?
|
|
puts " (Total Across Collaboration: #{format_money total_awarded})"
|
|
end
|
|
else
|
|
puts r["amount"]
|
|
end
|
|
when "collaborative"
|
|
r["collaborative"].each do |i|
|
|
puts i["institution"]
|
|
puts "(#{format_money i["amount"]})"
|
|
end
|
|
when "supplements"
|
|
unless award_value_is_string then
|
|
puts(r["supplements"].map do |supp|
|
|
"#{supp["type"]}"
|
|
end.join(", "))
|
|
puts "(#{"amount".pluralize(r["supplements"].length)} included in total above)"
|
|
else
|
|
puts(r["supplements"].map do |supp|
|
|
"#{supp["type"]} (#{format_money supp["amount"].to_f})"
|
|
end.join(", "))
|
|
end
|
|
else # case k
|
|
puts r[k]
|
|
end # case k
|
|
endl("0.02in")
|
|
end # unless r[k].nil?
|
|
end # fields_to_display.each
|
|
end # block("tabular") (field table)
|
|
endl("0.2in")
|
|
end # grants_in_category.each
|
|
end # unless grants_in_category.empty?
|
|
end # grant_categories.each
|
|
end
|
|
|
|
def render_short_grant_support
|
|
make_section("Grant Support"+since_title_subscript(:grants))
|
|
|
|
test_for_since = proc { |r| duration_is_since?(r, @since[:grants]) }
|
|
|
|
grants = @data["grants"].select { |r|
|
|
r["status"] == "accepted" and test_for_since.call(r)
|
|
}
|
|
build_itemize(grants, "noitemsep,leftmargin=5mm,label=--") do |r|
|
|
copis = r.fetch("copis", [])
|
|
copi_string = if copis.empty? then "" else "; with "+copis.oxford_comma end
|
|
puts "#{r["title"]} (#{format_money r["amount"]} from #{r["agency"].split(/:/)[0]}#{copi_string})"
|
|
end
|
|
|
|
end
|
|
############### PUBLICATIONS AND ARTEFACTS ################
|
|
|
|
|
|
def render_author_list(record)
|
|
advisors = $db["cv/#{@who}/education"].map { |r| r["Advisor"] }.compact
|
|
print_direct "#{
|
|
record["authors"].map do |name|
|
|
abbreviated_name = LabMetadata.person_name(name, :size => :short)
|
|
if LabMetadata.is_member? name
|
|
"\\textbf{#{abbreviated_name}}"
|
|
elsif advisors.include? name
|
|
"\\underline{#{abbreviated_name}}"
|
|
else
|
|
safe_text(abbreviated_name)
|
|
end
|
|
end.join(", ")
|
|
}#{
|
|
case record["authornote"]
|
|
when nil then ""
|
|
when "alpha" then " (\\textit{Authors listed in alphabetical order})"
|
|
else " (\\textit{#{safe_text(record["authornote"])}}"
|
|
end
|
|
}; "
|
|
end
|
|
|
|
def render_editor_list(record)
|
|
v =
|
|
eds = LabMetadata.complete_venue(record).
|
|
lookup_or_nil("editors").
|
|
lookup_or_nil(record["year"])
|
|
if eds
|
|
puts "Ed#{eds.length != 1 ? "s" : ""}. #{eds.join(", ")}"
|
|
end
|
|
end
|
|
|
|
def render_selectivity(record)
|
|
year = record["year"].to_s
|
|
v = LabMetadata.complete_venue(record)
|
|
sel_data = v["selectivity"]
|
|
|
|
rate = "acceptance rate"
|
|
|
|
if sel_data.nil?
|
|
"#{rate} not available"
|
|
elsif sel_data[year].is_a? Numeric
|
|
"#{rate} #{(sel_data[year]*100).round(2)}%"
|
|
elsif not sel_data[year].nil?
|
|
"#{rate} #{sel_data[year]}"
|
|
elsif sel_data["average"].is_a? Numeric
|
|
"#{rate} unknown; average rate for past conferences #{
|
|
get_avg_selectivity(record)
|
|
}"
|
|
elsif not sel_data["average"].nil?
|
|
"#{rate} #{sel_data["average"]}"
|
|
else
|
|
"#{rate} unknown; average rate for past conferences #{
|
|
get_avg_selectivity(record)
|
|
}"
|
|
end
|
|
end
|
|
|
|
def get_venue_type(record)
|
|
LabMetadata.complete_venue(record).
|
|
lookup_or_nil("type")
|
|
end
|
|
|
|
def get_publisher(record)
|
|
LabMetadata.complete_venue(record).
|
|
lookup_or_nil("publisher")
|
|
end
|
|
|
|
def get_pub_length_string(record)
|
|
case record["length"]
|
|
when String
|
|
record["length"]
|
|
else
|
|
"#{record["length"]} #{"page".pluralize(record["length"])}";
|
|
end
|
|
end
|
|
|
|
def get_avg_selectivity(record, rounding = 2)
|
|
LabMetadata.venue_selectivity(record, rounding: rounding)
|
|
end
|
|
|
|
def render_paper_title(title)
|
|
print_direct "\\textsc{#{title}}"
|
|
end
|
|
|
|
def render_one_pub_or_artifact(title,list,fmt,filter = proc { true })
|
|
list = list.select { |r| filter.call(r) }
|
|
unless list.empty?
|
|
subsection!("#{title} (#{list.length})")
|
|
build_itemize(list, "leftmargin=0mm,label=") { |r| fmt.call(r) }
|
|
end
|
|
end
|
|
def render_pubs_and_artifacts(args = {})
|
|
|
|
global_filter =
|
|
proc { |r| duration_is_since?(r, @since[:publications])}
|
|
|
|
all_my_pubs = LabMetadata.publications_for(@who)
|
|
|
|
make_section("Publications and Artifacts"+since_title_subscript(:publications))
|
|
|
|
center {
|
|
print_direct "\\noindent Students I advise or co-advise and I are in \\textbf{bold}, my former advisor is \\underline{underlined}"
|
|
}
|
|
|
|
# block("center") do
|
|
# puts "(Author lists marked with a * are not correlated with level of contribution)"
|
|
# end
|
|
unless skip?(:journal_pubs)
|
|
render_one_pub_or_artifact(
|
|
"Journal Publications",
|
|
all_my_pubs.where do |r|
|
|
case get_venue_type(r)
|
|
when "journal" then true
|
|
else false
|
|
end
|
|
end,
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "---"
|
|
extra_fields =
|
|
if r["volume"].nil? then []
|
|
else ["Volume #{r["volume"]}, Number #{r["number"]}"] end +
|
|
if r["issuetitle"].nil? then []
|
|
else [r["issuetitle"]] end
|
|
textit {
|
|
puts "#{LabMetadata.venue_name(r)} #{r["year"]}#{if extra_fields.length > 0 then " (#{extra_fields.join("; ")}), " else ", " end}"
|
|
}
|
|
puts "#{get_pub_length_string(r)}, "
|
|
puts render_selectivity(r)
|
|
puts " / "+r["notes"].join(" / ") if r.has_key? "notes"
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
unless skip?(:conference_pubs)
|
|
render_one_pub_or_artifact(
|
|
"Conference Publications",
|
|
all_my_pubs.where do |r|
|
|
case get_venue_type(r)
|
|
when "conference" then true
|
|
else false
|
|
end
|
|
end,
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "---"
|
|
textit{ puts LabMetadata.venue_name(r) }
|
|
puts "#{r["year"]}; "
|
|
venue = LabMetadata.complete_venue(r)
|
|
raise "Unknown location for venue: #{venue["acronym"] || venue["venue"]} #{r["year"]}" unless venue.has_key? "location"
|
|
puts "#{venue["location"]}; "
|
|
puts "#{get_pub_length_string(r)}, "
|
|
puts render_selectivity(r)
|
|
puts " / "+r["notes"].join(" / ") if r.has_key? "notes"
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
unless skip?(:workshop_pubs)
|
|
render_one_pub_or_artifact(
|
|
"Workshop Publications",
|
|
all_my_pubs.where do |r|
|
|
case get_venue_type(r)
|
|
when "workshop" then true
|
|
else false
|
|
end
|
|
end,
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "---"
|
|
textit { puts LabMetadata.venue_name(r) }
|
|
puts "#{r["year"]}; "
|
|
venue = LabMetadata.complete_venue(r)
|
|
raise "Unknown location for venue: #{venue["acronym"] || venue["venue"]} #{r["year"]}" unless venue.has_key? "location"
|
|
puts "#{venue["location"]}; "
|
|
puts "#{get_pub_length_string(r)}, "
|
|
puts render_selectivity(r)
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
unless skip?(:book_chapters)
|
|
render_one_pub_or_artifact(
|
|
"Book Chapters",
|
|
all_my_pubs.where do |r|
|
|
case get_venue_type(r)
|
|
when "chapter" then true
|
|
else false
|
|
end
|
|
end,
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "---"
|
|
textit { puts r["booktitle"] || LabMetadata.venue_name(r) }
|
|
render_editor_list(r)
|
|
publisher = get_publisher(r)
|
|
venue = LabMetadata.complete_venue(r)
|
|
series = r["series"] || venue["series"] || venue["fullname"]
|
|
puts "---" if publisher || series
|
|
puts "#{publisher}#{if series then ";" else "" end}" if publisher
|
|
puts series if series
|
|
textit { puts r["year"] }
|
|
puts "(#{get_pub_length_string(r)}, #{render_selectivity(r)})"
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
if @include_pending_papers
|
|
render_one_pub_or_artifact(
|
|
"Submitted and Planned Publications",
|
|
@data["publications_submitted"],
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "---"
|
|
textit {
|
|
puts "#{LabMetadata.venue_name(r)} #{r["year"]}"
|
|
case r.fetch("status", "unknown")
|
|
when "submitted"
|
|
puts " (under submission)"
|
|
when "planned"
|
|
puts " (planned for submission)"
|
|
end
|
|
puts " --- "
|
|
}
|
|
# puts "#{get_pub_length_string(r)}; "
|
|
puts "Historical average acceptance rate #{get_avg_selectivity(r, 0)}"
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
unless skip?(:tech_reports)
|
|
render_one_pub_or_artifact(
|
|
"Technical Reports",
|
|
all_my_pubs.where do |r|
|
|
case get_venue_type(r)
|
|
when "techreport" then true
|
|
else false
|
|
end
|
|
end,
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "---"
|
|
textit {
|
|
puts "#{LabMetadata.venue_name(r)}#{if r["id"].nil? then "" else " ##{r["id"]}" end}, "
|
|
}
|
|
puts get_pub_length_string(r)
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
unless skip?(:patents)
|
|
render_one_pub_or_artifact(
|
|
"Patents",
|
|
all_my_pubs.where do |r|
|
|
case get_venue_type(r)
|
|
when "patent" then true
|
|
else false
|
|
end
|
|
end,
|
|
proc do |r|
|
|
render_author_list(r)
|
|
textit {
|
|
render_paper_title(r["title"])
|
|
}
|
|
puts "--- #{r["country"]} Patent#{if r["status"] == "granted" then "" else " Application" end} ##{r["id"]}"
|
|
end,
|
|
global_filter
|
|
)
|
|
end
|
|
|
|
unless skip?(:artifacts)
|
|
render_one_pub_or_artifact(
|
|
"Artifacts",
|
|
@data["artifacts"],
|
|
proc do |r|
|
|
print_direct "\\textsc{#{safe_text r["name"]}} (#{safe_text r["class"]})"
|
|
unless r["released"].nil?
|
|
d = to_date(r["released"])
|
|
hfill
|
|
puts "First released #{d.strftime("%B %Y")}"
|
|
end
|
|
endl
|
|
print_direct "\\textit{#{safe_text r["description"]}}"
|
|
unless r["url"].nil?
|
|
endl
|
|
url(r["url"])
|
|
end
|
|
unless r["metrics"].nil?
|
|
unless r["metricsasof"].nil?
|
|
endl
|
|
puts "As of #{r["metricsasof"]}, #{r["name"]} had "
|
|
else
|
|
puts "#{r["name"]} has "
|
|
end
|
|
|
|
metrics = r["metrics"].to_a.map do |m,v|
|
|
case m
|
|
when "sitevisits" then "#{safe_text v} unique website visitors"
|
|
when "downloads" then "#{safe_text v} unique downloads"
|
|
when "github" then v.to_a.map { |gh_m, gh_v| "#{gh_v.to_i} GitHub #{gh_m}" }
|
|
else puts "#{safe_text v} #{safe_text m}"
|
|
end
|
|
end.flatten
|
|
|
|
case metrics.length
|
|
when 0 then raise "Empty Metrics Field for #{r["name"]}"
|
|
when 1 then puts metrics[0]
|
|
when 2 then puts metrics.join(" and ")
|
|
else
|
|
metrics.push("and #{metrics.pop}")
|
|
puts metrics.join(", ")
|
|
end
|
|
end
|
|
end
|
|
) if args.fetch(:show_artifacts, true)
|
|
end
|
|
end
|
|
|
|
def render_students
|
|
make_section("Students Advised")
|
|
|
|
priority = ["PhD", "MS", "BS"]
|
|
|
|
|
|
students =
|
|
($db["lab/members"].values + $db["lab/alumni"].values).
|
|
where { |r| r["advisor"].nil? or r["joint_advisor"] }.
|
|
map { |r| [ (r["degree"] or r["status"]), r ] }.
|
|
map { |cat, r|
|
|
cat = cat.split("-")[0]
|
|
cat = cat.split(/, */).sort_by { |c| priority.index(c) }[0]
|
|
[cat, r]
|
|
}.
|
|
where { |cat, r| priority.include? cat }.
|
|
my_reduce { |cat, records| records.sort_by { |r| [(r["year"] or 100000), r["name"]] }}
|
|
|
|
render_student_list = proc { |cat, students|
|
|
current = students.where { |s| s["year"].nil? }.size
|
|
graduated = students.where { |s| s["year"] }.size
|
|
subsection!("#{cat} Students Advised (#{graduated} graduated, #{current} current)")
|
|
puts(
|
|
students.
|
|
map { |r|
|
|
comments = []
|
|
if r["year"]
|
|
comments.push("Graduated in #{r["year"]}")
|
|
else
|
|
comments.push("Current Student")
|
|
end
|
|
comments.push("Jointly advised with #{r["advisor"].oxford_comma}") if r["advisor"]
|
|
comments.push("Expected Graduation in #{r["expected"]}") if r["expected"]
|
|
|
|
"#{r["name"]} (#{comments.join("; ")})"
|
|
}.
|
|
join(", ")
|
|
)
|
|
}
|
|
|
|
render_student_list.call("PhD", students["PhD"])
|
|
render_student_list.call("MS", students["MS"])
|
|
render_student_list.call("BS", students["BS"])
|
|
|
|
theses = @data["thesis_committees"]
|
|
# Thesis Committees
|
|
subsection!("Thesis Committees (Excluding joint advisees; #{theses.size} graduated)")
|
|
puts(
|
|
theses.map { |r| "#{r["name"]} (#{r["date"]})" }.join(", ")
|
|
)
|
|
end
|
|
|
|
end |