6 |
7 | 
9 |
10 | 
12 |
13 | 
15 |
16 | 
18 |
19 | 
20 |
21 | 
22 |
23 |
4 |
6 |
7 |
9 |
10 |
12 |
13 |
15 |
16 |
18 |
19 |
20 |
21 |
22 |
23 |
26 | 
28 |
34 | 
35 |
251 |
252 | Questions or comments can also be posted on the nl3 Github issues page.
253 |
254 | ### Maintainers
255 | Hector Gray (Twitter: @defstream)
256 |
257 | ### Contribute
258 | Pull Requests welcome. Please make sure all tests pass:
259 |
260 | ```shell
261 | $ npm test
262 | ```
263 |
264 | Please submit Github issues for any feature enhancements, bugs or documentation problems.
265 |
266 | ### License
267 | MIT
268 |
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 |
4 | 'use strict';
5 |
6 | var parse = require('./lib/parse');
7 | var rules = require('./lib/rules-engine');
8 | /** @exports nl3 **/
9 | var nl3 = {
10 | //@function
11 | /**
12 | * @name parse
13 | * @description Returns a triple based on language used.
14 | * @access public
15 | * @returns {Object}
16 | * @example nl3.parse('users who follow user 42') // returns...
17 | * // {
18 | * // subject: {
19 | * // type: 'user',
20 | * // value: undefined
21 | * // },
22 | * // predicate: {
23 | * // value: 'follow'
24 | * // },
25 | * // object: {
26 | * // type: 'user',
27 | * // value: '42'
28 | * // }
29 | * // }
30 | */
31 | parse: parse
32 | };
33 |
34 | /**
35 | * @param {Object} options The options required for parsing triples
36 | * @param {Object} options.grammar A set of valid triple relations.
37 | * @param {Object} options.vocabulary Extend the known vocabulary by mapping a word stem to a predicate.
38 | * @return {Object} An instance of the nl3 client.
39 | */
40 | module.exports = function create(options) {
41 | //@info triple rules
42 | var tream = rules({
43 | //@info defined triples
44 | grammar: options.grammar || [],
45 | //@info an additional set of words that map to our items with our original grammar
46 | vocabulary: options.vocabulary || {}
47 | });
48 | //@info create & return the new instance
49 | var instance = Object.create(nl3, {
50 | rules: {
51 | enumerable: true,
52 | value: tream
53 | }
54 | });
55 |
56 | return instance;
57 | };
58 |
--------------------------------------------------------------------------------
/lib/first.js:
--------------------------------------------------------------------------------
1 | /**
2 | * returns the first item in an array
3 | * @param {Array} array The array to return the first item from.
4 | * @return {*} The value of the first item in the array or undefined.
5 | */
6 | module.exports = function first(array) {
7 | return array[0];
8 | }
9 |
--------------------------------------------------------------------------------
/lib/object/index.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var objectType = require('./type');
6 | var objectValue = require('./value');
7 |
8 | /**
9 | * Given the parts of speech, this returns an objects type & value.
10 | * @param {Object} parts The parts of speech.
11 | * @return {Object} The parsed objects type & value.
12 | */
13 | module.exports = function object(parts) {
14 | return {
15 | type: objectType(parts),
16 | value: objectValue(parts)
17 | };
18 | };
19 |
--------------------------------------------------------------------------------
/lib/object/type.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var singularize = require('../text/singularize');
6 |
7 | /**
8 | * Given the parts of speech, this returns an objects type.
9 | * @param {Object} parts The parts of speech.
10 | * @return {String} The object type
11 | */
12 | module.exports = function objectType(parts) {
13 | return parts.objects.objects[0] || parts.subjects.subjects[0];
14 | };
15 |
--------------------------------------------------------------------------------
/lib/object/value.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var first = require('../first');
6 |
7 | /**
8 | * Given the parts of speech, this returns an objects value.
9 | * @param {Object} parts The parts of speech.
10 | * @return {String} The objects value.
11 | */
12 | module.exports = function objectValue(parts) {
13 | return first(
14 | parts.objects.after.map(first).concat(
15 | parts.objects.before.map(first)
16 | )
17 | );
18 | };
19 |
--------------------------------------------------------------------------------
/lib/parse.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var triple = require('./triple');
6 | var classify = require('./text/classify');
7 |
8 | /**
9 | * parse - parses text into a triple.
10 | * @memberof nl3
11 | * @param {String} text The text to parse.
12 | * @return {Object} The parsed triple.
13 | */
14 | module.exports = function parse(text, callback) {
15 | if (typeof text !== 'string' || !text.trim()) {
16 | var err = new Error(
17 | 'The supplied text could not be parsed into a triple. value: ' + text
18 | );
19 | if (callback) {
20 | return callback(err);
21 | }
22 | throw err;
23 | }
24 | var classification = classify(text);
25 | var trip = triple(
26 | classification,
27 | this.rules
28 | );
29 | return this.rules.process({
30 | triple: trip,
31 | classification: classification
32 | },
33 | callback
34 | );
35 | };
36 |
--------------------------------------------------------------------------------
/lib/predicate/index.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var predicateType = require('./type');
6 | var predicateValue = require('./value');
7 |
8 | /**
9 | * Given the parts of speech, this returns an predicates type & value.
10 | * @param {Object} parts The parts of speech.
11 | * @return {Object} The parsed predicate.
12 | */
13 | module.exports = function predicate(parts, predicates) {
14 | return {
15 | type: predicateType(parts),
16 | value: predicateValue(parts, predicates)
17 | };
18 | };
19 |
--------------------------------------------------------------------------------
/lib/predicate/type.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | /**
6 | * Given the parts of speech, this returns an predicates type.
7 | * @return {undefined}
8 | */
9 | module.exports = function predicateType(pars) {
10 | //@info not yet implemented.
11 | return undefined;
12 | };
13 |
--------------------------------------------------------------------------------
/lib/predicate/value.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var singularize = require('../text/singularize');
6 |
7 | var predicate = require('../rules-engine/parse/predicate')
8 | /**
9 | * Given the parts of speech, this returns an predicates value.
10 | * @param {Object} classification The classification of the text
11 | * @param {Object} rules The known triple rules
12 | * @return {String} The value of the first predicate
13 | */
14 | module.exports = function predicateValue(parts, predicates) {
15 | return parts && parts.predicate && parts.predicate[0] && predicate(
16 | parts.predicate[0], predicates
17 | );
18 | };
19 |
--------------------------------------------------------------------------------
/lib/rules-engine/flip/index.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 | var lastPredicate = require('../parse/last-predicate');
5 | /**
6 | * Determines if the "source" triple is valid against the target "rules"
7 | * @access private
8 | * @param {Object} source The source triple to validate.
9 | * @param {Object} target The target rules to validate against.
10 | * @return {Boolean} True if this triple abides by the rules, otherwise false.
11 | */
12 | function itAbides(source, target) {
13 | var subject = target.subjects[source.subject.type];
14 | var predicate = subject && subject.predicates && subject.predicates[source.predicate
15 | .value];
16 | var object = predicate && predicate.objects;
17 |
18 | if (subject && predicate && object.indexOf(source.object.type) > -1) {
19 | return true;
20 | }
21 | return false;
22 | }
23 |
24 | /**
25 | * Flip - Triple Flip
26 | * @type {Object}
27 | */
28 | module.exports = {
29 | /**
30 | * Returns true if the triple should be flipped, as determined by the rules. Otherwise false.
31 | * @param {Object} triple The triple to analyze
32 | * @param {Object} rules The rules to use during analyzation
33 | * @return {Boolean} True if the triple should be flipped, otherwise false.
34 | */
35 | able: function flippable(options) {
36 | var triple = options.triple;
37 | var rules = options.rules;
38 |
39 | if (itAbides(triple, rules) === false) {
40 | return itAbides({
41 | subject: triple.object,
42 | predicate: triple.predicate,
43 | object: triple.subject
44 | }, rules) || itAbides({
45 | subject: triple.object,
46 | predicate: {
47 | type: undefined,
48 | value: lastPredicate(options.classification, rules),
49 | },
50 | object: triple.subject
51 | }, rules) || undefined; //@info returns null if this triple is not valid in either direction.
52 | }
53 | return false;
54 | },
55 | /**
56 | * it - flips the subject and object of a triple
57 | * @param {Object} triple The triple to flip
58 | * @return {Object} The flipped triple
59 | */
60 | it: function flip(options) {
61 | var triple = options.triple;
62 | return {
63 | subject: triple.object,
64 | predicate: {
65 | type: undefined,
66 | value: lastPredicate(options.classification, options.rules),
67 | },
68 | object: triple.subject
69 | };
70 | }
71 | };
72 |
--------------------------------------------------------------------------------
/lib/rules-engine/index.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var flip = require('./flip');
6 | var processRules = require('./rules-processor');
7 | var parse = {
8 | rules: require('./parse/rules')
9 | };
10 |
11 | /**
12 | * creates an instance of a triple rules engine.
13 | * @param {Object} options The options for this rules engine.
14 | * @param {Object} options.grammar A set of valid triple relations.
15 | * @param {Object} options.vocabulary Extend the known vocabulary by mapping a word stem to a predicate.
16 | * @return {Object) The rules engine.
17 | */
18 | module.exports = function rulesEngine(options) {
19 | //@info extract the grammar
20 | var grammar = [].concat(options.grammar || []);
21 |
22 | //@info build the rules engine
23 | var rules = grammar.reduce(parse.rules, {
24 | subjects: {},
25 | predicates: [],
26 | objects: {}
27 | });
28 |
29 | //@property {Function} process - validates & transforms the triple if necessary.
30 | Object.defineProperty(rules, 'process', {
31 | value: processRules(rules)
32 | });
33 |
34 | //@property {Object} vocabulary - contains properties that are stem words, which map to defined predicates.
35 | Object.defineProperty(rules, 'vocabulary', {
36 | enumerable: true,
37 | value: options.vocabulary || {}
38 | });
39 |
40 | //@info return the created engine.
41 | return rules;
42 | };
43 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/first-non-predicate.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var parsePredicate = require('./predicate');
6 |
7 | /**
8 | * firstNonPredicate returns the first non predicate in array of strings, the extended vocabulary from the grammar rules are also applied.
9 | * @param {Array} tokens An array of strings from a query.
10 | * @param {Object} rules The grammar rules..
11 | * @return {String} The first found predicate, or undefined.
12 | */
13 | module.exports = function firstNonPredicate(tokens, rules) {
14 | var i = 0;
15 | var predicate;
16 | for (i = 0; i < tokens.length; i = i + 1) {
17 | predicate = parsePredicate(tokens[i], rules.vocabulary);
18 | if (!predicate) {
19 | return tokens[i];
20 | }
21 | }
22 | };
23 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/first-predicate.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var parsePredicate = require('./predicate');
6 |
7 | /**
8 | * firstPredicate returns the first predicate from an array of strings, using the vocabulary of the specified grammar rules.
9 | * @param {Object} classification The classification of the text
10 | * @param {Object} rules The known triple rules
11 | * @return {String} The first string that is a predicate from the array of tokens.
12 | */
13 | module.exports = function firstPredicate(classification, rules) {
14 | var tokens = classification.parts.map(function(part) {
15 | return part[0]
16 | });
17 | var i = 0;
18 | var predicate;
19 | for (i = 0; i < tokens.length; i = i + 1) {
20 | predicate = parsePredicate(tokens[i], rules.vocabulary);
21 | if (predicate) {
22 | return {
23 | index: i,
24 | value: predicate
25 | };
26 | }
27 | }
28 | return undefined;
29 | };
30 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/last-predicate.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var parsePredicate = require('./predicate');
6 |
7 | /**
8 | * lastPredicate returns the last predicate from an array of strings, using the vocabulary of the specified grammar rules.
9 | * @param {Object} classification The classification of the text
10 | * @param {Object} rules The known triple rules
11 | * @return {String} The last string that is a predicate from the array of tokens.
12 | */
13 | module.exports = function lastPredicate(classification, rules) {
14 | var tokens = classification.parts.map(function(part) {
15 | return part[0]
16 | });
17 | var i = 0;
18 | var predicate;
19 | for (i = tokens.length - 1; i < -1; i = i - 1) {
20 | predicate = parsePredicate(tokens[i], rules.vocabulary);
21 | if (predicate) {
22 | return {
23 | index: i,
24 | value: predicate
25 | };
26 | }
27 | }
28 | return undefined;
29 | };
30 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/objects.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | /**
6 | * Properly stores the subject, predicate and object, within the ruleset.
7 | * @param {Object} rules The ruleset.
8 | * @param {String} subject The subject to include into the rulset.
9 | * @param {String} predicate The predicate to include into the rulset.
10 | * @param {String} object The object to include into the rulset.
11 | * @return {Object} The updated ruleset.
12 | */
13 | module.exports = function includeObjects(rules, subject, predicate, object) {
14 | if (!rules.objects[object]) {
15 | rules.objects[object] = {
16 | predicates: {}
17 | };
18 | }
19 |
20 | var predicates = rules.objects[object].predicates[predicate];
21 |
22 | if (!predicates) {
23 | predicates = rules.objects[object].predicates[predicate] = {
24 | subjects: [subject]
25 | };
26 | }
27 |
28 | return rules;
29 | };
30 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/parts.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 | var reduceParts = require('./reduce-parts');
5 | var firstPredicate = require('./first-predicate');
6 | /**
7 | * Given classification and a rule set parse the parts of speach.
8 | * @param {Object} classification The classification of the text
9 | * @param {Object} rules The known triple rules
10 | * @return {String} The mapped predicate.
11 | */
12 | module.exports = function parts(classification, rules) {
13 | var predicate = firstPredicate(classification, rules);
14 | var predicateIndex = predicate && predicate.index || undefined;
15 | var prepositionIndex = classification.parts.reduce(function(result, part) {
16 | if (part[1] === 'IN') {
17 | result.found = true
18 | }
19 | if (!result.found) {
20 | result.index = result.index + 1;
21 | }
22 | return result;
23 | }, {
24 | index: 0,
25 | found: false
26 | }).index;
27 |
28 | var index = predicate && predicate.index
29 | var beforePredicate = index && classification.parts.slice(0, index) || [];
30 | var afterPredicate = index && classification.parts.slice(index + 1) || [];
31 |
32 | return {
33 | objects: reduceParts(afterPredicate, rules),
34 | subjects: reduceParts(beforePredicate, rules),
35 | predicate: predicate && classification.parts[predicate.index] || undefined
36 | };
37 | };
38 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/predicate.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var stemmer = require('stemmer');
6 | var singularize = require('../../text/singularize');
7 |
8 | /**
9 | * Given text and a array mapping of predicates, returns the mapped predicate.
10 | * @param {String} text The text to map to a predicate.
11 | * @param {Object} predicates An object whose keys are word stems and values are predicates that have been defined within the grammar.
12 | * @return {String} The mapped predicate.
13 | */
14 | module.exports = function mapPredicate(text, predicates) {
15 | var predicate = stemmer(
16 | singularize(text)
17 | );
18 | return predicates && predicates[predicate] || undefined;
19 | };
20 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/reduce-parts.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var firstPredicate = require('./last-predicate');
6 | var singularize = require('../../text/singularize');
7 | /**
8 | * Given an array of strings, identifies valid objects or subjects in the order they occur.
9 | * @param {Array} data An array of tokenized strings.
10 | * @param {Object} rules The known triple rules.
11 | * @return {String} The mapped predicate.
12 | */
13 | module.exports = function reduceParts(data, rules) {
14 | var parts = {
15 | objects: [],
16 | subjects: [],
17 | before: [],
18 | after: []
19 | };
20 | return data && data.reduce(function(result, part) {
21 | var normalizedPart = singularize(part[0]);
22 | var added = false;
23 | if (rules.objects[normalizedPart]) {
24 | result.objects.push(normalizedPart);
25 | added = true;
26 | }
27 | if (rules.subjects[normalizedPart]) {
28 | result.subjects.push(normalizedPart);
29 | added = true;
30 | }
31 | if (!added && part[1] !== 'IN' && part[1][0] !== 'W') {
32 | if (!result.subjects.length && !result.objects.length) {
33 | result.before.push(part);
34 | } else {
35 | result.after.push(part);
36 | }
37 | }
38 | return result;
39 | }, parts) || parts;
40 | };
41 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/reduce-predicates.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | /**
6 | * reducePredicates reduces the predicates from an array into the grammar rules.
7 | * If a predicate is found to be a member of the grammar rules, it is added as a predicate.
8 | * @param {Object} rules The grammar rules.
9 | * @param {String} predicate The predicate to attempt to parse.
10 | * @return {Object} rules The grammar rules.
11 | */
12 | module.exports = function reducePredicates(rules, predicate) {
13 | if (rules.predicates.indexOf(predicate) === -1) {
14 | rules.predicates.push(predicate);
15 | }
16 | return rules;
17 | };
18 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/rules.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var parseSubjects = require('./subjects');
6 | var parsePredicates = require('./reduce-predicates');
7 | var parseObjects = require('./objects');
8 | var singularize = require('../../text/singularize');
9 |
10 | /**
11 | * parses the grammar rules from a string array.
12 | * @param {Object} ruleset The ruleset to apply the parsed grammar rules to.
13 | * @param {Array} data An array of strings representing the grammar rules.
14 | * @return {Object} The parsed grammar rules.
15 | */
16 | module.exports = function rules(ruleset, data) {
17 | data = data.toString().split(' ');
18 |
19 | var subject = singularize(data[0]);
20 | var predicate = singularize(data[1]);
21 | var object = singularize(data[2]);
22 |
23 | ruleset = parseSubjects(ruleset, subject, predicate, object);
24 | ruleset = parsePredicates(ruleset, predicate);
25 | ruleset = parseObjects(ruleset, subject, predicate, object);
26 |
27 | return ruleset;
28 | };
29 |
--------------------------------------------------------------------------------
/lib/rules-engine/parse/subjects.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | /**
6 | * Properly stores the subject, predicate and object, within the ruleset.
7 | * @param {Object} rules The ruleset.
8 | * @param {String} subject The subject to include into the rulset.
9 | * @param {String} predicate The predicate to include into the rulset.
10 | * @param {String} object The object to include into the rulset.
11 | * @return {Object} The updated ruleset.
12 | */
13 | module.exports = function includeSubjects(rules, subject, predicate, object) {
14 | if (!rules.subjects[subject]) {
15 | rules.subjects[subject] = {
16 | predicates: {}
17 | };
18 | }
19 |
20 | var predicates = rules.subjects[subject].predicates[predicate];
21 |
22 | if (!predicates) {
23 | predicates = rules.subjects[subject].predicates[predicate] = {
24 | objects: [object]
25 | };
26 | }
27 |
28 | return rules;
29 | };
30 |
--------------------------------------------------------------------------------
/lib/rules-engine/rules-processor.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var flip = require('./flip');
6 |
7 | /**
8 | * Evaluates and returns triple, resolves any issues if necessary. An error is thrown if the triple is invalid.
9 | * @param {Object} triple The triple to process
10 | * @param {Function} callback The callback used to handle the result.
11 | */
12 | module.exports = function rulesProcessor(rules) {
13 | return function processRules(options, callback) {
14 | var triple = options.triple;
15 | var classification = options.classification;
16 | var opts = {
17 | triple: triple,
18 | classification: classification,
19 | rules: rules
20 | };
21 | var shouldFlip = flip.able(opts); //@info returns null if invalid.
22 | if (shouldFlip === true) {
23 | triple = flip.it(opts);
24 | return (callback && callback(null, triple)) || triple;
25 | }
26 | if (shouldFlip === false) {
27 | return (callback && callback(null, triple)) || triple;
28 | }
29 | //@info if we've received null, then return error.
30 | var err = new Error('Invalid triple:\n' + JSON.stringify(triple, null,
31 | ' '));
32 | if (callback) {
33 | return callback(err, triple);
34 | }
35 | throw err;
36 | };
37 | };
38 |
--------------------------------------------------------------------------------
/lib/subject/index.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var subjectType = require('./type');
6 | var subjectValue = require('./value');
7 |
8 | /**
9 | * Given the parts of speech, this returns an subjects type & value.
10 | * @param {Object} parts The parts of speech.
11 | * @return {Object} The parsed subjects type & value.
12 | */
13 | module.exports = function subject(parts) {
14 | return {
15 | type: subjectType(parts),
16 | value: subjectValue(parts)
17 | };
18 | };
19 |
--------------------------------------------------------------------------------
/lib/subject/type.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var singularize = require('../text/singularize');
6 |
7 | /**
8 | * Given the parts of speech, this returns an subjects type.
9 | * @param {Object} parts The parts of speech.
10 | * @return {String} The subject type
11 | */
12 | module.exports = function subjectType(parts) {
13 | return parts.subjects.subjects[0] || parts.subjects.objects[0];
14 | };
15 |
--------------------------------------------------------------------------------
/lib/subject/value.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var first = require('../first');
6 |
7 | /**
8 | * Given the parts of speech, this returns an subjects value.
9 | * @param {Object} parts The parts of speech.
10 | * @return {String} The subjects value.
11 | */
12 | module.exports = function subjectValue(parts) {
13 | return first(
14 | parts.subjects.after.map(first).concat(
15 | parts.subjects.before.map(first)
16 | )
17 | );
18 | };
19 |
--------------------------------------------------------------------------------
/lib/text/classify.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var pos = require('pos');
6 | var speakEasy = require('speakeasy-nlp');
7 |
8 | var lexer = new pos.Lexer();
9 | var tagger = new pos.Tagger();
10 |
11 | /**
12 | * Classifys the text within a given query ( identifies, nouns, subjects, verbs etc...).
13 | * @param {String} text The text to classify.
14 | * @return {Object} The text classification.
15 | */
16 | module.exports = function classify(text) {
17 | //@info classify the text within the text
18 | var classification = speakEasy.classify(text);
19 | classification.parts = tagger.tag(
20 | lexer.lex(text)
21 | );
22 | classification.text = text.trim();
23 | classification.value = parse(text);
24 | return classification;
25 | };
26 |
27 |
28 | function tag(text) {
29 | return tagger.tag(
30 | lexer.lex(text)
31 | );
32 | }
33 |
34 | function parse(text) {
35 | var parts = tag(text).reduce(function(result, tag) {
36 | if (tag[1] !== 'IN' && (tag[1][tag[1].length - 1] === 'N' || tag[1][0] === 'N') || tag[1] === 'CD') {
37 | if (!result.predicate.length) {
38 | result.subject = result.subject.concat(tag[0]);
39 | } else {
40 | result.object = result.object.concat(tag[0]);
41 | }
42 | }
43 | if (tag[1][0] === 'V') {
44 | if (!result.predicate.length) {
45 | result.predicate = result.predicate.concat(tag[0]);
46 | }
47 | }
48 | return result;
49 | }, {
50 | subject: [],
51 | predicate: [],
52 | object: []
53 | });
54 | return format(parts);
55 | }
56 |
57 |
58 | function format(parts) {
59 |
60 | if (parts.subject.length > 2 && !parts.object.length) {
61 | parts.object = parts.subject.splice(0, 1);
62 | }
63 | return {
64 | subject: {
65 | type: parts.subject[0],
66 | value: parts.subject[1]
67 | },
68 | predicate: {
69 | type: parts.predicate[1],
70 | value: parts.predicate[0]
71 | },
72 | object: {
73 | type: parts.object[0],
74 | value: parts.object[1]
75 | }
76 | };
77 | }
78 |
--------------------------------------------------------------------------------
/lib/text/is/plural.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var singularize = require('../singularize');
6 |
7 | /**
8 | * Returns true if the text is pluralized.
9 | * @param {String} text
10 | * @return {Boolean}
11 | */
12 | module.exports = function isPlural(text) {
13 | var textEndsWithS = text[text.length - 1].toLowerCase() === 's';
14 | var textMatchesSingularForm = text.toLowerCase() !== singularize(text).toLowerCase();
15 |
16 | if (textMatchesSingularForm || textEndsWithS) {
17 | return true;
18 | }
19 |
20 | return false;
21 | };
22 |
--------------------------------------------------------------------------------
/lib/text/singularize.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var singular = require('pluralize').singular;
6 |
7 | /**
8 | * Given text, returns the singularized form. ie: cats => cat.
9 | * @param {String} text [description]
10 | * @return {String} [description]
11 | */
12 | module.exports = function singularize(text) {
13 | //@info if text exists, return the singularized form, otherwise return the input.
14 | return (text && singular(text)) || text;
15 | };
16 |
--------------------------------------------------------------------------------
/lib/triple.js:
--------------------------------------------------------------------------------
1 | /*jslint node: true */
2 | /*global module, require*/
3 | 'use strict';
4 |
5 | var object = require('./object');
6 | var subject = require('./subject');
7 | var predicate = require('./predicate');
8 |
9 | var parseParts = require('./rules-engine/parse/parts');
10 |
11 | /**
12 | * Given a classification and a ruleset - returns a triple.
13 | * @param {Array} grammar A list of possible triples.
14 | * @param {Object} vocabulary Extend the known vocabulary by mapping a word stem to a predicate.
15 | * @return {Object} The parsed triple.
16 | */
17 | module.exports = function triple(classification, rules) {
18 | var parts = parseParts(classification, rules);
19 | return {
20 | subject: subject(parts),
21 | predicate: predicate(parts, rules.vocabulary),
22 | object: object(parts)
23 | };
24 | };
25 |
--------------------------------------------------------------------------------
/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/defstream/nl3/418f58b112b35c9108bb3a8c03332b9f1f45907c/logo.png
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "nl3",
3 | "version": "0.0.3",
4 | "description": "nl3 - natural language triples",
5 | "license": "MIT",
6 | "author": "Hector Gray