defaults.keys: fixed hint - ranger - mirror of ranger

diff options

author	hut <hut@lavabit.com>	2010-03-21 03:05:08 +0100
committer	hut <hut@lavabit.com>	2010-03-21 03:05:08 +0100
commit	1361ac5817fe5730b55deee8cf00763a296b475e (patch)
tree	b06c9f60be8e4a4504910f91d49ddec065da0a56 /test/tc_history.py
parent	650a672c0da0124199e17f207255a5c6b0d32c6b (diff)
download	ranger-1361ac5817fe5730b55deee8cf00763a296b475e.tar.gz

defaults.keys: fixed hint

Diffstat (limited to 'test/tc_history.py')

0 files changed, 0 insertions, 0 deletions

aab9bd95178'>bbdf9df ^

2c486cb ^

27b2517 ^

18
19
20

21
22

23
24
25

28
29
30

l.com>  2023-12-11 10:45:41 +0100

css: add case-insensitive matching' href='/ahoang/chawan/commit/src/css/match.nim?id=d2451e51ede8a733c22fbe0b285ccb341e272b16'>d2451e51 ^

acd24ae4 ^

91dee7d0 ^

d2451e51 ^

85796198 ^

167dd672 ^

fbdb7fc7 ^

167dd672 ^

fbdb7fc7 ^

dd9cb39c ^

fbdb7fc7 ^

2a94a270 ^

dd9cb39c ^

d207bf1d ^

dd9cb39c ^

62cba694 ^

c69a8ab7 ^

167dd672 ^

fbdb7fc7 ^

4eaa8830 ^

ea9df035 ^

4eaa8830 ^

167dd672 ^

fbdb7fc7 ^

167dd672 ^

fbdb7fc7 ^

4eaa8830 ^

ea9df035 ^

48c236c0 ^

4eaa8830 ^

48c236c0 ^

167dd672 ^

fbdb7fc7 ^

c69a8ab7 ^

24fc8e94 ^

d207bf1d ^

24fc8e94 ^

8bc1392c ^

fbdb7fc7 ^

a1c62fc9 ^

d4d45f41 ^

4a897f27 ^

d4d45f41 ^

72e171f6 ^

252174ba ^

dd9cb39c ^

85796198 ^

168bd542 ^

85796198 ^

fc730139 ^

85796198 ^

fc730139 ^

85796198 ^

fc730139 ^

85796198 ^

dd9cb39c ^

85796198 ^

2a94a270 ^

85796198 ^

fc730139 ^

167dd672 ^

af3dbce8 ^

167dd672 ^

2b26bfdc ^

167dd672 ^

dd9cb39c ^

167dd672 ^

dd9cb39c ^

167dd672 ^

85796198 ^

51d83224 ^

168bd542 ^

51d83224 ^

252174ba ^

51d83224 ^

252174ba ^

51d83224 ^

168bd542 ^

51d83224 ^

252174ba ^

51d83224 ^


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246




                   
 
                    

                         
                 
               
                   

                 
 
                                                                 
                                                              
                
                                                 













                                                                     
                         
                                 


























                                                                            
 
                                                                                                  
 


                                                                                                 


                 



                                                                                           
                   


                                                                                                                     
                  
                                                                      
                     
                                                   
                      
                                                                                         





                                                       
                                  
                                    







                                                    
                                                                                      


                           
                                                                                         





                                                       
                                  
                                        

                                           
                        




                                                    
                                                                                      
             
                
                    
                                                                        




                                             


                                                                      



                                                            

                                                
                 
                                                                    

                    
 
                                                                                           


                                  

                   
                                    
                    
                                      
                 
                            
                   
                                        
                     
                                                   
                     
               
                        
               















                                                                                                           
                                           





















                                                   

                                               
















                                                   


                                                                               

                                                                                                    


         
                                                  
 
                                                            
                                                                           
                               

                                         
                                                                               
 
                                                    
                                                                           
                               


                                         
                                                                      
import std/options
import std/streams
import std/strutils
import std/tables

import css/cssparser
import css/selectorparser
import css/stylednode
import html/catom
import html/dom
import utils/twtstr

import chame/tags

#TODO FLAG_NONE should match insensitively for certain properties
func attrSelectorMatches(elem: Element, sel: Selector): bool =
  case sel.rel.t
  of RELATION_EXISTS: return elem.attrb(sel.attr)
  of RELATION_EQUALS:
    case sel.rel.flag
    of FLAG_NONE: return elem.attr(sel.attr) == sel.value
    of FLAG_I: return elem.attr(sel.attr).equalsIgnoreCase(sel.value)
    of FLAG_S: return elem.attr(sel.attr) == sel.value
  of RELATION_TOKEN:
    let val = elem.attr(sel.attr)
    case sel.rel.flag
    of FLAG_NONE: return sel.value in val.split(AsciiWhitespace)
    of FLAG_I:
      let val = val.toLowerAscii()
      let selval = sel.value.toLowerAscii()
      return selval in val.split(AsciiWhitespace)
    of FLAG_S: return sel.value in val.split(AsciiWhitespace)
  of RELATION_BEGIN_DASH:
    let val = elem.attr(sel.attr)
    case sel.rel.flag
    of FLAG_NONE: return val == sel.value or sel.value.startsWith(val & '-')
    of FLAG_I:
      return val.equalsIgnoreCase(sel.value) or
        sel.value.startsWithIgnoreCase(val & '-')
    of FLAG_S: return val == sel.value or sel.value.startsWith(val & '-')
  of RELATION_STARTS_WITH:
    let val = elem.attr(sel.attr)
    case sel.rel.flag
    of FLAG_NONE: return val.startsWith(sel.value)
    of FLAG_I: return val.startsWithIgnoreCase(sel.value)
    of FLAG_S: return val.startsWith(sel.value)
  of RELATION_ENDS_WITH:
    let val = elem.attr(sel.attr)
    case sel.rel.flag
    of FLAG_NONE: return val.endsWith(sel.value)
    of FLAG_I: return val.endsWithIgnoreCase(sel.value)
    of FLAG_S: return val.endsWith(sel.value)
  of RELATION_CONTAINS:
    let val = elem.attr(sel.attr)
    case sel.rel.flag
    of FLAG_NONE: return val.contains(sel.value)
    of FLAG_I:
      let val = val.toLowerAscii()
      let selval = sel.value.toLowerAscii()
      return val.contains(selval)
    of FLAG_S: return val.contains(sel.value)

func selectorsMatch*[T: Element|StyledNode](elem: T, cxsel: ComplexSelector, felem: T = nil): bool

func selectorsMatch*[T: Element|StyledNode](elem: T, slist: SelectorList, felem: T = nil): bool =
  for cxsel in slist:
    if elem.selectorsMatch(cxsel, felem):
      return true
  return false

func pseudoSelectorMatches[T: Element|StyledNode](elem: T, sel: Selector, felem: T): bool =
  let selem = elem
  when elem is StyledNode:
    let elem = Element(elem.node)
  case sel.pseudo.t
  of PSEUDO_FIRST_CHILD: return elem.parentNode.firstElementChild == elem
  of PSEUDO_LAST_CHILD: return elem.parentNode.lastElementChild == elem
  of PSEUDO_ONLY_CHILD: return elem.parentNode.firstElementChild == elem and elem.parentNode.lastElementChild == elem
  of PSEUDO_HOVER:
    when selem is StyledNode: felem.addDependency(selem, DEPEND_HOVER)
    return elem.hover
  of PSEUDO_ROOT: return elem == elem.document.html
  of PSEUDO_NTH_CHILD:
    if sel.pseudo.ofsels.len != 0 and not selem.selectorsMatch(sel.pseudo.ofsels, felem):
      return false
    let A = sel.pseudo.anb.A # step
    let B = sel.pseudo.anb.B # start
    var i = 1
    let parent = when selem is StyledNode: selem.parent
    else: selem.parentNode
    if parent == nil: return false
    for child in parent.elementList:
      when selem is StyledNode:
        if not child.isDomElement: continue
      if child == selem:
        if A == 0:
          return i == B
        if A < 0:
          return (i - B) <= 0 and (i - B) mod A == 0
        return (i - B) >= 0 and (i - B) mod A == 0
      if sel.pseudo.ofsels.len == 0 or child.selectorsMatch(sel.pseudo.ofsels, felem):
        inc i
    return false
  of PSEUDO_NTH_LAST_CHILD:
    if sel.pseudo.ofsels.len == 0 and not selem.selectorsMatch(sel.pseudo.ofsels, felem):
      return false
    let A = sel.pseudo.anb.A # step
    let B = sel.pseudo.anb.B # start
    var i = 1
    let parent = when selem is StyledNode: selem.parent
    else: selem.parentNode
    if parent == nil: return false
    for child in parent.elementList_rev:
      when selem is StyledNode:
        if not child.isDomElement: continue
      if child == selem:
        if A == 0:
          return i == B
        if A < 0:
          return (i - B) <= 0 and (i - B) mod A == 0
        return (i - B) >= 0 and (i - B) mod A == 0
      if sel.pseudo.ofsels.len != 0 or child.selectorsMatch(sel.pseudo.ofsels, felem):
        inc i
    return false
  of PSEUDO_CHECKED:
    when selem is StyledNode: felem.addDependency(selem, DEPEND_CHECKED)
    if elem.tagType == TAG_INPUT:
      return HTMLInputElement(elem).checked
    elif elem.tagType == TAG_OPTION:
      return HTMLOptionElement(elem).selected
    return false
  of PSEUDO_FOCUS:
    when selem is StyledNode: felem.addDependency(selem, DEPEND_FOCUS)
    return elem.document.focus == elem
  of PSEUDO_NOT:
    return not selem.selectorsMatch(sel.pseudo.fsels, felem)
  of PSEUDO_IS, PSEUDO_WHERE:
    return selem.selectorsMatch(sel.pseudo.fsels, felem)
  of PSEUDO_LANG:
    return sel.pseudo.s == "en" #TODO languages?
  of PSEUDO_LINK:
    return elem.tagType in {TAG_A, TAG_AREA} and elem.attrb(satHref)
  of PSEUDO_VISITED:
    return false

func selectorMatches[T: Element|StyledNode](elem: T, sel: Selector, felem: T = nil): bool =
  let selem = elem
  when elem is StyledNode:
    let elem = Element(selem.node)
  case sel.t
  of TYPE_SELECTOR:
    return elem.localName == sel.tag
  of CLASS_SELECTOR:
    return sel.class in elem.classList
  of ID_SELECTOR:
    return sel.id == elem.id
  of ATTR_SELECTOR:
    return elem.attrSelectorMatches(sel)
  of PSEUDO_SELECTOR:
    return pseudoSelectorMatches(selem, sel, felem)
  of PSELEM_SELECTOR:
    return true
  of UNIVERSAL_SELECTOR:
    return true

func selectorsMatch[T: Element|StyledNode](elem: T, sels: CompoundSelector, felem: T): bool =
  for sel in sels:
    if not selectorMatches(elem, sel, felem):
      return false
  return true

func complexSelectorMatches[T: Element|StyledNode](elem: T, cxsel: ComplexSelector, felem: T = nil): bool =
  var e = elem
  for i in countdown(cxsel.high, 0):
    let sels = cxsel[i]
    if e == nil:
      return false
    var match = false
    case sels.ct
    of NO_COMBINATOR:
      match = e.selectorsMatch(sels, felem)
    of DESCENDANT_COMBINATOR:
      e = e.parentElement
      while e != nil:
        if e.selectorsMatch(sels, felem):
          match = true
          break
        e = e.parentElement
    of CHILD_COMBINATOR:
      e = e.parentElement
      if e != nil:
        match = e.selectorsMatch(sels, felem)
    of NEXT_SIBLING_COMBINATOR:
      if e.parentElement == nil: return false
      var found = false
      for child in e.parentElement.elementList_rev:
        when elem is StyledNode:
          if not child.isDomElement: continue
        if e == child:
          found = true
          continue
        if found:
          e = child
          match = e.selectorsMatch(sels, felem)
          break
    of SUBSEQ_SIBLING_COMBINATOR:
      var found = false
      if e.parentElement == nil: return false
      for child in e.parentElement.elementList_rev:
        when elem is StyledNode:
          if not child.isDomElement: continue
        if child == elem:
          found = true
          continue
        if not found: continue
        if child.selectorsMatch(sels, felem):
          e = child
          match = true
          break
    if not match:
      return false
  return true

# WARNING for StyledNode, this has the side effect of modifying depends.
#TODO make that an explicit flag or something, also get rid of the Element case
func selectorsMatch*[T: Element|StyledNode](elem: T, cxsel: ComplexSelector, felem: T = nil): bool =
  var felem = if felem != nil:
    felem
  else:
    elem
  return elem.complexSelectorMatches(cxsel, felem)

proc querySelectorAll(node: Node, q: string): seq[Element] =
  let selectors = parseSelectors(newStringStream(q), node.document.factory)
  for element in node.elements:
    if element.selectorsMatch(selectors):
      result.add(element)
doqsa = (proc(node: Node, q: string): seq[Element] = querySelectorAll(node, q))

proc querySelector(node: Node, q: string): Element =
  let selectors = parseSelectors(newStringStream(q), node.document.factory)
  for element in node.elements:
    if element.selectorsMatch(selectors):
      return element
  return nil
doqs = (proc(node: Node, q: string): Element = querySelector(node, q))


context:
space:
mode: