JuanCanham/HackMyResume
1
0
Fork 0
mirror of https://github.com/JuanCanham/HackMyResume.git synced 2025-06-07 21:16:14 +01:00
Code Issues Releases Wiki Activity

Relocate internal sources to HackMyAPI.

Browse Source 
Move internal sources and related tests to:

https://github.com/hacksalot/HackMyAPI
This commit is contained in:
hacksalot
2016-01-24 09:55:04 -05:00
parent fa29f9794d
commit d3194fba19
61 changed files with 15 additions and 6109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
src/inspectors/gap-inspector.js
View File

@ -1,166 +0,0 @@
/**
Employment gap analysis for HackMyResume.
@license MIT. See LICENSE.md for details.
@module inspectors/gap-inspector
*/
(function() {
var _ = require('underscore');
var FluentDate = require('../core/fluent-date');
var moment = require('moment');
var LO = require('lodash');
/**
Identify gaps in the candidate's employment history.
*/
var gapInspector = module.exports = {
moniker: 'gap-inspector',
/**
Run the Gap Analyzer on a resume.
@method run
@return {Array} An array of object representing gaps in the candidate's
employment history. Each object provides the start, end, and duration of the
gap:
{ <-- gap
start: // A Moment.js date
end: // A Moment.js date
duration: // Gap length
}
*/
run: function( rez ) {
// This is what we'll return
var coverage = {
gaps: [],
overlaps: [],
duration: {
total: 0,
work: 0,
gaps: 0
},
pct: '0%'
};
// Missing employment section? Bye bye.
var hist = LO.get( rez, 'employment.history' );
if( !hist || !hist.length ) { return coverage; }
// Convert the candidate's employment history to an array of dates,
// where each element in the array is a start date or an end date of a
// job -- it doesn't matter which.
var new_e = hist.map( function( job ){
var obj = _.pick( job, ['start', 'end'] );
if( obj && (obj.start || obj.end)) {
obj = _.pairs( obj );
obj[0][1] = FluentDate.fmt( obj[0][1] );
if( obj.length > 1 )
obj[1][1] = FluentDate.fmt( obj[1][1] );
}
return obj;
});
// Flatten the array, remove empties, and sort
new_e = _.filter( _.flatten( new_e, true ), function(v) {
return ( v && v.length && v[0] && v[0].length );
});
if( !new_e || !new_e.length ) return coverage;
new_e = _.sortBy( new_e, function( elem ) { return elem[1].unix(); });
// Iterate over elements in the array. Each time a start date is found,
// increment a reference count. Each time an end date is found, decrement
// the reference count. When the reference count reaches 0, we have a gap.
// When the reference count is > 0, the candidate is employed. When the
// reference count reaches 2, the candidate is overlapped.
var num_gaps = 0, ref_count = 0, total_gap_days = 0, gap_start;
new_e.forEach( function(point) {
var inc = point[0] === 'start' ? 1 : -1;
ref_count += inc;
// If the ref count just reached 0, start a new GAP
if( ref_count === 0 ) {
coverage.gaps.push( { start: point[1], end: null });
}
// If the ref count reached 1 by rising, end the last GAP
else if( ref_count === 1 && inc === 1 ) {
var lastGap = _.last( coverage.gaps );
if( lastGap ) {
lastGap.end = point[1];
lastGap.duration = lastGap.end.diff( lastGap.start, 'days' );
total_gap_days += lastGap.duration;
}
}
// If the ref count reaches 2 by rising, start a new OVERLAP
else if( ref_count === 2 && inc === 1 ) {
coverage.overlaps.push( { start: point[1], end: null });
}
// If the ref count reaches 1 by falling, end the last OVERLAP
else if( ref_count === 1 && inc === -1 ) {
var lastOver = _.last( coverage.overlaps );
if( lastOver ) {
lastOver.end = point[1];
lastOver.duration = lastOver.end.diff( lastOver.start, 'days' );
if( lastOver.duration === 0 ) {
coverage.overlaps.pop();
}
}
}
});
// It's possible that the last gap/overlap didn't have an explicit .end
// date.If so, set the end date to the present date and compute the
// duration normally.
if( coverage.overlaps.length ) {
var o = _.last( coverage.overlaps );
if( o && !o.end ) {
o.end = moment();
o.duration = o.end.diff( o.start, 'days' );
}
}
if( coverage.gaps.length ) {
var g = _.last( coverage.gaps );
if( g && !g.end ) {
g.end = moment();
g.duration = g.end.diff( g.start, 'days' );
}
}
// Package data for return to the client
var tdur = rez.duration('days');
var dur = {
total: tdur,
work: tdur - total_gap_days,
gaps: total_gap_days
};
coverage.pct = ( dur.total > 0 && dur.work > 0 ) ?
((((dur.total - dur.gaps) / dur.total) * 100)).toFixed(1) + '%' :
'???';
coverage.duration = dur;
return coverage;
}
};
}());

98
src/inspectors/keyword-inspector.js
View File

@ -1,98 +0,0 @@
/**
Keyword analysis for HackMyResume.
@license MIT. See LICENSE.md for details.
@module keyword-inspector.js
*/
(function() {
var _ = require('underscore');
var FluentDate = require('../core/fluent-date');
/**
Analyze the resume's use of keywords.
TODO: BUG: Keyword search regex is inaccurate, especially for one or two
letter keywords like "C" or "CLI".
@class keywordInspector
*/
var keywordInspector = module.exports = {
/**
A unique name for this inspector.
*/
moniker: 'keyword-inspector',
/**
Run the Keyword Inspector on a resume.
@method run
@return An collection of statistical keyword data.
*/
run: function( rez ) {
// "Quote" or safely escape a keyword so it can be used as a regex. For
// example, if the keyword is "C++", yield "C\+\+".
// http://stackoverflow.com/a/2593661/4942583
function regex_quote(str) {
return (str + '').replace(/[.?*+^$[\]\\(){}|-]/ig, "\\$&");
}
// Create a searchable plain-text digest of the resume
// TODO: BUG: Don't search within keywords for other keywords. Job A
// declares the "foo" keyword. Job B declares the "foo & bar" keyword. Job
// B's mention of "foobar" should not count as a mention of "foo".
// To achieve this, remove keywords from the search digest and treat them
// separately.
var searchable = '';
rez.transformStrings( ['imp', 'computed', 'safe'], function trxString( key, val ) {
searchable += ' ' + val;
});
// Assemble a regex skeleton we can use to test for keywords with a bit
// more
var prefix = '(?:' + ['^', '\\s+', '[\\.,]+'].join('|') + ')';
var suffix = '(?:' + ['$', '\\s+', '[\\.,]+'].join('|') + ')';
return rez.keywords().map(function(kw) {
// 1. Using word boundary or other regex class is inaccurate
//
// var regex = new RegExp( '\\b' + regex_quote( kw )/* + '\\b'*/, 'ig');
//
// 2. Searching for the raw keyword is inaccurate ("C" will match any
// word containing a 'c'!).
//
// var regex = new RegExp( regex_quote( kw ), 'ig');
//
// 3. Instead, use a custom regex with special delimeters.
var regex_str = prefix + regex_quote( kw ) + suffix;
var regex = new RegExp( regex_str, 'ig');
var myArray, count = 0;
while ((myArray = regex.exec( searchable )) !== null) {
count++;
}
return {
name: kw,
count: count
};
});
}
};
}());

63
src/inspectors/totals-inspector.js
View File

@ -1,63 +0,0 @@
/**
Section analysis for HackMyResume.
@license MIT. See LICENSE.md for details.
@module totals-inspector.js
*/
(function() {
var _ = require('underscore');
var FluentDate = require('../core/fluent-date');
/**
Retrieve sectional overview and summary information.
@class totalsInspector
*/
var totalsInspector = module.exports = {
moniker: 'totals-inspector',
/**
Run the Totals Inspector on a resume.
@method run
@return An object containing summary information for each section on the
resume.
*/
run: function( rez ) {
var sectionTotals = { };
_.each( rez, function(val, key){
if( _.isArray( val ) && !_.isString(val) ) {
sectionTotals[ key ] = val.length;
}
else if( val.history && _.isArray( val.history ) ) {
sectionTotals[ key ] = val.history.length;
}
else if( val.sets && _.isArray( val.sets ) ) {
sectionTotals[ key ] = val.sets.length;
}
});
return {
totals: sectionTotals,
numSections: Object.keys( sectionTotals ).length
};
}
};
}());