stew-select

# # **PredicateFactory** generates boolean-valued # functions that implement tests of specific # CSS selectors. # # Each generated function has the signature: # # predicate(node,node_metadata,dom_metadata) # # and returns `true` iff the given `node` matches # the associated CSS selection rule. # # (This is an internal class, primarily used by # the class `Stew`. These methods are subject to # change without notice.) # class PredicateFactory # **and_predicate** generates a function that returns `true` iff *all* of the given `predicates` evaluate to `true`. and_predicate:(predicates)-> return (node,node_metadata,dom_metadata)-> for predicate in predicates if not predicate(node,node_metadata,dom_metadata) return false return true # **or_predicate** generates a function that returns `true` iff *any* of the given `predicates` evaluate to `true`. or_predicate:(predicates)-> return (node,node_metadata,dom_metadata)-> for predicate in predicates if predicate(node,node_metadata,dom_metadata) return true return false # **by_attribute_predicate** creates a predicate # that returns `true` if the given `attrname` # matches the given `attrvalue`. # # * When `attrvalue` is `null`, then the predicate will # return `true` if the tested node has an attribute # named `attrname`. # # * When `attrvalue` is a String then the predicate will # return true if the value of the `attrname` attribute # *equals* the `attrvalue` *string*. # # * When `attrvalue` is a `RegExp` then the predicate will # return `true` if the value of the `attrname` attribute # *matches* the `attrvalue` *expression*. # # * When `valuedelim` is non-`null`, the specified value will # be used as a delimiter by which to split the value of # the `attrname` attribute, and the corresponding elements # will be tested rather than the entire string. # # For example, the call: # # by_attribute_predicate('class','foo',/\s+/) # # will return a function that tests if a given DOM node # has been assigned class `foo`. E.g, `true` for these: # # # # # # and `false` for these: # # # # # by_attribute_predicate:(attrname,attrvalue=null,valuedelim=null)-> if typeof(attrname) is 'string' np = (str)->str is attrname else np = (str)->attrname.test(str) if attrvalue is null vp = null else if typeof(attrvalue) is 'string' attrvalue = attrvalue.replace(/\\\"/g,'"') vp = (str)->str is attrvalue else if attrvalue?.test? vp = (str)->attrvalue.test(str) return (node)-> for name,value of node?.attribs if np(name) if vp is null return true else if valuedelim? if value? for token in value.split(valuedelim) if vp(token) return true else if vp(value) return true return false # **by_class_predicate** creates a predicate # that returns `true` if the given DOM node has # the specified `klass` value. by_class_predicate:(klass)=> return @by_attribute_predicate('class',klass,/\s+/) # **by_id_predicate** creates a predicate # that returns `true` if the given DOM node has # the specified `id` value. by_id_predicate:(id)=> return @by_attribute_predicate('id',id) # **by_attr_exists_predicate** creates a # predicate that returns `true` if the given DOM # node has an attribute with the specified `attrname`, # regardless of the value for the atttribute. by_attr_exists_predicate:(attrname)=> return @by_attribute_predicate(attrname,null) # **by_attr_value_predicate** is an alias to `by_attribute_predicate`. by_attr_value_predicate:(attrname,attrvalue,valuedelim)=> return @by_attribute_predicate(attrname,attrvalue,valuedelim) # **_escape_for_regexp** is an internal utility function that escapes # reserved characters to create a string that can be embedded # in a regular expression. _escape_for_regexp:(str)->return str.replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1") # **by_attr_value_pipe_equals** creates a predicate that # implements the `[name|=value]` CSS selector (matching tags # with a `name` attribute with a value matching `value` # (exactly) or a value that starts with `value` followed # by a `-` character.. # # (Used for selectors such as `[lang|=en]`, for example, # which will match the values `en`, `en-US` and `en-CA`.) # # When `attrvalue` is a regular expression: # # - If `attrvalue` doesn't already start with # `^` (matching the beginning of a line), # then `^` will be added. # # - If `attrvalue` doesn't already end with # `($|-)` (matching the end of a line, or `-`) # then `($|-)` will be added. # # Hence the regular expression `/f[aeio]o?/` # would be converted to `/^f[aeio]o?($|-)/` but # the regular expression `/^en($|-)/` would be # left alone. by_attr_value_pipe_equals:(attrname,attrvalue)=> if typeof attrvalue is 'string' regexp_source = @_escape_for_regexp(attrvalue) attrvalue = new RegExp("^#{regexp_source}($|-)") else regexp_source = attrvalue.source modifier = '' modifier += 'i' if attrvalue.ignoreCase modifier += 'g' if attrvalue.global modifier += 'm' if attrvalue.multiline unless /^\^/.test attrvalue.source regexp_source = "^#{regexp_source}" unless /$\$\|-$$/.test regexp_source regexp_source = "#{regexp_source}($|-)" attrvalue = new RegExp(regexp_source,modifier) return @by_attribute_predicate(attrname,attrvalue) # **by_tag_predicate** creates a # predicate that returns `true` if the given DOM # node is a tag with the specified `name`. # # If `name` is a RegExp then the predicate will # return true if tag's name *matches* the # specified *expression*. # # If `name` is a String then the predicate will # return true if the tag's name *equals* the # specified *string*. by_tag_predicate:(name)-> if typeof name is 'string' return (node)->(name is node.name) else return (node)->(name.test(node.name)) # **first_child_predicate** returns a predicate that evaluates to `true` # iff the given `node` is the first child *tag* node among all of # its siblings. # #{ TODO FIXME should :first-child also consider elements like <script>? first_child_predicate:()->return @_first_child_impl _first_child_impl:(node,node_metadata,dom_metadata)-> if node.type is 'tag' and node_metadata.siblings? for elt in node_metadata.siblings if elt.type is 'tag' return node._stew_node_id is elt._stew_node_id return false # **any_tag_predicate** returns a predicate that evaluates # to `true` iff the given `node` is a tag. any_tag_predicate:()->return @_any_tag_impl # (...and **_any_tag_impl** is the implementation of that predicate.) _any_tag_impl:(node)->(node?.type is 'tag') # **descendant_predicate** # returns a predicate that for the given array # *P* containing *n*, evaluates to `true` for # a given `node` if: # # - `P[n-1](node)` is `true`, and # # - `P[n-2](parent)` is `true` for some element # `parent` that is an ancestor of `node` # # - `P[n-3](parent2)` is `true` for some element # `parent2` that is an ancestor of `parent` # # - ...etc. # # In other words, the returned predicate will evalue to `true` # for the current `node` if each of the given `predicates` # evaluates to `true` for some ancestor of the node, *in sequence*. # (I.e., the node that matches `predicates[n]` must be an ancestor # of the node that mathces `predicates[n+1]`.) # descendant_predicate:(predicates)-> if predicates.length is 1 return predicates[0] else return (node,node_metadata,dom_metadata)-> if predicates[predicates.length-1](node,node_metadata,dom_metadata) cloned_path = [].concat(node_metadata.path) cloned_predicates = [].concat(predicates) cloned_predicates.pop() # drop last predicate, we just tested it while cloned_path.length > 0 node = cloned_path.pop() node_metadata = dom_metadata[node._stew_node_id] if cloned_predicates[cloned_predicates.length-1](node,node_metadata,dom_metadata) cloned_predicates.pop() if cloned_predicates.length is 0 return true break return false # **direct_descendant_predicate** returns a predicate # that evaluates to `true` iff `child_selector` evalutes # to `true` for the given `node` and `parent_selector` evalutes # to `true` for the given `node`'s parent. direct_descendant_predicate:(parent_selector,child_selector)-> return (node,node_metadata,dom_metadata)-> if child_selector(node,node_metadata,dom_metadata) parent = node_metadata.parent parent_metadata = dom_metadata[parent._stew_node_id] return parent_selector(parent,parent_metadata,dom_metadata) return false # **adjacent_sibling_predicate** returns a predicate # that evaluates to `true` iff `second` evaluates # to `true` for the given `node` and `first` evaluates # to `true` for the tag sibling immediately preceding # the given `node`. adjacent_sibling_predicate:(first,second)-> return (node,node_metadata,dom_metadata)-> if second(node,node_metadata,dom_metadata) prev_tag_index = node_metadata.sib_index - 1 while prev_tag_index > 0 if node_metadata.siblings[prev_tag_index].type is 'tag' prev_tag = node_metadata.siblings[prev_tag_index] return first(prev_tag,dom_metadata[prev_tag._stew_node_id],dom_metadata) else prev_tag_index -= 1 return false # **preceding_sibling_predicate** returns a predicate # that evaluates to `true` iff `second` evaluates # to `true` for the given `node` and `first` evaluates # to `true` for some tag sibling preceding # the given `node`. preceding_sibling_predicate:(first,second)-> return (node,node_metadata,dom_metadata)-> if second(node,node_metadata,dom_metadata) for prev,index in node_metadata.siblings if index is node_metadata.sib_index return false else if prev.type is 'tag' if first(prev,dom_metadata[prev._stew_node_id],dom_metadata) return true return false # The PredicateFactory class is exported under the name `PredicateFactory`. exports = exports ? this exports.PredicateFactory = PredicateFactory