terrier-engine 4.67.2 → 4.67.3

package/app/assets/javascripts/terrier/strings.coffee

@@ -0,0 +1,381 @@
+
+window.puts = (args...) ->
+	window.console.log args...
+
+########################################################################################
+# Maths
+########################################################################################
+
+window.hashCode = (s) ->
+	hash = 0
+	i = 0
+	len = s.length
+	while ( i < len )
+		hash = ((hash << 5) - hash + this.charCodeAt(i++)) << 0
+	return hash
+
+String::hashCode = ->
+	window.hashCode this
+
+window.leftPad = (s, width) ->
+	s += ''
+	if s.length >= width
+		s
+	else
+		new Array(width - s.length + 1).join('0') + s
+
+
+########################################################################################
+# Formatting
+########################################################################################
+
+_upcaseValues = ['cod', 'csr', 'html', 'pdf', 'ach', 'eft', 'wdi', 'wdo', 'sds']
+_upcaseBlacklist = ['at', 'by', 'to', 'is', 'or', 'of']
+
+# capitalizes the first character or the first 2 if conditions allow
+window.capitalize = (s, upcase=true) ->
+	unless s?
+		return ''
+	if upcase and ((s.length < 3 and _upcaseBlacklist.indexOf(s) < 0) or _upcaseValues.indexOf(s)>-1)
+		return s.toUpperCase()
+	s && s[0].toUpperCase() + s.slice(1)
+
+String::capitalize = (upcase) ->
+	window.capitalize this, upcase
+
+# capitalizes every word
+window.titleize = (s, upcase) ->
+	unless s?
+		return ''
+	s = s.toString()
+	if s == '_state'
+		return s
+	comps = s.split(/[\s_-]/g)
+	capitalized = _.map comps, (c) -> window.capitalize(c, upcase)
+	capitalized.join ' '
+
+String::titleize = (upcase) ->
+	window.titleize this, upcase
+
+# converts the string to camel-case
+window.camelize = (s) ->
+	unless s?
+		return ''
+	s.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (match, chr) ->
+		chr.toUpperCase()
+	)
+
+String::camelize = ->
+	window.camelize this
+
+# convert to lower case and join with underscores
+window.underscore = (s) ->
+	unless s?
+		return ''
+	s = s.toString()
+	comps = s.split(/[\s_]/g)
+	lowecased = _.map comps, (c) -> c.toLowerCase()
+	lowecased.join('_')
+
+String::underscore = ->
+	window.underscore this
+
+window.withoutParens = (s) ->
+	unless s?
+		return ''
+	s.replace(/\(.+\)/g, '').trim()
+
+String::withoutParams = ->
+	window.withoutParens this
+
+window.formatCommas = (n) ->
+	"#{ n }".replace(/\B(?=(\d{3})+(?!\d))/g, ",") # add commas in the thousands places
+
+window.formatCents = (cents, showCents=true) ->
+	dollars = ''
+	sign = if cents < 0 then '-' else ''
+	if showCents == 'nonZero'
+		showCents = cents % 100
+	if showCents
+		dollars = "#{sign}$#{(Math.abs(cents) / 100.0).toFixed(2)}"
+	else
+		dollars = "$#{sign}#{(Math.abs(cents) / 100.0).toFixed(0)}"
+	window.formatCommas(dollars)
+
+Number::formatCommas = () ->
+	window.formatCommas this
+
+String::formatCommas = () ->
+	window.formatCommas this
+
+Number::formatCents = (showCents=true) ->
+	window.formatCents this, showCents
+
+String::formatCents = (showCents=true) ->
+	window.formatCents this, showCents
+
+window.formatDollars = (dollars, showCents=true) ->
+	window.formatCents(dollars*100, showCents)
+
+Number::formatDollars = (showCents=true) ->
+	window.formatDollars this, showCents
+
+String::formatDollars = (showCents=true) ->
+	window.formatDollars this, showCents
+
+window.formatMinutes = (minutes) ->
+	hours = Math.floor(minutes / 60)
+	if hours > 24
+		days = Math.floor(hours / 24)
+		hours = hours % 24
+		return "#{days}d #{hours}h"
+	mins = (minutes % 60).toFixed(0)
+	if hours > 0
+		"#{hours}h #{mins}m"
+	else
+		"#{mins}m"
+
+Number::formatMinutes = ->
+	window.formatMinutes this
+
+String::formatMinutes = ->
+	window.formatMinutes this
+
+# ensures that num is at least size wide, filling with zeros to the left
+window.zeroPad = (num, size) ->
+	s = num + ''
+	while (s.length < size)
+		s = '0' + s
+	s
+
+Number::zeroPad = (size) ->
+	window.zeroPad this, size
+
+String::zeroPad = (size) ->
+	window.zeroPad this, size
+
+# represents a number in thousands in a k at the end
+window.thousandize = (num) ->
+	abs = Math.abs(num)
+	if abs < 1000
+		return num.toFixed(0)
+	if abs < 10000
+		return (num/1000.0).toFixed(1) + 'k'
+	if abs < 1000000
+		return (num/1000.0).toFixed(0) + 'k'
+	(num/1000000.0).toFixed(2) + 'M'
+
+Number::thousandize = ->
+	window.thousandize this
+
+String::thousandize = ->
+	window.thousandize this
+
+window.formatPhone = (s) ->
+	if s.match(/^\d{10}$/) # no dashes or spaces
+		"#{s[0..2]}-#{s[3..5]}-#{s[6..9]}"
+	else
+		s.toString()
+
+String::formatPhone = ->
+	window.formatPhone this
+
+window.formatPhoneAndType = (phone, type) ->
+	s = window.formatPhone phone
+	if type?.length
+		"#{window.titleize(type)}: #{s}"
+	else
+		s
+
+String::formatPhoneAndType = (type) ->
+	window.formatPhoneAndType this, type
+
+window.formatEmails = (emails) ->
+	unless emails?.length
+		return ''
+	emails.split(window.emailSplitRegex).join(', ')
+
+String::formatEmails = ->
+	window.formatEmails this
+
+window.formatShortDate = (s) ->
+	unless s.endsWith('Z') or s.match(/-\d{2}:\d{2}$/)
+		s += ' UTC'
+	d = new Date(s)
+	"#{leftPad(d.getMonth()+1, 2)}/#{leftPad(d.getDate(), 2)}/#{d.getFullYear().toString().substring(2)}"
+
+String::formatShortDate = ->
+	window.formatShortDate this
+
+window.formatSortableDate = (s) ->
+	unless s.endsWith('Z') or s.match(/-\d{2}:\d{2}$/)
+		s += ' UTC'
+	d = new Date(s)
+	d.formatSortableDate()
+
+Date::formatSortableDate = ->
+	"#{this.getFullYear().toString()}-#{leftPad(this.getMonth()+1, 2)}-#{leftPad(this.getDate(), 2)}"
+
+String::formatSortableDate = ->
+	window.formatSortableDate this
+
+window.formatShortDateTime = (s) ->
+	unless s.endsWith('Z') or s.match(/-\d{2}:\d{2}$/)
+		s += ' UTC'
+	d = new Date(s)
+	s = "#{leftPad(d.getMonth()+1, 2)}/#{leftPad(d.getDate(), 2)}/#{d.getFullYear().toString().substring(2)} "
+	s + d.toLocaleTimeString()
+
+String::formatShortDateTime = ->
+	window.formatShortDateTime this
+
+window.formatShortTime = (s) ->
+	unless s.endsWith('Z') or s.match(/-\d{2}:\d{2}$/)
+		s += ' UTC'
+	d = new Date(s)
+	d.toLocaleTimeString()
+
+String::formatShortTime = ->
+	window.formatShortTime this
+
+
+########################################################################################
+# Singular/Plural
+########################################################################################
+
+# pluralize a word if num is greater than 1
+window.pluralize = (num, word) ->
+	if num.toString() == "1" or !word?
+		return word
+	lowerWord = word.toString().toLowerCase()
+	lastChar = lowerWord.charAt(lowerWord.length-1)
+	if lowerWord.endsWith('ice') or lastChar == 's'
+		return word
+	else if lastChar == 'h' and lowerWord != 'month'
+		return word + 'es'
+	else if lowerWord.endsWith('ey') or lowerWord.endsWith('ay')
+		return word + 's'
+	else if lastChar == 'y'
+		return lowerWord.substring(0, word.length-1) + 'ies'
+	else
+		return word + 's'
+
+String::pluralize = (num=2) ->
+	window.pluralize num, this
+
+# only singularizes the word if num is 1
+window.singularize = (num, word) ->
+	unless num.toString() == '1'
+		return word
+	if word.endsWith('ice')
+		word.replace('ice', 'ouse')
+	else if word.endsWith('lies')
+		word.replace('lies', 'ly')
+	else if word.endsWith('les')
+		word.replace('les', 'le')
+	else if word.endsWith('kes')
+		word.replace('kes', 'ke') # snakes
+	else if word.endsWith('es')
+		word.replace('es', '')
+	else if word.endsWith('s')
+		word.replace(/s$/, '')
+	else
+		word
+
+String::singularize = (num=1) ->
+	window.singularize num, this
+
+
+########################################################################################
+# Possessive Noun Apostrophe
+########################################################################################
+
+window.possessiveize = (s) ->
+	if s.endsWith('s') then s.replace(/s$/, "s'") else "#{s}'s"
+
+String::possessiveize = ->
+	window.possessiveize this
+
+
+########################################################################################
+# Words and Sentences
+########################################################################################
+
+# creates an abbreviation using the first letters of each word in s
+window.abbreviate = (s) ->
+	(for w in s.split(' ')
+		w.substring(0,2)).join('')
+
+String::abbreviate = ->
+	window.abbreviate this
+
+# joins the strings with commas in an englishy way (i.e. no comma for two, an 'and' for more than two)
+window.joinWithCommas = (comps) ->
+	if !comps? or comps.length == 0
+		return ''
+	if comps.length == 1
+		return comps[0]
+	if comps.length == 2
+		return comps.join(' and ')
+	comps = _.clone(comps)
+	comps[comps.length-1] = 'and ' + comps[comps.length-1]
+	comps.join(', ')
+
+Array::joinWithCommas = ->
+	window.joinWithCommas this
+
+# replace all newlines in the string with break tags
+window.newlinesToBreaks = (s) ->
+	(s || '').replace(/\n/g, "<br/>")
+
+String::newlinesToBreaks = ->
+	window.newlinesToBreaks this
+
+
+########################################################################################
+# Paragraphs
+########################################################################################
+
+# splits a string into paragraphs based on newlines
+window.splitParagraphs = (s) ->
+	s.split(/\n\n/g)
+
+String::splitParagraphs = ->
+	window.splitParagraphs this
+
+
+########################################################################################
+# Validations
+########################################################################################
+
+window.emailSplitRegex = /[\s,;]+/
+
+# validate an email address string
+window.validateEmail = (s) ->
+	regex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
+	regex.test(s)
+
+window.validateEmailLoosely = (email) ->
+	regex = /[^\s@]+@[^\s@]+\.[^\s;,@]+/
+	return regex.test(email)
+
+
+String::validateEmail = ->
+	window.validateEmail this
+
+String::validateEmailLoosely = ->
+	window.validateEmailLoosely this
+
+
+
+########################################################################################
+# Booleans
+########################################################################################
+
+_trueStrings = ['1', 'on', 'true']
+
+String::isTrue = ->
+	this? and _trueStrings.includes(this.toLowerCase())
+
+Boolean::isTrue = ->
+	this

package/app/assets/javascripts/terrier/tables.coffee

@@ -0,0 +1,116 @@
+window.tables = {}
+
+_numberRegex = /^(?=.)([+-]?([0-9]*)(\.([0-9]+))?)$/g # pos/neg integer/float
+
+################################################################################
+# Sortable
+################################################################################
+
+window.tables.initSortable = (ui = $(document), col = null, dir = null) ->
+	params = getUrlParams()
+	path = window.location.pathname
+	table = ui.find 'table.sortable'
+	key = table.data 'sortable-persistence-key'
+	[storedCol, storedDir] = if key?
+		window.localStorage.getItem("sortable:#{key}:#{path}")?.split(',') ? [null, null]
+	else
+		[null, null]
+
+	col = col ? params.sortable_col ? storedCol 
+	dir = dir ? params.sortable_dir ? storedDir
+	
+	return unless col && dir
+	table.find("th a[data-column=#{col}]").each (_, link) ->
+		window.tables.sortByColLink($(link), col, dir)
+
+# computes the sorting value using a) input values, b) data-column attributes, or c) the text of the cell
+_computeCellValue = (cell) ->
+# a) use input value
+	if cell.is 'select'
+		return cell.find('option:selected').text() # sort based on the selected option's text, not it's raw value
+	if cell.is 'input'
+		if cell[0].type == 'checkbox'
+			return (if cell[0].checked then '0' else '1') # reverse behavior for checkboxes so that checked appear first when ascending
+		val = cell.val()?.toString() || ''
+
+	# b) use col-value or column-value data attributes
+	else if typeof cell.data('column-value') != 'undefined'
+		val = cell.data('column-value')
+	else
+		val = cell.data('col-value')
+
+	# return float if this value is numeric (starts with numbers or decimal point)
+	floatVal = parseFloat(val)
+	if !_.isNaN(floatVal) && val.toString().match(_numberRegex)
+		return floatVal
+
+	# use string data value or c) use raw text
+	return _blanksLast(val || cell.text())
+
+# return a string likely to be sorted last if the value is blank
+# this is crude but it seems simpler than trying to mess with the sorting logic itself
+_blanksLast = (s) ->
+	if s?.length
+		s
+	else
+		Number.MAX_SAFE_INTEGER.toString()
+
+window.tables.sortByColLink = (link, col = null, dir = null) ->
+	window.setLinkLoading? link
+	table = link.parents 'table'
+
+	# need to let the loading animation start
+	{ promise, resolve } = Promise.withResolvers()
+	setTimeout(resolve, 5)
+	await promise
+	
+	unless col
+		col = link.data 'column'
+		urls.replaceParam 'sortable_col', col
+	unless dir
+		descOnly = table.hasClass 'desc-only'
+		dir = if descOnly or link.hasClass('asc')
+			'desc'
+		else
+			'asc'
+		urls.replaceParam 'sortable_dir', dir
+
+	# Save sort preferences
+	path = window.location.pathname
+	key = table.data 'sortable-persistence-key'
+	window.localStorage.setItem("sortable:#{key}:#{path}", [col, dir].join(',')) if key?
+
+	table.find('th a').removeClass('asc').removeClass('desc')
+	link.addClass dir
+
+	# sort the rows
+	t = performance.now()
+	rows = table.find('tbody tr').not('.always-top')
+	rows.sort (a, b) ->
+		aCol = $(a).find(".col-#{col}, .column-#{col}")
+		aVal = _computeCellValue aCol
+		bCol = $(b).find(".col-#{col}, .column-#{col}")
+		bVal = _computeCellValue bCol
+		comp = if aVal > bVal
+			1
+		else
+			-1
+		if dir == 'desc'
+			return -comp
+		comp
+	console.log "Sorted rows in #{(performance.now() - t).toFixed(2)} ms"
+
+	t = performance.now()
+	alwaysTopRow = table.find('tr.always-top')
+	if alwaysTopRow.length > 0
+		table.find('tbody').prepend(alwaysTopRow)
+	rows.detach().appendTo table.find('tbody')
+	table.find('tbody tr.total').detach().appendTo table.find('tbody')
+	console.log "Re-attached rows in #{(performance.now() - t).toFixed(2)} ms"
+	if window.unsetLinkLoading?
+		window.unsetLinkLoading link
+
+$(document).on 'click', 'table.sortable th a[data-column]', (evt) ->
+	evt.stopPropagation()
+	window.tables.sortByColLink($ this)
+	false

package/app/assets/javascripts/terrier/tiny-logger.coffee

@@ -0,0 +1,37 @@
+window.tinyLogger = {}
+
+_getTime = ->
+	date = new Date()
+	date.toLocaleTimeString().split(' ').join(".#{date.getMilliseconds().toString()} ") # show time with milliseconds
+
+_logTemplate = tinyTemplate (prefix, level, t, message) ->
+	div ".log.#{level}", ->
+		span '.prefix', "[#{prefix}]"
+		span '.level', level.toUpperCase()
+		span '.timestamp', t
+		span '.message', message
+
+window.tinyLogger.init = (object, options={}) ->
+	prefix = options.prefix || object.__proto__?.constructor?.name || 'TinyLogger'
+	output = null
+	if options.output?.length
+		output = $ options.output
+
+	log = (level, message, args...) ->
+		t = _getTime()
+		s = "[#{prefix} #{level.toUpperCase()} #{t}] #{message}"
+		console[level] s, args...
+		if output
+			output.append _logTemplate(prefix, level, t, message)
+
+	object.debug = (m, args...) ->
+		log 'debug', m, args...
+
+	object.info = (m, args...) ->
+		log 'info', m, args...
+
+	object.warn = (m, args...) ->
+		log 'warn', m, args...
+
+	object.error = (m, args...) ->
+		log 'error', m, args...