Match Objects with Expressions

Use expression patterns to compare object values

Table of Contents

• ExMatch.js
  • Installation
  • Expressions
  • Configuration
  • Methods
    • Add Patterns
    • Match
    • Single Expression Match
    • Custom Selector and Comparer

  • Usage
    • Keystone dependsOn
    • Examples
  • Testing
  • History
  • License

Installation

npm install expression-match

Expressions

• add
• any
• eq
• gt
• gte
• in
• lt
• lte
• ne
• not
• or
• regex

Configuration

var ExMatch = require('expression-match');

var searchFields = {
    str1: 'string',
    str2: 'hello',
    str3: 'plug',
    str4: ['1','2'],
    num1: 1,
    num2: '2',
    num3: '3',
    check1:'true',
    check2: false,
    check3: undefined,
    check4: 0,
    check5: true,
    check6: 'false'
}
var patterns = {
    // true
    e1: { $or:[ { str1:['first','third'] } , {check1: 'true'} ] },
    e2: { $gt: { num3:1 }, $and:[{num1:'1'}, {str3: { or: ['cork','clog','plug'] } }, {num2:{$lt:4}}] },
    e3: { str2: ['hi', 'hello'], str3: { $regex: 'plu.*/i' } },
    e4: { num3: { $lte: 3 } },
    e5: { str1: [{ or: 'strings' }, { or: 'string'}] },
}

/* debug can be any truthy or 2 for compare only
 * @param {object} matchPatterns
 * @param {object} matchAgainst
 * @param {object/boolean} options - debug only when boolean 
 * */
 
// `options.expression` changes the default expression which is `$and`.  
var Match = new ExMatch( patterns.e2, searchFields, { debug: true, expression: '$and' });  

// debig messages only.  
var Match = new ExMatch( patterns.e3, searchFields, true);

Add Patterns

Each method returns this for chainability

Match.
    addSearchParams( patterns.e3 ).
    and( patterns.e1 ).
    any( patterns.e3 ).
    eq( { num1: 2, str2: 'hello' } )
    gt( [ { num1: 2 } ] ).
    gte( [ { num1: 2 }, { num2: 5 } ] ).
    in( { num1: ['2', '1'] } )
    lt( { num1: 2 } ).
    lte( { num1: 2 } ).
    ne( { num1: 2 } ).
    not( { str1: 'test' } ).
    regex( { str1: 'fir.*/i' } );

Match

Run all expression searches in the queue

Match.match()

Select Expression Match

Run a single Expression search from the queue

Match.regex({str2: { $regex: 'hel.*/i'}});
var ret = Match.$regex();

/* All return boolean true/false */
Match.$and();
Match.$any(); 
Match.$eq();
Match.$gt();
Match.$gte();
Match.$in();
Match.$lt();
Match.$lte();
Match.$ne();
Match.$not();
Match.$or();
Match.$regex();

Custom Selector and Comparer

in progress

###Usage

Keystone dependsOn

var Tester = new keystone.List('Tester');

var patterns = {
    earth: { $and:[ {str1:'earth'} , {check2:true} ] },
    and: { $lte:[ {num1:1} , {num3:4} ] },
    ice: { $gt:[{num3:1}],$and:[{num1:'1'},{sel1:['first','third']},{num2:{$lt:4}}] },
    water: { $or:[ {num1:{$gte:6}} , {num2:{$lte:4}} ] },
    fire: { sel1:'second',str3: {$regex: 'fir.*/i'} }
}

Tester.add({
}, 'Depends On', {
    isIce: { type: Boolean, label: 'Ice', dependsOn: patterns.ice},
    isFire: { type: Boolean, label: 'Fire' ,dependsOn: patterns.fire},
    isEarth: { type: Boolean, label: 'Earth', dependsOn: patterns.earth},
    isWater: { type: Boolean, label: 'Water', dependsOn: patterns.water},
    isAnd: { type: Boolean, label: 'And', dependsOn: patterns.and }

}, 'Show Dependants When', {

    sel1: { type: Types.Select, many: true, emptyOption: true },
    check1: { type: Boolean,  label: 'Check 1' , note:'earth ' },
    check2: { type: Boolean,  label: 'Check 2'  },
    num1: {type: Types.Number, note:'show `Water` when >= `6`  -- --  `<=1` == `And` with num3'  },
    num2: {type: Types.Number, note:'show `Water` when <= `4`'},
    num3: {type: Types.Number, note: '`<=4` show `And` with num1'  },
    str1: {type:String, note:'type earth with check2 to show `Earth`'},
    str2: String,
    str3: {type:String, note:'regex `fir*`  with `sel1`==`second` to show `Fire`'},
});

Tester.register();

Examples

var ExMatch = require('exmatch');

// Create a searchfield:value object and some test search objects
    searchFields = {
        str1: 'string',  str2: 'hello',  str3: 'plug',
        num1: 1,  num2: '2',  num3: '3', 
        check1:'true',  check2: false
    }
    
    var Match = new ExMatch({
        $or:[ {str1:['string1']}, {check1:'true'} ],
        num2:'2',
        num1:{ $lt:2 }
    },searchFields);
    var ret = Match.match();
    ==> true
    
    var m7 = new ExMatch({}, searchFields, 2);  //dubug on for compare only
    m7.
        and({check2:false}).
        any({check1:false}).
        any({ str2: { $regex: 'hel.*/i'} });
    var ret = m7.match();
    ==> true
    
    var Match = new ExMatch({ num2:{$eq:2} , $eq:{num3:'3'}, $eq:[{num1:'1'}] }, searchFields);
    var ret = Match.match();
    ==> false
    
    var Match = new ExMatch({ num2:{$eq:2} ,$eq:{num2:2}, $eq:[{num2:1}] } , searchFields);
    var ret = Match.match();
    ==> false
    
    var regex = new ExMatch({}, searchFields, true); //dubug on
    regex.regex({str2: { $regex: 'hel.*/i'}});
    var ret = regex.$regex();
    ==> true
   

Testing

Test file located in test dir

npm i -g mocha

npm test

License

MIT License