├── .eslintignore
├── .npmignore
├── .codeclimate.yml
├── .eslintrc.json
├── .travis.yml
├── .babelrc
├── modules
    ├── index.js
    ├── parser.js
    ├── methods
    │   ├── inspectTags.js
    │   ├── inspectSiblings.js
    │   ├── index.js
    │   ├── inspectSpecialAttributes.js
    │   ├── validationHelpers.js
    │   ├── inspectElementID.js
    │   ├── inspectNthChild.js
    │   └── inspectNthChild.test.js
    ├── exposeOnWindow.js
    ├── convertSelectorStateIntoCSSSelector.js
    ├── stackHierarchy.js
    ├── validateSelector.js
    ├── parser.test.js
    ├── configuration.js
    ├── convertSelectorStateIntoCSSSelector.test.js
    ├── stackHeirarchy.test.js
    ├── queryEngine.test.js
    ├── queryEngine.js
    └── simmer.js
├── __tests__
    ├── server.js
    ├── integration
    │   ├── utils.js
    │   ├── fixture.js
    │   └── index.test.js
    └── e2e
    │   ├── test.html
    │   └── index.js
├── .gitignore
├── LICENSE
├── rollup.config.js
├── package.json
├── nightwatch.conf.js
├── README.md
└── dist
    └── simmer.js


/.eslintignore:
--------------------------------------------------------------------------------
1 | **/lib/*.js
2 | **/lib/**/*.js
3 | **/dist/*.js


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | *.log
3 | modules/**/*.test.js
4 | __tests__


--------------------------------------------------------------------------------
/.codeclimate.yml:
--------------------------------------------------------------------------------
1 | languages:
2 |   JavaScript: true
3 | exclude_paths:
4 | - "node_modules"
5 | 


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "standard",
3 |   "plugins": [
4 |     "jest"
5 |   ],
6 |   "env": {
7 |     "jest/globals": true
8 |   }
9 | }


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |     - "node"
4 | sudo: false
5 | install:
6 |     - npm install
7 | script:
8 |     - npm test
9 | 


--------------------------------------------------------------------------------
/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "presets": [
 3 |     "es2015",
 4 |     "es2016"
 5 |   ],
 6 |   "plugins": [
 7 |     "transform-object-rest-spread"
 8 |   ]
 9 | }
10 | 


--------------------------------------------------------------------------------
/modules/index.js:
--------------------------------------------------------------------------------
1 | /* global window, document */
2 | import simmer from './simmer'
3 | import exposeOnWindow from './exposeOnWindow'
4 | 
5 | exposeOnWindow(window, simmer(window))
6 | 


--------------------------------------------------------------------------------
/modules/parser.js:
--------------------------------------------------------------------------------
 1 | export default function Parser (parsingMethods) {
 2 |   const queue = parsingMethods.getMethods()
 3 |   return {
 4 |     finished () {
 5 |       return queue.length === 0
 6 |     },
 7 |     next (...args) {
 8 |       if (this.finished()) {
 9 |         return false
10 |       }
11 |       return queue.shift()(...args)
12 |     }
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/__tests__/server.js:
--------------------------------------------------------------------------------
 1 | function makeServer(done = () => {}) {
 2 |   var express = require('express');
 3 |   var path = require('path');
 4 |   var app = express();
 5 | 
 6 |   app.get('/', function (req, res) {
 7 |   	res.status(200).sendFile(`__tests__/e2e/test.html`, {root: path.resolve()});
 8 |   });
 9 |   app.get('/simmer.js', function (req, res) {
10 |   	res.status(200).sendFile(`dist/simmer.js`, {root: path.resolve()});
11 |   });
12 |   var server = app.listen(3993, function () {
13 |   	var port = server.address().port;
14 |   	done()
15 |   });
16 |   return server;
17 | }
18 | module.exports = makeServer;
19 | 


--------------------------------------------------------------------------------
/modules/methods/inspectTags.js:
--------------------------------------------------------------------------------
 1 | import { tagName } from './validationHelpers'
 2 | 
 3 | /**
 4 | /**
 5 |  * Inspect the elements' Tag names and add them to the calculates CSS selector
 6 |  * @param {array} hierarchy. The hierarchy of elements
 7 |  * @param {object} state. The current calculated CSS selector
 8 |  */
 9 | export default function (hierarchy, state) {
10 |   return hierarchy.reduce((selectorState, currentElem, index) => {
11 |     ;[currentElem.el.nodeName].filter(tagName).forEach(tagName => {
12 |       selectorState.stack[index].splice(0, 0, tagName)
13 |       selectorState.specificity += 10
14 |     })
15 |     return selectorState
16 |   }, state)
17 | }
18 | 


--------------------------------------------------------------------------------
/modules/exposeOnWindow.js:
--------------------------------------------------------------------------------
 1 | export default function (windowScope, simmerInstance) {
 2 |   // Save the previous value of the `simmer` variable.
 3 |   let conflictedSimmer = windowScope.Simmer
 4 |   windowScope.Simmer = simmerInstance
 5 | 
 6 |   /**
 7 |    * Revert the global window.simmer variable to it's original value and return this simmer object.
 8 |    * This allows users to include multiple versions of Simmer objects on a single page.
 9 |    * @example
10 |    <code><pre>
11 |    Simmer.noConflict();
12 |    </pre></code>
13 |    */
14 |   simmerInstance.noConflict = function () {
15 |     windowScope.Simmer = conflictedSimmer
16 |     return simmerInstance
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | ### Intellij ###
 2 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode
 3 | 
 4 | ## Directory-based project format
 5 | .idea/
 6 | # if you remove the above rule, at least ignore user-specific stuff:
 7 | # .idea/workspace.xml
 8 | # .idea/tasks.xml
 9 | # and these sensitive or high-churn files:
10 | # .idea/dataSources.ids
11 | # .idea/dataSources.xml
12 | # .idea/sqlDataSources.xml
13 | # .idea/dynamic.xml
14 | 
15 | ## File-based project format
16 | *.ipr
17 | *.iws
18 | *.iml
19 | 
20 | ## Additional for IntelliJ
21 | out/
22 | 
23 | # generated by mpeltonen/sbt-idea plugin
24 | .idea_modules/
25 | 
26 | 
27 | # files created by the build process and the "node install" command
28 | node_modules/*
29 | bower_components/*
30 | report/*
31 | reports/*
32 | selenium-debug.log
33 | screenshots/
34 | .DS_Store
35 | lib/


--------------------------------------------------------------------------------
/modules/convertSelectorStateIntoCSSSelector.js:
--------------------------------------------------------------------------------
 1 | import takeRight from 'lodash.takeright'
 2 | /**
 3 |    * Conver the Selector State into a merged CSS selector
 4 |    * @param state (object) The current selector state (has the stack and specificity sum)
 5 |    * @param depth (int) The number of levels to merge (1..state.stack.length)
 6 |    */
 7 | export default function (state, depth = state.stack.length) {
 8 |   return (
 9 |     takeRight(
10 |       state.stack.reduceRight((selectorSegments, elementState) => {
11 |         if (elementState.length) {
12 |           selectorSegments.push(elementState.join(''))
13 |         } else if (selectorSegments.length) {
14 |           selectorSegments.push('*')
15 |         }
16 |         return selectorSegments
17 |       }, []),
18 |       depth
19 |     ).join(' > ') || '*'
20 |   )
21 | }
22 | 


--------------------------------------------------------------------------------
/modules/stackHierarchy.js:
--------------------------------------------------------------------------------
 1 | function push (arr, val) {
 2 |   arr.push(val)
 3 |   return arr
 4 | }
 5 | 
 6 | function tail (arr) {
 7 |   return arr[arr.length - 1]
 8 | }
 9 | /**
10 |  * Retireve the element's ancestors up to the configured level.
11 |  * This is an internal function and is not to be used from the outside (nor can it, it is private)
12 |  * @param element (Object) The elemen't whose ancestry we want to retrieve
13 |  * @param depth (number) How deep to into the heirarchy to collect elements
14 |  */
15 | export default function stackHierarchy (element, depth) {
16 |   if (depth <= 0) {
17 |     throw new Error(`Simmer: An invalid depth of ${depth} has been specified`)
18 |   }
19 |   return Array(depth - 1)
20 |     .fill()
21 |     .reduce(
22 |       (acc, val) => (tail(acc).parent() ? push(acc, tail(acc).parent()) : acc),
23 |       [element]
24 |     )
25 | }
26 | 


--------------------------------------------------------------------------------
/modules/methods/inspectSiblings.js:
--------------------------------------------------------------------------------
 1 | import take from 'lodash.take'
 2 | import { className as validateClassName } from './validationHelpers'
 3 | /**
 4 | /**
 5 |  * Inspect the element's siblings by CSS Class names and compare them to the analyzed element.
 6 |  * @param {array} hierarchy. The hierarchy of elements
 7 |  * @param {object} state. The current calculated CSS selector
 8 |  */
 9 | export default function (hierarchy, state) {
10 |   return hierarchy.reduce((selectorState, currentElem, index) => {
11 |     const validClasses = take(currentElem.getClasses(), 10)
12 |       .filter(validateClassName)
13 |       .map(className => `.${className}`)
14 | 
15 |     if (validClasses.length) {
16 |       // limit to 10 classes
17 |       selectorState.stack[index].push(validClasses.join(''))
18 |       selectorState.specificity += 10 * validClasses.length
19 |     }
20 |     return selectorState
21 |   }, state)
22 | }
23 | 


--------------------------------------------------------------------------------
/modules/methods/index.js:
--------------------------------------------------------------------------------
 1 | import inspectElementID from './inspectElementID'
 2 | import inspectTags from './inspectTags'
 3 | import inspectSiblings from './inspectSiblings'
 4 | import inspectNthChild from './inspectNthChild'
 5 | import inspectSpecialAttributes from './inspectSpecialAttributes'
 6 | 
 7 | /**
 8 |  * The ParsingMethods are the key methods for the parsing process. They provide the various ways by which we analyze an element.
 9 |  * This object is a wrapper for building the list of available parsing methods and managing the context in which they are run so
10 |  * that they all have access to basic parsing helper methods
11 |  * */
12 | const parsingMethods = {
13 |   methods: [],
14 |   getMethods: function () {
15 |     return this.methods.slice(0)
16 |   },
17 |   addMethod: function (fn) {
18 |     this.methods.push(fn)
19 |   }
20 | }
21 | 
22 | parsingMethods.addMethod(inspectElementID)
23 | parsingMethods.addMethod(inspectTags)
24 | parsingMethods.addMethod(inspectSpecialAttributes)
25 | parsingMethods.addMethod(inspectSiblings)
26 | parsingMethods.addMethod(inspectNthChild)
27 | 
28 | export default parsingMethods
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Gidi Meir Morris AKA "CheKofif"
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/rollup.config.js:
--------------------------------------------------------------------------------
 1 | // rollup.config.js
 2 | import resolve from 'rollup-plugin-node-resolve'
 3 | import babel from 'rollup-plugin-babel'
 4 | import closure from 'rollup-plugin-closure-compiler-js'
 5 | import commonjs from 'rollup-plugin-commonjs'
 6 | import fs from 'fs'
 7 | 
 8 | const babelrc = JSON.parse(fs.readFileSync('./.babelrc', 'utf8'))
 9 | 
10 | const babelConfig = {
11 |   babelrc: false,
12 |   presets: [['es2015', { modules: false }]].concat(
13 |     (babelrc.presets || []).filter(preset => preset !== 'es2015')
14 |   ),
15 |   plugins: ['external-helpers'].concat(babelrc.plugins || [])
16 | }
17 | 
18 | export default {
19 |   entry: 'modules/index.js',
20 |   format: 'iife',
21 |   plugins: [
22 |     resolve({
23 |       jsnext: true,
24 |       main: true
25 |     }),
26 |     commonjs({
27 |       // non-CommonJS modules will be ignored, but you can also
28 |       // specifically include/exclude files
29 |       include: 'node_modules/**',
30 | 
31 |       // if true then uses of `global` won't be dealt with by this plugin
32 |       ignoreGlobal: false,
33 | 
34 |       // if false then skip sourceMap generation for CommonJS modules
35 |       sourceMap: false
36 |     }),
37 |     babel(babelConfig),
38 |     closure()
39 |   ],
40 |   dest: 'dist/simmer.js'
41 | }
42 | 


--------------------------------------------------------------------------------
/modules/methods/inspectSpecialAttributes.js:
--------------------------------------------------------------------------------
 1 | const handlers = {
 2 |   A: (state, elm) => {
 3 |     const attribute = elm.el.getAttribute('href')
 4 |     if (attribute) {
 5 |       state.stack[0].push(`A[href="${attribute}"]`)
 6 |       state.specificity += 10
 7 |     }
 8 |     return state
 9 |   },
10 |   IMG: (state, elm) => {
11 |     const attribute = elm.el.getAttribute('src')
12 |     if (attribute) {
13 |       state.stack[0].push(`IMG[src="${attribute}"]`)
14 |       state.specificity += 10
15 |     }
16 |     return state
17 |   }
18 | }
19 | 
20 | /**
21 |  * Inspect the elements' special attributes which are likely to be unique to the element
22 |  * @param {array} hierarchy. The hierarchy of elements
23 |  * @param {object} state. The current calculated CSS selector
24 |  */
25 | export default function (hierarchy, state, validateSelector) {
26 |   const elm = hierarchy[0]
27 |   const tag = elm.el.nodeName
28 | 
29 |   if (handlers[tag]) {
30 |     state = handlers[tag](state, elm)
31 |     if (validateSelector(state)) {
32 |       // the unique attribute worked!
33 |       state.verified = true
34 |     } else {
35 |       // turns out our so called unique attribute isn't as unique as we thought,
36 |       // we'll remove it to keep the selector's noise level down
37 |       state.stack[0].pop()
38 |     }
39 |   }
40 |   return state
41 | }
42 | 


--------------------------------------------------------------------------------
/modules/methods/validationHelpers.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Validate the syntax of a tagName to make sure that it has a valid syntax for the query engine.
 3 |  * Many libraries use invalid property and tag names, such as Facebook that use FB: prefixed tags.
 4 |  * These make the query engines fail and must be filtered out.
 5 |  * @param {string} tagName. The element's tag name
 6 |  */
 7 | export function tagName (tagName) {
 8 |   if (
 9 |     typeof tagName === 'string' &&
10 |     tagName.match(/^[a-zA-Z0-9]+$/gi) !== null
11 |   ) {
12 |     return tagName
13 |   }
14 |   return false
15 | }
16 | /**
17 |  * Validate the syntax of an attribute to make sure that it has a valid syntax for the query engine.
18 |  * @param {string} attribute. The element's attribute's value
19 |  */
20 | export function attr (attribute) {
21 |   if (
22 |     typeof attribute === 'string' &&
23 |     attribute.match(/^[0-9a-zA-Z][a-zA-Z_\-:0-9.]*$/gi) !== null
24 |   ) {
25 |     return attribute
26 |   }
27 |   return false
28 | }
29 | 
30 | /**
31 |  * Validate the syntax of an attribute to make sure that it has a valid syntax for the query engine.
32 |  * @param {string} attribute. The element's attribute's value
33 |  */
34 | export function className (className) {
35 |   if (
36 |     typeof className === 'string' &&
37 |     className.match(/^\.?[a-zA-Z_\-:0-9]*$/gi) !== null
38 |   ) {
39 |     return className
40 |   }
41 |   return false
42 | }
43 | 


--------------------------------------------------------------------------------
/modules/validateSelector.js:
--------------------------------------------------------------------------------
 1 | import convertSelectorStateIntoCSSSelector from './convertSelectorStateIntoCSSSelector'
 2 | /**
 3 |    * Execute a query using the current selector state and see if it produces a unique result.
 4 |    * If the result is unique then the analysis is complete and we can finish the process.
 5 |    * @param {object} element. The element we are trying to build a selector for
 6 |    * @param {object} state. The current selector state (has the stack and specificity sum)
 7 |    */
 8 | export default function (element, config, query, onError) {
 9 |   const { selectorMaxLength } = config
10 |   return function (state) {
11 |     let validated = false
12 |     let selector
13 |     let results
14 |     for (let depth = 1; depth <= state.stack.length && !validated; depth += 1) {
15 |       // use selector to query an element and see if it is a one-to-one selection
16 | 
17 |       selector = convertSelectorStateIntoCSSSelector(state, depth).trim()
18 | 
19 |       if (!(selector && selector.length)) {
20 |         // too short
21 |         return false
22 |       }
23 |       if (selectorMaxLength && selector.length > selectorMaxLength) {
24 |         // the selector is too long
25 |         return false
26 |       }
27 |       results = query(selector, onError)
28 |       validated =
29 |         results.length === 1 &&
30 |         (element.el !== undefined
31 |           ? results[0] === element.el
32 |           : results[0] === element)
33 | 
34 |       // we have to mark how deep the valdiation passed at
35 |       if (validated) {
36 |         state.verificationDepth = depth
37 |       }
38 |     }
39 | 
40 |     return validated
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/modules/parser.test.js:
--------------------------------------------------------------------------------
 1 | import Parser from './parser'
 2 | 
 3 | describe('Parser', () => {
 4 |   describe('next', () => {
 5 |     test(`calls the next function in the queue with the supplied arguments`, function () {
 6 |       const returnValue = { some: 0 }
 7 |       const method = jest.fn(() => returnValue)
 8 |       const parser = new Parser({
 9 |         getMethods: () => [method]
10 |       })
11 | 
12 |       expect(parser.next(1, 2, 3)).toBe(returnValue)
13 | 
14 |       expect(method.mock.calls[0]).toMatchObject([1, 2, 3])
15 |     })
16 |     test(`removes the called method`, function () {
17 |       const first = jest.fn(val => val)
18 |       const second = jest.fn(val => val)
19 |       const parser = new Parser({
20 |         getMethods: () => [first, second]
21 |       })
22 | 
23 |       expect(parser.next(1, 2, 3, 4, 5, 6)).toBe(1)
24 | 
25 |       expect(parser.next(6, 5, 4, 3, 2, 1)).toBe(6)
26 | 
27 |       expect(second.mock.calls[0]).toMatchObject([6, 5, 4, 3, 2, 1])
28 |     })
29 |     test(`returns false if no more methods are left`, function () {
30 |       const parser = new Parser({
31 |         getMethods: () => [val => val]
32 |       })
33 | 
34 |       parser.next(1, 2, 3, 4, 5, 6)
35 | 
36 |       expect(parser.next(6, 5, 4, 3, 2, 1)).toBe(false)
37 |     })
38 |   })
39 |   describe('finish', () => {
40 |     test(`returns true if no methods are left in the queue`, function () {
41 |       const parser = new Parser({
42 |         getMethods: () => []
43 |       })
44 | 
45 |       expect(parser.finished()).toBe(true)
46 |     })
47 |     test(`returns false if there are methods left in the queue`, function () {
48 |       const parser = new Parser({
49 |         getMethods: () => [() => 123]
50 |       })
51 | 
52 |       expect(parser.finished()).toBe(false)
53 |     })
54 |   })
55 | })
56 | 


--------------------------------------------------------------------------------
/modules/configuration.js:
--------------------------------------------------------------------------------
 1 | // Configuration
 2 | export const DEFAULT_CONFIGURATION = {
 3 |   // A function for calling an external query engine for testing CSS selectors such as jQuery or Sizzle
 4 |   // (If you have jQuery or Sizzle on the page, you have no need to supply such a function as Simmer will detect
 5 |   // these and use them if they are available. this will not work if you have these libraries in noConflict mode.
 6 |   queryEngine: null,
 7 |   // A minimum specificty level. Once the parser reaches this level it starts verifying the selector after every method is called
 8 |   // This can cut down our execution time by avoiding needless parsing but can also hurt execution times by performing many
 9 |   // verifications. This number will have to be tweeked here and there as we use the component...
10 |   specificityThreshold: 100,
11 |   // How deep into the DOM hierarchy should Simmer go in order to reach a unique selector.
12 |   // This is a delicate game because the higher the number the more likely you are to reach a unique selector,
13 |   // but it also means a longer and more breakable one. Assuming you want to store this selector to use later,
14 |   // making it longer also means it is more likely to change and loose it's validity.
15 |   depth: 3,
16 |   // Handling errors in the Simmer analysis process.
17 |   // true / false / callback
18 |   // false: errors are ignored by Simmer
19 |   // true: errors rethrown by the process
20 |   // a function callback will be called with two parameters: the exception and the element being analyzed
21 |   errorHandling: false,
22 |   // A maximum length for the CSS selector can be specified - if no specific selector can be found which is shorter than this length
23 |   // then it is treated as if no selector could be found
24 |   selectorMaxLength: 512
25 | }
26 | 
27 | export function configure (config = {}) {
28 |   return {
29 |     ...DEFAULT_CONFIGURATION,
30 |     ...config
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/modules/methods/inspectElementID.js:
--------------------------------------------------------------------------------
 1 | import { isUniqueElementID } from '../queryEngine'
 2 | import { attr } from './validationHelpers'
 3 | /**
 4 |  * Inspect the elements' IDs and add them to the CSS Selector
 5 |  * @param {array} hierarchy. The hierarchy of elements
 6 |  * @param {object} state. The current selector state (has the stack and specificity sum)
 7 |  */
 8 | export default function (hierarchy, state, validateSelector, config, query) {
 9 |   return hierarchy.reduce((selectorState, currentElem, index) => {
10 |     if (!selectorState.verified) {
11 |       const [validatedState] = [currentElem.el.getAttribute('id')]
12 |         .filter(id => attr(id))
13 |         // make sure the ID is unique
14 |         .filter(id => isUniqueElementID(query, id))
15 |         .map(validId => {
16 |           selectorState.stack[index].push(`[id='${validId}']`)
17 |           selectorState.specificity += 100
18 | 
19 |           if (selectorState.specificity >= config.specificityThreshold) {
20 |             // we have reached the minimum specificity, lets try verifying now, as this will save us having to add more IDs to the selector
21 |             if (validateSelector(selectorState)) {
22 |               // The ID worked like a charm - mark this state as verified and move on!
23 |               selectorState.verified = true
24 |             }
25 |           }
26 | 
27 |           if (!selectorState.verified && index === 0) {
28 |             // if the index is 0 then this is the ID of the actual element! Which means we have found our selector!
29 |             // The ID wasn't enough, this means the page, this should never happen as we tested for the ID's uniquness, but just incase
30 |             // we will pop it from the stack as it only adds noise
31 |             selectorState.stack[index].pop()
32 |             selectorState.specificity -= 100
33 |           }
34 |           return selectorState
35 |         })
36 |       return validatedState || selectorState
37 |     }
38 |     return selectorState
39 |   }, state)
40 | }
41 | 


--------------------------------------------------------------------------------
/modules/convertSelectorStateIntoCSSSelector.test.js:
--------------------------------------------------------------------------------
 1 | import convertSelectorStateIntoCSSSelector from './convertSelectorStateIntoCSSSelector'
 2 | 
 3 | describe.only('convertSelectorStateIntoCSSSelector', () => {
 4 |   test(`converts an empty stack into a "select all" selector`, function () {
 5 |     expect(
 6 |       convertSelectorStateIntoCSSSelector({
 7 |         stack: [[]]
 8 |       })
 9 |     ).toBe('*')
10 |   })
11 | 
12 |   test(`converts an one level stack with one selector into that selector`, function () {
13 |     expect(
14 |       convertSelectorStateIntoCSSSelector({
15 |         stack: [['DIV']]
16 |       })
17 |     ).toBe('DIV')
18 |   })
19 | 
20 |   test(`converts an one level stack with multiple selectors into a merged selector`, function () {
21 |     expect(
22 |       convertSelectorStateIntoCSSSelector({
23 |         stack: [['DIV', '.className']]
24 |       })
25 |     ).toBe('DIV.className')
26 |   })
27 | 
28 |   test(`converts an multi level stack with multiple selectors into a merged selector`, function () {
29 |     expect(
30 |       convertSelectorStateIntoCSSSelector({
31 |         stack: [['span'], ['DIV', '#someId'], ['DIV', '.className']]
32 |       })
33 |     ).toBe('DIV.className > DIV#someId > span')
34 |   })
35 | 
36 |   test(`converts an empty selector in a multi level stack into a "select all" selector`, function () {
37 |     expect(
38 |       convertSelectorStateIntoCSSSelector({
39 |         stack: [['span'], [], ['DIV', '.className']]
40 |       })
41 |     ).toBe('DIV.className > * > span')
42 |   })
43 | 
44 |   test(`omits "select all" selectors from the parent levels`, function () {
45 |     expect(
46 |       convertSelectorStateIntoCSSSelector({
47 |         stack: [['span'], [], ['DIV', '.className'], [], []]
48 |       })
49 |     ).toBe('DIV.className > * > span')
50 |   })
51 | 
52 |   test(`takes a depth level which will omit any selectors beyond that depth`, function () {
53 |     expect(
54 |       convertSelectorStateIntoCSSSelector(
55 |         {
56 |           stack: [
57 |             ['span'],
58 |             [],
59 |             ['DIV', '.className'],
60 |             [],
61 |             ['DIV', '#someId'],
62 |             ['ARTICLE'],
63 |             []
64 |           ]
65 |         },
66 |         3
67 |       )
68 |     ).toBe('DIV.className > * > span')
69 |   })
70 | })
71 | 


--------------------------------------------------------------------------------
/__tests__/integration/utils.js:
--------------------------------------------------------------------------------
 1 | // code utils
 2 | export const either = (value, left, right) =>
 3 |   value ? right(value) : left(value)
 4 | export const identity = i => i
 5 | export const compose = (f, ...fns) => {
 6 |   if (fns.length === 1) {
 7 |     const g = fns.pop()
 8 |     return (...args) => f(g(...args))
 9 |   }
10 |   return (...args) => f(compose(...fns)(...args))
11 | }
12 | export const rcompose = (...fns) => {
13 |   return compose(...fns.reverse())
14 | }
15 | export const mapfn = fn => arr => arr.map(fn)
16 | export const reducefn = (fn, init) => arr => arr.reduce(fn, init)
17 | 
18 | // Dom utils
19 | // use query in current scope
20 | export const queryEngine = document => ({
21 |   query: (...args) => {
22 |     if (!document) {
23 |       throw Error(
24 |         'No global scoped document is available - somethign is wrong with the test runner'
25 |       )
26 |     }
27 |     let elm = document.querySelectorAll(...args)
28 |     if (elm && elm.length) {
29 |       if (elm.length === 1) {
30 |         return elm[0]
31 |       }
32 |       throw new Error(
33 |         `Invalid number of elements returned for query: ${elm.join()}`
34 |       )
35 |     }
36 |     return elm
37 |   },
38 |   default: true
39 | })
40 | 
41 | export const setQueryFunction = (queryFn, name) => {
42 |   queryEngine.default = false
43 |   queryEngine.query = queryFn
44 |   describe(`Simmer tests along side a ${name} selector engine`)
45 | }
46 | 
47 | export const NoResult = { el: undefined, SimmerEl: false }
48 | 
49 | export const compareParentElementAndSimmer = (windowScope, elementSelector) => {
50 |   const comp = compareElementsAndSimmer(windowScope, elementSelector)
51 |   if (comp !== NoResult && comp.element) {
52 |     comp.el = comp.el.parentNode
53 |   }
54 |   return comp
55 | }
56 | 
57 | export const compareElementsAndSimmer = (windowScope, elementSelector) => {
58 |   var element, selector
59 |   if (typeof elementSelector === 'string') {
60 |     element = windowScope.document.querySelectorAll(elementSelector)[0]
61 |   } else {
62 |     element = elementSelector
63 |   }
64 | 
65 |   if (!element) {
66 |     return NoResult
67 |   }
68 | 
69 |   selector = windowScope.Simmer(element)
70 |   if (selector === false) {
71 |     return false
72 |   }
73 | 
74 |   return {
75 |     el: element,
76 |     SimmerEl: queryEngine(windowScope.document).query(selector),
77 |     selector: selector
78 |   }
79 | }
80 | 


--------------------------------------------------------------------------------
/modules/methods/inspectNthChild.js:
--------------------------------------------------------------------------------
 1 | import difference from 'lodash.difference'
 2 | import flatmap from 'lodash.flatmap'
 3 | /**
 4 |  * Inspect the element's siblings by index (nth-child) name and compare them to the analyzed element.
 5 |  * The sibling comparison is done from level 0 (the analyzed element) upwards in the hierarchy, In an effort to avoid unneeded parsing.
 6 |  * @param {array} hierarchy. The hierarchy of elements
 7 |  * @param {object} state. The current calculated CSS selector
 8 |  */
 9 | 
10 | const not = i => !i
11 | const getNodeNames = siblings => siblings.map(sibling => sibling.el.nodeName)
12 | /***
13 |  * The main method splits up the hierarchy and isolates each element, while this helper method is designed
14 |  * to then take each level in the hierarchy and fid into it's surounding siblings.
15 |  * We've separated these to make the code more managable.
16 |  * @param siblingElement
17 |  * @param siblings
18 |  * @returns {boolean}
19 |  */
20 | export function analyzeElementSiblings (element, siblings) {
21 |   return (
22 |     difference(
23 |       element.getClasses(),
24 |       flatmap(siblings, sibling => sibling.getClasses())
25 |     ).length > 0 || not(getNodeNames(siblings).includes(element.el.nodeName))
26 |   )
27 | }
28 | 
29 | export default function (hierarchy, state, validateSelector) {
30 |   return hierarchy.reduce((selectorState, currentElem, index) => {
31 |     if (!selectorState.verified) {
32 |       // get siblings BEFORE out element
33 |       const prevSiblings = currentElem.prevAll()
34 |       const nextSiblings = currentElem.nextAll()
35 | 
36 |       // get element's index by the number of elements before it
37 |       // note that the nth-child selector uses a 1 based index, not 0
38 |       const indexOfElement = prevSiblings.length + 1
39 | 
40 |       // If the element has no siblings!
41 |       // we have no need for the nth-child selector
42 |       if (
43 |         (prevSiblings.length || nextSiblings.length) &&
44 |         !analyzeElementSiblings(currentElem, [...prevSiblings, ...nextSiblings])
45 |       ) {
46 |         // if we don't have a unique tag or a unique class, then we need a nth-child to help us
47 |         // differenciate our element from the rest of the pack
48 |         selectorState.stack[index].push(`:nth-child(${indexOfElement})`)
49 | 
50 |         // Verify the selector as we don't want to go on and parse the parent's siblings
51 |         // if we don't have to!
52 |         selectorState.verified = validateSelector(selectorState)
53 |       }
54 |     }
55 |     return selectorState
56 |   }, state)
57 | }
58 | 


--------------------------------------------------------------------------------
/modules/stackHeirarchy.test.js:
--------------------------------------------------------------------------------
 1 | import { wrap } from './queryEngine'
 2 | import stackHierarchy from './stackHierarchy'
 3 | const { JSDOM } = require('jsdom')
 4 | 
 5 | const createElementHeirarchy = (dom = '', selector) =>
 6 |   new JSDOM(`<body>${dom}</body>`).window.document.querySelector(selector)
 7 | 
 8 | describe('stackHierarchy', () => {
 9 |   test(`takes a wrapped element and a depth and returns the element heirarchy up tp that depth`, function () {
10 |     const child = createElementHeirarchy(
11 |       `
12 |         <div id="el1">
13 |           <div id="el2">
14 |             <div id="el3">
15 |               <div id="leaf">
16 |               </div>
17 |             </div>
18 |           </div>
19 |         </div>
20 |       `,
21 |       `#leaf`
22 |     )
23 |     const stackedHeirarchy = stackHierarchy(wrap(child), 3)
24 | 
25 |     expect(stackedHeirarchy[0].el).toBe(child)
26 |     expect(stackedHeirarchy[1].el).toBe(child.parentNode)
27 |     expect(stackedHeirarchy[2].el).toBe(child.parentNode.parentNode)
28 |     expect(stackedHeirarchy.length).toBe(3)
29 |   })
30 | 
31 |   test(`throws an error if the depth is invalid`, function () {
32 |     const child = createElementHeirarchy(
33 |       `
34 |         <div id="el1">
35 |           <div id="el2">
36 |             <div id="el3">
37 |               <div id="leaf">
38 |               </div>
39 |             </div>
40 |           </div>
41 |         </div>
42 |       `,
43 |       `#leaf`
44 |     )
45 | 
46 |     expect(() => stackHierarchy(wrap(child), 0)).toThrowError(
47 |       /An invalid depth of/
48 |     )
49 | 
50 |     expect(() => stackHierarchy(wrap(child), -5)).toThrowError(
51 |       /An invalid depth of/
52 |     )
53 |   })
54 | 
55 |   test(`returns a partial heirarchy if the depth is higher than what is available on the DOM`, function () {
56 |     const child = createElementHeirarchy(
57 |       `
58 |         <div id="el1">
59 |           <div id="leaf">
60 |           </div>
61 |         </div>
62 |       `,
63 |       `#leaf`
64 |     )
65 | 
66 |     const stackedHeirarchy = stackHierarchy(wrap(child), 10)
67 | 
68 |     expect(stackedHeirarchy[0].el).toBe(child)
69 |     expect(stackedHeirarchy[1].el).toBe(child.parentNode)
70 |     // Body
71 |     expect(stackedHeirarchy[2].el).toBe(child.parentNode.parentNode)
72 |     /// HTML
73 |     expect(stackedHeirarchy[3].el).toBe(child.parentNode.parentNode.parentNode)
74 |     // Document
75 |     expect(stackedHeirarchy[4].el).toBe(
76 |       child.parentNode.parentNode.parentNode.parentNode
77 |     )
78 | 
79 |     expect(stackedHeirarchy.length).toBe(5)
80 |   })
81 | })
82 | 


--------------------------------------------------------------------------------
/modules/queryEngine.test.js:
--------------------------------------------------------------------------------
 1 | import initQueryEngine, { isUniqueElementID } from './queryEngine'
 2 | const { JSDOM } = require('jsdom')
 3 | const createElement = (dom = '') =>
 4 |   new JSDOM(`<body><div></div></body>`).window.document.querySelector('div')
 5 | /// HTMLElement
 6 | describe('QueryEngine', () => {
 7 |   describe('attachQueryEngine', () => {
 8 |     test(`defaults to using the document.querySelectorAll as queryEngine`, function () {
 9 |       const returnValue = [{ tagName: 'div' }, { tagName: 'div' }]
10 |       const querySelectorAll = jest.fn(() => returnValue)
11 | 
12 |       const windowScope = {
13 |         document: {
14 |           querySelectorAll
15 |         }
16 |       }
17 | 
18 |       const $ = initQueryEngine(windowScope)
19 | 
20 |       expect($('div')).toBe(returnValue)
21 | 
22 |       expect(querySelectorAll.mock.calls[0][0]).toBe('div')
23 |     })
24 | 
25 |     test(`takes a query engine and uses it to query`, function () {
26 |       const returnValue = [{ tagName: 'div' }, { tagName: 'div' }]
27 |       const customQueryEngine = jest.fn(() => returnValue)
28 |       const querySelectorAll = jest.fn(() => [])
29 | 
30 |       const windowScope = {
31 |         document: {
32 |           querySelectorAll
33 |         }
34 |       }
35 | 
36 |       const $ = initQueryEngine(windowScope, customQueryEngine)
37 | 
38 |       expect($('div')).toBe(returnValue)
39 | 
40 |       expect(querySelectorAll.mock.calls.length).toBe(0)
41 |       expect(customQueryEngine.mock.calls[0][0]).toBe('div')
42 |     })
43 |   })
44 | 
45 |   describe('isUniqueElementID', () => {
46 |     test(`takes a query engine and an id and returns true if the query engine has only one result for that id`, function () {
47 |       const query = jest.fn(() => [createElement()])
48 | 
49 |       expect(isUniqueElementID(query, 'uniqueId')).toBe(true)
50 | 
51 |       expect(query.mock.calls[0][0]).toBe(`[id="uniqueId"]`)
52 |     })
53 | 
54 |     test(`takes a query engine and an id and returns false if the query engine has no result for that id`, function () {
55 |       const query = jest.fn(() => [])
56 | 
57 |       expect(isUniqueElementID(query, 'uniqueId')).toBe(false)
58 | 
59 |       expect(query.mock.calls[0][0]).toBe(`[id="uniqueId"]`)
60 |     })
61 | 
62 |     test(`takes a query engine and an id and returns false if the query engine returns multiple result for that id`, function () {
63 |       const query = jest.fn(() => [createElement(), createElement()])
64 | 
65 |       expect(isUniqueElementID(query, 'uniqueId')).toBe(false)
66 | 
67 |       expect(query.mock.calls[0][0]).toBe(`[id="uniqueId"]`)
68 |     })
69 |   })
70 | })
71 | 


--------------------------------------------------------------------------------
/modules/queryEngine.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Verify a specific ID's uniqueness one the page
 3 |  * @param {object} element. The element we are trying to build a selector for
 4 |  * @param {object} state. The current selector state (has the stack and specificity sum)
 5 |  */
 6 | export function isUniqueElementID (query, elementID) {
 7 |   // use selector to query an element and see if it is a one-to-one selection
 8 |   var results = query(`[id="${elementID}"]`) || []
 9 |   return results.length === 1
10 | }
11 | 
12 | function traverseAttribute (el, dir) {
13 |   const matched = []
14 |   let cur = el[dir]
15 | 
16 |   while (cur && cur.nodeType !== 9) {
17 |     if (cur.nodeType === 1) {
18 |       matched.push(wrap(cur))
19 |     }
20 |     cur = cur[dir]
21 |   }
22 |   return matched
23 | }
24 | 
25 | export function wrap (el) {
26 |   /// When the DOM wrapper return the selected element it wrapps
27 |   /// it with helper methods which aid in analyzing the result
28 |   return {
29 |     el,
30 | 
31 |     getClass: function () {
32 |       return this.el.getAttribute('class') || ''
33 |     },
34 | 
35 |     getClasses: function () {
36 |       return this.getClass()
37 |         .split(' ')
38 |         .map(className => className.replace(/^\s\s*/, '').replace(/\s\s*$/, ''))
39 |         .filter(className => className.length > 0)
40 |     },
41 | 
42 |     prevAll: function () {
43 |       return traverseAttribute(this.el, 'previousSibling')
44 |     },
45 | 
46 |     nextAll: function () {
47 |       return traverseAttribute(this.el, 'nextSibling')
48 |     },
49 | 
50 |     parent: function () {
51 |       return this.el.parentNode && this.el.parentNode.nodeType !== 11
52 |         ? wrap(this.el.parentNode)
53 |         : null
54 |     }
55 |   }
56 | }
57 | 
58 | const INVALID_DOCUMENT = {
59 |   querySelectorAll () {
60 |     throw new Error(
61 |       'An invalid context has been provided to Simmer, it doesnt know how to query it'
62 |     )
63 |   }
64 | }
65 | 
66 | const documentQuerySelector = scope => {
67 |   const document = typeof scope.querySelectorAll === 'function'
68 |     ? scope
69 |     : scope.document ? scope.document : INVALID_DOCUMENT
70 |   return (selector, onError) => {
71 |     try {
72 |       return document.querySelectorAll(selector)
73 |     } catch (ex) {
74 |       // handle error
75 |       onError(ex)
76 |     }
77 |   }
78 | }
79 | 
80 | /**
81 |  * A DOM manipulation object. Provides both CSS selector querying for verifications and a wrapper for the elements them selves to provide
82 |  * key behavioural methods, such as sibling querying etc.
83 |  * @param {object} elementOrSelector. An element we wish to wrapper or a CSS query string
84 |  */
85 | export default function (scope, configuredQueryEngine) {
86 |   const queryEngine = typeof configuredQueryEngine === 'function'
87 |     ? configuredQueryEngine
88 |     : documentQuerySelector(scope)
89 | 
90 |   // If no selector we return an empty array - no CSS selector will ever be generated in this situation!
91 |   return (selector, onError) =>
92 |     typeof selector !== 'string' ? [] : queryEngine(selector, onError, scope)
93 | }
94 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "simmerjs",
 3 |   "description": "A pure Javascript reverse CSS selector engine which calculates a DOM element's unique CSS selector on the current page.",
 4 |   "version": "0.5.6",
 5 |   "author": "Gidi Meir Morris",
 6 |   "main": "lib/simmer.js",
 7 |   "jsnext:main": "modules/simmer.js",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "https://github.com/gmmorris/simmerjs.git"
11 |   },
12 |   "licenses": [
13 |     {
14 |       "type": "MIT",
15 |       "url": "https://github.com/gmmorris/simmerjs/blob/master/LICENSE"
16 |     }
17 |   ],
18 |   "dependencies": {
19 |     "lodash.difference": "^4.5.0",
20 |     "lodash.flatmap": "^4.5.0",
21 |     "lodash.isfunction": "^3.0.8",
22 |     "lodash.take": "^4.1.1",
23 |     "lodash.takeright": "^4.1.1"
24 |   },
25 |   "scripts": {
26 |     "test": "npm run testUnit && npm run testIntegration",
27 |     "testw": "jest .test.js  --watch",
28 |     "testUnit": "jest ./modules",
29 |     "testIntegration": "jest ./**/integration/*.test.js",
30 |     "testE2E": "npm run build && nightwatch --config nightwatch.conf.js",
31 |     "build": "npm run buildBrowser && npm run buildModule",
32 |     "buildBrowser": "rollup -c",
33 |     "buildModule": "rm -rf ./lib && babel modules -d lib --ignore .test.js",
34 |     "lint": "eslint ./modules/**/*.js",
35 |     "format": "prettier-eslint --write \"modules/**/*.js\"",
36 |     "formatTests": "prettier-eslint --write \"__tests__/integration/*.js\"",
37 |     "precommit": "lint-staged",
38 |     "prepublish": "npm run buildModule"
39 |   },
40 |   "lint-staged": {
41 |     "*.js": [
42 |       "npm run format",
43 |       "npm run lint",
44 |       "git add"
45 |     ]
46 |   },
47 |   "devDependencies": {
48 |     "babel-cli": "^6.24.1",
49 |     "babel-jest": "^20.0.3",
50 |     "babel-plugin-external-helpers": "^6.22.0",
51 |     "babel-plugin-transform-object-rest-spread": "^6.23.0",
52 |     "babel-preset-env": "^1.5.1",
53 |     "babel-preset-es2015": "^6.24.1",
54 |     "babel-preset-es2016": "^6.24.1",
55 |     "env2": "^2.2.0",
56 |     "eslint": "^4.0.0",
57 |     "eslint-config-standard": "^10.2.1",
58 |     "eslint-plugin-import": "^2.3.0",
59 |     "eslint-plugin-jest": "^20.0.3",
60 |     "eslint-plugin-node": "^5.0.0",
61 |     "eslint-plugin-promise": "^3.5.0",
62 |     "eslint-plugin-standard": "^3.0.1",
63 |     "express": "^4.15.3",
64 |     "husky": "^0.13.4",
65 |     "jest": "^20.0.4",
66 |     "jest-codemods": "^0.10.1",
67 |     "jsdom": "^11.0.0",
68 |     "lint-staged": "^4.0.0",
69 |     "nightwatch": "^0.9.15",
70 |     "path": "^0.12.7",
71 |     "prettier": "^1.4.4",
72 |     "prettier-eslint-cli": "^4.1.1",
73 |     "regenerator-runtime": "^0.10.5",
74 |     "rollup": "^0.42.0",
75 |     "rollup-plugin-babel": "^2.7.1",
76 |     "rollup-plugin-closure-compiler-js": "^1.0.4",
77 |     "rollup-plugin-commonjs": "^8.0.2",
78 |     "rollup-plugin-node-resolve": "^3.0.0",
79 |     "selenium-download": "^2.0.10",
80 |     "sinon": "^2.3.2",
81 |     "standard": "^10.0.2"
82 |   },
83 |   "keywords": [
84 |     "Simmer",
85 |     "css",
86 |     "css selector",
87 |     "sizzle"
88 |   ]
89 | }
90 | 


--------------------------------------------------------------------------------
/nightwatch.conf.js:
--------------------------------------------------------------------------------
 1 | const SCREENSHOT_PATH = "./screenshots/";
 2 | const BINPATH = './node_modules/nightwatch/bin/';
 3 | 
 4 | // we use a nightwatch.conf.js file so we can include comments and helper functions
 5 | module.exports = {
 6 |   "src_folders": [
 7 |     "__tests__/e2e"// Where you are storing your Nightwatch e2e tests
 8 |   ],
 9 |   "output_folder": "./reports", // reports (test outcome) output by nightwatch
10 |   "selenium": { // downloaded by selenium-download module (see readme)
11 |     "start_process": true, // tells nightwatch to start/stop the selenium process
12 |     "server_path": "./node_modules/nightwatch/bin/selenium.jar",
13 |     "host": "127.0.0.1",
14 |     "port": 4444, // standard selenium port
15 |     "cli_args": { // chromedriver is downloaded by selenium-download (see readme)
16 |       "webdriver.chrome.driver" : "./node_modules/nightwatch/bin/chromedriver"
17 |     }
18 |   },
19 |   "test_settings": {
20 |     "default": {
21 |       "screenshots": {
22 |         "enabled": true, // if you want to keep screenshots
23 |         "path": './screenshots' // save screenshots here
24 |       },
25 |       "globals": {
26 |         "waitForConditionTimeout": 5000 // sometimes internet is slow so wait.
27 |       },
28 |       "desiredCapabilities": { // use Chrome as the default browser for tests
29 |         "browserName": "chrome"
30 |       }
31 |     },
32 |     "chrome": {
33 |       "desiredCapabilities": {
34 |         "browserName": "chrome",
35 |         "javascriptEnabled": true // turn off to test progressive enhancement
36 |       }
37 |     }
38 |   }
39 | }
40 | /**
41 |  * selenium-download does exactly what it's name suggests;
42 |  * downloads (or updates) the version of Selenium (& chromedriver)
43 |  * on your localhost where it will be used by Nightwatch.
44 |  /the following code checks for the existence of `selenium.jar` before trying to run our tests.
45 |  */
46 | 
47 | require('fs').stat(BINPATH + 'selenium.jar', function (err, stat) { // got it?
48 |   if (err || !stat || stat.size < 1) {
49 |     require('selenium-download').ensure(BINPATH, function(error) {
50 |       if (error) throw new Error(error); // no point continuing so exit!
51 |       console.log('✔ Selenium & Chromedriver downloaded to:', BINPATH);
52 |     });
53 |   }
54 | });
55 | 
56 | function padLeft (count) { // theregister.co.uk/2016/03/23/npm_left_pad_chaos/
57 |   return count < 10 ? '0' + count : count.toString();
58 | }
59 | 
60 | var FILECOUNT = 0; // "global" screenshot file count
61 | /**
62 |  * The default is to save screenshots to the root of your project even though
63 |  * there is a screenshots path in the config object above! ... so we need a
64 |  * function that returns the correct path for storing our screenshots.
65 |  * While we're at it, we are adding some meta-data to the filename, specifically
66 |  * the Platform/Browser where the test was run and the test (file) name.
67 |  */
68 | function imgpath (browser) {
69 |   var a = browser.options.desiredCapabilities;
70 |   var meta = [a.platform];
71 |   meta.push(a.browserName ? a.browserName : 'any');
72 |   meta.push(a.version ? a.version : 'any');
73 |   meta.push(a.name); // this is the test filename so always exists.
74 |   var metadata = meta.join('~').toLowerCase().replace(/ /g, '');
75 |   return SCREENSHOT_PATH + metadata + '_' + padLeft(FILECOUNT++) + '_';
76 | }
77 | 
78 | module.exports.imgpath = imgpath;
79 | module.exports.SCREENSHOT_PATH = SCREENSHOT_PATH;


--------------------------------------------------------------------------------
/modules/methods/inspectNthChild.test.js:
--------------------------------------------------------------------------------
  1 | import { analyzeElementSiblings } from './inspectNthChild'
  2 | 
  3 | describe('analyzeElementSiblings', () => {
  4 |   test(`takes an only child with no classes and identifies it as having a unique tag / class`, function () {
  5 |     expect(
  6 |       analyzeElementSiblings(
  7 |         { el: { nodeName: 'DIV' }, getClasses: () => [] },
  8 |         []
  9 |       )
 10 |     ).toBe(true)
 11 |   })
 12 | 
 13 |   test(`takes an only child with classes and identifies it as having a unique tag / class`, function () {
 14 |     expect(
 15 |       analyzeElementSiblings(
 16 |         { el: { nodeName: 'DIV' }, getClasses: () => ['someClass'] },
 17 |         []
 18 |       )
 19 |     ).toBe(true)
 20 |   })
 21 | 
 22 |   test(`takes an child with a sibling and identifies it as having a unique tag`, function () {
 23 |     expect(
 24 |       analyzeElementSiblings(
 25 |         { el: { nodeName: 'DIV' }, getClasses: () => ['someClass'] },
 26 |         [{ el: { nodeName: 'P' }, getClasses: () => [] }]
 27 |       )
 28 |     ).toBe(true)
 29 |   })
 30 | 
 31 |   test(`takes an child with a sibling and identifies it as having a unique class`, function () {
 32 |     expect(
 33 |       analyzeElementSiblings(
 34 |         { el: { nodeName: 'DIV' }, getClasses: () => ['someClass'] },
 35 |         [{ el: { nodeName: 'DIV' }, getClasses: () => [] }]
 36 |       )
 37 |     ).toBe(true)
 38 |   })
 39 | 
 40 |   test(`takes an child with a sibling and identifies it as having a unique class among matching classes`, function () {
 41 |     expect(
 42 |       analyzeElementSiblings(
 43 |         {
 44 |           el: { nodeName: 'DIV' },
 45 |           getClasses: () => ['someAClass', 'someUniqueClass', 'someBClass']
 46 |         },
 47 |         [
 48 |           {
 49 |             el: { nodeName: 'DIV' },
 50 |             getClasses: () => ['someAClass', 'someBClass']
 51 |           }
 52 |         ]
 53 |       )
 54 |     ).toBe(true)
 55 |   })
 56 | 
 57 |   test(`takes an child with multiple sibling and identifies it as having a unique class among matching classes`, function () {
 58 |     expect(
 59 |       analyzeElementSiblings(
 60 |         {
 61 |           el: { nodeName: 'DIV' },
 62 |           getClasses: () => ['someAClass', 'someUniqueClass', 'someBClass']
 63 |         },
 64 |         [
 65 |           {
 66 |             el: { nodeName: 'DIV' },
 67 |             getClasses: () => ['someAClass', 'someBClass']
 68 |           },
 69 |           { el: { nodeName: 'DIV' }, getClasses: () => ['someBClass'] },
 70 |           { el: { nodeName: 'DIV' }, getClasses: () => ['someBClass'] },
 71 |           { el: { nodeName: 'DIV' }, getClasses: () => ['someDClass'] }
 72 |         ]
 73 |       )
 74 |     ).toBe(true)
 75 |   })
 76 | 
 77 |   test(`takes an child with multiple sibling and identifies it as having no unique class`, function () {
 78 |     expect(
 79 |       analyzeElementSiblings(
 80 |         {
 81 |           el: { nodeName: 'DIV' },
 82 |           getClasses: () => ['someAClass', 'someBClass']
 83 |         },
 84 |         [
 85 |           {
 86 |             el: { nodeName: 'DIV' },
 87 |             getClasses: () => ['someAClass', 'someBClass']
 88 |           },
 89 |           { el: { nodeName: 'DIV' }, getClasses: () => ['someBClass'] },
 90 |           { el: { nodeName: 'DIV' }, getClasses: () => ['someBClass'] },
 91 |           { el: { nodeName: 'DIV' }, getClasses: () => ['someDClass'] }
 92 |         ]
 93 |       )
 94 |     ).toBe(false)
 95 |   })
 96 | 
 97 |   test(`takes an child with multiple sibling and identifies it as having no unique tag`, function () {
 98 |     expect(
 99 |       analyzeElementSiblings(
100 |         { el: { nodeName: 'DIV' }, getClasses: () => [] },
101 |         [
102 |           { el: { nodeName: 'DIV' }, getClasses: () => [] },
103 |           { el: { nodeName: 'DIV' }, getClasses: () => [] }
104 |         ]
105 |       )
106 |     ).toBe(false)
107 |   })
108 | })
109 | 


--------------------------------------------------------------------------------
/__tests__/integration/fixture.js:
--------------------------------------------------------------------------------
 1 | export default `
 2 |   <div id="fixture" style="display:none">
 3 |       <div id="TopContainer">
 4 |           <div class="header"><span id="NavBar"> <ul>
 5 |               <Li class="Edge"><a href="./page/link_1">Page #1</a></Li>
 6 |               <Li><span>Here:<span id="helper"></span></span><a href="./page/link_2">Page #2</a></Li>
 7 |               <Li class="Active"><a href="./page/link_3">Page #3</a></Li>
 8 |               <Li><a href="./page/link_4">Page #4 <img src="./image/Pixel.png"/></a></Li>
 9 |               <Li class="Edge"><a href="./page/link_5">Page #5</a></Li>
10 |           </ul> </span></div>
11 |           <div id="111"></div>
12 |           <div id="a111a"></div>
13 |           <div id="a111"></div>
14 |           <div id="111aaaaaa"></div>
15 |           <div id="BodyDiv">
16 |               <div id="NonUniqueDiv"><img src="./image/NoID.png"></div>
17 |               <div><img src="./image/NonUniqueSRC.png">
18 |                   <table>
19 |                       <tr>
20 |                           <th><a href="non.html">First</a></th>
21 |                           <th><a href="second.html">Second</a></th>
22 |                           <th><a href="non.html">Third<a/></th>
23 |                       </tr>
24 |                       <tr>
25 |                           <td>1 <span class="sameclass diferentclass1"></span> <span class="diferentclass2"></span> <span
26 |                                   class="diferentclass1"></span> <span class="diferentclass1 sameclass"></span> <span
27 |                                   class="diferentclass1"></span></td>
28 |                           <td>2</td>
29 |                           <td>Cell to target!</td>
30 |                       </tr>
31 |                       <tr>
32 |                           <td>A</td>
33 |                           <td>B</td>
34 |                           <td>C</td>
35 |                       </tr>
36 |                   </table>
37 |               </div>
38 |               <div id="NonUniqueDiv"><img src="./image/NonUniqueSRC.png"></div>
39 |           </div>
40 |           <div><span><span><span><span><span><p><a href="a">a</a></p></span></span></span></span></span><span><span><span><span><span><p>
41 |               <a href="a" id="placeholderId">a</a></p></span></span></span></span></span><span><span><p><a href="a">a</a>
42 |           </p></span></span></div>
43 |           <div class="invalid_child_tag">
44 |               <gidi:test><span></span></gidi:test>
45 |           </div>
46 |           <div id="placeholder_4">
47 |               <div>
48 |                   <div class="uniqueClassName"></div>
49 |               </div>
50 |           </div>
51 |           <div id="placeholder_4">
52 |               <div class="secondLevelUniqueClassName">
53 |                   <div></div>
54 |               </div>
55 |           </div>
56 |           <div id="placeholder_5">
57 |               <div>
58 |                   <div id=":asd" class="invalidIDElement"></div>
59 |               </div>
60 |           </div>
61 |       </div>
62 |       <div>
63 |           <div>
64 |               <div>
65 |                   <div>
66 |                       <div>
67 |                           <div>
68 |                               <div>
69 |                                   <div id="aZROCRDPX41Qkden3aiC3o9Tkl0xqENUjIgNSWbe6pSddw86ogN018T9lD67zAF1YHaLkRngy8YVq88IBfqdvtO9aXZZbD1NsSBiUo6txcv22ufrkRs9AZKkxIkTF1gNAZ3Oh4M6TcYWRARVJqOZwo3dQufTDm904ep3yHZ5vdHqIyFqTFdZYPWYumx5gJBmWn7GbZQ3O3HodzmHYIHhCYg4dCDfSN8iCHzezerdHbzWUKR7pzMDOzvq017a63LSqYkSJ0gWxrgJFj45HR25eJj5szEFmuQlCfkbWpCwYopeNhy1toC9PvSfVCnHpI7EXeqVcspP0aQISflgD0pBMgg2ieITRa5gXRnKoDdem1yXvHjcDBXJFoUy63zDwg6tTtRR6rijcvoxNzGjWCgQhdqzlv6CW2CVgK2aa0VSX9RMSUTSKXmru7mvZUXJxv7RO7n1Zw9meFygwHwgNrZgeRWVYhsXBtEG8Bak7sPQ7x37QXgIgbJRcbhqMK2F5baa"></div>
70 |                               </div>
71 |                           </div>
72 |                       </div>
73 |                   </div>
74 |               </div>
75 |           </div>
76 |       </div>
77 |   </div>
78 |   `
79 | 


--------------------------------------------------------------------------------
/__tests__/e2e/test.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 |     <head>
  3 |         <script type="application/javascript" src="./simmer.js"></script>
  4 |     </head>
  5 |     <body>
  6 |         hello
  7 |         <div id="fixture" style="display:none">
  8 |         <div id="TopContainer">
  9 |             <div class="header"><span id="NavBar"> <ul>
 10 |                 <Li class="Edge"><a href="./page/link_1">Page #1</a></Li>
 11 |                 <Li><span>Here:<span id="helper"></span></span><a href="./page/link_2">Page #2</a></Li>
 12 |                 <Li class="Active"><a href="./page/link_3">Page #3</a></Li>
 13 |                 <Li><a href="./page/link_4">Page #4 <img src="./image/Pixel.png"/></a></Li>
 14 |                 <Li class="Edge"><a href="./page/link_5">Page #5</a></Li>
 15 |             </ul> </span></div>
 16 |             <div id="111"></div>
 17 |             <div id="a111a"></div>
 18 |             <div id="a111"></div>
 19 |             <div id="111aaaaaa"></div>
 20 |             <div id="BodyDiv">
 21 |                 <div id="NonUniqueDiv"><img src="./image/NoID.png"></div>
 22 |                 <div><img src="./image/NonUniqueSRC.png">
 23 |                     <table>
 24 |                         <tr>
 25 |                             <th><a href="non.html">First</a></th>
 26 |                             <th><a href="second.html">Second</a></th>
 27 |                             <th><a href="non.html">Third<a/></th>
 28 |                         </tr>
 29 |                         <tr>
 30 |                             <td>1 <span class="sameclass diferentclass1"></span> <span class="diferentclass2"></span> <span
 31 |                                     class="diferentclass1"></span> <span class="diferentclass1 sameclass"></span> <span
 32 |                                     class="diferentclass1"></span></td>
 33 |                             <td>2</td>
 34 |                             <td>Cell to target!</td>
 35 |                         </tr>
 36 |                         <tr>
 37 |                             <td>A</td>
 38 |                             <td>B</td>
 39 |                             <td>C</td>
 40 |                         </tr>
 41 |                     </table>
 42 |                 </div>
 43 |                 <div id="NonUniqueDiv"><img src="./image/NonUniqueSRC.png"></div>
 44 |             </div>
 45 |             <div>
 46 |                 <span>
 47 |                     <span>
 48 |                         <span>
 49 |                             <span>
 50 |                             <span>
 51 |                                 <p><a href="a">a</a></p>
 52 |                             </span>
 53 |                             </span>
 54 |                         </span>
 55 |                     </span>
 56 |                 </span>
 57 |                 <span id="deepId">
 58 |                     <span>
 59 |                         <span>
 60 |                             <span>
 61 |                             <span>
 62 |                                 <p>
 63 |                                     <a href="a" id="placeholderId">a</a>
 64 |                                 </p>
 65 |                             </span>
 66 |                             </span>
 67 |                         </span>
 68 |                     </span>
 69 |                 </span>
 70 |                 <span>
 71 |                     <span>
 72 |                         <p><a href="a">a</a>
 73 |                         </p>
 74 |                     </span>
 75 |                 </span>
 76 |             </div>
 77 |             <div class="invalid_child_tag">
 78 |                 <gidi:test><span></span></gidi:test>
 79 |             </div>
 80 |             <div id="placeholder_4">
 81 |                 <div>
 82 |                     <div class="uniqueClassName"></div>
 83 |                 </div>
 84 |             </div>
 85 |             <div id="placeholder_4">
 86 |                 <div class="secondLevelUniqueClassName">
 87 |                     <div></div>
 88 |                 </div>
 89 |             </div>
 90 |             <div id="placeholder_5">
 91 |                 <div>
 92 |                     <div id=":asd" class="invalidIDElement"></div>
 93 |                 </div>
 94 |             </div>
 95 |         </div>
 96 |         <div>
 97 |             <div>
 98 |                 <div>
 99 |                     <div>
100 |                         <div>
101 |                             <div>
102 |                                 <div>
103 |                                     <div id="aZROCRDPX41Qkden3aiC3o9Tkl0xqENUjIgNSWbe6pSddw86ogN018T9lD67zAF1YHaLkRngy8YVq88IBfqdvtO9aXZZbD1NsSBiUo6txcv22ufrkRs9AZKkxIkTF1gNAZ3Oh4M6TcYWRARVJqOZwo3dQufTDm904ep3yHZ5vdHqIyFqTFdZYPWYumx5gJBmWn7GbZQ3O3HodzmHYIHhCYg4dCDfSN8iCHzezerdHbzWUKR7pzMDOzvq017a63LSqYkSJ0gWxrgJFj45HR25eJj5szEFmuQlCfkbWpCwYopeNhy1toC9PvSfVCnHpI7EXeqVcspP0aQISflgD0pBMgg2ieITRa5gXRnKoDdem1yXvHjcDBXJFoUy63zDwg6tTtRR6rijcvoxNzGjWCgQhdqzlv6CW2CVgK2aa0VSX9RMSUTSKXmru7mvZUXJxv7RO7n1Zw9meFygwHwgNrZgeRWVYhsXBtEG8Bak7sPQ7x37QXgIgbJRcbhqMK2F5baa"></div>
104 |                                 </div>
105 |                             </div>
106 |                         </div>
107 |                     </div>
108 |                 </div>
109 |             </div>
110 |         </div>
111 |         </div>
112 |     </body>
113 | </html>


--------------------------------------------------------------------------------
/modules/simmer.js:
--------------------------------------------------------------------------------
  1 | import initQueryEngine, { wrap } from './queryEngine'
  2 | import parsingMethods from './methods'
  3 | import validateSelector from './validateSelector'
  4 | import convertSelectorStateIntoCSSSelector from './convertSelectorStateIntoCSSSelector'
  5 | import Parser from './parser'
  6 | import stackHierarchy from './stackHierarchy'
  7 | import { configure } from './configuration'
  8 | 
  9 | export default function createSimmer (
 10 |   windowScope = window,
 11 |   customConfig = {},
 12 |   customQuery = false
 13 | ) {
 14 |   const config = configure(customConfig)
 15 |   const query = customQuery || initQueryEngine(windowScope, config.queryEngine)
 16 |   /**
 17 |      * Handle errors in accordance with what is specified in the configuration
 18 |      * @param {object/string} ex. The exception object or message
 19 |      * @param {object} element. The element Simmer was asked to process
 20 |      */
 21 |   function onError (ex, element) {
 22 |     // handle error
 23 |     if (config.errorHandling === true) {
 24 |       throw ex
 25 |     }
 26 |     if (typeof config.errorHandling === 'function') {
 27 |       config.errorHandling(ex, element)
 28 |     }
 29 |   }
 30 | 
 31 |   // Initialize the Simmer object and set it over the reference on the window
 32 |   /**
 33 |    * The main Simmer action - parses an element on the page to produce a CSS selector for it.
 34 |    * This function will be returned into the global Simmer object.
 35 |    * @param {object} element. A DOM element you wish to create a selector for.
 36 |    * @example
 37 |    <code><pre>
 38 |    var cssSelectorForDonJulio = Simmer(document.getElementByID('DonJulio'));
 39 |    </pre></code>
 40 |    */
 41 |   const simmer = function (element) {
 42 |     if (!element) {
 43 |       // handle error
 44 |       onError.call(
 45 |         simmer,
 46 |         new Error('Simmer: No element was specified for parsing.'),
 47 |         element
 48 |       )
 49 |       return false
 50 |     }
 51 | 
 52 |     // The parser cycles through a set of parsing methods specified in an order optimal
 53 |     // for creating as specific as possible a selector
 54 |     const parser = new Parser(parsingMethods)
 55 | 
 56 |     // get the element's ancestors
 57 |     const hierarchy = stackHierarchy(wrap(element), config.depth)
 58 | 
 59 |     // initialize the state of the selector
 60 |     let selectorState = {
 61 |       // the stack is used to build a layer of selectors, each layer coresponding to a specific element in the heirarchy
 62 |       // for each level we create a private stack of properties, so that we can then merge them
 63 |       // comfortably and allow all methods to see the level at which existing properties have been set
 64 |       stack: Array(hierarchy.length).fill().map(() => []),
 65 |       // follow the current specificity level of the selector - the higher the better
 66 |       specificity: 0
 67 |     }
 68 | 
 69 |     const validator = validateSelector(element, config, query, onError)
 70 | 
 71 |     // cycle through the available parsing methods and while we still have yet to find the requested element's one-to-one selector
 72 |     // we keep calling the methods until we are either satisfied or run out of methods
 73 |     while (!parser.finished() && !selectorState.verified) {
 74 |       try {
 75 |         selectorState = parser.next(
 76 |           hierarchy,
 77 |           selectorState,
 78 |           validator,
 79 |           config,
 80 |           query
 81 |         )
 82 | 
 83 |         // if we have reached a satisfactory level of specificity, try the selector, perhaps we have found our selector?
 84 |         if (
 85 |           selectorState.specificity >= config.specificityThreshold &&
 86 |           !selectorState.verified
 87 |         ) {
 88 |           selectorState.verified = validator(selectorState)
 89 |         }
 90 |       } catch (ex) {
 91 |         // handle error
 92 |         onError.call(simmer, ex, element)
 93 |       }
 94 |     }
 95 | 
 96 |     // if we were not able to produce a one-to-one selector, return false
 97 |     if (
 98 |       selectorState.verified === undefined ||
 99 |       selectorState.specificity < config.specificityThreshold
100 |     ) {
101 |       // if it is undefined then verfication has never been run!
102 |       // try and verify, and if verification fails - return false
103 |       // if it is false and the specificity is too low to actually try and find the element in the first place, then we may simply have not run
104 |       // an up to date verification - try again
105 |       selectorState.verified = validator(selectorState)
106 |     }
107 | 
108 |     if (!selectorState.verified) {
109 |       return false
110 |     }
111 | 
112 |     if (selectorState.verificationDepth) {
113 |       return convertSelectorStateIntoCSSSelector(
114 |         selectorState,
115 |         selectorState.verificationDepth
116 |       )
117 |     }
118 |     return convertSelectorStateIntoCSSSelector(selectorState)
119 |   }
120 | 
121 |   /**
122 |    * Get/Set the configuration for the Simmer object
123 |    * @param config (Object) A configuration object with any of the properties tweeked (none/depth/minimumSpecificity)
124 |    * @example
125 |    <code><pre>
126 |    configuration({
127 |             depth: 3
128 |          });
129 |    </pre></code>
130 |    */
131 |   simmer.configure = function (configValues = {}, scope = windowScope) {
132 |     const newConfig = configure({
133 |       ...config,
134 |       ...configValues
135 |     })
136 |     return createSimmer(
137 |       scope,
138 |       newConfig,
139 |       initQueryEngine(scope, newConfig.queryEngine)
140 |     )
141 |   }
142 | 
143 |   return simmer
144 | }
145 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Simmer JS [![Build Status](https://travis-ci.org/gmmorris/simmerjs.svg?branch=master)](https://travis-ci.org/gmmorris/simmerjs) [![Code Climate](https://codeclimate.com/github/gmmorris/simmerjs/badges/gpa.svg)](https://codeclimate.com/github/gmmorris/simmerjs)
  2 | =========
  3 | 
  4 | ## Docs
  5 | 
  6 | A pure Javascript reverse CSS selector engine which calculates a DOM element's unique CSS selector on the current page.
  7 | 
  8 | ## Installation
  9 | Simmer is now meant to be consumed as a module via npm and is no longer meant as a drop in script into the browser.
 10 | That said, we still build a version meant to be dropped into the browser which resides on *window.Simmer* as before.
 11 | 
 12 | We highly recommend you consume Simmer in the following manner, but in the interest of supporting exosting users we've retained the previous API.
 13 | 
 14 | ```bash
 15 | npm i --save simmerjs
 16 | ```
 17 | 
 18 | And then in your code:
 19 | ```js
 20 | import Simmer from 'simmerjs'
 21 | 
 22 | const simmer = new Simmer()
 23 | 
 24 | const el =  document.getElementById('#SomeElement')
 25 | 
 26 | expect(
 27 |     simmer(el)
 28 | ).to.equal(
 29 |     '#SomeElement'
 30 | )
 31 | 
 32 | ```
 33 | 
 34 | When using the distribution located in the repo under **dist/simmer.js** a global *Simmer* function will be exposed on the **window**.
 35 | This is **not** the constructor, but rather a default instance which has exposed itself on the window wit ha default configuration.
 36 | This is not an idea API and is meant to maintain the original API dating back to 2011 when this library was originally written.
 37 | 
 38 | ### Basic usage
 39 | 
 40 | To use Simmer to analyze an element and produce a unique CSS selector for it, all you have to do is instansiate a simmer query engine and pass it an element on the page.
 41 | Usually you'd create a single instance which you would then use multiple times.
 42 | 
 43 | 
 44 | ```html
 45 | <div id="myUniqueElement">
 46 |     <span></span>
 47 |     <br/>
 48 |     <span></span>
 49 | </div>
 50 | ```
 51 | 
 52 | ```js
 53 | import Simmer from 'simmerjs'
 54 | 
 55 | const simmer = new Simmer(window, { /* some custom configuration */ })
 56 | var myElement = document.getElementById("#myUniqueElement");
 57 | 
 58 | console.log(simmer(myElement)); // prints "[id='myUniqueElement']"
 59 | ```
 60 | ## API
 61 | 
 62 | ### Simmer
 63 | ```js
 64 |     Simmer([Scope], [Options], [query])
 65 | ```
 66 | 
 67 | #### Scope
 68 | When you create an instance of Simmer its first argument is the context in which Simmer should query for elements.
 69 | Generally speaking this would be the **window**, which is the default value, but it would be overriden in a situation where you might be using Simmer against a Virtual Dom implementation.
 70 | If you _are_ using a Virtual DOM, you should provide the Window object of the Virtual DOM
 71 | 
 72 | #### Options
 73 | The second argument is an Options object allowing you to override the default configuration for Simmer's behaviour.
 74 | 
 75 | The options are:
 76 | 
 77 | | Option | Default |
 78 | | ------ | ------- |
 79 | | **specificityThreshold** - A minimum specificty level. Once the parser reaches this level it starts verifying the selector after every method is called. This can cut down our execution time by avoiding needless parsing but can also hurt execution times by performing many verifications. Specificity is calculated based on the W3C spec: http://www.w3.org/TR/css3-selectors/#specificity |  100 |
 80 | | **depth** - How deep into the DOM hierarchy should Simmer go in order to reach a unique selector. This is a delicate game because the higher the number the more likely you are to reach a unique selector, but it also means a longer and more breakable one. Assuming you want to store this selector to use later, making it longer also means it is more likely to change and loose it's validity. | 3 | |
 81 | | **errorHandling** - How to handle errors which occur during the analysis <br/><br/>Valid Options<br/><ul><li>_false_: errors are ignored by Simmer</li><li>_true_: errors rethrown and expected to be caught by the user</li><li>_a function callback will be called with two parameters: the exception and the element being analyzed</li></ul> | false |
 82 | | **selectorMaxLength** - A maximum length for the CSS selector can be specified - if no specific selector can be found which is shorter than this length then it is treated as if no selector could be found. | 520 |
 83 | 
 84 | #### query
 85 | The third argument is a query engine you wish Simmer to use when evaluating generated selectors.
 86 | By default Simmer uses the **window.document.querySelectorAll** function and if you provide a window to the scope, Simmer will assume that you want it to use the **document.querySelectorAll** on that **window**.
 87 | But if you wish Simmer to use another custom function, such as your own tweaked version of jQuery, you can do so by passing the third argument to the Simmer constructor.
 88 | 
 89 | The signature the query function should provide is this:
 90 | 
 91 | ##### query(selector: String, onError: Error => {}) : Array(DomElements)
 92 | What this means is that the function you provide should expect to receive a string CSS selector and a function.
 93 | It should them query for elements matching the selector and return an array of the results (even if there is only one result, it should be returned in an Array.).
 94 | 
 95 | The second argument is a function which should be called if any error is encountered when querying for the elements.
 96 | If an error occurs or a problem is encountered, instead of throwing, you should call the function and pass the error object to it. Simmer will then handle the error as per its configuration.
 97 | 
 98 | ### Reconfiguring
 99 | If you have an existing instance of Simmer, you can use its **configure** method to instanciate a new Simmer which has the same scope and configuration as the existing one, with any new configuration you wish to apply.
100 | 
101 | So, for example, in the browser, you can replace the global Simmer wit ha newly configured version:
102 | ```js
103 | 
104 | window.Simmer = window.Simmer.configure({
105 |     depth: 10
106 | })
107 | ```
108 | 
109 | And in Node:
110 | ```js
111 | import Simmer from 'simmerjs'
112 | 
113 | const virtualWindow = new JSDom()
114 | 
115 | const simmer = new Simmer(virtualWindow)
116 | 
117 | const reconfiguredSimmer = simmer.configure({ /* some custom configuration */ })
118 | 
119 | ```
120 | 
121 | ### Conflict
122 | When the Simmer browser dist located at **dist/simmer.js** is injected in to the browser it adds the noConflict function on itself.
123 | This is not relevant in a Node environment and isn't available there.
124 | 
125 | Just in case you also had the brilliant idea of using a variable called "Simmer", or you wish to move it off of the global object then you can use the noConflict method to receive a reference to the object and remove it from the window.
126 | Calling it will also revert the original value of window.Simmer which was there before loading the Simmer.js script (if there was one)
127 | 
128 | ```js
129 |     var mySimmer = Simmer.noConflict();
130 |     mySimmer(myElm);
131 | ```
132 | 


--------------------------------------------------------------------------------
/__tests__/integration/index.test.js:
--------------------------------------------------------------------------------
  1 | import fixture from './fixture'
  2 | import {
  3 |   queryEngine,
  4 |   NoResult,
  5 |   compareParentElementAndSimmer,
  6 |   compareElementsAndSimmer
  7 | } from './utils'
  8 | 
  9 | import createSimmer from '../../modules/simmer'
 10 | import exposeOnWindow from '../../modules/exposeOnWindow'
 11 | 
 12 | const { JSDOM } = require('jsdom')
 13 | 
 14 | const installSimmerOnWindow = windowScope => {
 15 |   exposeOnWindow(
 16 |     windowScope,
 17 |     createSimmer(windowScope, { errorHandling: e => console.log(e) })
 18 |   )
 19 |   return windowScope
 20 | }
 21 | 
 22 | const createWindow = (dom = '') =>
 23 |   installSimmerOnWindow(new JSDOM(`<body>${dom}</body>`).window)
 24 | 
 25 | test(`can analyze an element with an ID`, function () {
 26 |   const windowScope = createWindow(fixture)
 27 |   var elements = compareElementsAndSimmer(windowScope, '#BodyDiv')
 28 |   expect(elements).not.toBe(undefined)
 29 |   expect(elements.SimmerEl).not.toBe(undefined)
 30 |   expect(elements.el).not.toBe(undefined)
 31 |   expect(elements.el).toBe(elements.SimmerEl)
 32 | })
 33 | 
 34 | test(`can analyze an element with classes only (No ID)`, function () {
 35 |   const windowScope = createWindow(fixture)
 36 |   var elements = compareElementsAndSimmer(windowScope, '.header')
 37 |   expect(elements).not.toBe(undefined)
 38 |   expect(elements.SimmerEl).not.toBe(undefined)
 39 |   expect(elements.el).not.toBe(undefined)
 40 |   expect(elements.el).toBe(elements.SimmerEl)
 41 | })
 42 | 
 43 | test(`can analyze an element which is a child of an element with an ID`, function () {
 44 |   const windowScope = createWindow(fixture)
 45 |   var elements = compareElementsAndSimmer(windowScope, '#NavBar ul')
 46 |   expect(elements).not.toBe(undefined)
 47 |   expect(elements.SimmerEl).not.toBe(undefined)
 48 |   expect(elements.el).not.toBe(undefined)
 49 |   expect(elements.el).toBe(elements.SimmerEl)
 50 | })
 51 | 
 52 | test(`can analyze anelement which has a class only (no IDs on it or its direct parent)`, function () {
 53 |   const windowScope = createWindow(fixture)
 54 |   var elements = compareElementsAndSimmer(windowScope, '.Active')
 55 |   expect(elements).not.toBe(undefined)
 56 |   expect(elements.el).toBe(elements.SimmerEl)
 57 |   expect(elements.SimmerEl).not.toBe(undefined)
 58 |   expect(elements.el).not.toBe(undefined)
 59 | })
 60 | 
 61 | test(`can analyze an element with an invalid ID (isn't unique)`, function () {
 62 |   const windowScope = createWindow(fixture)
 63 |   var elements = compareElementsAndSimmer(
 64 |     windowScope,
 65 |     '#BodyDiv div:nth-child(3)'
 66 |   )
 67 |   expect(elements.el).toBe(elements.SimmerEl)
 68 |   expect(elements.SimmerEl).not.toBe(undefined)
 69 |   expect(elements.el).not.toBe(undefined)
 70 |   expect(elements).not.toBe(undefined)
 71 | })
 72 | 
 73 | test(`can analyze an element with an invalid ID (isn't unique) at same level as other element with the same ID`, function () {
 74 |   const windowScope = createWindow(fixture)
 75 |   var elements = compareElementsAndSimmer(
 76 |     windowScope,
 77 |     '#BodyDiv div:nth-child(1)'
 78 |   )
 79 |   expect(elements).not.toBe(undefined)
 80 |   expect(elements.el).toBe(elements.SimmerEl)
 81 |   expect(elements.SimmerEl).not.toBe(undefined)
 82 |   expect(elements.el).not.toBe(undefined)
 83 | })
 84 | 
 85 | test(`can analyze an element with identical siblings (neither unique ID nor class)`, function () {
 86 |   const windowScope = createWindow(fixture)
 87 |   var elements = compareElementsAndSimmer(windowScope, '.Edge:nth-child(5)')
 88 |   expect(elements).not.toBe(undefined)
 89 |   expect(elements.SimmerEl).not.toBe(undefined)
 90 |   expect(elements.el).not.toBe(undefined)
 91 |   expect(elements.el).toBe(elements.SimmerEl)
 92 | })
 93 | 
 94 | test(`can analyze an element with a parent which has identical siblings`, function () {
 95 |   const windowScope = createWindow(fixture)
 96 |   var elements = compareParentElementAndSimmer(windowScope, '#helper') // parent of #helper!
 97 |   expect(elements).not.toBe(undefined)
 98 |   expect(elements.SimmerEl).not.toBe(undefined)
 99 |   expect(elements.el).not.toBe(undefined)
100 |   expect(elements.el).toBe(elements.SimmerEl)
101 | })
102 | 
103 | test(`can analyze an image who'se paren't has an invalid ID`, function () {
104 |   const windowScope = createWindow(fixture)
105 |   var elements = compareElementsAndSimmer(
106 |     windowScope,
107 |     '#BodyDiv div:nth-child(1) img'
108 |   )
109 |   expect(elements).not.toBe(undefined)
110 |   expect(elements.SimmerEl).not.toBe(undefined)
111 |   expect(elements.el).not.toBe(undefined)
112 |   expect(elements.el).toBe(elements.SimmerEl)
113 | })
114 | 
115 | test(`can analyze an image with a non unique src attribute`, function () {
116 |   const windowScope = createWindow(fixture)
117 |   var elements = compareElementsAndSimmer(
118 |     windowScope,
119 |     '#BodyDiv div:nth-child(2) img'
120 |   )
121 |   expect(elements).not.toBe(undefined)
122 |   expect(elements.SimmerEl).not.toBe(undefined)
123 |   expect(elements.el).not.toBe(undefined)
124 |   expect(elements.el).toBe(elements.SimmerEl)
125 | })
126 | 
127 | test(`can analyze an image with a unique src attribute`, function () {
128 |   const windowScope = createWindow(fixture)
129 |   var elements = compareElementsAndSimmer(
130 |     windowScope,
131 |     'img[src="./image/Pixel.png"]'
132 |   )
133 |   expect(elements).not.toBe(undefined)
134 |   expect(elements.SimmerEl).not.toBe(undefined)
135 |   expect(elements.el).not.toBe(undefined)
136 |   expect(elements.el).toBe(elements.SimmerEl)
137 | })
138 | 
139 | test(`can analyze a child of a hierarchy with identical siblings and no unique IDs`, function () {
140 |   const windowScope = createWindow(fixture)
141 |   var elements = compareElementsAndSimmer(
142 |     windowScope,
143 |     'tr:nth-child(2) td:nth-child(3)'
144 |   )
145 |   expect(elements).not.toBe(undefined)
146 |   expect(elements.SimmerEl).not.toBe(undefined)
147 |   expect(elements.el).not.toBe(undefined)
148 |   expect(elements.el).toBe(elements.SimmerEl)
149 | })
150 | 
151 | test(`can analyze an anchor (link) with a unique href attribute`, function () {
152 |   const windowScope = createWindow(fixture)
153 |   var elements = compareElementsAndSimmer(
154 |     windowScope,
155 |     'table tr th:nth-child(2) a'
156 |   )
157 |   expect(elements).not.toBe(undefined)
158 |   expect(elements.SimmerEl).not.toBe(undefined)
159 |   expect(elements.el).not.toBe(undefined)
160 |   expect(elements.el).toBe(elements.SimmerEl)
161 | })
162 | 
163 | test(`can analyze a link with a non unique href attribute and a heirarchy which has no unique IDs`, function () {
164 |   const windowScope = createWindow(fixture)
165 |   var elements = compareElementsAndSimmer(
166 |     windowScope,
167 |     'table tr th:nth-child(3) a'
168 |   )
169 |   expect(elements).not.toBe(undefined)
170 |   expect(elements.SimmerEl).not.toBe(undefined)
171 |   expect(elements.el).not.toBe(undefined)
172 |   expect(elements.el).toBe(elements.SimmerEl)
173 | })
174 | 
175 | test(`can analyze an element with identical siblings, no IDs and sibling with the same class`, function () {
176 |   const windowScope = createWindow(fixture)
177 |   var elements = compareElementsAndSimmer(windowScope, 'td span:nth-child(3)')
178 |   expect(elements).not.toBe(undefined)
179 |   expect(elements.SimmerEl).not.toBe(undefined)
180 |   expect(elements.el).not.toBe(undefined)
181 |   expect(elements.el).toBe(elements.SimmerEl)
182 | })
183 | 
184 | test(`can analyze an element with identical siblings, no ID and same class as sibling but different class order`, function () {
185 |   const windowScope = createWindow(fixture)
186 |   var elements = compareElementsAndSimmer(windowScope, 'td span:nth-child(4)')
187 |   expect(elements).not.toBe(undefined)
188 |   expect(elements.SimmerEl).not.toBe(undefined)
189 |   expect(elements.el).not.toBe(undefined)
190 |   expect(elements.el).toBe(elements.SimmerEl)
191 | })
192 | 
193 | test(`can analyze an element with identical siblings, no ID and different classes completely`, function () {
194 |   const windowScope = createWindow(fixture)
195 |   var elements = compareElementsAndSimmer(windowScope, 'td span:nth-child(2)')
196 |   expect(elements).not.toBe(undefined)
197 |   expect(elements.SimmerEl).not.toBe(undefined)
198 |   expect(elements.el).not.toBe(undefined)
199 |   expect(elements.el).toBe(elements.SimmerEl)
200 | })
201 | 
202 | test(`cannot parse an element with an identical hierarchy whithin the Simmer's default configured depth`, function () {
203 |   const windowScope = createWindow(fixture)
204 |   var placeHolder = queryEngine(windowScope.document).query('#placeholderId')
205 |   placeHolder.removeAttribute('id')
206 |   const elements = compareElementsAndSimmer(windowScope, placeHolder[0])
207 |   expect(elements).not.toBe(undefined)
208 |   expect(elements).toEqual(NoResult)
209 | })
210 | 
211 | test(`can analyze an element with a parent which has an invalid Tag name`, function () {
212 |   const windowScope = createWindow(fixture)
213 |   var elements = compareElementsAndSimmer(
214 |     windowScope,
215 |     '.invalid_child_tag span'
216 |   )
217 |   expect(elements).not.toBe(undefined)
218 |   expect(elements.SimmerEl).not.toBe(undefined)
219 |   expect(elements.el).not.toBe(undefined)
220 |   expect(elements.el).toBe(elements.SimmerEl)
221 | })
222 | 
223 | test(`can analyze an element based only on child elements when specific enough at level 1`, function () {
224 |   const windowScope = createWindow(fixture)
225 |   var elements = compareElementsAndSimmer(windowScope, '.uniqueClassName')
226 |   expect(elements).not.toBe(undefined)
227 |   expect(elements.SimmerEl).not.toBe(undefined)
228 |   expect(elements.el).not.toBe(undefined)
229 |   expect(elements.el).toBe(elements.SimmerEl)
230 |   // make sure the selector is one level deep
231 |   expect(elements.selector.split('>').length).toBe(1)
232 | })
233 | 
234 | test(`can analyze an element based only on child elements when specific enough at level 2`, function () {
235 |   const windowScope = createWindow(fixture)
236 |   var elements = compareElementsAndSimmer(
237 |     windowScope,
238 |     '.secondLevelUniqueClassName div'
239 |   )
240 |   expect(elements).not.toBe(undefined)
241 |   expect(elements.SimmerEl).not.toBe(undefined)
242 |   expect(elements.el).not.toBe(undefined)
243 |   expect(elements.el).toBe(elements.SimmerEl)
244 |   // make sure the selector is one level deep
245 |   expect(elements.selector.split('>').length).toBe(2)
246 | })
247 | 
248 | test(`can analyze an element with a valid ID that ends with numbers in it's ID`, function () {
249 |   const windowScope = createWindow(fixture)
250 |   var elements = compareElementsAndSimmer(windowScope, '#a111')
251 |   expect(elements).not.toBe(undefined)
252 |   expect(elements.SimmerEl).not.toBe(undefined)
253 |   expect(elements.el).not.toBe(undefined)
254 |   expect(elements.el).toBe(elements.SimmerEl)
255 |   // make sure the selector is one level deep
256 |   expect(elements.selector.match('a111')).toBeTruthy()
257 | })
258 | 
259 | test(`can analyze an element with a valid ID that has numbers in the middle of it's ID`, function () {
260 |   const windowScope = createWindow(fixture)
261 |   var elements = compareElementsAndSimmer(windowScope, '#a111a')
262 |   expect(elements).not.toBe(undefined)
263 |   expect(elements.SimmerEl).not.toBe(undefined)
264 |   expect(elements.el).not.toBe(undefined)
265 |   expect(elements.el).toBe(elements.SimmerEl)
266 |   // make sure the selector is one level deep
267 |   expect(elements.selector.match('a111a')).toBeTruthy()
268 | })
269 | 
270 | test(`can analyze an element with an invalid ID (not unique)`, function () {
271 |   const windowScope = createWindow(fixture)
272 |   var elements = compareElementsAndSimmer(windowScope, '.invalidIDElement')
273 |   expect(elements).not.toBe(undefined)
274 |   expect(elements.SimmerEl).not.toBe(undefined)
275 |   expect(elements.el).not.toBe(undefined)
276 |   expect(elements.el).toBe(elements.SimmerEl)
277 |   // make sure the selector is one level deep
278 |   expect(elements.selector.match(':asd')).toBe(null)
279 | })
280 | 
281 | test(`can't analyze an element which is longer than the selectorMaxLength chars`, function () {
282 |   const windowScope = createWindow(fixture)
283 |   const placeHolder = queryEngine(windowScope.document).query(
284 |     '#aZROCRDPX41Qkden3aiC3o9Tkl0xqENUjIgNSWbe6pSddw86ogN018T9lD67zAF1YHaLkRngy8YVq88IBfqdvtO9aXZZbD1NsSBiUo6txcv22ufrkRs9AZKkxIkTF1gNAZ3Oh4M6TcYWRARVJqOZwo3dQufTDm904ep3yHZ5vdHqIyFqTFdZYPWYumx5gJBmWn7GbZQ3O3HodzmHYIHhCYg4dCDfSN8iCHzezerdHbzWUKR7pzMDOzvq017a63LSqYkSJ0gWxrgJFj45HR25eJj5szEFmuQlCfkbWpCwYopeNhy1toC9PvSfVCnHpI7EXeqVcspP0aQISflgD0pBMgg2ieITRa5gXRnKoDdem1yXvHjcDBXJFoUy63zDwg6tTtRR6rijcvoxNzGjWCgQhdqzlv6CW2CVgK2aa0VSX9RMSUTSKXmru7mvZUXJxv7RO7n1Zw9meFygwHwgNrZgeRWVYhsXBtEG8Bak7sPQ7x37QXgIgbJRcbhqMK2F5baa'
285 |   )
286 |   const elements = compareElementsAndSimmer(windowScope, placeHolder[0])
287 |   expect(elements).not.toBe(undefined)
288 |   expect(elements).toEqual(NoResult)
289 | })
290 | 


--------------------------------------------------------------------------------
/__tests__/e2e/index.js:
--------------------------------------------------------------------------------
  1 | // var config = require('../../nightwatch.conf.js')
  2 | 
  3 | const compareElementsAndSimmer = (
  4 |   browser,
  5 |   selector,
  6 |   onFinish = () => browser.end()
  7 | ) => {
  8 |   browser.execute(
  9 |     function (selector) {
 10 |       var el = document.querySelector(selector)
 11 |       var simmerSelector = window.Simmer(el)
 12 |       var simmerEl = document.querySelector(simmerSelector)
 13 | 
 14 |       return {
 15 |         simmerSelector,
 16 |         didTheyMatch: el === simmerEl
 17 |       }
 18 |     },
 19 |     [selector],
 20 |     function (result) {
 21 |       browser.assert.equal(result.value.didTheyMatch, true)
 22 |       onFinish(result.value.simmerSelector)
 23 |     }
 24 |   )
 25 | }
 26 | 
 27 | const assertUnqueriableBySimmer = (
 28 |   browser,
 29 |   selector,
 30 |   onFinish = () => browser.end()
 31 | ) => {
 32 |   browser.execute(
 33 |     function (selector) {
 34 |       var el = document.querySelector(selector)
 35 |       var simmerSelector = window.Simmer(el)
 36 | 
 37 |       return {
 38 |         simmerSelector,
 39 |         wasUnselectable: simmerSelector === false
 40 |       }
 41 |     },
 42 |     [selector],
 43 |     function (result) {
 44 |       browser.assert.equal(result.value.wasUnselectable, true)
 45 |       onFinish(result.value.simmerSelector)
 46 |     }
 47 |   )
 48 | }
 49 | 
 50 | const compareElementsAndSimmerWithReconfiguration = (
 51 |   browser,
 52 |   id,
 53 |   configuration,
 54 |   onFinish = () => browser.end()
 55 | ) => {
 56 |   browser.execute(
 57 |     function (id, configuration) {
 58 |       var el = document.getElementById(id)
 59 |       el.removeAttribute('id')
 60 | 
 61 |       var simmerSelector = window.Simmer(el)
 62 | 
 63 |       var reconfiguredSimmer = window.Simmer.configure(configuration)
 64 | 
 65 |       var reconfiguredSimmerSelector = reconfiguredSimmer(el)
 66 |       var simmerEl = document.querySelector(reconfiguredSimmerSelector)
 67 | 
 68 |       return {
 69 |         configuration,
 70 |         reconfiguredSimmerSelector,
 71 |         didItFailAtDefault: simmerSelector === false,
 72 |         didTheyMatch: el === simmerEl
 73 |       }
 74 |     },
 75 |     [id, configuration],
 76 |     function (result) {
 77 |       browser.assert.equal(result.value.didItFailAtDefault, true)
 78 |       browser.assert.equal(result.value.didTheyMatch, true)
 79 |       onFinish(result.value.reconfiguredSimmerSelector)
 80 |     }
 81 |   )
 82 | }
 83 | 
 84 | let server
 85 | module.exports = {
 86 |   before: function (browser, done) {
 87 |     server = require('../server')(done) // done is a callback that executes when the server is started
 88 |   },
 89 | 
 90 |   after: function () {
 91 |     server.close()
 92 |   },
 93 | 
 94 |   'can analyze an element with an ID': function (browser) {
 95 |     browser
 96 |       .url('localhost:3993') // visit the local url
 97 |       .waitForElementVisible('body') // wait for the body to be rendered
 98 | 
 99 |     compareElementsAndSimmer(browser, '#BodyDiv')
100 |   },
101 | 
102 |   'can analyze an element with classes only (No ID)': function (browser) {
103 |     browser
104 |       .url('localhost:3993') // visit the local url
105 |       .waitForElementVisible('body') // wait for the body to be rendered
106 | 
107 |     compareElementsAndSimmer(browser, '.header')
108 |   },
109 | 
110 |   'can analyze an element which is a child of an element with an ID': function (
111 |     browser
112 |   ) {
113 |     browser
114 |       .url('localhost:3993') // visit the local url
115 |       .waitForElementVisible('body') // wait for the body to be rendered
116 | 
117 |     compareElementsAndSimmer(browser, '#NavBar ul')
118 |   },
119 | 
120 |   'can analyze anelement which has a class only (no IDs on it or its direct parent)': function (
121 |     browser
122 |   ) {
123 |     browser
124 |       .url('localhost:3993') // visit the local url
125 |       .waitForElementVisible('body') // wait for the body to be rendered
126 | 
127 |     compareElementsAndSimmer(browser, '.Active')
128 |   },
129 | 
130 |   'can analyze an element with an invalid ID (isnt unique)': function (browser) {
131 |     browser
132 |       .url('localhost:3993') // visit the local url
133 |       .waitForElementVisible('body') // wait for the body to be rendered
134 | 
135 |     compareElementsAndSimmer(browser, '#BodyDiv div:nth-child(3)')
136 |   },
137 | 
138 |   'can analyze an element with an invalid ID (isnt unique) at same level as other element with the same ID': function (
139 |     browser
140 |   ) {
141 |     browser
142 |       .url('localhost:3993') // visit the local url
143 |       .waitForElementVisible('body') // wait for the body to be rendered
144 | 
145 |     compareElementsAndSimmer(browser, '#BodyDiv div:nth-child(1)')
146 |   },
147 | 
148 |   'can analyze an element with identical siblings (neither unique ID nor class)': function (
149 |     browser
150 |   ) {
151 |     browser
152 |       .url('localhost:3993') // visit the local url
153 |       .waitForElementVisible('body') // wait for the body to be rendered
154 | 
155 |     compareElementsAndSimmer(browser, '.Edge:nth-child(5)')
156 |   },
157 | 
158 |   'can analyze an element with a parent which has identical siblings': function (
159 |     browser
160 |   ) {
161 |     browser
162 |       .url('localhost:3993') // visit the local url
163 |       .waitForElementVisible('body') // wait for the body to be rendered
164 | 
165 |     compareElementsAndSimmer(browser, '#helper') // parent of #helper!
166 |   },
167 | 
168 |   'can analyze an image whose parent has an invalid ID': function (browser) {
169 |     browser
170 |       .url('localhost:3993') // visit the local url
171 |       .waitForElementVisible('body') // wait for the body to be rendered
172 | 
173 |     compareElementsAndSimmer(browser, '#BodyDiv div:nth-child(1) img')
174 |   },
175 | 
176 |   'can analyze an image with a non unique src attribute': function (browser) {
177 |     browser
178 |       .url('localhost:3993') // visit the local url
179 |       .waitForElementVisible('body') // wait for the body to be rendered
180 | 
181 |     compareElementsAndSimmer(browser, '#BodyDiv div:nth-child(2) img')
182 |   },
183 | 
184 |   'can analyze an image with a unique src attribute': function (browser) {
185 |     browser
186 |       .url('localhost:3993') // visit the local url
187 |       .waitForElementVisible('body') // wait for the body to be rendered
188 | 
189 |     compareElementsAndSimmer(browser, 'img[src="./image/Pixel.png"]')
190 |   },
191 | 
192 |   'can analyze a child of a hierarchy with identical siblings and no unique IDs': function (
193 |     browser
194 |   ) {
195 |     browser
196 |       .url('localhost:3993') // visit the local url
197 |       .waitForElementVisible('body') // wait for the body to be rendered
198 | 
199 |     compareElementsAndSimmer(browser, 'tr:nth-child(2) td:nth-child(3)')
200 |   },
201 | 
202 |   'can analyze an anchor (link) with a unique href attribute': function (
203 |     browser
204 |   ) {
205 |     browser
206 |       .url('localhost:3993') // visit the local url
207 |       .waitForElementVisible('body') // wait for the body to be rendered
208 | 
209 |     compareElementsAndSimmer(browser, 'table tr th:nth-child(2) a')
210 |   },
211 | 
212 |   'can analyze a link with a non unique href attribute and a heirarchy which has no unique IDs': function (
213 |     browser
214 |   ) {
215 |     browser
216 |       .url('localhost:3993') // visit the local url
217 |       .waitForElementVisible('body') // wait for the body to be rendered
218 | 
219 |     compareElementsAndSimmer(browser, 'table tr th:nth-child(3) a')
220 |   },
221 | 
222 |   'can analyze an element with identical siblings, no IDs and sibling with the same class': function (
223 |     browser
224 |   ) {
225 |     browser
226 |       .url('localhost:3993') // visit the local url
227 |       .waitForElementVisible('body') // wait for the body to be rendered
228 | 
229 |     compareElementsAndSimmer(browser, 'td span:nth-child(3)')
230 |   },
231 | 
232 |   'can analyze an element with identical siblings, no ID and same class as sibling but different class order': function (
233 |     browser
234 |   ) {
235 |     browser
236 |       .url('localhost:3993') // visit the local url
237 |       .waitForElementVisible('body') // wait for the body to be rendered
238 | 
239 |     compareElementsAndSimmer(browser, 'td span:nth-child(4)')
240 |   },
241 | 
242 |   'can analyze an element with identical siblings, no ID and different classes completely': function (
243 |     browser
244 |   ) {
245 |     browser
246 |       .url('localhost:3993') // visit the local url
247 |       .waitForElementVisible('body') // wait for the body to be rendered
248 | 
249 |     compareElementsAndSimmer(browser, 'td span:nth-child(2)')
250 |   },
251 | 
252 |   'cannot parse an element with an identical hierarchy whithin the Simmers default configured depth': function (
253 |     browser
254 |   ) {
255 |     browser
256 |       .url('localhost:3993') // visit the local url
257 |       .waitForElementVisible('body') // wait for the body to be rendered
258 | 
259 |     compareElementsAndSimmerWithReconfiguration(
260 |       browser,
261 |       'placeholderId',
262 |       { depth: 7 },
263 |       selector => {
264 |         browser.assert.equal(
265 |           selector,
266 |           "SPAN[id='deepId'] > SPAN > SPAN > SPAN > SPAN > P > A"
267 |         )
268 |         browser.end()
269 |       }
270 |     )
271 |   },
272 | 
273 |   'can analyze an element with a parent which has an invalid Tag name': function (
274 |     browser
275 |   ) {
276 |     browser
277 |       .url('localhost:3993') // visit the local url
278 |       .waitForElementVisible('body') // wait for the body to be rendered
279 | 
280 |     compareElementsAndSimmer(browser, '.invalid_child_tag span')
281 |   },
282 | 
283 |   'can analyze an element based only on child elements when specific enough at level 1': function (
284 |     browser
285 |   ) {
286 |     browser
287 |       .url('localhost:3993') // visit the local url
288 |       .waitForElementVisible('body') // wait for the body to be rendered
289 | 
290 |     compareElementsAndSimmer(browser, '.uniqueClassName', selector => {
291 |       // make sure the selector is one level deep
292 |       browser.assert.equal(selector.split('>').length, 1)
293 |       browser.end()
294 |     })
295 |   },
296 | 
297 |   'can analyze an element based only on child elements when specific enough at level 2': function (
298 |     browser
299 |   ) {
300 |     browser
301 |       .url('localhost:3993') // visit the local url
302 |       .waitForElementVisible('body') // wait for the body to be rendered
303 | 
304 |     compareElementsAndSimmer(
305 |       browser,
306 |       '.secondLevelUniqueClassName div',
307 |       selector => {
308 |         // make sure the selector is one level deep
309 |         browser.assert.equal(selector.split('>').length, 2)
310 |         browser.end()
311 |       }
312 |     )
313 |   },
314 | 
315 |   'can analyze an element with a valid ID that ends with numbers in its ID': function (
316 |     browser
317 |   ) {
318 |     browser
319 |       .url('localhost:3993') // visit the local url
320 |       .waitForElementVisible('body') // wait for the body to be rendered
321 | 
322 |     compareElementsAndSimmer(browser, '#a111', selector => {
323 |       browser.assert.equal(selector.match('a111')[0], 'a111')
324 |       browser.end()
325 |     })
326 |   },
327 | 
328 |   'can analyze an element with a valid ID that has numbers in the middle of its ID': function (
329 |     browser
330 |   ) {
331 |     browser
332 |       .url('localhost:3993') // visit the local url
333 |       .waitForElementVisible('body') // wait for the body to be rendered
334 | 
335 |     compareElementsAndSimmer(browser, '#a111a', selector => {
336 |       browser.assert.equal(selector.match('a111a')[0], 'a111a')
337 |       browser.end()
338 |     })
339 |   },
340 | 
341 |   'can analyze an element with an invalid ID (not unique)': function (browser) {
342 |     browser
343 |       .url('localhost:3993') // visit the local url
344 |       .waitForElementVisible('body') // wait for the body to be rendered
345 | 
346 |     compareElementsAndSimmer(browser, '.invalidIDElement', selector => {
347 |       // make sure the invalid ID is ommited
348 |       browser.assert.equal(selector.match(':asd'), null)
349 |       browser.end()
350 |     })
351 |   },
352 | 
353 |   'cant analyze an element which is longer than the selectorMaxLength chars': function (
354 |     browser
355 |   ) {
356 |     browser
357 |       .url('localhost:3993') // visit the local url
358 |       .waitForElementVisible('body') // wait for the body to be rendered
359 | 
360 |     assertUnqueriableBySimmer(
361 |       browser,
362 |       '#aZROCRDPX41Qkden3aiC3o9Tkl0xqENUjIgNSWbe6pSddw86ogN018T9lD67zAF1YHaLkRngy8YVq88IBfqdvtO9aXZZbD1NsSBiUo6txcv22ufrkRs9AZKkxIkTF1gNAZ3Oh4M6TcYWRARVJqOZwo3dQufTDm904ep3yHZ5vdHqIyFqTFdZYPWYumx5gJBmWn7GbZQ3O3HodzmHYIHhCYg4dCDfSN8iCHzezerdHbzWUKR7pzMDOzvq017a63LSqYkSJ0gWxrgJFj45HR25eJj5szEFmuQlCfkbWpCwYopeNhy1toC9PvSfVCnHpI7EXeqVcspP0aQISflgD0pBMgg2ieITRa5gXRnKoDdem1yXvHjcDBXJFoUy63zDwg6tTtRR6rijcvoxNzGjWCgQhdqzlv6CW2CVgK2aa0VSX9RMSUTSKXmru7mvZUXJxv7RO7n1Zw9meFygwHwgNrZgeRWVYhsXBtEG8Bak7sPQ7x37QXgIgbJRcbhqMK2F5baa'
363 |     )
364 |   }
365 | }
366 | 


--------------------------------------------------------------------------------
/dist/simmer.js:
--------------------------------------------------------------------------------
 1 | var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.owns=function(d,k){return Object.prototype.hasOwnProperty.call(d,k)};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(d,k,e){d!=Array.prototype&&d!=Object.prototype&&(d[k]=e.value)};
 2 | $jscomp.getGlobal=function(d){return"undefined"!=typeof window&&window===d?d:"undefined"!=typeof global&&null!=global?global:d};$jscomp.global=$jscomp.getGlobal(this);$jscomp.polyfill=function(d,k,e,h){if(k){e=$jscomp.global;d=d.split(".");for(h=0;h<d.length-1;h++){var q=d[h];q in e||(e[q]={});e=e[q]}d=d[d.length-1];h=e[d];k=k(h);k!=h&&null!=k&&$jscomp.defineProperty(e,d,{configurable:!0,writable:!0,value:k})}};
 3 | $jscomp.polyfill("Object.assign",function(d){return d?d:function(d,e){for(var k=1;k<arguments.length;k++){var q=arguments[k];if(q)for(var r in q)$jscomp.owns(q,r)&&(d[r]=q[r])}return d}},"es6-impl","es3");$jscomp.SYMBOL_PREFIX="jscomp_symbol_";$jscomp.initSymbol=function(){$jscomp.initSymbol=function(){};$jscomp.global.Symbol||($jscomp.global.Symbol=$jscomp.Symbol)};$jscomp.symbolCounter_=0;$jscomp.Symbol=function(d){return $jscomp.SYMBOL_PREFIX+(d||"")+$jscomp.symbolCounter_++};
 4 | $jscomp.initSymbolIterator=function(){$jscomp.initSymbol();var d=$jscomp.global.Symbol.iterator;d||(d=$jscomp.global.Symbol.iterator=$jscomp.global.Symbol("iterator"));"function"!=typeof Array.prototype[d]&&$jscomp.defineProperty(Array.prototype,d,{configurable:!0,writable:!0,value:function(){return $jscomp.arrayIterator(this)}});$jscomp.initSymbolIterator=function(){}};$jscomp.arrayIterator=function(d){var k=0;return $jscomp.iteratorPrototype(function(){return k<d.length?{done:!1,value:d[k++]}:{done:!0}})};
 5 | $jscomp.iteratorPrototype=function(d){$jscomp.initSymbolIterator();d={next:d};d[$jscomp.global.Symbol.iterator]=function(){return this};return d};$jscomp.polyfill("Array.from",function(d){return d?d:function(d,e,h){$jscomp.initSymbolIterator();e=null!=e?e:function(d){return d};var k=[],r=d[Symbol.iterator];if("function"==typeof r)for(d=r.call(d);!(r=d.next()).done;)k.push(e.call(h,r.value));else for(var r=d.length,K=0;K<r;K++)k.push(e.call(h,d[K]));return k}},"es6-impl","es3");
 6 | $jscomp.iteratorFromArray=function(d,k){$jscomp.initSymbolIterator();d instanceof String&&(d+="");var e=0,h={next:function(){if(e<d.length){var q=e++;return{value:k(q,d[q]),done:!1}}h.next=function(){return{done:!0,value:void 0}};return h.next()}};h[Symbol.iterator]=function(){return h};return h};$jscomp.polyfill("Array.prototype.keys",function(d){return d?d:function(){return $jscomp.iteratorFromArray(this,function(d){return d})}},"es6-impl","es3");
 7 | $jscomp.polyfill("Object.is",function(d){return d?d:function(d,e){return d===e?0!==d||1/d===1/e:d!==d&&e!==e}},"es6-impl","es3");$jscomp.polyfill("Array.prototype.includes",function(d){return d?d:function(d,e){var h=this;h instanceof String&&(h=String(h));var k=h.length;for(e=e||0;e<k;e++)if(h[e]==d||Object.is(h[e],d))return!0;return!1}},"es7","es3");
 8 | $jscomp.checkStringArgs=function(d,k,e){if(null==d)throw new TypeError("The 'this' value for String.prototype."+e+" must not be null or undefined");if(k instanceof RegExp)throw new TypeError("First argument to String.prototype."+e+" must not be a regular expression");return d+""};$jscomp.polyfill("String.prototype.includes",function(d){return d?d:function(d,e){return-1!==$jscomp.checkStringArgs(this,d,"includes").indexOf(d,e||0)}},"es6-impl","es3");
 9 | $jscomp.polyfill("Array.prototype.fill",function(d){return d?d:function(d,e,h){var k=this.length||0;0>e&&(e=Math.max(0,k+e));if(null==h||h>k)h=k;h=Number(h);0>h&&(h=Math.max(0,k+h));for(e=Number(e||0);e<h;e++)this[e]=d;return this}},"es6-impl","es3");
10 | (function(){function d(a,b){var c=[];for(a=a[b];a&&9!==a.nodeType;)1===a.nodeType&&c.push(k(a)),a=a[b];return c}function k(a){return{el:a,getClass:function(){return this.el.getAttribute("class")||""},getClasses:function(){return this.getClass().split(" ").map(function(a){return a.replace(/^\s\s*/,"").replace(/\s\s*$/,"")}).filter(function(a){return 0<a.length})},prevAll:function(){return d(this.el,"previousSibling")},nextAll:function(){return d(this.el,"nextSibling")},parent:function(){return this.el.parentNode&&
11 | 11!==this.el.parentNode.nodeType?k(this.el.parentNode):null}}}function e(a){return"string"===typeof a&&null!==a.match(/^[a-zA-Z0-9]+$/gi)?a:!1}function h(a){return"string"===typeof a&&null!==a.match(/^\.?[a-zA-Z_\-:0-9]*$/gi)?a:!1}function q(a){var b="undefined"===typeof a?"undefined":l(a);return!!a&&("object"==b||"function"==b)}function r(a){if("number"==typeof a)return a;var b=a;if("symbol"==("undefined"===typeof b?"undefined":l(b))||b&&"object"==("undefined"===typeof b?"undefined":l(b))&&"[object Symbol]"==
12 | Ha.call(b))return W;q(a)&&(a="function"==typeof a.valueOf?a.valueOf():a,a=q(a)?a+"":a);if("string"!=typeof a)return 0===a?a:+a;a=a.replace(Ia,"");return(b=Ja.test(a))||Ka.test(a)?La(a.slice(2),b?2:8):Ma.test(a)?W:+a}function K(a,b,c){switch(c.length){case 0:return a.call(b);case 1:return a.call(b,c[0]);case 2:return a.call(b,c[0],c[1]);case 3:return a.call(b,c[0],c[1],c[2])}return a.apply(b,c)}function Ga(a,b){var c;if(c=!(!a||!a.length)){a:if(b!==b)b:{b=Na;c=a.length;for(var g=-1;++g<c;)if(b(a[g],
13 | g,a)){a=g;break b}a=-1}else{c=-1;for(g=a.length;++c<g;)if(a[c]===b){a=c;break a}a=-1}c=-1<a}return c}function Na(a){return a!==a}function Oa(a,b){return a.has(b)}function Pa(a){var b=!1;if(null!=a&&"function"!=typeof a.toString)try{b=!!(a+"")}catch(c){}return b}function x(a){var b=-1,c=a?a.length:0;for(this.clear();++b<c;){var g=a[b];this.set(g[0],g[1])}}function C(a){var b=-1,c=a?a.length:0;for(this.clear();++b<c;){var g=a[b];this.set(g[0],g[1])}}function D(a){var b=-1,c=a?a.length:0;for(this.clear();++b<
14 | c;){var g=a[b];this.set(g[0],g[1])}}function N(a){var b=-1,c=a?a.length:0;for(this.__data__=new D;++b<c;)this.add(a[b])}function O(a,b){for(var c=a.length;c--;){var g=a[c][0];if(g===b||g!==g&&b!==b)return c}return-1}function X(a,b,c,g,d){var u=-1,e=a.length;c||(c=Qa);for(d||(d=[]);++u<e;){var k=a[u];if(0<b&&c(k))if(1<b)X(k,b-1,c,g,d);else for(var h=d,l=-1,v=k.length,z=h.length;++l<v;)h[z+l]=k[l];else g||(d[d.length]=k)}return d}function P(a,b){a=a.__data__;var c="undefined"===typeof b?"undefined":
15 | l(b);return("string"==c||"number"==c||"symbol"==c||"boolean"==c?"__proto__"!==b:null===b)?a["string"==typeof b?"string":"hash"]:a.map}function Y(a,b){a=null==a?void 0:a[b];b=!Z(a)||ma&&ma in a?!1:(aa(a)||Pa(a)?Ra:Sa).test(Ta(a));return b?a:void 0}function Qa(a){var b;(b=kb(a))||(b=Q(a)&&R.call(a,"callee")&&(!lb.call(a,"callee")||"[object Arguments]"==na.call(a)));return b||!!(oa&&a&&a[oa])}function Ta(a){if(null!=a){try{return pa.call(a)}catch(b){}return a+""}return""}function Q(a){var b;if(b=!!a&&
16 | "object"==("undefined"===typeof a?"undefined":l(a))){if(b=null!=a)b=a.length,b="number"==typeof b&&-1<b&&0==b%1&&9007199254740991>=b;b=b&&!aa(a)}return b}function aa(a){a=Z(a)?na.call(a):"";return"[object Function]"==a||"[object GeneratorFunction]"==a}function Z(a){var b="undefined"===typeof a?"undefined":l(a);return!!a&&("object"==b||"function"==b)}function mb(a,b){return 0<nb(a.getClasses(),ob(b,function(a){return a.getClasses()})).length||!pb(b).includes(a.el.nodeName)}function qa(a){var b="undefined"===
17 | typeof a?"undefined":l(a);return!!a&&("object"==b||"function"==b)}function qb(a){if("number"==typeof a)return a;var b=a;if("symbol"==("undefined"===typeof b?"undefined":l(b))||b&&"object"==("undefined"===typeof b?"undefined":l(b))&&"[object Symbol]"==rb.call(b))return ra;qa(a)&&(a="function"==typeof a.valueOf?a.valueOf():a,a=qa(a)?a+"":a);if("string"!=typeof a)return 0===a?a:+a;a=a.replace(sb,"");return(b=tb.test(a))||ub.test(a)?vb(a.slice(2),b?2:8):wb.test(a)?ra:+a}function xb(a){var b=a.getMethods();
18 | return{finished:function(){return 0===b.length},next:function(){return this.finished()?!1:b.shift().apply(void 0,arguments)}}}function yb(a,b){if(0>=b)throw Error("Simmer: An invalid depth of "+b+" has been specified");return Array(b-1).fill().reduce(function(a,b){a[a.length-1].parent()&&(b=a[a.length-1].parent(),a.push(b));return a},[a])}function sa(){return ta({},zb,0<arguments.length&&void 0!==arguments[0]?arguments[0]:{})}function ba(){function a(a,b){if(!0===g.errorHandling)throw a;"function"===
19 | typeof g.errorHandling&&g.errorHandling(a,b)}var b=0<arguments.length&&void 0!==arguments[0]?arguments[0]:window,c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:!1,g=sa(1<arguments.length&&void 0!==arguments[1]?arguments[1]:{}),d=c||ua(b,g.queryEngine),c=function eb(b){if(!b)return a.call(eb,Error("Simmer: No element was specified for parsing."),b),!1;for(var c=new xb(w),u=yb(k(b),g.depth),e={stack:Array(u.length).fill().map(function(){return[]}),specificity:0},h=Ab(b,g,d,a);!c.finished()&&
20 | !e.verified;)try{e=c.next(u,e,h,g,d),e.specificity>=g.specificityThreshold&&!e.verified&&(e.verified=h(e))}catch(Bb){a.call(eb,Bb,b)}if(void 0===e.verified||e.specificity<g.specificityThreshold)e.verified=h(e);return e.verified?e.verificationDepth?S(e,e.verificationDepth):S(e):!1};c.configure=function(){var a=1<arguments.length&&void 0!==arguments[1]?arguments[1]:b,c=sa(ta({},g,0<arguments.length&&void 0!==arguments[0]?arguments[0]:{}));return ba(a,c,ua(a,c.queryEngine))};return c}var Cb={querySelectorAll:function(){throw Error("An invalid context has been provided to Simmer, it doesnt know how to query it");
21 | }},Db=function(a){var b="function"===typeof a.querySelectorAll?a:a.document?a.document:Cb;return function(a,g){try{return b.querySelectorAll(a)}catch(u){g(u)}}},ua=function(a,b){var c="function"===typeof b?b:Db(a);return function(b,d){return"string"!==typeof b?[]:c(b,d,a)}},l="function"===typeof Symbol&&"symbol"===typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"===typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},ta=Object.assign||function(a){for(var b=
22 | 1;b<arguments.length;b++){var c=arguments[b],d;for(d in c)Object.prototype.hasOwnProperty.call(c,d)&&(a[d]=c[d])}return a},Eb=function(){return function(a,b){if(Array.isArray(a))return a;if(Symbol.iterator in Object(a)){var c=[],d=!0,e=!1,k=void 0;try{for(var h=a[Symbol.iterator](),l;!(d=(l=h.next()).done)&&(c.push(l.value),!b||c.length!==b);d=!0);}catch(B){e=!0,k=B}finally{try{if(!d&&h["return"])h["return"]()}finally{if(e)throw k;}}return c}throw new TypeError("Invalid attempt to destructure non-iterable instance");
23 | }}(),ca=function(a){if(Array.isArray(a)){for(var b=0,c=Array(a.length);b<a.length;b++)c[b]=a[b];return c}return Array.from(a)},da=1/0,W=0/0,Ia=/^\s+|\s+$/g,Ma=/^[-+]0x[0-9a-f]+$/i,Ja=/^0b[01]+$/i,Ka=/^0o[0-7]+$/i,La=parseInt,Ha=Object.prototype.toString,Fb=function(a,b,c){if(!a||!a.length)return[];c||void 0===b?c=1:((c=b)?(c=r(c),c=c===da||c===-da?1.7976931348623157e+308*(0>c?-1:1):c===c?c:0):c=0===c?c:0,b=c%1,c=c===c?b?c-b:c:0);b=c;c=0;var d=0>b?0:b;b=-1;var e=a.length;0>c&&(c=-c>e?0:e+c);d=d>e?
24 | e:d;0>d&&(d+=e);e=c>d?0:d-c>>>0;c>>>=0;for(d=Array(e);++b<e;)d[b]=a[b+c];return d},H="undefined"!==typeof window?window:"undefined"!==typeof global?global:"undefined"!==typeof self?self:{},Sa=/^\[object .+?Constructor\]$/,y="object"==l(H)&&H&&H.Object===Object&&H,ea="object"==("undefined"===typeof self?"undefined":l(self))&&self&&self.Object===Object&&self,y=y||ea||Function("return this")(),ea=Array.prototype,T=Function.prototype,fa=Object.prototype,ga=y["__core-js_shared__"],ma=function(){var a=
25 | /[^.]+$/.exec(ga&&ga.keys&&ga.keys.IE_PROTO||"");return a?"Symbol(src)_1."+a:""}(),pa=T.toString,R=fa.hasOwnProperty,na=fa.toString,Ra=RegExp("^"+pa.call(R).replace(/[\\^$.*+?()[\]{}|]/g,"\\$\x26").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),T=y.Symbol,lb=fa.propertyIsEnumerable,Gb=ea.splice,oa=T?T.isConcatSpreadable:void 0,ha=Math.max,Hb=Y(y,"Map"),L=Y(Object,"create");x.prototype.clear=function(){this.__data__=L?L(null):{}};x.prototype["delete"]=function(a){return this.has(a)&&
26 | delete this.__data__[a]};x.prototype.get=function(a){var b=this.__data__;return L?(a=b[a],"__lodash_hash_undefined__"===a?void 0:a):R.call(b,a)?b[a]:void 0};x.prototype.has=function(a){var b=this.__data__;return L?void 0!==b[a]:R.call(b,a)};x.prototype.set=function(a,b){this.__data__[a]=L&&void 0===b?"__lodash_hash_undefined__":b;return this};C.prototype.clear=function(){this.__data__=[]};C.prototype["delete"]=function(a){var b=this.__data__;a=O(b,a);if(0>a)return!1;a==b.length-1?b.pop():Gb.call(b,
27 | a,1);return!0};C.prototype.get=function(a){var b=this.__data__;a=O(b,a);return 0>a?void 0:b[a][1]};C.prototype.has=function(a){return-1<O(this.__data__,a)};C.prototype.set=function(a,b){var c=this.__data__,d=O(c,a);0>d?c.push([a,b]):c[d][1]=b;return this};D.prototype.clear=function(){this.__data__={hash:new x,map:new (Hb||C),string:new x}};D.prototype["delete"]=function(a){return P(this,a)["delete"](a)};D.prototype.get=function(a){return P(this,a).get(a)};D.prototype.has=function(a){return P(this,
28 | a).has(a)};D.prototype.set=function(a,b){P(this,a).set(a,b);return this};N.prototype.add=N.prototype.push=function(a){this.__data__.set(a,"__lodash_hash_undefined__");return this};N.prototype.has=function(a){return this.__data__.has(a)};var y=function(a,b){b=ha(void 0===b?a.length-1:b,0);return function(){for(var c=arguments,d=-1,e=ha(c.length-b,0),h=Array(e);++d<e;)h[d]=c[b+d];d=-1;for(e=Array(b+1);++d<b;)e[d]=c[d];e[b]=h;return K(a,this,e)}}(function(a,b){if(Q(a)){b=X(b,1,Q,!0);var c=-1,d=Ga,e=
29 | !0,h=a.length,k=[],l=b.length;if(h)b:for(200<=b.length&&(d=Oa,e=!1,b=new N(b));++c<h;){var B=a[c],q=B,B=0!==B?B:0;if(e&&q===q){for(var v=l;v--;)if(b[v]===q)continue b;k.push(B)}else d(b,q,void 0)||k.push(B)}a=k}else a=[];return a}),kb=Array.isArray,nb=y,ob=function(a,b){return b={exports:{}},a(b,b.exports),b.exports}(function(a,b){function c(f,a){for(var b=-1,m=f?f.length:0,c=Array(m);++b<m;)c[b]=a(f[b],b,f);return c}function d(a,b){for(var f=-1,m=a?a.length:0;++f<m;)if(b(a[f],f,a))return!0;return!1}
30 | function e(a){return function(f){return null==f?void 0:f[a]}}function h(a){return function(f){return a(f)}}function k(a){var f=!1;if(null!=a&&"function"!=typeof a.toString)try{f=!!(a+"")}catch(p){}return f}function q(a){var f=-1,b=Array(a.size);a.forEach(function(a,m){b[++f]=[m,a]});return b}function B(a){var f=-1,b=Array(a.size);a.forEach(function(a){b[++f]=a});return b}function r(a){var f=-1,b=a?a.length:0;for(this.clear();++f<b;){var c=a[f];this.set(c[0],c[1])}}function v(a){var f=-1,b=a?a.length:
31 | 0;for(this.clear();++f<b;){var c=a[f];this.set(c[0],c[1])}}function z(a){var f=-1,b=a?a.length:0;for(this.clear();++f<b;){var c=a[f];this.set(c[0],c[1])}}function x(a){var f=-1,b=a?a.length:0;for(this.__data__=new z;++f<b;)this.add(a[f])}function E(a){this.__data__=new v(a)}function y(a,b){for(var f=a.length;f--;)if(Y(a[f][0],b))return f;return-1}function C(a,b,c,d,e){var f=-1,m=a.length;c||(c=ga);for(e||(e=[]);++f<m;){var p=a[f];if(0<b&&c(p))if(1<b)C(p,b-1,c,d,e);else for(var t=e,g=-1,h=p.length,
32 | k=t.length;++g<h;)t[k+g]=p[g];else d||(e[e.length]=p)}return e}function D(a,b){b=wa(b,a)?[b]:Q(b);for(var f=0,m=b.length;null!=a&&f<m;)a=a[xa(b[f++])];return f&&f==m?a:void 0}function w(a,b,c,d,e){if(a===b)return!0;if(null==a||null==b||!ia(a)&&!ya(b))return a!==a&&b!==b;a:{var f=F(a),m=F(b),p="[object Array]",g="[object Array]";f||(p=I(a),p="[object Arguments]"==p?"[object Object]":p);m||(g=I(b),g="[object Arguments]"==g?"[object Object]":g);var t="[object Object]"==p&&!k(a),m="[object Object]"==
33 | g&&!k(b);if((g=p==g)&&!t)e||(e=new E),b=f||Ta(a)?S(a,b,w,c,d,e):ea(a,b,p,w,c,d,e);else{if(!(d&2)&&(f=t&&G.call(a,"__wrapped__"),p=m&&G.call(b,"__wrapped__"),f||p)){a=f?a.value():a;b=p?b.value():b;e||(e=new E);b=w(a,b,c,d,e);break a}if(g){e||(e=new E);b:{var h,f=d&2,p=za(a),m=p.length,g=za(b).length;if(m==g||f){for(t=m;t--;){var A=p[t];if(!(f?A in b:G.call(b,A))){b=!1;break b}}if((g=e.get(a))&&e.get(b))b=g==b;else{g=!0;e.set(a,b);e.set(b,a);for(var u=f;++t<m;){A=p[t];var l=a[A],n=b[A];c&&(h=f?c(n,
34 | l,A,b,a,e):c(l,n,A,a,b,e));if(void 0===h?l!==n&&!w(l,n,c,d,e):!h){g=!1;break}u||(u="constructor"==A)}g&&!u&&(c=a.constructor,d=b.constructor,c!=d&&"constructor"in a&&"constructor"in b&&!("function"==typeof c&&c instanceof c&&"function"==typeof d&&d instanceof d)&&(g=!1));e["delete"](a);e["delete"](b);b=g}}else b=!1}}else b=!1}}return b}function K(a,b,c,d){var f,m=c.length,e=m,p=!d;if(null==a)return!e;for(a=Object(a);m--;){var g=c[m];if(p&&g[2]?g[1]!==a[g[0]]:!(g[0]in a))return!1}for(;++m<e;){g=c[m];
35 | var t=g[0],h=a[t],k=g[1];if(p&&g[2]){if(void 0===h&&!(t in a))return!1}else if(g=new E,d&&(f=d(h,k,t,a,b,g)),void 0===f?!w(k,h,d,3,g):!f)return!1}return!0}function L(a){return ya(a)&&Ua(a.length)&&!!n[U.call(a)]}function N(a,b){var f=-1,c=Aa(a)?Array(a.length):[];Qa(a,function(a,m,d){c[++f]=b(a,m,d)});return c}function O(a){var b=fa(a);return 1==b.length&&b[0][2]?X(b[0][0],b[0][1]):function(f){return f===a||K(f,a,b)}}function P(a,b){return wa(a)&&b===b&&!ia(b)?X(xa(a),b):function(f){var c=null==f?
36 | void 0:D(f,a);c=void 0===c?void 0:c;if(void 0===c&&c===b){if(c=null!=f){c=a;c=wa(c,f)?[c]:Q(c);for(var m,d=-1,e=c.length;++d<e;){var g=xa(c[d]);if(!(m=null!=f&&null!=f&&g in Object(f)))break;f=f[g]}m?c=m:(e=f?f.length:0,c=!!e&&Ua(e)&&W(g,e)&&(F(f)||Va(f)))}g=c}else g=w(b,c,void 0,3);return g}}function R(a){return function(b){return D(b,a)}}function T(a){if("string"==typeof a)return a;if(Wa(a))return fb?fb.call(a):"";var b=a+"";return"0"==b&&1/a==-aa?"-0":b}function Q(a){return F(a)?a:Sa(a)}function S(a,
37 | b,c,e,g,h){var f,m=g&2,p=a.length,k=b.length;if(p!=k&&!(m&&k>p))return!1;if((k=h.get(a))&&h.get(b))return k==b;var k=-1,t=!0,u=g&1?new x:void 0;h.set(a,b);for(h.set(b,a);++k<p;){var l=a[k],va=b[k];e&&(f=m?e(va,l,k,b,a,h):e(l,va,k,a,b,h));if(void 0!==f){if(f)continue;t=!1;break}if(u){if(!d(b,function(a,b){if(!u.has(b)&&(l===a||c(l,a,e,g,h)))return u.add(b)})){t=!1;break}}else if(l!==va&&!c(l,va,e,g,h)){t=!1;break}}h["delete"](a);h["delete"](b);return t}function ea(a,b,c,d,e,g,h){switch(c){case "[object DataView]":if(a.byteLength!=
38 | b.byteLength||a.byteOffset!=b.byteOffset)break;a=a.buffer;b=b.buffer;case "[object ArrayBuffer]":if(a.byteLength!=b.byteLength||!d(new gb(a),new gb(b)))break;return!0;case "[object Boolean]":case "[object Date]":case "[object Number]":return Y(+a,+b);case "[object Error]":return a.name==b.name&&a.message==b.message;case "[object RegExp]":case "[object String]":return a==b+"";case "[object Map]":var f=q;case "[object Set]":f||(f=B);if(a.size!=b.size&&!(g&2))break;if(c=h.get(a))return c==b;g|=1;h.set(a,
39 | b);b=S(f(a),f(b),d,e,g,h);h["delete"](a);return b;case "[object Symbol]":if(Xa)return Xa.call(a)==Xa.call(b)}return!1}function Ba(a,b){a=a.__data__;var f="undefined"===typeof b?"undefined":l(b);return("string"==f||"number"==f||"symbol"==f||"boolean"==f?"__proto__"!==b:null===b)?a["string"==typeof b?"string":"hash"]:a.map}function fa(a){for(var b=za(a),f=b.length;f--;){var c=b[f],d=a[c];b[f]=[c,d,d===d&&!ia(d)]}return b}function V(a,b){a=null==a?void 0:a[b];b=!ia(a)||hb&&hb in a?!1:(Z(a)||k(a)?Ha:
40 | sa).test(M(a));return b?a:void 0}function ga(a){return F(a)||Va(a)||!!(ib&&a&&a[ib])}function W(a,b){b=null==b?9007199254740991:b;return!!b&&("number"==typeof a||ta.test(a))&&-1<a&&0==a%1&&a<b}function wa(a,b){if(F(a))return!1;var f="undefined"===typeof a?"undefined":l(a);return"number"==f||"symbol"==f||"boolean"==f||null==a||Wa(a)?!0:oa.test(a)||!na.test(a)||null!=b&&a in Object(b)}function X(a,b){return function(f){return null==f?!1:f[a]===b&&(void 0!==b||a in Object(f))}}function xa(a){if("string"==
41 | typeof a||Wa(a))return a;var b=a+"";return"0"==b&&1/a==-aa?"-0":b}function M(a){if(null!=a){try{return jb.call(a)}catch(m){}return a+""}return""}function Ya(a,b){if("function"!=typeof a||b&&"function"!=typeof b)throw new TypeError("Expected a function");var f=function A(){var f=arguments,c=b?b.apply(this,f):f[0],d=A.cache;if(d.has(c))return d.get(c);f=a.apply(this,f);A.cache=d.set(c,f);return f};f.cache=new (Ya.Cache||z);return f}function Y(a,b){return a===b||a!==a&&b!==b}function Va(a){return ya(a)&&
42 | Aa(a)&&G.call(a,"callee")&&(!Ia.call(a,"callee")||"[object Arguments]"==U.call(a))}function Aa(a){return null!=a&&Ua(a.length)&&!Z(a)}function Z(a){a=ia(a)?U.call(a):"";return"[object Function]"==a||"[object GeneratorFunction]"==a}function Ua(a){return"number"==typeof a&&-1<a&&0==a%1&&9007199254740991>=a}function ia(a){var b="undefined"===typeof a?"undefined":l(a);return!!a&&("object"==b||"function"==b)}function ya(a){return!!a&&"object"==("undefined"===typeof a?"undefined":l(a))}function Wa(a){return"symbol"==
43 | ("undefined"===typeof a?"undefined":l(a))||ya(a)&&"[object Symbol]"==U.call(a)}function za(a){if(Aa(a)){if(F(a)||Va(a)){var b=a.length;for(var c=String,f=-1,d=Array(b);++f<b;)d[f]=c(f);b=d}else b=[];var c=b.length,f=!!c;for(e in a)!G.call(a,e)||f&&("length"==e||W(e,c))||b.push(e);a=b}else{var e=a&&a.constructor;if(a===("function"==typeof e&&e.prototype||Ca)){e=[];for(b in Object(a))G.call(a,b)&&"constructor"!=b&&e.push(b);a=e}else a=Ka(a)}return a}function ma(a){return a}var aa=1/0,na=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
44 | oa=/^\w*$/,pa=/^\./,qa=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,ra=/\\(\\)?/g,sa=/^\[object .+?Constructor\]$/,ta=/^(?:0|[1-9]\d*)$/,n={};n["[object Float32Array]"]=n["[object Float64Array]"]=n["[object Int8Array]"]=n["[object Int16Array]"]=n["[object Int32Array]"]=n["[object Uint8Array]"]=n["[object Uint8ClampedArray]"]=n["[object Uint16Array]"]=n["[object Uint32Array]"]=!0;n["[object Arguments]"]=n["[object Array]"]=n["[object ArrayBuffer]"]=
45 | n["[object Boolean]"]=n["[object DataView]"]=n["[object Date]"]=n["[object Error]"]=n["[object Function]"]=n["[object Map]"]=n["[object Number]"]=n["[object Object]"]=n["[object RegExp]"]=n["[object Set]"]=n["[object String]"]=n["[object WeakMap]"]=!1;var ba="object"==l(H)&&H&&H.Object===Object&&H,ua="object"==("undefined"===typeof self?"undefined":l(self))&&self&&self.Object===Object&&self,J=ba||ua||Function("return this")(),ca=b&&!b.nodeType&&b,da=ca&&!0&&a&&!a.nodeType&&a,ha=da&&da.exports===ca&&
46 | ba.process;a:{try{var Za=ha&&ha.binding("util");break a}catch(f){}Za=void 0}var la=Za&&Za.isTypedArray,Fa=Array.prototype,Ga=Function.prototype,Ca=Object.prototype,$a=J["__core-js_shared__"],hb=function(){var a=/[^.]+$/.exec($a&&$a.keys&&$a.keys.IE_PROTO||"");return a?"Symbol(src)_1."+a:""}(),jb=Ga.toString,G=Ca.hasOwnProperty,U=Ca.toString,Ha=RegExp("^"+jb.call(G).replace(/[\\^$.*+?()[\]{}|]/g,"\\$\x26").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),Da=J.Symbol,gb=
47 | J.Uint8Array,Ia=Ca.propertyIsEnumerable,Ja=Fa.splice,ib=Da?Da.isConcatSpreadable:void 0,Ka=function(a,b){return function(c){return a(b(c))}}(Object.keys,Object),ab=V(J,"DataView"),ja=V(J,"Map"),bb=V(J,"Promise"),cb=V(J,"Set"),db=V(J,"WeakMap"),ka=V(Object,"create"),La=M(ab),Ma=M(ja),Na=M(bb),Oa=M(cb),Pa=M(db),Ea=Da?Da.prototype:void 0,Xa=Ea?Ea.valueOf:void 0,fb=Ea?Ea.toString:void 0;r.prototype.clear=function(){this.__data__=ka?ka(null):{}};r.prototype["delete"]=function(a){return this.has(a)&&delete this.__data__[a]};
48 | r.prototype.get=function(a){var b=this.__data__;return ka?(a=b[a],"__lodash_hash_undefined__"===a?void 0:a):G.call(b,a)?b[a]:void 0};r.prototype.has=function(a){var b=this.__data__;return ka?void 0!==b[a]:G.call(b,a)};r.prototype.set=function(a,b){this.__data__[a]=ka&&void 0===b?"__lodash_hash_undefined__":b;return this};v.prototype.clear=function(){this.__data__=[]};v.prototype["delete"]=function(a){var b=this.__data__;a=y(b,a);if(0>a)return!1;a==b.length-1?b.pop():Ja.call(b,a,1);return!0};v.prototype.get=
49 | function(a){var b=this.__data__;a=y(b,a);return 0>a?void 0:b[a][1]};v.prototype.has=function(a){return-1<y(this.__data__,a)};v.prototype.set=function(a,b){var c=this.__data__,d=y(c,a);0>d?c.push([a,b]):c[d][1]=b;return this};z.prototype.clear=function(){this.__data__={hash:new r,map:new (ja||v),string:new r}};z.prototype["delete"]=function(a){return Ba(this,a)["delete"](a)};z.prototype.get=function(a){return Ba(this,a).get(a)};z.prototype.has=function(a){return Ba(this,a).has(a)};z.prototype.set=
50 | function(a,b){Ba(this,a).set(a,b);return this};x.prototype.add=x.prototype.push=function(a){this.__data__.set(a,"__lodash_hash_undefined__");return this};x.prototype.has=function(a){return this.__data__.has(a)};E.prototype.clear=function(){this.__data__=new v};E.prototype["delete"]=function(a){return this.__data__["delete"](a)};E.prototype.get=function(a){return this.__data__.get(a)};E.prototype.has=function(a){return this.__data__.has(a)};E.prototype.set=function(a,b){var c=this.__data__;if(c instanceof
51 | v){c=c.__data__;if(!ja||199>c.length)return c.push([a,b]),this;c=this.__data__=new z(c)}c.set(a,b);return this};var Qa=function(a,b){return function(c,d){if(null==c)return c;if(!Aa(c))return a(c,d);for(var f=c.length,e=b?f:-1,g=Object(c);(b?e--:++e<f)&&!1!==d(g[e],e,g););return c}}(function(a,b){return a&&Ra(a,b,za)}),Ra=function(a){return function(b,c,d){var e=-1,f=Object(b);d=d(b);for(var g=d.length;g--;){var h=d[a?g:++e];if(!1===c(f[h],h,f))break}return b}}(),I=function(a){return U.call(a)};if(ab&&
52 | "[object DataView]"!=I(new ab(new ArrayBuffer(1)))||ja&&"[object Map]"!=I(new ja)||bb&&"[object Promise]"!=I(bb.resolve())||cb&&"[object Set]"!=I(new cb)||db&&"[object WeakMap]"!=I(new db))I=function(a){var b=U.call(a);if(a=(a="[object Object]"==b?a.constructor:void 0)?M(a):void 0)switch(a){case La:return"[object DataView]";case Ma:return"[object Map]";case Na:return"[object Promise]";case Oa:return"[object Set]";case Pa:return"[object WeakMap]"}return b};var Sa=Ya(function(a){a=null==a?"":T(a);var b=
53 | [];pa.test(a)&&b.push("");a.replace(qa,function(a,c,d,e){b.push(d?e.replace(ra,"$1"):c||a)});return b});Ya.Cache=z;var F=Array.isArray,Ta=la?h(la):L;a.exports=function(a,b){var d=F(a)?c:N;b="function"==typeof b?b:null==b?ma:"object"==("undefined"===typeof b?"undefined":l(b))?F(b)?P(b[0],b[1]):O(b):wa(b)?e(xa(b)):R(b);a=d(a,b);return C(a,1)}}),pb=function(a){return a.map(function(a){return a.el.nodeName})},la={A:function(a,b){if(b=b.el.getAttribute("href"))a.stack[0].push('A[href\x3d"'+b+'"]'),a.specificity+=
54 | 10;return a},IMG:function(a,b){if(b=b.el.getAttribute("src"))a.stack[0].push('IMG[src\x3d"'+b+'"]'),a.specificity+=10;return a}},w={methods:[],getMethods:function(){return this.methods.slice(0)},addMethod:function(a){this.methods.push(a)}};w.addMethod(function(a,b,c,d,e){return a.reduce(function(a,b,g){return a.verified?a:(b=[b.el.getAttribute("id")].filter(function(a){a="string"===typeof a&&null!==a.match(/^[0-9a-zA-Z][a-zA-Z_\-:0-9.]*$/gi)?a:!1;return a}).filter(function(a){return 1===(e('[id\x3d"'+
55 | a+'"]')||[]).length}).map(function(b){a.stack[g].push("[id\x3d'"+b+"']");a.specificity+=100;a.specificity>=d.specificityThreshold&&c(a)&&(a.verified=!0);a.verified||0!==g||(a.stack[g].pop(),a.specificity-=100);return a}),Eb(b,1)[0]||a)},b)});w.addMethod(function(a,b){return a.reduce(function(a,b,d){[b.el.nodeName].filter(e).forEach(function(b){a.stack[d].splice(0,0,b);a.specificity+=10});return a},b)});w.addMethod(function(a,b,c){a=a[0];var d=a.el.nodeName;la[d]&&(b=la[d](b,a),c(b)?b.verified=!0:
56 | b.stack[0].pop());return b});w.addMethod(function(a,b){return a.reduce(function(a,b,d){b=Fb(b.getClasses(),10).filter(h).map(function(a){return"."+a});b.length&&(a.stack[d].push(b.join("")),a.specificity+=10*b.length);return a},b)});w.addMethod(function(a,b,c){return a.reduce(function(a,b,d){if(!a.verified){var e=b.prevAll(),g=b.nextAll(),h=e.length+1;!e.length&&!g.length||mb(b,[].concat(ca(e),ca(g)))||(a.stack[d].push(":nth-child("+h+")"),a.verified=c(a))}return a},b)});var Fa=1/0,ra=0/0,sb=/^\s+|\s+$/g,
57 | wb=/^[-+]0x[0-9a-f]+$/i,tb=/^0b[01]+$/i,ub=/^0o[0-7]+$/i,vb=parseInt,rb=Object.prototype.toString,Ib=function(a,b,c){var d=a?a.length:0;if(!d)return[];c||void 0===b?b=1:(b?(b=qb(b),b=b===Fa||b===-Fa?1.7976931348623157e+308*(0>b?-1:1):b===b?b:0):b=0===b?b:0,c=b%1,b=b===b?c?b-c:b:0);b=d-b;b=0>b?0:b;var e=d,d=-1;c=a.length;0>b&&(b=-b>c?0:c+b);e=e>c?c:e;0>e&&(e+=c);c=b>e?0:e-b>>>0;b>>>=0;for(e=Array(c);++d<c;)e[d]=a[d+b];return e},S=function(a){var b=1<arguments.length&&void 0!==arguments[1]?arguments[1]:
58 | a.stack.length;return Ib(a.stack.reduceRight(function(a,b){b.length?a.push(b.join("")):a.length&&a.push("*");return a},[]),b).join(" \x3e ")||"*"},Ab=function(a,b,c,d){var e=b.selectorMaxLength;return function(b){for(var g=!1,h=1;h<=b.stack.length&&!g;h+=1){g=S(b,h).trim();if(!g||!g.length||e&&g.length>e)return!1;g=c(g,d);if(g=1===g.length&&(void 0!==a.el?g[0]===a.el:g[0]===a))b.verificationDepth=h}return g}},zb={queryEngine:null,specificityThreshold:100,depth:3,errorHandling:!1,selectorMaxLength:512};
59 | (function(a,b){var c=a.Simmer;a.Simmer=b;b.noConflict=function(){a.Simmer=c;return b}})(window,ba(window))})();
60 | 


--------------------------------------------------------------------------------